import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";

import { createDiscoveryPrimitivesFromToolCatalog } from "./discovery";
import { toTool } from "./tool-map";
import {
  ToolDescriptorSchema,
  ToolNamespaceSchema,
  type ToolCatalog,
  type ToolMap,
  type ToolPath,
} from "./types";

const asToolPath = (value: string): ToolPath => value as ToolPath;

const catalogNamespacesInputSchema = Schema.standardSchemaV1(
  Schema.Struct({
    limit: Schema.optional(Schema.Number),
  }),
);

const catalogNamespacesOutputSchema = Schema.standardSchemaV1(
  Schema.Struct({
    namespaces: Schema.Array(ToolNamespaceSchema),
  }),
);

const catalogToolsInputSchema = Schema.standardSchemaV1(
  Schema.Struct({
    namespace: Schema.optional(Schema.String),
    query: Schema.optional(Schema.String),
    limit: Schema.optional(Schema.Number),
    includeSchemas: Schema.optional(Schema.Boolean),
  }),
);

const catalogToolsOutputSchema = Schema.standardSchemaV1(
  Schema.Struct({
    results: Schema.Array(ToolDescriptorSchema),
  }),
);

const describeToolInputSchema = Schema.standardSchemaV1(
  Schema.Struct({
    path: Schema.String,
    includeSchemas: Schema.optional(Schema.Boolean),
  }),
);

const describeToolOutputSchema = Schema.standardSchemaV1(
  Schema.NullOr(ToolDescriptorSchema),
);

const discoverInputSchema = Schema.standardSchemaV1(
  Schema.Struct({
    query: Schema.String,
    limit: Schema.optional(Schema.Number),
    includeSchemas: Schema.optional(Schema.Boolean),
  }),
);

const discoverResultItemSchema = Schema.extend(
  ToolDescriptorSchema,
  Schema.Struct({
    score: Schema.Number,
  }),
);

const discoverOutputSchema = Schema.standardSchemaV1(
  Schema.Struct({
    bestPath: Schema.NullOr(Schema.String),
    results: Schema.Array(discoverResultItemSchema),
    total: Schema.Number,
  }),
);

export type CreateSystemToolMapInput = {
  catalog?: ToolCatalog;
  getCatalog?: () => ToolCatalog;
  sourceKey?: string;
};

export const createSystemToolMap = (
  input: CreateSystemToolMapInput,
): ToolMap => {
  const sourceKey = input.sourceKey ?? "system";
  const getCatalog = (): ToolCatalog => {
    if (input.catalog) {
      return input.catalog;
    }
    if (input.getCatalog) {
      return input.getCatalog();
    }

    throw new Error("createSystemToolMap requires a catalog or getCatalog");
  };
  const getPrimitives = () =>
    createDiscoveryPrimitivesFromToolCatalog({
      catalog: getCatalog(),
    }) as Required<ReturnType<typeof createDiscoveryPrimitivesFromToolCatalog>>;

  const tools: ToolMap = {};

  tools["catalog.namespaces"] = toTool({
    tool: {
      description: "List available namespaces with display names and tool counts",
      inputSchema: catalogNamespacesInputSchema,
      outputSchema: catalogNamespacesOutputSchema,
      execute: ({ limit }: { limit?: number }) =>
        Effect.runPromise(
          getPrimitives().catalog.namespaces((limit !== undefined ? { limit } : {})),
        ),
    },
    metadata: {
      sourceKey,
      interaction: "auto",
    },
  });

  tools["catalog.tools"] = toTool({
    tool: {
      description: "List tools with optional namespace and query filters",
      inputSchema: catalogToolsInputSchema,
      outputSchema: catalogToolsOutputSchema,
      execute: (
        toolInput: {
          namespace?: string;
          query?: string;
          limit?: number;
          includeSchemas?: boolean;
        },
      ) =>
        Effect.runPromise(
          getPrimitives().catalog.tools({
            ...(toolInput.namespace !== undefined
              ? { namespace: toolInput.namespace }
              : {}),
            ...(toolInput.query !== undefined ? { query: toolInput.query } : {}),
            ...(toolInput.limit !== undefined ? { limit: toolInput.limit } : {}),
            ...(toolInput.includeSchemas !== undefined
              ? { includeSchemas: toolInput.includeSchemas }
              : {}),
          }),
        ),
    },
    metadata: {
      sourceKey,
      interaction: "auto",
    },
  });

  tools["describe.tool"] = toTool({
    tool: {
      description: "Get metadata and optional schemas for a tool path",
      inputSchema: describeToolInputSchema,
      outputSchema: describeToolOutputSchema,
      execute: ({ path, includeSchemas }: { path: string; includeSchemas?: boolean }) =>
        Effect.runPromise(
          getPrimitives().describe.tool({
            path: asToolPath(path),
            ...(includeSchemas !== undefined ? { includeSchemas } : {}),
          }),
        ),
    },
    metadata: {
      sourceKey,
      interaction: "auto",
    },
  });

  tools.discover = toTool({
    tool: {
      description: "Search tools by intent and return ranked matches",
      inputSchema: discoverInputSchema,
      outputSchema: discoverOutputSchema,
      execute: (
        toolInput: {
          query: string;
          limit?: number;
          includeSchemas?: boolean;
        },
      ) =>
        Effect.runPromise(
          getPrimitives().discover({
            query: toolInput.query,
            ...(toolInput.limit !== undefined ? { limit: toolInput.limit } : {}),
            ...(toolInput.includeSchemas !== undefined
              ? { includeSchemas: toolInput.includeSchemas }
              : {}),
          }),
        ),
    },
    metadata: {
      sourceKey,
      interaction: "auto",
    },
  });

  return tools;
};

export type MergeToolMapsOptions = {
  conflictMode?: "throw" | "override";
};

export const mergeToolMaps = (
  maps: ReadonlyArray<ToolMap>,
  options: MergeToolMapsOptions = {},
): ToolMap => {
  const conflictMode = options.conflictMode ?? "throw";
  const merged: ToolMap = {};

  for (const map of maps) {
    for (const [path, tool] of Object.entries(map)) {
      if (conflictMode === "throw" && path in merged) {
        throw new Error(`Tool path conflict: ${path}`);
      }
      merged[path] = tool;
    }
  }

  return merged;
};