import { apiFetch } from "@/core/api/fetch-client";
import { getBackendBaseURL } from "@/core/config";

import type { ClarificationPayload } from "./multi-agent";
import { reportRoundtableError } from "./diagnostics-report";
import { resolveAllowMultiple } from "@/roundtable-planning/lib/clarification";
import { normalizeIntentReadySummary } from "@/roundtable-planning/lib/roundtable-constants";

export type { ClarificationPayload };

/** Stable built-in agent used by the multi-agent roundtable Step 1 flow. */
export const INTENT_AGENT_ID = "roundtable-intent";
/** Dedicated Step 1 agent for the position-roundtable workspace. */
export const POSITION_INTENT_AGENT_ID = "position-roundtable-intent";
/** Dedicated Step 1 agent for the 8BF roundtable workspace (same prompt family
 *  as `roundtable-intent`, independently tunable via the agent config UI). */
export const EIGHTBF_INTENT_AGENT_ID = "eightbf-roundtable-intent";

/**
 * Task-intent agent (Step 1) API. Mirror of multi-agent.ts but with a single
 * built-in agent and no per-call coordinator: one /init creates a thread
 * tied to the built-in `roundtable-intent` agent, and each /stream POST is
 * one user-turn of the clarification dialogue. The terminal status frame
 * carries either `asking` (more turns needed) or `done` (structured summary
 * available — hand off to Step 2).
 */

export interface IntentInitResponse {
  status: "success";
  agent_id: string;
  thread_id: string;
}

/**
 * Structured diagnostic payload surfaced by the backend whenever an intent
 * route raises (init) or yields a final `status: "error"` frame (stream).
 * Same shape across `init_intent` / `stream_intent`; renderer keys off `code`
 * for quick visual triage, but also shows `hint` + `trace_tail` as a panel
 * so deployment-time issues (config.yaml unreachable LLM, missing builtin
 * agent dirs, loopback going through proxy) are debuggable from the UI alone
 * without tail-ing backend logs.
 */
export interface IntentErrorDetail {
  /** Stable short category — see backend `_diagnose_exception`. */
  code: string;
  /** One-line human-readable description (already includes exception type). */
  message: string;
  exception_type: string;
  exception_repr: string;
  /** Root of the `__cause__` chain when distinct from the outer exception. */
  root_type?: string | null;
  root_repr?: string | null;
  /** Actionable hint in Chinese, keyed by `code`. May be null for unrecognized errors. */
  hint?: string | null;
  /** Last ~12 lines of the traceback for in-UI inspection. */
  trace_tail?: string[];
  /** Caller-supplied label (e.g. "intent_init"). */
  context?: string | null;
}

/**
 * Thrown by `initIntent` when the HTTP call fails. Carries the parsed
 * `IntentErrorDetail` (if the backend emitted one) so the page can render
 * a rich diagnostic panel instead of a one-line message.
 */
export class IntentInitError extends Error {
  /** HTTP status (typically 500 for diagnosed failures, 401/403 for auth). */
  readonly status: number;
  /** Structured detail when the backend emitted `_diagnose_exception` output. */
  readonly detail: IntentErrorDetail | null;
  /** Raw body text when JSON parse failed (kept for completeness). */
  readonly rawBody: string;

  constructor(status: number, detail: IntentErrorDetail | null, rawBody: string) {
    super(detail?.message || `init intent failed (${status}): ${rawBody}`);
    this.name = "IntentInitError";
    this.status = status;
    this.detail = detail;
    this.rawBody = rawBody;
  }
}

function parseIntentErrorDetail(value: unknown): IntentErrorDetail | null {
  if (!value || typeof value !== "object") return null;
  const obj = value as Record<string, unknown>;
  if (typeof obj.code !== "string" || typeof obj.message !== "string") return null;
  return {
    code: obj.code,
    message: obj.message,
    exception_type: typeof obj.exception_type === "string" ? obj.exception_type : "",
    exception_repr: typeof obj.exception_repr === "string" ? obj.exception_repr : "",
    root_type: typeof obj.root_type === "string" ? obj.root_type : null,
    root_repr: typeof obj.root_repr === "string" ? obj.root_repr : null,
    hint: typeof obj.hint === "string" ? obj.hint : null,
    trace_tail: Array.isArray(obj.trace_tail) ? obj.trace_tail.filter((l): l is string => typeof l === "string") : [],
    context: typeof obj.context === "string" ? obj.context : null,
  };
}

/**
 * Create a fresh thread for an intent-clarification session.
 * The backend returns the built-in agent id so the frontend doesn't hardcode it.
 *
 * On failure throws `IntentInitError` whose `.detail` carries the backend's
 * `_diagnose_exception` payload — the page should surface `detail.hint` /
 * `detail.trace_tail` to help diagnose intranet deployment issues without
 * shell access to the server.
 */
export async function initIntent(
  model?: string,
  taskContext?: Record<string, unknown> | null,
  intentAgentId?: string,
): Promise<IntentInitResponse> {
  const res = await apiFetch(`${getBackendBaseURL()}/api/intent/init`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    // 岗位会商在创建意图线程时就写入父任务标识。这样即使用户尚未确认
    // 业务链，第一阶段的对话也已经可以按 taskId 恢复。
    body: JSON.stringify({
      model,
      task_context: taskContext ?? undefined,
      intent_agent_id: intentAgentId || undefined,
    }),
  });
  if (!res.ok) {
    const raw = await res.text().catch(() => "");
    let detail: IntentErrorDetail | null = null;
    try {
      const parsed = JSON.parse(raw);
      // FastAPI HTTPException(detail=dict) → { "detail": {...} }
      if (parsed && typeof parsed === "object" && parsed !== null) {
        detail = parseIntentErrorDetail((parsed as { detail?: unknown }).detail) || parseIntentErrorDetail(parsed);
      }
    } catch {
      // body wasn't JSON — fall through with raw text only.
    }
    throw new IntentInitError(res.status, detail, raw);
  }
  return (await res.json()) as IntentInitResponse;
}

/**
 * Structured task summary the intent agent emits when it judges the user's
 * task is fully specified. The frontend feeds this into Step 2's initial
 * leader prompt.
 */
export interface IntentSummary {
  /** One-line statement of what the user wants accomplished. */
  objective: string;
  /** Hard constraints (budget / time / compliance / scope). At least 1 entry. */
  constraints: string[];
  /** Optional assumptions the agent is making on the user's behalf. */
  assumptions?: string[];
  /** Present only for the dedicated position-roundtable intent agent. */
  coreGoals?: string[];
  riskWarnings?: string[];
  keyPoints?: string[];
  strategicSignificance?: string[];
}

/** Final hand-off shape emitted only by the position-roundtable intent agent. */
export interface PositionIntentSummary {
  coreGoals: string[];
  riskWarnings: string[];
  keyPoints: string[];
  strategicSignificance: string[];
}

/**
 * Same phases as streamMultiAgent so the UI can reuse one phase-label mapper.
 * `connecting` ≈ HTTP sent, no frames yet; `connected` ≈ got `event: metadata`;
 * `streaming` ≈ first AI text chunk; `tool_calling` ≈ ask_clarification or
 * similar tool call (which usually means the run is about to interrupt and
 * the user-visible text won't grow further this turn).
 */
export type IntentStreamPhase = "connecting" | "connected" | "streaming" | "tool_calling";

/**
 * 用户上传文件的引用（已经过 `/api/threads/{thread_id}/uploads`）。透传给后端
 * `additional_kwargs.files`，由 UploadsMiddleware 注入文件清单并解锁 read_file 等工具。
 * 字段与普通聊天的 `FileInMessage` 对齐：`path` 用上传返回的 `virtual_path`。
 */
export interface IntentFileRef {
  filename: string;
  size: number;
  path: string;
  status?: "uploading" | "uploaded";
}

export interface StreamIntentRequest {
  threadId: string;
  message: string;
  model?: string;
  /** Explicit built-in Step-1 agent. Omit to retain the multi-agent default. */
  intentAgentId?: string;
  /**
   * 本回合幂等键（Phase 4 单飞）：同一 (threadId, clientTurnId) 在后端至多一个 run。
   * 缺省由调用方（useStep1Intent）每条消息生成；同一回合的重试 / 双击复用它，后端据此
   * 去重（在跑→丢弃重复请求 / 已完成→幂等回放），杜绝并发下双发意图 / 重复澄清卡。
   */
  clientTurnId?: string;
  /** Optional hidden business/task context injected into the model run. */
  taskContext?: Record<string, unknown> | null;
  /** Step 1 用户上传的参考文件（可选）。 */
  files?: IntentFileRef[];
  signal?: AbortSignal;
  /** Fires for every AI text chunk parsed out of LangGraph messages-tuple frames. */
  onTextDelta?: (text: string, messageId: string) => void;
  /**
   * Fires whenever the inferred SSE phase changes. The UI uses this to flip
   * the placeholder bubble's caption from "调度中" → "已连接,等待响应" →
   * "正在输出" so users see what's happening during the inevitable LLM
   * first-token wait.
   */
  onPhaseChange?: (
    phase: IntentStreamPhase,
    toolName?: string,
    args?: Record<string, unknown>,
  ) => void;
  /**
   * Fires for every `ask_clarification` tool message parsed out of the live
   * stream (the intent agent may emit several in a single turn). Lets the UI
   * surface each assistance question in real-time instead of waiting for the
   * terminal frame. `index` is the 0-based arrival order within this turn.
   */
  onClarification?: (clarification: ClarificationPayload, index: number) => void;
}

export interface StreamIntentResult {
  /** "asking" → keep the dialogue going; "clarification" → structured question card; "done" → summary is ready; "error" → backend failure. */
  status: "asking" | "clarification" | "done" | "error";
  /** Final assistant text for this turn (markdown, may contain the [INTENT_READY] block). */
  content: string;
  /** Populated only when status === "done". */
  summary: IntentSummary | null;
  /**
   * Populated when the intent agent called ask_clarification — render option
   * cards + custom input instead of treating the turn as plain text only.
   * This is the *first* clarification (kept for backward compat); prefer
   * `clarifications` which carries the full set.
   */
  clarification: ClarificationPayload | null;
  /**
   * All `ask_clarification` questions the agent asked this turn, in arrival
   * order. Collected live and reconciled against the terminal frame so a
   * reconnect cannot lose cards. Empty unless status === "clarification".
   */
  clarifications: ClarificationPayload[];
  /**
   * Populated only when status === "error" and the backend emitted a
   * structured diagnostic (new in `_diagnose_exception`). UI uses this to show
   * the same rich panel as init failures.
   */
  errorDetail: IntentErrorDetail | null;
}

/**
 * Recognise the terminal status frame the backend appends after the upstream
 * LangGraph stream finishes. Must carry `status` and `content`; `summary`
 * is optional.
 */
function isFinalIntentFrame(value: unknown): value is {
  status: "asking" | "clarification" | "done" | "error";
  content?: string;
  summary?: IntentSummary | null;
  question?: string;
  clarification_type?: string;
  clarification_context?: string;
  options?: unknown[];
  allow_custom?: boolean;
  allow_multiple?: boolean;
  clarifications?: unknown[];
  error_detail?: unknown;
} {
  if (!value || typeof value !== "object") return false;
  if (!("status" in value) || !("content" in value)) return false;
  const status = (value as { status: unknown }).status;
  return (
    status === "asking" ||
    status === "clarification" ||
    status === "done" ||
    status === "error"
  );
}

/**
 * Reuse the same delta-extraction shape as multi-agent.ts so AI text streams
 * smoothly into the frontend bubble. Returns null for tool / value / tool
 * result frames.
 */
function extractAiTextDelta(parsed: unknown): { text: string; id: string } | null {
  if (!Array.isArray(parsed) || parsed.length < 1) return null;
  const chunk = parsed[0];
  if (!chunk || typeof chunk !== "object") return null;
  const obj = chunk as Record<string, unknown>;
  const type = String(obj.type ?? "").toLowerCase();
  if (type !== "ai" && type !== "aimessagechunk" && type !== "aimessage") return null;
  const content = obj.content;
  let text = "";
  if (typeof content === "string") {
    text = content;
  } else if (Array.isArray(content)) {
    for (const item of content) {
      if (typeof item === "string") text += item;
      else if (item && typeof item === "object") {
        const block = item as Record<string, unknown>;
        const blockText = block.text;
        if (typeof blockText === "string") text += blockText;
      }
    }
  }
  if (!text) return null;
  const id = typeof obj.id === "string" ? obj.id : "";
  return { text, id };
}

/**
 * Parse a live `type:"tool"` `ask_clarification` frame into a ClarificationPayload.
 *
 * The intent agent emits one such frame per question (ClarificationMiddleware
 * formats them), each carrying a fully-formed clarification in
 * `additional_kwargs.clarification` — options already normalized to
 * `{id, label}` objects, snake_case keys. Returns null for any other frame
 * (AI text chunks, tool_call_chunks, value snapshots).
 */
function extractClarificationToolMessage(
  parsed: unknown,
): { payload: ClarificationPayload; toolCallId: string } | null {
  if (!Array.isArray(parsed) || parsed.length < 1) return null;
  const msg = parsed[0];
  if (!msg || typeof msg !== "object") return null;
  const obj = msg as Record<string, unknown>;
  if (String(obj.type ?? "").toLowerCase() !== "tool") return null;
  if (obj.name !== "ask_clarification") return null;
  const kwargs = obj.additional_kwargs;
  if (!kwargs || typeof kwargs !== "object") return null;
  const clar = (kwargs as Record<string, unknown>).clarification;
  if (!clar || typeof clar !== "object") return null;
  const c = clar as Record<string, unknown>;
  const toolCallId =
    typeof obj.tool_call_id === "string" && obj.tool_call_id
      ? obj.tool_call_id
      : typeof obj.id === "string"
        ? obj.id
        : "";
  const clarificationType =
    typeof c.clarification_type === "string" ? c.clarification_type : "";
  return {
    toolCallId,
    payload: {
      id: toolCallId || undefined,
      question: typeof c.question === "string" ? c.question : "",
      clarificationType,
      context: typeof c.context === "string" ? c.context : "",
      options: Array.isArray(c.options) ? c.options : [],
      allowCustom: c.allow_custom !== false,
      allowMultiple: resolveAllowMultiple(
        typeof c.allow_multiple === "boolean" ? c.allow_multiple : undefined,
        clarificationType,
      ),
    },
  };
}

/**
 * Normalize one clarification included in the terminal status frame. This is
 * the reconnect / proxy fallback for cases where one or more live `tool`
 * frames were not delivered to the browser.
 */
function parseTerminalClarification(
  value: unknown,
): { payload: ClarificationPayload; toolCallId: string } | null {
  if (!value || typeof value !== "object") return null;
  const raw = value as Record<string, unknown>;
  const clarificationType =
    typeof raw.clarification_type === "string" ? raw.clarification_type : "";
  const toolCallId = typeof raw.id === "string" ? raw.id : "";
  return {
    toolCallId,
    payload: {
      id: toolCallId || undefined,
      question: typeof raw.question === "string" ? raw.question : "",
      clarificationType,
      context:
        typeof raw.clarification_context === "string"
          ? raw.clarification_context
          : typeof raw.context === "string"
            ? raw.context
            : "",
      options: Array.isArray(raw.options) ? raw.options : [],
      allowCustom: raw.allow_custom !== false,
      allowMultiple: resolveAllowMultiple(
        typeof raw.allow_multiple === "boolean" ? raw.allow_multiple : undefined,
        clarificationType,
      ),
    },
  };
}

/**
 * Open an SSE connection to /api/intent/stream and resolve when the upstream
 * stream completes. Each call is one user turn; reuse the same threadId
 * across calls to keep the dialogue history.
 */
export async function streamIntent(req: StreamIntentRequest): Promise<StreamIntentResult> {
  const res = await apiFetch(`${getBackendBaseURL()}/api/intent/stream`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      thread_id: req.threadId,
      message: req.message,
      model: req.model,
      intent_agent_id: req.intentAgentId || undefined,
      task_context: req.taskContext ?? undefined,
      // Phase 4 单飞幂等键：缺省由后端兜底生成，但调用方应始终传（useStep1Intent 每条消息生成）。
      client_turn_id: req.clientTurnId || undefined,
      // 仅在有文件时带上，空数组后端也安全忽略。
      files: req.files && req.files.length > 0 ? req.files : undefined,
    }),
    signal: req.signal,
  });

  if (!res.ok || !res.body) {
    const text = await res.text().catch(() => "");
    reportRoundtableError({
      stage: "step1_intent", event: "intent_stream_http_error",
      message: `第一步意图生成失败 (HTTP ${res.status}): ${text.slice(0, 500)}`,
      httpStatus: res.status,
    });
    throw new Error(`intent/stream failed (${res.status}): ${text}`);
  }

  const reader = res.body.getReader();
  const decoder = new TextDecoder();
  let buffer = "";
  let lastEvent = "";

  // Single source of truth for the inferred SSE phase. The helper only fires
  // the callback when the phase actually changes (or when a tool name is
  // provided, since the same `tool_calling` phase may surface a new tool).
  let currentPhase: IntentStreamPhase = "connecting";
  req.onPhaseChange?.("connecting");
  const setPhase = (
    next: IntentStreamPhase,
    toolName?: string,
    args?: Record<string, unknown>,
  ) => {
    if (next === currentPhase && !toolName) return;
    currentPhase = next;
    req.onPhaseChange?.(next, toolName, args);
  };

  const result: StreamIntentResult = {
    status: "asking",
    content: "",
    summary: null,
    clarification: null,
    clarifications: [],
    errorDetail: null,
  };

  // Clarifications collected live from `type:"tool"` frames, deduped by
  // tool_call_id, then reconciled against the complete terminal list.
  const seenClarificationIds = new Set<string>();
  // A clarification tool call is a hard pause in the Step 1 conversation.
  // Some model providers keep emitting text (and can even produce an
  // INTENT_READY terminal frame) after the tool result. That text belongs to
  // a continuation the user has not approved yet, so never let it replace the
  // assistance card in the current turn.
  let awaitingUserClarification = false;
  const collectClarification = (payload: ClarificationPayload, toolCallId: string) => {
    awaitingUserClarification = true;
    const dedupeKey = toolCallId || `idx-${result.clarifications.length}`;
    if (seenClarificationIds.has(dedupeKey)) return;
    seenClarificationIds.add(dedupeKey);
    const index = result.clarifications.length;
    result.clarifications.push(payload);
    if (!result.clarification) result.clarification = payload;
    req.onClarification?.(payload, index);
  };

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split("\n");
    buffer = lines.pop() ?? "";

    for (const rawLine of lines) {
      const line = rawLine.trimEnd();
      if (!line) continue;
      if (line.startsWith("event:")) {
        lastEvent = line.slice(6).trim();
        // First `event: metadata` = the upstream LangGraph run was accepted.
        // Flip out of "connecting" so the bubble label changes from
        // "调度中" → "已连接,等待响应".
        if (lastEvent === "metadata" && currentPhase === "connecting") {
          setPhase("connected");
        }
        continue;
      }
      if (!line.startsWith("data:")) continue;
      const payload = line.slice(5).trim();
      if (!payload) continue;

      let parsed: unknown;
      try {
        parsed = JSON.parse(payload);
      } catch {
        continue;
      }

      if (isFinalIntentFrame(parsed)) {
        // Reconcile any terminal clarification cards, but preserve the first
        // tool-call pause as the authoritative state for this turn. In
        // particular, do not accept a later `done` frame / summary before the
        // user has answered the displayed questions.
        if (awaitingUserClarification) {
          if (parsed.status === "clarification") {
            const terminalCards = Array.isArray(parsed.clarifications)
              ? parsed.clarifications
                  .map(parseTerminalClarification)
                  .filter((item): item is { payload: ClarificationPayload; toolCallId: string } => item !== null)
              : [];
            if (terminalCards.length > 0) {
              terminalCards.forEach((card, index) => {
                collectClarification(card.payload, card.toolCallId || `terminal-${index}`);
              });
            }
          }
          continue;
        }
        result.status = parsed.status;
        if (typeof parsed.content === "string") result.content = parsed.content;
        if (parsed.summary && typeof parsed.summary === "object") {
          result.summary = normalizeIntentReadySummary(parsed.summary);
        }
        if (parsed.status === "error") {
          result.errorDetail = parseIntentErrorDetail(parsed.error_detail);
          reportRoundtableError({
            stage: "step1_intent", event: "intent_error_frame",
            message: `第一步意图生成报错：${(result.content || "").slice(0, 800)}`,
            detail: result.errorDetail,
          });
        }
        if (parsed.status === "clarification") {
          // Newer backend frames contain every card. Merge them even when a
          // subset already arrived live: an SSE reconnect can otherwise leave
          // the user with only the first card in a multi-question assistance
          // round. Older backends still fall back to the legacy top-level card.
          const terminalCards = Array.isArray(parsed.clarifications)
            ? parsed.clarifications
                .map(parseTerminalClarification)
                .filter((item): item is { payload: ClarificationPayload; toolCallId: string } => item !== null)
            : [];
          if (terminalCards.length > 0) {
            terminalCards.forEach((card, index) => {
              collectClarification(card.payload, card.toolCallId || `terminal-${index}`);
            });
          } else if (result.clarifications.length === 0) {
            const fallback = parseTerminalClarification(parsed);
            if (fallback) {
              collectClarification(fallback.payload, fallback.toolCallId || "terminal-0");
            }
          }
        }
        continue;
      }

      if (lastEvent === "messages") {
        // `ask_clarification` tool result frame → collect + surface in real-time.
        // These carry the fully-formed clarification (one per question); the
        // agent may emit several in a single turn.
        const toolClar = extractClarificationToolMessage(parsed);
        if (toolClar) {
          collectClarification(toolClar.payload, toolClar.toolCallId);
          continue;
        }

        // Do not show follow-up thinking / generated summary text while the
        // user-assistance card is waiting for an answer. This also prevents a
        // later AI delta from hiding the card through an [INTENT_READY] block.
        if (awaitingUserClarification) continue;

        // Phase inference from LangGraph messages-tuple frames. Tool calls
        // (typically ask_clarification) flip phase to tool_calling; AI text
        // chunks flip to streaming. Everything else leaves phase alone.
        if (Array.isArray(parsed) && parsed.length > 0) {
          const chunk = parsed[0];
          if (chunk && typeof chunk === "object") {
            const chunkObj = chunk as Record<string, unknown>;
            const chunkType = String(chunkObj.type ?? "").toLowerCase();
            const toolCalls = chunkObj.tool_calls;
            const toolCallChunks = chunkObj.tool_call_chunks;
            const content = chunkObj.content;
            const hasToolCall =
              (Array.isArray(toolCalls) && toolCalls.length > 0) ||
              (Array.isArray(toolCallChunks) && toolCallChunks.length > 0);
            if (hasToolCall) {
              const firstCall = Array.isArray(toolCalls) && toolCalls.length > 0
                ? (toolCalls[0] as Record<string, unknown>)
                : Array.isArray(toolCallChunks) && toolCallChunks.length > 0
                  ? (toolCallChunks[0] as Record<string, unknown>)
                  : null;
              const toolName = firstCall && typeof firstCall.name === "string" ? firstCall.name : "";
              // 把 tool args 一并透传给 UI;onPhaseChange 在 useStep1Intent 里
              // 会把 args 累积进 message.steps,让 MessageStepsCard 渲染路径 chip /
              // 命令代码块等子节点(与主聊天 MessageGroup 视觉一致)。
              const toolArgs =
                firstCall && typeof firstCall.args === "object" && firstCall.args !== null
                  ? (firstCall.args as Record<string, unknown>)
                  : undefined;
              setPhase("tool_calling", toolName, toolArgs);
            } else if (
              (chunkType === "ai" || chunkType === "aimessagechunk" || chunkType === "aimessage") &&
              ((typeof content === "string" && content.length > 0) || (Array.isArray(content) && content.length > 0))
            ) {
              setPhase("streaming");
            }
          }
        }

        const delta = extractAiTextDelta(parsed);
        if (delta) req.onTextDelta?.(delta.text, delta.id);
      }
    }
  }

  if (awaitingUserClarification && result.clarifications.length > 0) {
    result.status = "clarification";
    result.summary = null;
    result.clarification = result.clarifications[0] ?? null;
  }

  return result;
}