import type {
  CreateDraftResponse,
  HomeFocusRequest,
  HomeFocusResponse,
  ProjectActivityRequest,
  ProjectActivityResponse,
  UpdateProjectActivityRequest,
  ProjectEditResponse,
  ProjectIndexPage,
  ProjectUpdateRequest,
  PublishResponse,
  ReleaseEditResponse,
  ReleaseIndexPage,
  ReleaseUpdateRequest,
  TopicEdit,
} from "../../contracts/management/contract.ts";
import type { ManagementGateway } from "../../application/ports/management-gateway.ts";
import { ManagementGatewayError } from "../../application/ports/management-gateway-error.ts";
import type { StudioOperationExecutor } from "./http-studio-gateway.ts";

export type { ManagementGateway };

const ROUTE_ID = "TECH_LOG_STUDIO";

/**
 * 주제·프로젝트 관리 게이트웨이.
 *
 * <p>Studio 게이트웨이와 같은 실패 규약을 쓴다 — 실패는 던지고, 화면은 `usePublicContent` 가 아니라
 * Studio 쪽 상태 처리를 그대로 쓴다. 여기서 Result 로 감싸면 이 표면만 다른 규약이 된다.
 */

export {
  ManagementGatewayError,
  managementFailureMessage,
} from "../../application/ports/management-gateway-error.ts";

export function createHttpManagementGateway(
  deps: Readonly<{ operations: StudioOperationExecutor }>,
): ManagementGateway {
  async function run<T>(operationId: string, input: unknown): Promise<T> {
    const outcome = await deps.operations.execute(operationId, input, { routeId: ROUTE_ID });
    if (outcome.kind === "SUCCESS") return outcome.value as T;
    if (outcome.kind === "PROBLEM") {
      // The management surface answers with the ADR-006 envelope, which nests
      // the code under `error` — reading `problem.code` found nothing and every
      // failure surfaced as the literal "PROBLEM", matching no i18n key.
      const body = outcome.problem as
        | Readonly<{
            code?: unknown;
            detail?: unknown;
            error?: Readonly<{ code?: unknown; message?: unknown }>;
          }>
        | null;
      const code =
        typeof body?.code === "string"
          ? body.code
          : typeof body?.error?.code === "string"
            ? body.error.code
            : "PROBLEM";
      const detail =
        typeof body?.error?.message === "string"
          ? body.error.message
          : typeof body?.detail === "string"
            ? body.detail
            : "";
      throw new ManagementGatewayError(operationId, code, detail);
    }
    throw new ManagementGatewayError(operationId, outcome.kind, "");
  }

  return Object.freeze({
    listTopics: () => run<TopicEdit[]>("listStudioTopics", {}),
    createTopic: (input: TopicEdit) => run<TopicEdit>("createTopic", input),
    updateTopic: (id: string, body: TopicEdit) => run<TopicEdit>("updateTopic", { id, body }),
    deleteTopic: async (id: string, expectedVersion: number) => {
      await run<void>("deleteTopic", { id, expectedVersion });
    },
    listProjects: (page?: number, size?: number) =>
      run<ProjectIndexPage>("listStudioProjects", { ...(page !== undefined ? { page } : {}), ...(size !== undefined ? { size } : {}) }),
    getProject: (id: string) => run<ProjectEditResponse>("getProjectForEdit", { id }),
    createProject: (title: string) => run<CreateDraftResponse>("createProject", { title }),
    updateProject: (id: string, body: ProjectUpdateRequest) =>
      run<ProjectEditResponse>("updateProject", { id, body }),
    listReleases: (page?: number, size?: number) =>
      run<ReleaseIndexPage>("listStudioReleases", { ...(page !== undefined ? { page } : {}), ...(size !== undefined ? { size } : {}) }),
    getRelease: (id: string) => run<ReleaseEditResponse>("getReleaseForEdit", { id }),
    createRelease: (title: string) => run<CreateDraftResponse>("createRelease", { title }),
    updateRelease: (id: string, body: ReleaseUpdateRequest) =>
      run<ReleaseEditResponse>("updateRelease", { id, body }),
    deleteRelease: async (id: string, expectedVersion: number) => {
      await run<void>("deleteRelease", { id, expectedVersion });
    },
    listProjectActivities: (id: string) =>
      run<ProjectActivityResponse[]>("listStudioProjectActivities", { id }),
    createProjectActivity: (id: string, body: ProjectActivityRequest) =>
      run<ProjectActivityResponse>("createProjectActivity", { id, body }),
    updateProjectActivity: (
      id: string,
      activityId: string,
      body: UpdateProjectActivityRequest,
    ) => run<ProjectActivityResponse>("updateProjectActivity", { id, activityId, body }),
    deleteProjectActivity: async (id: string, activityId: string, expectedVersion: number) => {
      await run<void>("deleteProjectActivity", { id, activityId, expectedVersion });
    },
    publishProject: (
      id: string,
      expectedVersion: number,
      visibility: "PUBLIC" | "UNLISTED" = "PUBLIC",
    ) => run<PublishResponse>("publishProject", { id, expectedVersion, visibility }),
    unpublishProject: (id: string, expectedVersion: number) =>
      run<ProjectEditResponse>("unpublishProject", { id, expectedVersion }),
    getHomeFocus: () => run<HomeFocusResponse>("getHomeFocus", {}),
    updateHomeFocus: (body: HomeFocusRequest) =>
      run<HomeFocusResponse>("updateHomeFocus", body),
    publishRelease: (id: string, expectedVersion: number) =>
      run<PublishResponse>("publishRelease", { id, expectedVersion }),
    archiveRelease: (id: string, expectedVersion: number) =>
      run<ReleaseEditResponse>("archiveRelease", { id, expectedVersion }),
    deleteDocument: async (
      kind: "CASE" | "REFERENCE" | "QUESTION",
      id: string,
      expectedVersion: number,
    ) => {
      const operationId =
        kind === "CASE"
          ? "deleteCaseDraft"
          : kind === "REFERENCE"
            ? "deleteReferenceDraft"
            : "deleteQuestion";
      await run<void>(operationId, { id, expectedVersion });
    },
    deleteDecision: async (projectId: string, decisionId: string, expectedVersion: number) => {
      await run<void>("deleteProjectDecision", { id: projectId, decisionId, expectedVersion });
    },
    deleteProject: async (id: string, expectedVersion: number) => {
      await run<void>("deleteProject", { id, expectedVersion });
    },
  });
}