import { describe, expect, it } from "@effect/vitest";
import { Option } from "effect";

import { decodeOpenApiSpecOverrides } from "../sdk/spec-overrides";
import { Exit } from "effect";

import {
  composeQuickAddAuth,
  performQuickAdd,
  quickAddRequestPayloads,
  quickAddSpecPlan,
  type QuickAddDeps,
} from "./integration-plugin";

// The quick add's composition is where review found bugs twice: first it
// suppressed spec-declared methods, then it derived auth from the unmodified
// document while adding the overridden one. These pin the contract.

const scopeOverride = decodeOpenApiSpecOverrides([
  {
    op: "replace",
    path: "/components/securitySchemes/OAuth2/flows/authorizationCode/scopes",
    value: { "files:read": "" },
  },
])!;

describe("quickAddSpecPlan", () => {
  it("uses the same effective overrides for preview and add, preset first", () => {
    const registryOverrides = decodeOpenApiSpecOverrides([
      { op: "remove", path: "/components/securitySchemes/Cookie" },
    ]);
    const plan = quickAddSpecPlan(
      {
        id: "figma",
        name: "Figma",
        summary: "",
        specFormat: "plain-ish",
        specOverrides: [...scopeOverride],
      },
      registryOverrides,
    );
    // Preset overrides win over the registry's, mirroring the full add page.
    expect(plan.specOverrides).toEqual(scopeOverride);
    expect(plan.specFormat).toBe("plain-ish");
  });

  it("an explicitly EMPTY preset override list suppresses the registry's", () => {
    // Presence-based, like the full page's `presetOverrides ?? registry`:
    // an empty list is a decision, not an absence.
    const registryOverrides = decodeOpenApiSpecOverrides([
      { op: "remove", path: "/components/securitySchemes/Cookie" },
    ]);
    const plan = quickAddSpecPlan(
      { id: "custom", name: "Custom", summary: "", specOverrides: [] },
      registryOverrides,
    );
    expect(plan.specOverrides).toBeUndefined();
  });

  it("falls through to registry overrides when the preset has none", () => {
    const registryOverrides = decodeOpenApiSpecOverrides([
      { op: "remove", path: "/components/securitySchemes/Cookie" },
    ]);
    const plan = quickAddSpecPlan(undefined, registryOverrides);
    expect(plan.specOverrides).toEqual(registryOverrides);
    expect(plan.specFormat).toBeUndefined();
  });
});

describe("composeQuickAddAuth", () => {
  const registryPlacement = {
    carrier: "header",
    name: "Authorization",
    prefix: "Bearer ",
  } as const;

  it("keeps override-derived OAuth scopes and appends the registry key", () => {
    // The preview reflects the OVERRIDDEN document (quickAddSpecPlan sends
    // the same overrides to preview): its oauth preset carries the replaced
    // scopes. The composed template must retain them verbatim and add the
    // registry header only because no key method was detected.
    const template = composeQuickAddAuth([], registryPlacement, {
      headerPresets: [],
      oauth2Presets: [
        {
          label: "OAuth2",
          securitySchemeName: "OAuth2",
          flow: "authorizationCode" as const,
          authorizationUrl: Option.some("https://example.com/authorize"),
          tokenUrl: "https://example.com/token",
          resource: Option.none(),
          refreshUrl: Option.none(),
          // The overridden document's scopes — the whole point: the preview
          // reflects the SAME effective spec the add stores.
          scopes: { "files:read": "" },
          identityScopes: [] as const,
        },
      ],
      servers: [{ url: "https://api.example.com" }],
    });
    expect(template).toHaveLength(2);
    const oauth = template.find((method) => "kind" in method && method.kind === "oauth2");
    expect(oauth && "scopes" in oauth ? oauth.scopes : undefined).toEqual(["files:read"]);
    const key = template.find((method) => !("kind" in method) || method.kind !== "oauth2");
    expect(JSON.stringify(key)).toContain("Authorization");
  });

  it("does not append the registry key when the spec already declares one", () => {
    const template = composeQuickAddAuth([], registryPlacement, {
      headerPresets: [
        {
          label: "API key",
          headers: { "X-API-Key": null },
          secretHeaders: ["X-API-Key"],
          secretQueryParams: [],
        },
      ],
      oauth2Presets: [],
      servers: [{ url: "https://api.example.com" }],
    });
    expect(template).toHaveLength(1);
    expect(JSON.stringify(template[0])).toContain("X-API-Key");
  });
});

describe("quickAddRequestPayloads", () => {
  it("the preview and the add carry the identical spec plan", () => {
    // The regression contract itself: reverting either call site to a bare
    // payload makes these fields diverge and this test fail.
    const plan = quickAddSpecPlan(
      {
        id: "figma",
        name: "Figma",
        summary: "",
        specFormat: "fmt",
        specOverrides: [...scopeOverride],
      },
      undefined,
    );
    const requests = quickAddRequestPayloads(
      { url: "https://example.com/spec.yaml", name: "Figma API", domain: "figma.com" },
      "figma_api",
      plan,
    );
    expect(requests.preview.specFormat).toBe("fmt");
    expect(requests.preview.specOverrides).toEqual(scopeOverride);
    expect(requests.add.specFormat).toBe(requests.preview.specFormat);
    expect(requests.add.specOverrides).toEqual(requests.preview.specOverrides);
    expect(requests.add.displayDomain).toBe("figma.com");
    expect(requests.add.spec).toEqual({ kind: "url", url: "https://example.com/spec.yaml" });
  });
});

describe("performQuickAdd", () => {
  // The OPERATION under test, with the two mutations captured — the guard
  // the review demanded twice: helper tests kept passing while a call site
  // could quietly stop using the shared plan.
  it("sends the identical spec plan to preview and add, and composed auth", async () => {
    const previews: unknown[] = [];
    const adds: unknown[] = [];
    const deps: QuickAddDeps = {
      presets: [
        {
          id: "figma",
          name: "Figma",
          summary: "",
          url: "https://example.com/spec.yaml",
          specFormat: "fmt",
          specOverrides: [...scopeOverride],
        },
      ],
      preview: (payload) => {
        previews.push(payload);
        return Promise.resolve(
          Exit.succeed({
            headerPresets: [],
            oauth2Presets: [
              {
                label: "OAuth2",
                securitySchemeName: "OAuth2",
                flow: "authorizationCode" as const,
                authorizationUrl: Option.some("https://example.com/authorize"),
                tokenUrl: "https://example.com/token",
                resource: Option.none(),
                refreshUrl: Option.none(),
                scopes: { "files:read": "" },
                identityScopes: [] as const,
              },
            ],
            servers: [{ url: "https://api.example.com" }],
          }),
        );
      },
      add: (payload) => {
        adds.push(payload);
        return Promise.resolve(Exit.succeed({ slug: "figma_api" }));
      },
    };
    const result = await performQuickAdd(deps, {
      url: "https://example.com/spec.yaml",
      name: "Figma API",
      slug: "figma-api",
      domain: "figma.com",
      authHeader: "Authorization: Bearer {token}",
    });
    expect(result).toEqual({ ok: true, slug: "figma_api" });
    expect(previews).toHaveLength(1);
    expect(adds).toHaveLength(1);
    const preview = previews[0] as Record<string, unknown>;
    const add = adds[0] as Record<string, unknown>;
    // The regression contract: BOTH real payloads carry the one spec plan.
    expect(preview.specFormat).toBe("fmt");
    expect(preview.specOverrides).toEqual(scopeOverride);
    expect(add.specFormat).toBe(preview.specFormat);
    expect(add.specOverrides).toEqual(preview.specOverrides);
    expect(add.slug).toBe("figma_api");
    expect(add.displayDomain).toBe("figma.com");
    // Auth derived from the overridden document, registry key appended.
    const template = add.authenticationTemplate as readonly unknown[];
    expect(JSON.stringify(template)).toContain("files:read");
    expect(JSON.stringify(template)).toContain("Authorization");
  });

  it("skips the preview entirely when the registry declared no header", async () => {
    const previews: unknown[] = [];
    const deps: QuickAddDeps = {
      presets: [],
      preview: (payload) => {
        previews.push(payload);
        return Promise.resolve(Exit.fail("unexpected"));
      },
      add: () => Promise.resolve(Exit.succeed({ slug: "plain" })),
    };
    const result = await performQuickAdd(deps, {
      url: "https://example.com/openapi.json",
      name: "Plain API",
    });
    expect(result).toEqual({ ok: true, slug: "plain" });
    expect(previews).toHaveLength(0);
  });
});