import type { Context } from "hono";
import { error, success } from "@/lib/response";
import { logError } from "@/lib/logger";
import { elevenLabsRequest, ElevenLabsApiError } from "@/lib/elevenlabs/client";
import { createClickUpTask } from "@/lib/clickup/client";
import type { RepositoryContext } from "@/internal/datastore/repository";
import { KevoRepository } from "@/internal/kevo/kevo.repository";
import { KevoServices, redactSensitive } from "@/internal/kevo/kevo.service";
import { KevoPublishServices } from "@/internal/kevo/kevo-publish.service";
import {
  FlagIssueSchema,
  KnowledgeListSchema,
  KnowledgeUpsertSchema,
  ListFlagsSchema,
  UpdateFlagSchema,
} from "@/internal/kevo/kevo.schema";

const servicesFor = (c: Context) =>
  KevoServices({ KevoRepository: KevoRepository(c as RepositoryContext) });
const repoFor = (c: Context) => KevoRepository(c as RepositoryContext);
const publishFor = (c: Context) =>
  KevoPublishServices(c.get("datastore"));
const actorOf = (c: Context) => ({
  id: c.get("consoleUserId") as string,
  email: (c.get("adminEmail") as string) ?? "unknown",
});

/** Dashboard deep link — the URL pattern is not in the API docs, so it is
 * overridable without a deploy. */
const dashboardUrl = (conversationId: string) =>
  (
    process.env.ELEVENLABS_DASHBOARD_URL_TEMPLATE ||
    "https://elevenlabs.io/app/agents/history/{conversation_id}"
  ).replace("{conversation_id}", conversationId);

const parseJson = async (c: Context): Promise<unknown | null> => {
  try {
    return await c.req.json();
  } catch {
    return null;
  }
};

// ---- flags ----

export const listFlagsHandler = async (c: Context) => {
  const parsed = ListFlagsSchema.safeParse((await parseJson(c)) ?? {});
  if (!parsed.success)
    return error(c, parsed.error.issues.map((i) => i.message).join(", "), 400);
  const { flags, total } = await repoFor(c).listFlags(parsed.data);
  return success(c, {
    flags: flags.map(({ total: _t, ...f }) => f),
    total,
    page: parsed.data.page,
    limit: parsed.data.limit,
  });
};

export const flagStatsHandler = async (c: Context) =>
  success(c, await repoFor(c).flagStats());

export const getFlagHandler = async (c: Context) => {
  const repo = repoFor(c);
  const flag = await repo.getFlagByReference((c.req.param("reference") ?? ""));
  if (!flag) return error(c, "Flag not found", 404);
  const audit = await repo.auditTrail(flag.id);
  return success(c, {
    flag,
    audit,
    dashboard_url: dashboardUrl(flag.conversation_id),
  });
};

export const updateFlagHandler = async (c: Context) => {
  const parsed = UpdateFlagSchema.safeParse(await parseJson(c));
  if (!parsed.success)
    return error(c, parsed.error.issues.map((i) => i.message).join(", "), 400);
  const flag = await servicesFor(c).reviewFlag(
    (c.req.param("reference") ?? ""),
    parsed.data,
    actorOf(c),
  );
  if (!flag) return error(c, "Flag not found", 404);
  return success(c, flag);
};

export const manualFlagHandler = async (c: Context) => {
  const parsed = FlagIssueSchema.safeParse(await parseJson(c));
  if (!parsed.success)
    return error(c, parsed.error.issues.map((i) => i.message).join(", "), 400);
  const actor = actorOf(c);
  const { flag, created } = await servicesFor(c).createFlag(
    parsed.data,
    "MANUAL",
    actor.email,
  );
  return success(
    c,
    { flag, created },
    created ? "Flag created" : "A matching flag already exists",
  );
};

export const routeFlagToClickUpHandler = async (c: Context) => {
  const repo = repoFor(c);
  const flag = await repo.getFlagByReference((c.req.param("reference") ?? ""));
  if (!flag) return error(c, "Flag not found", 404);
  if (flag.clickup_task_id)
    return success(c, flag, "Flag already has a ClickUp task");

  const consoleBase =
    process.env.CONSOLE_BASE_URL || "http://localhost:3002";
  const summary = (flag.requested_change || flag.member_question || "").slice(
    0,
    80,
  );
  try {
    const task = await createClickUpTask({
      name: `[Kevo] ${flag.category}: ${summary}`,
      markdown_description: [
        `**Flag:** ${flag.reference} (${flag.category})`,
        `**Member:** ${flag.member_id ?? "unknown"}`,
        `**Conversation:** ${flag.conversation_id}`,
        flag.member_question ? `**Question:** ${flag.member_question}` : null,
        flag.requested_change
          ? `**Requested change:** ${flag.requested_change}`
          : null,
        "",
        `[Open in Console](${consoleBase}/admin/kevo/flags/${flag.reference})`,
        `[Open in ElevenLabs](${dashboardUrl(flag.conversation_id)})`,
      ]
        .filter((l) => l !== null)
        .join("\n"),
    });
    const actor = actorOf(c);
    const updated = await repo.updateFlag(flag.id, {
      clickup_task_id: task.id,
      clickup_task_url: task.url,
      status: "ROUTED",
      reviewer_id: actor.id,
    });
    await repo.insertAudit({
      flag_id: flag.id,
      action: "clickup.created",
      actor_email: actor.email,
      metadata: { task_id: task.id },
    });
    return success(c, updated, "ClickUp task created");
  } catch (err) {
    // No background retry here on purpose: the reviewer sees the error and
    // clicks again — that IS the retry for a human-triggered action.
    logError(`[Kevo] ClickUp task creation failed: ${err}`);
    return error(c, "ClickUp task creation failed, try again", 502);
  }
};

// ---- conversation transcript (fetched on demand, never stored) ----

export const getConversationHandler = async (c: Context) => {
  const conversationId = c.req.param("conversationId") ?? "";
  try {
    const detail = await elevenLabsRequest<{
      conversation_id: string;
      transcript?: Array<{
        role: string;
        message: string | null;
        time_in_call_secs?: number;
        tool_calls?: Array<{ tool_name?: string; params_as_json?: string }>;
        tool_results?: Array<{ tool_name?: string; result_value?: string }>;
      }>;
      metadata?: { start_time_unix_secs?: number; call_duration_secs?: number };
      analysis?: { transcript_summary?: string; call_successful?: string };
    }>(`/v1/convai/conversations/${conversationId}`);

    return success(c, {
      conversation_id: detail.conversation_id,
      started_at: detail.metadata?.start_time_unix_secs
        ? new Date(detail.metadata.start_time_unix_secs * 1000)
        : null,
      duration_secs: detail.metadata?.call_duration_secs ?? null,
      summary: detail.analysis?.transcript_summary
        ? redactSensitive(detail.analysis.transcript_summary)
        : null,
      call_successful: detail.analysis?.call_successful ?? null,
      dashboard_url: dashboardUrl(conversationId),
      turns: (detail.transcript ?? []).map((t) => ({
        role: t.role,
        message: t.message ? redactSensitive(t.message) : null,
        time_in_call_secs: t.time_in_call_secs ?? null,
        tool_calls: (t.tool_calls ?? []).map((tc) => ({
          tool_name: tc.tool_name ?? null,
          params: tc.params_as_json
            ? redactSensitive(tc.params_as_json)
            : null,
        })),
        tool_results: (t.tool_results ?? []).map((tr) => ({
          tool_name: tr.tool_name ?? null,
          result: tr.result_value ? redactSensitive(tr.result_value) : null,
        })),
      })),
    });
  } catch (err) {
    if (err instanceof ElevenLabsApiError && err.status === 404) {
      return error(c, "Conversation not found in ElevenLabs", 404);
    }
    logError(`[Kevo] transcript fetch failed: ${err}`);
    return error(c, "Could not fetch the conversation from ElevenLabs", 502);
  }
};

// ---- knowledge ----

export const listKnowledgeHandler = async (c: Context) => {
  const parsed = KnowledgeListSchema.safeParse((await parseJson(c)) ?? {});
  if (!parsed.success)
    return error(c, parsed.error.issues.map((i) => i.message).join(", "), 400);
  return success(c, await repoFor(c).listKnowledge(parsed.data));
};

export const createKnowledgeHandler = async (c: Context) => {
  const parsed = KnowledgeUpsertSchema.safeParse(await parseJson(c));
  if (!parsed.success)
    return error(c, parsed.error.issues.map((i) => i.message).join(", "), 400);
  const entry = await servicesFor(c).createKnowledge(
    parsed.data,
    actorOf(c).email,
  );
  return success(c, entry, "Knowledge entry created");
};

export const updateKnowledgeHandler = async (c: Context) => {
  const parsed = KnowledgeUpsertSchema.partial().safeParse(await parseJson(c));
  if (!parsed.success)
    return error(c, parsed.error.issues.map((i) => i.message).join(", "), 400);
  const { flag_id: _ignored, ...patch } = parsed.data;
  const entry = await servicesFor(c).updateKnowledge(
    (c.req.param("id") ?? ""),
    patch,
    actorOf(c).email,
  );
  return success(c, entry, "Knowledge entry updated");
};

export const approveKnowledgeHandler = async (c: Context) =>
  success(
    c,
    await servicesFor(c).approveKnowledge((c.req.param("id") ?? ""), actorOf(c)),
    "Knowledge entry approved",
  );

export const retireKnowledgeHandler = async (c: Context) =>
  success(
    c,
    await servicesFor(c).retireKnowledge((c.req.param("id") ?? ""), actorOf(c).email),
    "Knowledge entry retired",
  );

// ---- publishing ----

export const publishPreviewHandler = async (c: Context) =>
  success(c, await publishFor(c).preview());

export const publishHandler = async (c: Context) => {
  try {
    const result = await publishFor(c).publish(actorOf(c).email);
    return success(
      c,
      result,
      result.skipped
        ? "Content unchanged since the last publish — nothing sent"
        : "Published to the Kevo agent",
    );
  } catch (err) {
    logError(`[Kevo] publish failed: ${err}`);
    return error(
      c,
      err instanceof Error ? err.message : "Publish failed",
      502,
    );
  }
};

export const publishLogHandler = async (c: Context) =>
  success(c, await repoFor(c).listPublishLog());
