import { Effect, Option } from "effect";
import { FetchHttpClient, HttpClient } from "@effect/platform";
import type { Layer } from "effect";

import {
  definePlugin,
  type ExecutorPlugin,
  type PluginContext,
  ToolId,
  type ToolRegistration,
} from "@executor/sdk";

import { parse } from "./parse";
import { extract } from "./extract";
import { makeOpenApiInvoker } from "./invoke";
import { resolveBaseUrl } from "./openapi-utils";
import {
  makeInMemoryOperationStore,
  type OpenApiOperationStore,
} from "./operation-store";
import { previewSpec, type SpecPreview } from "./preview";
import {
  type ExtractedOperation,
  InvocationConfig,
  OperationBinding,
} from "./types";

// ---------------------------------------------------------------------------
// Plugin config
// ---------------------------------------------------------------------------

/** A header value — either a static string or a reference to a secret */
export type HeaderValue = string | { readonly secretId: string; readonly prefix?: string };

export interface OpenApiSpecConfig {
  readonly spec: string;
  readonly baseUrl?: string;
  readonly namespace?: string;
  /** Headers applied to every request. Values can reference secrets. */
  readonly headers?: Record<string, HeaderValue>;
}

// ---------------------------------------------------------------------------
// Plugin extension
// ---------------------------------------------------------------------------

export interface OpenApiPluginExtension {
  /** Preview a spec without registering — returns metadata, auth strategies, header presets */
  readonly previewSpec: (
    specText: string,
  ) => Effect.Effect<SpecPreview, Error>;

  /** Add an OpenAPI spec and register its operations as tools */
  readonly addSpec: (
    config: OpenApiSpecConfig,
  ) => Effect.Effect<{ readonly toolCount: number }, Error>;

  /** Remove all tools from a previously added spec by namespace */
  readonly removeSpec: (namespace: string) => Effect.Effect<void>;
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

const operationDescription = (op: ExtractedOperation): string =>
  Option.getOrElse(op.description, () =>
    Option.getOrElse(op.summary, () =>
      `${op.method.toUpperCase()} ${op.pathTemplate}`,
    ),
  );

const toRegistration = (
  op: ExtractedOperation,
  namespace: string,
): ToolRegistration => ({
  id: ToolId.make(`${namespace}.${op.operationId}`),
  pluginKey: "openapi",
  name: op.operationId as string,
  description: operationDescription(op),
  tags: [...op.tags, "openapi", namespace],
  inputSchema: Option.getOrUndefined(op.inputSchema),
  outputSchema: Option.getOrUndefined(op.outputSchema),
});

const toBinding = (op: ExtractedOperation): OperationBinding =>
  new OperationBinding({
    method: op.method,
    pathTemplate: op.pathTemplate,
    parameters: [...op.parameters],
    requestBody: op.requestBody,
  });

// ---------------------------------------------------------------------------
// Plugin factory
// ---------------------------------------------------------------------------

export const openApiPlugin = (options?: {
  readonly httpClientLayer?: Layer.Layer<HttpClient.HttpClient>;
  readonly operationStore?: OpenApiOperationStore;
}): ExecutorPlugin<"openapi", OpenApiPluginExtension> => {
  const httpClientLayer = options?.httpClientLayer ?? FetchHttpClient.layer;
  const operationStore = options?.operationStore ?? makeInMemoryOperationStore();

  return definePlugin({
    key: "openapi",
    init: (ctx: PluginContext) =>
      Effect.gen(function* () {
        yield* ctx.tools.registerInvoker(
          "openapi",
          makeOpenApiInvoker({
            operationStore,
            httpClientLayer,
            secrets: ctx.secrets,
            scopeId: ctx.scope.id,
          }),
        );

        return {
          extension: {
            previewSpec: (specText: string) => previewSpec(specText),

            addSpec: (config: OpenApiSpecConfig) =>
              Effect.gen(function* () {
                const doc = yield* parse(config.spec);
                const result = yield* extract(doc);

                const namespace =
                  config.namespace ??
                  Option.getOrElse(result.title, () => "api")
                    .toLowerCase()
                    .replace(/[^a-z0-9]+/g, "_");

                if (doc.components?.schemas) {
                  yield* ctx.tools.registerDefinitions(doc.components.schemas);
                }

                const baseUrl = config.baseUrl ?? resolveBaseUrl(result.servers);
                const invocationConfig = new InvocationConfig({
                  baseUrl,
                  headers: config.headers ?? {},
                });

                const registrations = result.operations.map((op) =>
                  toRegistration(op, namespace),
                );

                yield* Effect.forEach(
                  result.operations,
                  (op) =>
                    operationStore.put(
                      ToolId.make(`${namespace}.${op.operationId}`),
                      namespace,
                      toBinding(op),
                      invocationConfig,
                    ),
                  { discard: true },
                );

                yield* ctx.tools.register(registrations);
                return { toolCount: registrations.length };
              }),

            removeSpec: (namespace: string) =>
              Effect.gen(function* () {
                const toolIds = yield* operationStore.removeByNamespace(namespace);
                if (toolIds.length > 0) {
                  yield* ctx.tools.unregister(toolIds);
                }
              }),
          },

          close: () =>
            Effect.gen(function* () {
              const allTools = yield* ctx.tools.list({ tags: ["openapi"] });
              if (allTools.length > 0) {
                yield* ctx.tools.unregister(allTools.map((t) => t.id));
              }
            }),
        };
      }),
  });
};