import type { Kysely } from "kysely";
import { logInfo } from "@/lib/logger";
import { elevenLabsRequest } from "@/lib/elevenlabs/client";
import { KevoRepositoryFromDb } from "./kevo.repository";
import { redactSensitive } from "./kevo.service";
import type { KevoFlagCategory } from "@/internal/datastore/kevo.types";

/**
 * Post-call safety net (PLAN.md part 2): after every conversation, ElevenLabs
 * analysis results are checked for problems the agent did not flag in-call.
 * Runs inside a BullMQ job — retries/backoff come from the queue; everything
 * here is idempotent (conversation upsert + flag dedupe).
 */

// Criteria/field ids — must match what kevo-setup.ts configures on the agent.
export const EVAL_CRITERIA_IDS = {
  answeredCorrectly: "answered_correctly_without_gaps",
  notDisputed: "member_disputed_information",
  nothingUnresolved: "unresolved_request",
} as const;
export const DATA_COLLECTION_IDS = {
  knowledgeGapTopic: "knowledge_gap_topic",
  disputedFact: "disputed_fact",
  dataChangeRequested: "data_change_requested",
} as const;

interface ConversationDetail {
  conversation_id: string;
  metadata?: { start_time_unix_secs?: number; call_duration_secs?: number };
  analysis?: {
    call_successful?: string;
    transcript_summary?: string;
    evaluation_criteria_results?: Record<
      string,
      { criteria_id: string; result: string; rationale?: string }
    >;
    data_collection_results?: Record<
      string,
      { data_collection_id: string; value?: unknown; rationale?: string }
    >;
  };
  conversation_initiation_client_data?: {
    dynamic_variables?: Record<string, unknown>;
  };
}

/** Recursively redact string values without breaking JSON structure. */
const redactDeep = (value: unknown): unknown => {
  if (typeof value === "string") return redactSensitive(value);
  if (Array.isArray(value)) return value.map(redactDeep);
  if (value && typeof value === "object") {
    return Object.fromEntries(
      Object.entries(value as Record<string, unknown>).map(([k, v]) => [
        k,
        redactDeep(v),
      ]),
    );
  }
  return value;
};

const asText = (v: unknown): string | undefined => {
  if (typeof v !== "string") return undefined;
  const t = v.trim();
  return t ? t : undefined;
};

export async function processKevoPostCall(
  pool: Kysely<unknown>,
  conversationId: string,
): Promise<void> {
  const repo = KevoRepositoryFromDb(pool);

  const detail = await elevenLabsRequest<ConversationDetail>(
    `/v1/convai/conversations/${conversationId}`,
  );

  const analysis = detail.analysis ?? {};
  const dynamicVars =
    detail.conversation_initiation_client_data?.dynamic_variables ?? {};
  const memberId = asText(dynamicVars.member_id) ?? null;
  const summary = analysis.transcript_summary
    ? redactSensitive(analysis.transcript_summary).slice(0, 4000)
    : null;

  await repo.upsertConversation({
    conversation_id: conversationId,
    member_id: memberId,
    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,
    analysis_json: redactDeep({
      call_successful: analysis.call_successful,
      evaluation_criteria_results: analysis.evaluation_criteria_results,
      data_collection_results: analysis.data_collection_results,
    }),
  });

  const failed = (id: string) =>
    analysis.evaluation_criteria_results?.[id]?.result === "failure";
  const collected = (id: string) =>
    asText(analysis.data_collection_results?.[id]?.value);

  const gapTopic = collected(DATA_COLLECTION_IDS.knowledgeGapTopic);
  const disputedFact = collected(DATA_COLLECTION_IDS.disputedFact);
  const dataChange = collected(DATA_COLLECTION_IDS.dataChangeRequested);

  const candidates: Array<{
    category: KevoFlagCategory;
    entity?: string;
    member_claim?: string;
    requested_change?: string;
  }> = [];

  if (gapTopic || failed(EVAL_CRITERIA_IDS.answeredCorrectly)) {
    candidates.push({
      category: "KNOWLEDGE_GAP",
      entity: gapTopic?.slice(0, 190),
    });
  }
  if (disputedFact || failed(EVAL_CRITERIA_IDS.notDisputed)) {
    candidates.push({
      category: "WRONG_INFO",
      entity: gapTopic?.slice(0, 190),
      member_claim: disputedFact,
    });
  }
  if (dataChange) {
    candidates.push({
      category: "DATA_UPDATE_REQUEST",
      requested_change: dataChange,
    });
  } else if (failed(EVAL_CRITERIA_IDS.nothingUnresolved)) {
    candidates.push({ category: "ESCALATION" });
  }

  if (candidates.length === 0) return;

  // "Auto-create a flag ... AND no in-call flag already exists for that
  // topic": one flag per category per conversation is the working rule.
  const already = await repo.flaggedCategories(conversationId);

  for (const cand of candidates) {
    if (already.has(cand.category)) continue;
    const { flag, created } = await repo.insertFlag({
      source: "POST_CALL",
      category: cand.category,
      conversation_id: conversationId,
      member_id: memberId,
      member_question: summary,
      agent_answer: null,
      member_claim: cand.member_claim
        ? redactSensitive(cand.member_claim).slice(0, 4000)
        : null,
      entity: cand.entity ?? null,
      requested_change: cand.requested_change
        ? redactSensitive(cand.requested_change).slice(0, 4000)
        : null,
    });
    if (created) {
      await repo.insertAudit({
        flag_id: flag.id,
        action: "flag.created",
        metadata: { source: "POST_CALL", category: cand.category },
      });
      logInfo(`[Kevo] post-call flag ${flag.reference} (${cand.category})`);
    }
  }
}
