import type { Event as OpencodeEvent, Part } from "@opencode-ai/sdk/v2";

import { containsForbiddenPersistentContent } from "../utils/persistencePolicy.js";
import { logger } from "../logger.js";
import { type QuestionAnswers } from "../runtime/opencode.js";

export type PermissionRequestPayload = {
  session_id: string;
  request_id: string;
  permission: string;
  patterns: string[];
  target?: string;
  always: string[];
  tool?: {
    messageID: string;
    callID: string;
  };
  created_at: number;
};

type QuestionOptionPayload = {
  label: string;
  description: string;
};

type QuestionInfoPayload = {
  header: string;
  question: string;
  options: QuestionOptionPayload[];
  multiple?: boolean;
  custom?: boolean;
};

export type QuestionRequestPayload = {
  session_id: string;
  request_id: string;
  questions: QuestionInfoPayload[];
  tool?: {
    messageID: string;
    callID: string;
  };
  created_at: number;
};

export type TodoItemPayload = {
  id: string;
  content: string;
  status: "pending" | "in_progress" | "completed" | "cancelled";
  priority?: "low" | "medium" | "high";
  created_at?: number;
  updated_at?: number;
};

export type TodoUpdatePayload = {
  session_id: string;
  message_id?: string;
  todos: TodoItemPayload[];
  created_at: number;
};

const isDevelopmentDebugLoggingEnabled = process.env.NODE_ENV === "development";

const toolLabels: Record<string, string> = {
  present_view: "展示地图与图表",
  memory_manager: "记忆写入",
  session_search: "历史会话检索",
  skill_manager: "流程沉淀",
};

export const logDevelopmentDebug = (
  message: string,
  metadata: Record<string, unknown>,
) => {
  if (!isDevelopmentDebugLoggingEnabled) {
    return;
  }
  logger.info(metadata, message);
};

export const getErrorMessage = (error: {
  name: string;
  data?: { message?: string };
}) => error.data?.message ?? error.name;

export const getUnknownErrorMessage = (error: unknown) => {
  if (
    typeof error === "object" &&
    error !== null &&
    "name" in error &&
    typeof error.name === "string"
  ) {
    const maybeData = "data" in error ? error.data : undefined;
    return getErrorMessage({
      name: error.name,
      data:
        typeof maybeData === "object" && maybeData !== null && "message" in maybeData
          ? { message: typeof maybeData.message === "string" ? maybeData.message : undefined }
          : undefined,
    });
  }
  return error instanceof Error ? error.message : String(error);
};

export const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
  typeof value === "object" && value !== null && !Array.isArray(value);

export const normalizeToolParams = (value: unknown): Record<string, unknown> => {
  if (isObjectRecord(value)) {
    return value;
  }
  if (typeof value === "string") {
    try {
      const parsed = JSON.parse(value) as unknown;
      return isObjectRecord(parsed) ? parsed : {};
    } catch {
      return {};
    }
  }
  return {};
};

// New tools use reason; aliases are read-only compatibility for existing events.
const reasonKeys = ["reason", "request_reason", "why", "purpose", "rationale"];

export const extractRequestReason = (params: Record<string, unknown>) => {
  for (const key of reasonKeys) {
    const value = params[key];
    if (typeof value === "string") {
      const normalized = value.trim();
      if (normalized) {
        return normalized;
      }
    }
  }
  return "";
};

export const isSkillEvent = (event: OpencodeEvent) =>
  event.type.toLowerCase().includes("skill");

export const extractSkillAuditInfo = (event: OpencodeEvent) => {
  const payload = isObjectRecord(event.properties)
    ? (event.properties as Record<string, unknown>)
    : {};
  const candidateName =
    typeof payload.skill === "string"
      ? payload.skill
      : typeof payload.skillName === "string"
        ? payload.skillName
        : typeof payload.name === "string"
          ? payload.name
          : event.type;
  const reason = extractRequestReason(payload);
  return {
    name: candidateName,
    reason,
    payload,
  };
};

export const hasToolParams = (params: Record<string, unknown>) =>
  Object.keys(params).length > 0;

export const isSessionEvent = (event: OpencodeEvent, sessionId: string) =>
  "properties" in event &&
  typeof event.properties === "object" &&
  event.properties !== null &&
  "sessionID" in event.properties &&
  event.properties.sessionID === sessionId;

export const isPermissionAskedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "permission.asked" }> =>
  event.type === "permission.asked";

export const isPermissionV2AskedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "permission.v2.asked" }> =>
  event.type === "permission.v2.asked";

export const isPermissionRepliedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "permission.replied" }> =>
  event.type === "permission.replied";

export const isPermissionV2RepliedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "permission.v2.replied" }> =>
  event.type === "permission.v2.replied";

export const isQuestionAskedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "question.asked" }> =>
  event.type === "question.asked";

export const isQuestionV2AskedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "question.v2.asked" }> =>
  event.type === "question.v2.asked";

export const isQuestionRepliedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "question.replied" }> =>
  event.type === "question.replied";

export const isQuestionV2RepliedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "question.v2.replied" }> =>
  event.type === "question.v2.replied";

export const isQuestionRejectedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "question.rejected" }> =>
  event.type === "question.rejected";

export const isQuestionV2RejectedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "question.v2.rejected" }> =>
  event.type === "question.v2.rejected";

export const buildPermissionDetail = (
  event: Extract<OpencodeEvent, { type: "permission.asked" }>,
) => {
  const patterns = event.properties.patterns.length
    ? event.properties.patterns.join(", ")
    : event.properties.permission;
  return `需要用户确认权限：${event.properties.permission}；匹配规则：${patterns}`;
};

export const buildPermissionV2Detail = (
  event: Extract<OpencodeEvent, { type: "permission.v2.asked" }>,
) => {
  const resources = event.properties.resources.length
    ? event.properties.resources.join(", ")
    : event.properties.action;
  return `需要用户确认权限：${event.properties.action}；资源：${resources}`;
};

export const normalizeQuestionPayload = (
  event: Extract<OpencodeEvent, { type: "question.asked" | "question.v2.asked" }>,
  clientSessionId: string,
): QuestionRequestPayload => ({
  session_id: clientSessionId,
  request_id: event.properties.id,
  questions: event.properties.questions.map((question) => ({
    header: question.header,
    question: question.question,
    options: question.options.map((option) => ({
      label: option.label,
      description: option.description,
    })),
    multiple: question.multiple,
    custom: question.custom,
  })),
  tool: event.properties.tool,
  created_at: Date.now(),
});

export const normalizeQuestionAnswers = (answers: QuestionAnswers | undefined) =>
  Array.isArray(answers)
    ? answers.map((answer) =>
        Array.isArray(answer)
          ? answer.filter((item): item is string => typeof item === "string")
          : [],
      )
    : [];

const questionToolNames = new Set(["question", "request_user_input"]);

const normalizeQuestionOptions = (value: unknown): QuestionOptionPayload[] =>
  Array.isArray(value)
    ? value.filter(isObjectRecord).map((option) => ({
        label: typeof option.label === "string" ? option.label : "",
        description:
          typeof option.description === "string" ? option.description : "",
      })).filter((option) => option.label.trim().length > 0)
    : [];

const normalizeToolQuestionInfo = (value: unknown): QuestionInfoPayload | undefined => {
  if (!isObjectRecord(value) || typeof value.question !== "string") {
    return undefined;
  }
  const question = value.question.trim();
  if (!question) {
    return undefined;
  }
  return {
    header:
      typeof value.header === "string" && value.header.trim()
        ? value.header
        : "补充信息",
    question,
    options: normalizeQuestionOptions(value.options),
    multiple: typeof value.multiple === "boolean" ? value.multiple : undefined,
    custom: typeof value.custom === "boolean" ? value.custom : undefined,
  };
};

export const normalizeQuestionToolPayload = (
  part: Extract<Part, { type: "tool" }>,
  params: Record<string, unknown>,
  clientSessionId: string,
): QuestionRequestPayload | undefined => {
  // Native V2 question tools create a separate frm_ request. A call ID is not a form ID.
  if ("metadata" in part.state && part.state.metadata?.native_form === true) {
    return undefined;
  }
  if (!questionToolNames.has(part.tool)) {
    return undefined;
  }
  const questions = Array.isArray(params.questions)
    ? params.questions
        .map(normalizeToolQuestionInfo)
        .filter((question): question is QuestionInfoPayload => Boolean(question))
    : [];
  if (questions.length === 0) {
    return undefined;
  }
  return {
    session_id: clientSessionId,
    request_id: part.callID || part.id,
    questions,
    tool: {
      messageID: part.messageID,
      callID: part.callID,
    },
    created_at: Date.now(),
  };
};

export const normalizeTodoStatus = (status: string): TodoItemPayload["status"] => {
  if (status === "in_progress" || status === "completed" || status === "cancelled") {
    return status;
  }
  return "pending";
};

export const normalizeTodoPriority = (
  priority: string,
): TodoItemPayload["priority"] | undefined => {
  if (priority === "low" || priority === "medium" || priority === "high") {
    return priority;
  }
  return undefined;
};

export const collectTextContent = (parts: Part[]) =>
  parts
    .filter((part): part is Extract<Part, { type: "text" }> => part.type === "text")
    .map((part) => part.text)
    .join("");

export const normalizeToolStatus = (status: string) => {
  if (status === "completed") return "completed";
  if (status === "error") return "error";
  return "running";
};

/** Browser-visible tool inputs: retain useful values without credentials or large payloads. */
export const sanitizeToolProgressInput = (params: Record<string, unknown>): Record<string, unknown> => {
  let remaining = 16_000;
  let nodes = 512;
  const visit = (value: unknown, depth: number): unknown => {
    if (remaining <= 0 || nodes-- <= 0) return "[truncated]";
    if (typeof value === "string") {
      if (containsForbiddenPersistentContent(value)) return "[redacted]";
      const limit = Math.min(remaining, 4_000);
      remaining -= Math.min(value.length, limit);
      return value.length > limit ? `${value.slice(0, limit)}… [truncated]` : value;
    }
    if (value === null || typeof value === "boolean" || typeof value === "number") return value;
    if (depth >= 5) return "[truncated]";
    if (Array.isArray(value)) {
      const items = value.slice(0, 64).map((item) => visit(item, depth + 1));
      if (value.length > 64) items.push("[truncated]");
      return items;
    }
    if (value && typeof value === "object") {
      const entries = Object.entries(value).slice(0, 64).map(([rawKey, item]) => {
        const key = rawKey.slice(0, 100);
        remaining -= key.length;
        return [key, /authorization|cookie|password|secret|token|api[_-]?key|credential|headers?/i.test(key)
          ? "[redacted]" : visit(item, depth + 1)];
      });
      if (Object.keys(value).length > 64) entries.push(["…", "[truncated]"]);
      return Object.fromEntries(entries);
    }
    return "[unsupported]";
  };
  return visit(params, 0) as Record<string, unknown>;
};

const formatProgressValue = (value: unknown): string => {
  if (typeof value === "string") {
    return value.length > 120 ? `${value.slice(0, 117)}...` : value;
  }
  if (
    typeof value === "number" ||
    typeof value === "boolean" ||
    value === null ||
    value === undefined
  ) {
    return String(value);
  }
  try {
    const serialized = JSON.stringify(value);
    return serialized.length > 120 ? `${serialized.slice(0, 117)}...` : serialized;
  } catch {
    return "[unserializable]";
  }
};

const normalizeProgressText = (chunks: string[]) =>
  chunks.join("").replace(/\s+/g, " ").trim();

const truncateProgressText = (text: string, maxLength: number) =>
  text.length > maxLength ? `${text.slice(0, maxLength - 3)}...` : text;

const summarizeToolParams = (params: Record<string, unknown>) => {
  const ignoredKeys = new Set(reasonKeys);
  const summary = Object.entries(params)
    .filter(([key]) => !ignoredKeys.has(key))
    .slice(0, 4)
    .map(([key, value]) => `${key}=${formatProgressValue(value)}`)
    .join(", ");

  return summary || "无附加参数";
};

export const buildSessionStatusDetail = (status: { type: string; message?: string }) => {
  if (status.type === "retry") {
    return status.message
      ? `模型请求需要重试，原因：${status.message}`
      : "模型请求正在重试，等待下一次响应。";
  }
  if (status.type === "busy") {
    return status.message
      ? `Agent 正在处理中：${status.message}`
      : "Agent 正在执行推理、工具调用或结果整理。";
  }
  if (status.type === "idle") {
    return status.message
      ? `Agent 已空闲：${status.message}`
      : "当前会话暂时没有待处理任务。";
  }
  return status.message ? `会话状态更新：${status.message}` : `会话状态更新：${status.type}`;
};

export const buildReasoningProgressDetail = (
  chunks: string[],
  ended?: string | number | Date | null,
) => {
  const reasoningText = truncateProgressText(normalizeProgressText(chunks), 800);
  if (ended) {
    return reasoningText
      ? `推理过程：${reasoningText}`
      : "当前推理阶段已完成，Agent 将继续输出答案或进入工具执行。";
  }
  return reasoningText
    ? `正在推理：${reasoningText}`
    : "Agent 正在拆解问题、梳理执行步骤并判断是否需要调用工具。";
};

export const buildToolProgressDetail = (
  tool: string,
  status: string,
  params: Record<string, unknown>,
  reason: string,
  error?: string,
  output?: string,
) => {
  const toolName = toolLabels[tool] ?? tool;
  const reasonText = reason ? `；说明：${containsForbiddenPersistentContent(reason) ? "[redacted]" : reason}` : "";
  const paramsText = `；关键参数：${summarizeToolParams(sanitizeToolProgressInput(params))}`;

  if (status === "error") {
    const errorText = error ? `；错误：${containsForbiddenPersistentContent(error) ? "[redacted]" : error}` : "";
    return `${toolName} 调用失败${reasonText}${paramsText}${errorText}`;
  }
  if (status === "completed") {
    const calculation = calculationProgress(output);
    if (calculation) return `${toolName}：${calculation.label}；计算任务：${calculation.jobId}${reasonText}${paramsText}`;
    return `${toolName} 已执行完成${reasonText}${paramsText}`;
  }
  if (status === "pending") {
    return `${toolName} 已进入待执行状态${reasonText}${paramsText}`;
  }
  return `${toolName} 正在执行${reasonText}${paramsText}`;
};

const calculationProgress = (output?: string) => {
  if (!output || output.length > 100_000) return null;
  try {
    const value = JSON.parse(output);
    if (value?.semantics !== "task" || typeof value.data?.job_id !== "string" ||
        !/^[0-9a-f-]{36}$/i.test(value.data.job_id)) return null;
    const labels: Record<string, string> = {
      queued: "已提交，等待计算", running: "后台计算中", cancel_requested: "已请求取消，等待计算停止",
      succeeded: "计算已完成", failed: "计算失败", cancelled: "计算已取消",
      interrupted: "计算已中断", timed_out: "计算执行超时",
    };
    const label = labels[value.data.status];
    return label ? { label, jobId: value.data.job_id } : null;
  } catch { return null; }
};

export const getToolProgressTitle = (tool: string, status: string, output?: string) => {
  const toolName = toolLabels[tool] ?? tool;
  if (status === "completed") {
    const calculation = calculationProgress(output);
    if (calculation) return `${toolName}：${calculation.label}`;
  }
  if (status === "completed") return `${toolName} 已完成`;
  if (status === "error") return `${toolName} 执行失败`;
  if (status === "pending") return `准备调用 ${toolName}`;
  return `正在调用 ${toolName}`;
};