import { Hono } from "hono";
import type { Context } from "hono";
import { createMiddleware } from "hono/factory";
import type { ZodType } from "zod";
import { logError } from "@/lib/logger";
import { safeEqual } from "@/middlewares/apiKeyAuth";
import { rateLimit } from "@/middlewares/rate-limit";
import {
  ToolAvailabilitySchema,
  ToolByBookingSchema,
  ToolByMembershipSchema,
  ToolConversationOnlySchema,
  ToolExternalBookingSchema,
  ToolLookupMemberSchema,
  ToolProposeActionSchema,
  ToolSubmissionLogSchema,
  ToolUpdateTicketSchema,
} from "@/internal/guru/guru.schema";
import { proposeAction } from "@/internal/guru/guru-actions.service";
import {
  getAvailability,
  getBooking,
  getBookings,
  getEntitlements,
  getExternalBookingStatus,
  getMemberOverview,
  getTicketHistory,
  getPoints,
  getSubmissionLog,
  lookupMember,
  ticketForConversation,
  updateTicket,
  type ToolResult,
} from "@/internal/guru/guru-tools.service";

/**
 * Public (non-console-session) Subito AI Guru endpoints, mounted at /v1/guru.
 * Called by ElevenLabs server tools, never by the browser.
 *
 * Auth layers:
 *  1. X-Guru-Secret shared-secret header (timing-safe), set by ElevenLabs
 *     from a workspace secret — proves the call comes from our agent.
 *  2. conversation_id, bound to system__conversation_id in the tool schema
 *     (the LLM cannot write it), must map to a ticket a concierge opened in
 *     the Console — proves the call belongs to a real, owned session.
 *
 * These are READ/diagnosis tools plus ticket annotation. Member-data writes
 * never happen here: the agent can only propose actions that an allowlisted
 * console user explicitly confirms through the session-authenticated
 * console API (docs/subito-ai-guru.md §2).
 *
 * Excluded from the activity-log middleware: payloads carry member issue
 * text. Responses are read by the agent — small, plain JSON, no console
 * {success,data} envelope.
 */
export const GuruPublicRoutes = new Hono();

const guruToolAuth = () =>
  createMiddleware(async (c, next) => {
    const secret = process.env.GURU_TOOL_SHARED_SECRET;
    if (!secret) {
      logError("[Guru] GURU_TOOL_SHARED_SECRET is not set");
      return c.text("Server configuration error", 500);
    }
    const provided = c.req.header("x-guru-secret");
    if (!provided || !safeEqual(provided.trim(), secret)) {
      return c.text("Unauthorized", 401);
    }
    await next();
  });

GuruPublicRoutes.use("/tools/*", guruToolAuth(), rateLimit("guru", 120, 60));

/**
 * Shared tool plumbing: parse JSON → validate with the tool's schema →
 * resolve the conversation's ticket → run → map failures to agent-readable
 * JSON. A tool timeout guards slow upstreams (Viewpoint, member DB).
 */
const TOOL_TIMEOUT_MS = 15_000;

const tool = <S extends ZodType<{ conversation_id: string }>>(
  schema: S,
  run: (
    c: Context,
    input: S["_output"],
    ticket: NonNullable<Awaited<ReturnType<typeof ticketForConversation>>>,
  ) => Promise<ToolResult> | ToolResult,
) =>
  async (c: Context) => {
    let body: unknown;
    try {
      body = await c.req.json();
    } catch {
      return c.json({ status: "error", message: "Invalid JSON body" }, 400);
    }
    const parsed = schema.safeParse(body);
    if (!parsed.success) {
      return c.json(
        {
          status: "error",
          message: parsed.error.issues
            .map((i) => `${i.path.join(".")}: ${i.message}`)
            .join(", "),
        },
        400,
      );
    }
    try {
      const ticket = await ticketForConversation(
        c,
        parsed.data.conversation_id,
      );
      if (!ticket) {
        return c.json(
          {
            status: "error",
            message:
              "This conversation is not linked to a Console ticket. Ask the concierge to restart the chat from Console 2.",
          },
          403,
        );
      }
      const result = await Promise.race([
        Promise.resolve(run(c, parsed.data, ticket)),
        new Promise<ToolResult>((resolve) =>
          setTimeout(
            () =>
              resolve({
                status: "error",
                message: "The lookup timed out. Try once more.",
              }),
            TOOL_TIMEOUT_MS,
          ),
        ),
      ]);
      return c.json(result, result.status === "error" ? 500 : 200);
    } catch (err) {
      logError(`[Guru] tool ${c.req.path} failed: ${err}`);
      return c.json(
        {
          status: "error",
          message:
            "The lookup failed. Tell the concierge and try again, or escalate.",
        },
        500,
      );
    }
  };

GuruPublicRoutes.post(
  "/tools/lookup-member",
  tool(ToolLookupMemberSchema, (c, input) => lookupMember(c, input)),
);
GuruPublicRoutes.post(
  "/tools/member-overview",
  tool(ToolByMembershipSchema, (c, input) =>
    getMemberOverview(c, input.membership_number),
  ),
);
GuruPublicRoutes.post(
  "/tools/bookings",
  tool(ToolByMembershipSchema, (c, input) =>
    getBookings(c, input.membership_number),
  ),
);
GuruPublicRoutes.post(
  "/tools/booking",
  tool(ToolByBookingSchema, (c, input) =>
    getBooking(c, input.booking_number),
  ),
);
GuruPublicRoutes.post(
  "/tools/points",
  tool(ToolByMembershipSchema, (c, input) =>
    getPoints(c, input.membership_number),
  ),
);
GuruPublicRoutes.post(
  "/tools/entitlements",
  tool(ToolByMembershipSchema, (c, input) =>
    getEntitlements(c, input.membership_number),
  ),
);
GuruPublicRoutes.post(
  "/tools/external-booking-status",
  tool(ToolExternalBookingSchema, (c, input) =>
    getExternalBookingStatus(c, input),
  ),
);
GuruPublicRoutes.post(
  "/tools/submission-log",
  tool(ToolSubmissionLogSchema, (c, input) => getSubmissionLog(c, input)),
);
GuruPublicRoutes.post(
  "/tools/availability",
  tool(ToolAvailabilitySchema, (c, input) => getAvailability(c, input)),
);
GuruPublicRoutes.post(
  "/tools/propose-action",
  tool(ToolProposeActionSchema, (c, input, ticket) =>
    proposeAction(c, ticket, input),
  ),
);
GuruPublicRoutes.post(
  "/tools/ticket-history",
  tool(ToolConversationOnlySchema, (c, _input, ticket) =>
    getTicketHistory(c, ticket),
  ),
);
GuruPublicRoutes.post(
  "/tools/update-ticket",
  tool(ToolUpdateTicketSchema, (c, input, ticket) =>
    updateTicket(c, ticket, input),
  ),
);
