import { createHttpCapabilities } from "../capabilities/http-client";
import type { ColineActorRef } from "../capabilities/types";
import type { ColineAppV2, ColineToolContext } from "../define/types";
import { validateChatCardTree } from "../tree/chat-card";
import {
  ColineProtocolError,
  parseSignedProtocolRequest,
} from "./protocol";
import {
  TOOL_INVOKE_KIND,
  toolInvokePayloadSchema,
  type ToolInvokeResponse,
} from "./tool-invoke";

/**
 * The external app server handler (plan §10.3): mount at the route Coline
 * delivers tool invocations to (conventionally `POST {baseUrl}/coline/tools`).
 *
 * ```ts
 * // app/coline/tools/route.ts (Next.js) — or any fetch-shaped server
 * import app from "../../../app.config";
 * import { createColineToolHandler } from "@colineapp/sdk/v2";
 *
 * export const POST = createColineToolHandler({
 *   app,
 *   secret: process.env.COLINE_DELIVERY_SECRET!,
 * });
 * ```
 *
 * The handler verifies the protocol-2 signature, dispatches to the tool's
 * `execute` with a `coline` capability client bound to this invocation, and
 * returns the wire-shaped result. Effect ceilings are enforced by Coline's
 * capability endpoint — a lying tool fails at the capability call, not here.
 */

function json(body: ToolInvokeResponse, status: number): Response {
  return new Response(JSON.stringify(body), {
    status,
    headers: { "content-type": "application/json" },
  });
}

export function createColineToolHandler(params: {
  app: ColineAppV2;
  secret: string;
}): (request: Request) => Promise<Response> {
  return async (request) => {
    let envelope;
    let payload;
    try {
      const parsed = await parseSignedProtocolRequest({
        request,
        secret: params.secret,
        payloadSchema: toolInvokePayloadSchema,
      });
      envelope = parsed.envelope;
      payload = parsed.payload;
    } catch (error) {
      if (error instanceof ColineProtocolError) {
        return json({ error: { code: error.code, message: error.message } }, 401);
      }
      throw error;
    }

    if (envelope.kind !== TOOL_INVOKE_KIND) {
      return json(
        {
          error: {
            code: "unsupported_kind",
            message: `This endpoint handles "${TOOL_INVOKE_KIND}" requests; received "${envelope.kind}".`,
          },
        },
        400,
      );
    }

    const tool = params.app.runtime.tools.get(payload.tool);
    if (!tool) {
      return json(
        {
          error: {
            code: "unknown_tool",
            message: `App "${params.app.manifest.key}" does not define a tool named "${payload.tool}".`,
          },
        },
        404,
      );
    }

    const input = tool.input.safeParse(payload.input);
    if (!input.success) {
      return json(
        {
          error: {
            code: "invalid_input",
            message: `Tool input is invalid: ${input.error.issues
              .map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`)
              .join("; ")}`,
          },
        },
        400,
      );
    }

    const actor: ColineActorRef =
      envelope.actor.kind === "user"
        ? { kind: "user", userId: envelope.actor.userId }
        : { kind: "app" };

    const context: ColineToolContext = {
      coline: createHttpCapabilities(payload.capabilities),
      workspace: {
        workspaceId: envelope.workspace.workspaceId,
        workspaceSlug: envelope.workspace.workspaceSlug,
        workspaceName: envelope.workspace.workspaceSlug,
      },
      actor,
      app: {
        appKey: envelope.app.appKey,
        installId: envelope.app.installId,
      },
    };

    try {
      const result = await tool.execute(input.data as never, context);
      if (result.card) {
        const validation = validateChatCardTree(result.card);
        if (!validation.ok) {
          return json(
            {
              error: {
                code: "invalid_card",
                message: `Tool result card rejected: ${validation.reason}`,
              },
            },
            400,
          );
        }
      }
      return json(
        {
          result: {
            ...(result.output !== undefined ? { output: result.output } : {}),
            ...(result.card ? { card: result.card } : {}),
          },
        },
        200,
      );
    } catch (error) {
      return json(
        {
          error: {
            code: "tool_execution_failed",
            message: error instanceof Error ? error.message : String(error),
          },
        },
        500,
      );
    }
  };
}