// ---------------------------------------------------------------------------
// OpenAPI plugin — spec-in-blob storage coverage.
//
// The resolved spec text must live in the plugin blob store (content-addressed
// `spec/<sha256>`), NOT inline in `integration.config`: the catalog row rides
// along on every integrations list, so a multi-MB inline spec turns a
// metadata read into a bulk transfer. These tests pin:
//   - addSpec stores a pointer config (`specHash`, no inline `spec`) and the
//     blob round-trips through the store,
//   - the e2e path (addSpec → connection → invoke) works off the blob,
//   - legacy rows that still inline `spec` resolve tools unchanged,
//   - remove + re-add of the same spec is idempotent over the shared blob.
// ---------------------------------------------------------------------------

import { describe, expect, it } from "@effect/vitest";
import { Effect, Schema } from "effect";
import { FetchHttpClient, HttpServerRequest } from "effect/unstable/http";
import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";

import {
  createExecutor,
  AuthTemplateSlug,
  ConnectionName,
  IntegrationSlug,
  ToolAddress,
  sha256Hex,
  type IntegrationConfig,
} from "@executor-js/sdk";
import { makeTestConfig, memoryCredentialsPlugin } from "@executor-js/sdk/testing";
import { variable } from "@executor-js/sdk/http-auth";

import { openApiPlugin } from "./plugin";
import type { OpenapiStore } from "./store";
import type { AuthenticationInput } from "./types";
import { defsBlobKey, specBlobKey } from "./store";
import {
  makeOpenApiHttpApiTestIntegrationConfig,
  serveOpenApiHttpApiTestServer,
  unwrapInvocation,
} from "../testing";

const testPlugins = (httpClientLayer = FetchHttpClient.layer) =>
  [openApiPlugin({ httpClientLayer }), memoryCredentialsPlugin()] as const;

const EchoHeaders = Schema.Struct({
  "x-api-key": Schema.optional(Schema.String),
});

const EchoGroup = HttpApiGroup.make("items").add(
  HttpApiEndpoint.get("echoHeaders", "/echo-headers", { success: EchoHeaders }),
);
const TestApi = HttpApi.make("testApi").add(EchoGroup);

const EchoGroupLive = HttpApiBuilder.group(TestApi, "items", (handlers) =>
  handlers.handle("echoHeaders", () =>
    Effect.gen(function* () {
      const req = yield* HttpServerRequest.HttpServerRequest;
      return EchoHeaders.make({ "x-api-key": req.headers["x-api-key"] });
    }),
  ),
);

const specText = () => {
  const spec = makeOpenApiHttpApiTestIntegrationConfig(TestApi, {}).spec;
  if (spec.kind === "blob") return spec.value;
  return spec.url;
};

const specTextWithDefinition = () =>
  JSON.stringify({
    openapi: "3.1.0",
    info: { title: "Catalog", version: "1.0.0" },
    paths: {
      "/items": {
        get: {
          operationId: "listItems",
          responses: {
            "200": {
              description: "ok",
              content: {
                "application/json": {
                  schema: {
                    type: "array",
                    items: { $ref: "#/components/schemas/Item" },
                  },
                },
              },
            },
          },
        },
      },
    },
    components: {
      schemas: {
        Item: {
          type: "object",
          properties: { id: { type: "string" } },
          required: ["id"],
        },
      },
    },
  });

const apiKeyTemplate: AuthenticationInput = {
  slug: AuthTemplateSlug.make("apiKey"),
  type: "apiKey",
  headers: { "x-api-key": [variable("token")] },
};

const openApiBlobNamespace = "o:test-tenant/openapi";

describe("OpenAPI plugin — spec blob storage", () => {
  it.effect("addSpec stores a content pointer, not the inline spec text", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const executor = yield* createExecutor(makeTestConfig({ plugins: testPlugins() }));
        const text = specText();

        yield* executor.openapi.addSpec({
          spec: { kind: "blob", value: text },
          slug: "blob_api",
        });

        const config = yield* executor.openapi.getConfig("blob_api");
        expect(Object.keys(config ?? {})).not.toContain("spec");
        expect(config?.specHash).toBe(yield* sha256Hex(text));
      }),
    ),
  );

  it.effect("invokes a tool end-to-end off the blob-backed spec", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const server = yield* serveOpenApiHttpApiTestServer({
          api: TestApi,
          handlersLayer: EchoGroupLive,
        });
        const executor = yield* createExecutor(makeTestConfig({ plugins: testPlugins() }));

        yield* executor.openapi.addSpec({
          spec: { kind: "blob", value: server.specJson },
          slug: "blob_invoke",
          baseUrl: server.baseUrl,
          authenticationTemplate: [apiKeyTemplate],
        });
        yield* executor.connections.create({
          owner: "org",
          name: ConnectionName.make("main"),
          integration: IntegrationSlug.make("blob_invoke"),
          template: AuthTemplateSlug.make("apiKey"),
          value: "secret-key-123",
        });

        const result = unwrapInvocation(
          yield* executor.execute(
            ToolAddress.make("tools.blob_invoke.org.main.items.echoHeaders"),
            {},
          ),
        ).data as { "x-api-key"?: string };

        expect(result["x-api-key"]).toBe("secret-key-123");
      }),
    ),
  );

  it.effect(
    "stale sync preserves tools and definitions when the spec blob parses to a non-object",
    () =>
      Effect.scoped(
        Effect.gen(function* () {
          const config = makeTestConfig({ plugins: testPlugins() });
          const executor = yield* createExecutor(config);
          const text = specTextWithDefinition();
          const hash = yield* sha256Hex(text);

          yield* executor.openapi.addSpec({
            spec: { kind: "blob", value: text },
            slug: "corrupt_blob",
          });
          yield* executor.connections.create({
            owner: "org",
            name: ConnectionName.make("main"),
            integration: IntegrationSlug.make("corrupt_blob"),
            template: AuthTemplateSlug.make("none"),
            values: {},
          });

          const beforeTools = yield* executor.tools.list({
            integration: IntegrationSlug.make("corrupt_blob"),
          });
          const beforeDefinitions = yield* Effect.promise(() =>
            config.db.findMany("definition", {
              where: (b) => b("integration", "=", "corrupt_blob"),
            }),
          );
          expect(beforeTools.length).toBeGreaterThan(0);
          expect(beforeDefinitions.length).toBeGreaterThan(0);

          yield* Effect.promise(() =>
            config.db.updateMany("blob", {
              where: (b) =>
                b.and(b("namespace", "=", openApiBlobNamespace), b("key", "=", specBlobKey(hash))),
              set: { value: JSON.stringify("not an object") },
            }),
          );
          yield* Effect.promise(() =>
            config.db.deleteMany("blob", {
              where: (b) =>
                b.and(b("namespace", "=", openApiBlobNamespace), b("key", "=", defsBlobKey(hash))),
            }),
          );
          yield* Effect.promise(() =>
            config.db.updateMany("connection", {
              where: (b) => b.and(b("integration", "=", "corrupt_blob"), b("name", "=", "main")),
              set: { tools_synced_at: null },
            }),
          );

          const afterTools = yield* executor.tools.list({
            integration: IntegrationSlug.make("corrupt_blob"),
          });
          const afterDefinitions = yield* Effect.promise(() =>
            config.db.findMany("definition", {
              where: (b) => b("integration", "=", "corrupt_blob"),
            }),
          );
          const connection = yield* executor.connections.get({
            owner: "org",
            integration: IntegrationSlug.make("corrupt_blob"),
            name: ConnectionName.make("main"),
          });

          expect(afterTools.map((tool) => String(tool.name)).sort()).toEqual(
            beforeTools.map((tool) => String(tool.name)).sort(),
          );
          expect(afterDefinitions).toHaveLength(beforeDefinitions.length);
          expect(connection?.lastHealth).toMatchObject({
            status: "degraded",
            detail: expect.stringContaining("OpenAPI spec could not be parsed"),
          });
        }),
      ),
  );

  it.effect("stale sync preserves tools and definitions when the spec blob is missing", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const config = makeTestConfig({ plugins: testPlugins() });
        const executor = yield* createExecutor(config);
        const text = specTextWithDefinition();
        const hash = yield* sha256Hex(text);

        yield* executor.openapi.addSpec({
          spec: { kind: "blob", value: text },
          slug: "missing_blob",
        });
        yield* executor.connections.create({
          owner: "org",
          name: ConnectionName.make("main"),
          integration: IntegrationSlug.make("missing_blob"),
          template: AuthTemplateSlug.make("none"),
          values: {},
        });

        const beforeTools = yield* executor.tools.list({
          integration: IntegrationSlug.make("missing_blob"),
        });
        const beforeDefinitions = yield* Effect.promise(() =>
          config.db.findMany("definition", {
            where: (b) => b("integration", "=", "missing_blob"),
          }),
        );
        expect(beforeTools.length).toBeGreaterThan(0);
        expect(beforeDefinitions.length).toBeGreaterThan(0);

        yield* Effect.promise(() =>
          config.db.deleteMany("blob", {
            where: (b) =>
              b.and(
                b("namespace", "=", openApiBlobNamespace),
                b("key", "in", [specBlobKey(hash), defsBlobKey(hash)]),
              ),
          }),
        );
        yield* Effect.promise(() =>
          config.db.updateMany("connection", {
            where: (b) => b.and(b("integration", "=", "missing_blob"), b("name", "=", "main")),
            set: { tools_synced_at: null },
          }),
        );

        const afterTools = yield* executor.tools.list({
          integration: IntegrationSlug.make("missing_blob"),
        });
        const afterDefinitions = yield* Effect.promise(() =>
          config.db.findMany("definition", {
            where: (b) => b("integration", "=", "missing_blob"),
          }),
        );
        const connection = yield* executor.connections.get({
          owner: "org",
          integration: IntegrationSlug.make("missing_blob"),
          name: ConnectionName.make("main"),
        });

        expect(afterTools.map((tool) => String(tool.name)).sort()).toEqual(
          beforeTools.map((tool) => String(tool.name)).sort(),
        );
        expect(afterDefinitions).toHaveLength(beforeDefinitions.length);
        expect(connection?.lastHealth).toMatchObject({
          status: "degraded",
          detail: expect.stringContaining("OpenAPI spec blob could not be loaded"),
        });
      }),
    ),
  );

  it.effect("explicit spec refresh accepts a valid OpenAPI document with zero operations", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const executor = yield* createExecutor(makeTestConfig({ plugins: testPlugins() }));
        const emptySpec = JSON.stringify({
          openapi: "3.1.0",
          info: { title: "Empty", version: "1.0.0" },
          paths: {},
        });

        yield* executor.openapi.addSpec({
          spec: { kind: "blob", value: specText() },
          slug: "healthy_zero",
        });
        yield* executor.connections.create({
          owner: "org",
          name: ConnectionName.make("main"),
          integration: IntegrationSlug.make("healthy_zero"),
          template: AuthTemplateSlug.make("none"),
          values: {},
        });
        expect(
          (yield* executor.tools.list({ integration: IntegrationSlug.make("healthy_zero") }))
            .length,
        ).toBeGreaterThan(0);

        const update = yield* executor.openapi.updateSpec("healthy_zero", {
          spec: { kind: "blob", value: emptySpec },
        });
        const tools = yield* executor.tools.list({
          integration: IntegrationSlug.make("healthy_zero"),
        });

        expect(update.toolCount).toBe(0);
        expect(tools).toEqual([]);
      }),
    ),
  );

  it.effect("resolveTools reads the spec from the store, never an inline field", () =>
    Effect.gen(function* () {
      const plugin = openApiPlugin({ httpClientLayer: FetchHttpClient.layer });
      const text = specText();
      const hash = yield* sha256Hex(text);
      const storage: OpenapiStore = {
        putOperations: () => Effect.void,
        appendOperations: () => Effect.void,
        getOperation: () => Effect.succeed(null),
        listOperations: () => Effect.succeed([]),
        removeOperations: () => Effect.void,
        putSpec: () => Effect.void,
        getSpec: (specHash) => Effect.succeed(specHash === hash ? text : null),
        putDefs: () => Effect.void,
        getDefs: () => Effect.succeed(null),
      };

      const resolve = (config: IntegrationConfig) =>
        plugin.resolveTools!({
          integration: {
            slug: IntegrationSlug.make("pointer_api"),
            name: "pointer",
            description: "pointer",
            kind: "openapi",
            canRemove: true,
            canRefresh: false,
            authMethods: [],
          },
          config,
          connection: {
            owner: "org",
            integration: IntegrationSlug.make("pointer_api"),
            name: ConnectionName.make("main"),
          },
          template: null,
          storage,
          httpClientLayer: FetchHttpClient.layer,
          getValue: () => Effect.succeed(null),
          getValues: () => Effect.succeed({}),
        });

      const fromPointer = yield* resolve({ specHash: hash } as IntegrationConfig);
      expect(fromPointer.tools.map((tool) => String(tool.name))).toContain("items.echoHeaders");

      // A pre-migration row that still inlines `spec` yields no tools: the
      // spec-to-blob migrations rewrite those rows before this code runs, so
      // the runtime carries no inline-read path.
      const fromInline = yield* resolve({ spec: text } as IntegrationConfig);
      expect(fromInline.tools).toHaveLength(0);
    }),
  );

  it.effect("remove + re-add of the same spec is idempotent over the shared blob", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const executor = yield* createExecutor(makeTestConfig({ plugins: testPlugins() }));
        const text = specText();

        yield* executor.openapi.addSpec({ spec: { kind: "blob", value: text }, slug: "re_add" });
        yield* executor.openapi.removeSpec("re_add");
        // The blob deliberately survives removal (another integration may share
        // the hash); re-adding must re-point at it without conflict.
        const second = yield* executor.openapi.addSpec({
          spec: { kind: "blob", value: text },
          slug: "re_add",
        });

        expect(second.toolCount).toBeGreaterThan(0);
        const config = yield* executor.openapi.getConfig("re_add");
        expect(config?.specHash).toBe(yield* sha256Hex(text));
      }),
    ),
  );
});