import { describe, expect, it, vi } from "vitest";

import { createFailure } from "../../../src/contracts/errors.ts";
import {
  createReferenceHttpGateway,
  type RawReferenceHttpExecutor,
} from "../../../src/features/reference-feature/adapters/reference-http-gateway.ts";
import type { ReferenceResource } from "../../../src/features/reference-feature/domain/reference-resource.ts";

const resources = Object.freeze({
  first: Object.freeze({
    id: "reference-1",
    displayName: "First",
    createdAt: null,
  }),
  created: Object.freeze({
    id: "reference-2",
    displayName: "Created",
    createdAt: "2026-07-26T00:00:00.000Z",
  }),
}) satisfies Readonly<Record<string, ReferenceResource>>;

describe("reference HTTP operation gateway", () => {
  it("builds the exact registered request for every gateway operation", async () => {
    const execute = vi
      .fn<RawReferenceHttpExecutor["execute"]>()
      .mockResolvedValueOnce({ ok: true, value: [resources.first] })
      .mockResolvedValueOnce({ ok: true, value: resources.created })
      .mockResolvedValueOnce({ ok: true, value: resources.first });
    const gateway = createReferenceHttpGateway({ execute });
    const signal = new AbortController().signal;

    await expect(
      gateway.list({ cursor: "next", limit: 20, tags: ["active"] }, { signal }),
    ).resolves.toEqual({ ok: true, value: [resources.first] });
    await expect(
      gateway.create({ name: "Created", note: "safe note" }),
    ).resolves.toEqual({ ok: true, value: resources.created });
    await expect(
      gateway.get("reference-1", { signal }),
    ).resolves.toEqual({ ok: true, value: resources.first });

    expect(execute.mock.calls).toEqual([
      [
        {
          operationId: "LIST_REFERENCE_RESOURCES",
          routeId: "REFERENCE_RESOURCE_LIST",
          searchParams: {
            cursor: "next",
            limit: 20,
            tags: ["active"],
          },
          signal,
        },
      ],
      [
        {
          operationId: "CREATE_REFERENCE_RESOURCE",
          routeId: "REFERENCE_RESOURCE_LIST",
          body: { name: "Created", note: "safe note" },
        },
      ],
      [
        {
          operationId: "GET_REFERENCE_RESOURCE",
          routeId: "REFERENCE_RESOURCE_DETAIL",
          pathParams: { resourceId: "reference-1" },
          signal,
        },
      ],
    ]);
  });

  it("preserves a validated raw failure without casting it into success", async () => {
    const failure = createFailure(
      "SCHEMA_MISMATCH",
      "GET_REFERENCE_RESOURCE",
      0,
    );
    const execute = vi
      .fn<RawReferenceHttpExecutor["execute"]>()
      .mockResolvedValue({ ok: false, error: failure });
    const gateway = createReferenceHttpGateway({ execute });

    await expect(gateway.get("invalid")).resolves.toEqual({
      ok: false,
      error: failure,
    });
  });

  it("fails closed when a raw success does not match its operation result", async () => {
    const execute = vi
      .fn<RawReferenceHttpExecutor["execute"]>()
      .mockResolvedValue({ ok: true, value: { id: "not-a-list" } });
    const gateway = createReferenceHttpGateway({ execute });

    await expect(gateway.list({ limit: 20 })).resolves.toMatchObject({
      ok: false,
      error: {
        kind: "MAPPING_CONTRACT_VIOLATION",
        code: "BOUND_RESULT_TYPE_MISMATCH",
        operationId: "LIST_REFERENCE_RESOURCES",
      },
    });
  });
});