import { createInteractionRequestApi, type InteractionRequestApi } from "./interaction-requests";
import { env } from "@/shared/config/env";
import type { AccessTokenProvider } from "@/shared/auth/keycloak-auth";
import { agentMessagePageSchema, type AgentMessagePage } from "./agent-messages";
import { AnswerViewStateApiError, readAnswerViewStateResponse, type AnswerViewStateRecord, type AnswerViewStateWrite } from "./answer-view-state";

export type AgentRunStatus = "running" | "completed" | "error" | "aborted" | "waiting_input";
export type AgentSessionPurpose = "ordinary_chat" | "task_execution" | "task_collaboration";

export type AgentEventTriggerContext = {
  schema_version: "agent-trigger@1";
  kind: "event";
  trigger_id: string;
  occurred_at: string;
  source: "peripheral_sample";
  subject_type: "work_order";
  subject_id: string;
  workflow: "water_quality_complaint";
  payload: {
    title: string;
    summary: string;
    location?: string | null;
    priority: "low" | "normal" | "high" | "urgent";
    scenario_code?: string | null;
    origin: "system_data";
  };
};

export type AgentPermissionReply = "once" | "always" | "reject";

export type AgentModelOption = {
  id: string;
  label: string;
  description: string;
  icon: "bolt" | "sparkle";
};

export type AgentModelsResponse = {
  defaultModel: string;
  models: AgentModelOption[];
};

export type AgentInputDelivery = "steer" | "queue";
export type AgentResponseInput = { id: string; text: string; delivery: AgentInputDelivery; status: "pending" | "delivered" | "cancelled" };
export class AgentResponseFinishedError extends Error {}
export class AgentSessionStreamError extends Error {
  constructor(message: string, readonly status: number) { super(message); }
}

export type AgentTopic = { id: string; name: string; createdAt: string; updatedAt: string };

export type AgentChatSession = {
  id?: string;
  session_id: string;
  title?: string;
  topic_id?: string | null;
  status?: string;
  run_status?: AgentRunStatus;
  is_streaming?: boolean;
  messages?: unknown[];
  created_at?: number | string;
  updated_at?: number | string;
  is_title_manually_edited?: boolean;
  parent_session_id?: string;
  created?: boolean;
  event_duplicate?: boolean;
  trigger_id?: string;
  purpose?: AgentSessionPurpose;
  task_id?: string;
};

export type AgentChatSessionSummary = {
  trigger?: { subjectId: string; workflow: "water_quality_complaint"; occurredAt: string };
  id: string;
  title: string;
  topicId?: string | null;
  topicName?: string;
  searchSnippet?: string;
  createdAt: number;
  updatedAt: number;
  status?: string;
  parentSessionId?: string;
  isStreaming?: boolean;
  runStatus?: AgentRunStatus;
  needsInput?: boolean;
  purpose: AgentSessionPurpose;
  taskId?: string;
};

export type AgentRecentActivity = {
  id: string;
  kind: "alert" | "task" | "analysis" | "session";
  title: string;
  occurred_at: string;
  summary?: string;
  status?: string;
  origin: "backend" | "agent" | "demo";
};

export type AgentPromptSuggestion = {
  question: string;
  activityId: string | null;
};

export type AgentMessagePagination = { hasMore: boolean; beforeCursor: string | null };
export type AgentSessionPage = { sessions: AgentChatSessionSummary[]; hasMore: boolean; nextCursor: string | null };
export type AgentHistoryMessagePage = { messages: unknown[]; messagePage: AgentMessagePagination };

export type AgentLoadedChatSession = AgentChatSessionSummary & {
  sessionId: string;
  isTitleManuallyEdited: boolean;
  messages: unknown[];
  messagePage?: AgentMessagePagination;
};

export type AgentSessionStreamDataEventType =
  | "execution_plan"
  | "final_answer"
  | "token"
  | "progress"
  | "todo_update"
  | "permission_request"
  | "permission_response"
  | "run_status"
  | "interaction_request"
  | "question_request"
  | "question_response"
  | "tool_call"
  | "frontend_action"
  | "frontend_action_result"
  | "answer_ui"
  | "ui_envelope"
  | "session_title"
  | "done"
  | "aborted"
  | "error"
  | "auth_required"
  | "credential_refresh_required"
  | "credential_refreshed"
  | "credential_refresh_failed"
  | "agent_message"
  | "user_input";

export type AgentSessionStreamEvent =
  | {
      type: "state";
      executionPlans?: unknown[];
      messagePage?: AgentMessagePagination;
      sessionId: string;
      messages: unknown[];
      isStreaming: boolean;
      runStatus?: AgentRunStatus;
    }
  | {
      type: AgentSessionStreamDataEventType;
      sessionId?: string;
      data: Record<string, unknown>;
    };

export type AgentApiClient = InteractionRequestApi & {
  getHealth: (signal: AbortSignal) => Promise<void>;
  getAnswerViewState: (sessionId: string, messageId: string, blockId: string) => Promise<AnswerViewStateRecord>;
  putAnswerViewState: (sessionId: string, state: AnswerViewStateWrite) => Promise<AnswerViewStateRecord>;
  downloadFile: (path: string) => Promise<void>;
  submitResponseInput: (sessionId: string, text: string, delivery: AgentInputDelivery, id: string) => Promise<AgentResponseInput>;
  listResponseInputs: (sessionId: string) => Promise<AgentResponseInput[]>;
  updateResponseInput: (sessionId: string, id: string, delivery: AgentInputDelivery) => Promise<AgentResponseInput>;
  cancelResponseInput: (sessionId: string, id: string) => Promise<AgentResponseInput>;
  listAgentMessages: (sessionId: string, options?: { cursor?: string; signal?: AbortSignal }) => Promise<AgentMessagePage>;
  streamAgentMessages: (sessionId: string, options: { signal?: AbortSignal; onMessage: () => void }) => Promise<void>;
  generatePromptSuggestions: (activities: AgentRecentActivity[], model: string, signal?: AbortSignal) => Promise<AgentPromptSuggestion[]>;
  createSession: (options?: { triggerContext?: AgentEventTriggerContext; topicId?: string }) => Promise<AgentChatSession>;
  listSessions: (options?: { purpose?: AgentSessionPurpose; taskId?: string }) => Promise<AgentChatSessionSummary[]>;
  listSessionPage: (options?: { q?: string; cursor?: string; limit?: number; purpose?: AgentSessionPurpose; topicId?: string; includeCollaboration?: boolean; signal?: AbortSignal }) => Promise<AgentSessionPage>;
  listTopics: () => Promise<AgentTopic[]>;
  createTopic: (name: string) => Promise<AgentTopic>;
  renameTopic: (id: string, name: string) => Promise<AgentTopic>;
  deleteTopic: (id: string) => Promise<void>;
  moveSessionToTopic: (sessionId: string, topicId: string | null) => Promise<void>;
  loadOlderMessages: (sessionId: string, before: string, signal?: AbortSignal) => Promise<AgentHistoryMessagePage>;
  createTaskCollaborationSession: (taskId: string) => Promise<AgentChatSession>;
  createTaskExecutionDebugSession: (taskId: string, runId: string, sessionId: string) => Promise<AgentChatSession>;
  loadTaskExecutionSession: (taskId: string, runId: string, sessionId: string, signal?: AbortSignal) => Promise<AgentLoadedChatSession | null>;
  loadSession: (sessionId: string, options?: { messageLimit?: number; signal?: AbortSignal }) => Promise<AgentLoadedChatSession | null>;
  streamSession: (
    sessionId: string,
    options: {
      signal?: AbortSignal;
      messageLimit?: number;
      onEvent: (event: AgentSessionStreamEvent) => void;
    }
  ) => Promise<void>;
  updateSessionTitle: (
    sessionId: string,
    title: string,
    options?: { isTitleManuallyEdited?: boolean }
  ) => Promise<void>;
  deleteSession: (sessionId: string) => Promise<void>;
  getModels: () => Promise<AgentModelsResponse>;
  getUiRegistry: () => Promise<unknown>;
  getFrontendActionRegistry: () => Promise<unknown>;
  submitFrontendActionResult: (sessionId: string, actionId: string, result: unknown) => Promise<void>;
  resolveRenderRef: (renderRef: string, sessionId: string) => Promise<unknown>;
  replyPermission: (
    requestId: string,
    options: { sessionId: string; reply: AgentPermissionReply; message?: string }
  ) => Promise<void>;
  getQuestionStatus: (sessionId: string, requestId: string) => Promise<{ status: "pending" | "answered" | "rejected" | "invalidated" }>;
  replyQuestion: (
    requestId: string,
    options: { sessionId: string; answers: string[][] }
  ) => Promise<void>;
  rejectQuestion: (requestId: string, options: { sessionId: string }) => Promise<void>;
  refreshCredential: (sessionId: string, requestId: string) => Promise<void>;
  abort: (sessionId: string) => Promise<void>;
};

export type AgentApiClientOptions = {
  getAccessToken?: AccessTokenProvider;
  getProjectId?: () => Promise<string | undefined>;
};

const API_PATH = "/api/v1";

export function createAgentApiClient(
  baseUrl: string = env.TJWATER_AGENT_URL,
  options: AgentApiClientOptions = {}
): AgentApiClient {
  const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
  const request = (path: string, init?: RequestInit) =>
    fetchAgent(
      normalizedBaseUrl,
      path,
      init,
      options.getAccessToken,
      options.getProjectId
    );
  const requestJson = async <T,>(path: string, init?: RequestInit) => {
    const response = await request(path, init);
    const text = await response.text();
    const data = text ? JSON.parse(text) : null;

    if (!response.ok) {
      throw new Error(getResponseErrorMessage(data, response.status));
    }

    return data as T;
  };
  let answerStateActor: string | undefined;
  const checkedAnswerStateToken = options.getAccessToken ? async () => {
    const token = await options.getAccessToken!();
    const actor = answerStateTokenActor(token);
    if (answerStateActor !== undefined && actor !== answerStateActor) {
      throw new AnswerViewStateApiError("登录身份已变化，请刷新后继续。", 403, "ANSWER_VIEW_IDENTITY_CHANGED");
    }
    answerStateActor = actor;
    return token;
  } : undefined;
  const answerStateRequest = async (path: string, init?: RequestInit) => {
    const response = await fetchAgent(normalizedBaseUrl, path, init,
      checkedAnswerStateToken, options.getProjectId);
    // An identity change while awaiting the network also invalidates the result.
    await checkedAnswerStateToken?.();
    return response;
  };

  return {
    ...createInteractionRequestApi(answerStateRequest),
    async getHealth(signal) {
      const response = await fetchAgent(normalizedBaseUrl, "/health", { signal, cache: "no-store" }, undefined, undefined, "");
      if (!response.ok) throw new Error("Agent 服务暂不可用");
      const data: unknown = await response.json();
      if (!isRecord(data) || data.ok !== true || data.ready !== true) throw new Error("Agent 服务尚未就绪");
    },
    async getAnswerViewState(sessionId, messageId, blockId) {
      const query = new URLSearchParams({ message_id: messageId, block_id: blockId });
      return readAnswerViewStateResponse(await answerStateRequest(`/session/${encodeURIComponent(sessionId)}/ui-state?${query}`));
    },
    async putAnswerViewState(sessionId, state) {
      return readAnswerViewStateResponse(await answerStateRequest(`/session/${encodeURIComponent(sessionId)}/ui-state`, {
        method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify(state)
      }));
    },
    async downloadFile(path) {
      const match = /^\/api\/v1(\/session\/[^/?#]+\/files\/mcp-[a-f0-9-]{36}\.(?:zip|xlsx))$/.exec(path);
      if (!match) throw new Error("无效的会话文件地址");
      const response = await request(match[1], { redirect: "error" });
      if (!response.ok) throw new Error("文件不可用或当前账号无权下载");
      const blob = await response.blob();
      const url = URL.createObjectURL(blob);
      const anchor = document.createElement("a");
      anchor.href = url;
      anchor.download = path.split("/").at(-1) ?? "export.zip";
      anchor.click();
      setTimeout(() => URL.revokeObjectURL(url), 1000);
    },
    async submitResponseInput(sessionId, text, delivery, id) {
      const response = await request("/responses", {
        method: "POST", headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ input: text, conversation: sessionId, stream: false, tjwater: { delivery, input_id: id } })
      });
      const data = await response.json();
      if (response.status === 409 && data?.code === "RESPONSE_FINISHED") throw new AgentResponseFinishedError("当前回复已结束");
      if (!response.ok) throw new Error(getResponseErrorMessage(data, response.status));
      return data as AgentResponseInput;
    },
    async listResponseInputs(sessionId) {
      const result = await requestJson<{ items: AgentResponseInput[] }>(`/session/${encodeURIComponent(sessionId)}/inputs`);
      return result.items;
    },
    async updateResponseInput(sessionId, id, delivery) {
      return requestJson<AgentResponseInput>(`/session/${encodeURIComponent(sessionId)}/inputs/${encodeURIComponent(id)}`, {
        method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ delivery })
      });
    },
    async cancelResponseInput(sessionId, id) {
      return requestJson<AgentResponseInput>(`/session/${encodeURIComponent(sessionId)}/inputs/${encodeURIComponent(id)}`, {
        method: "DELETE"
      });
    },
    async generatePromptSuggestions(activities, model, signal) {
      const result = await requestJson<unknown>("/suggestions", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ activities, model }),
        signal,
      });
      if (!isRecord(result) || !Array.isArray(result.suggestions) || result.suggestions.length < 1 || result.suggestions.length > 3) {
        throw new Error("Invalid Agent suggestions");
      }
      const ids = new Set(activities.map((item) => item.id));
      const questions = new Set<string>();
      return result.suggestions.map((item): AgentPromptSuggestion => {
        if (!isRecord(item) || typeof item.question !== "string" || !item.question.trim() || item.question.length > 180 ||
          (item.activity_id !== null && (typeof item.activity_id !== "string" || !ids.has(item.activity_id)))) {
          throw new Error("Invalid Agent suggestion");
        }
        const question = item.question.trim();
        if (questions.has(question)) throw new Error("Duplicate Agent suggestion");
        questions.add(question);
        return { question, activityId: item.activity_id as string | null };
      });
    },
    async createSession(options) {
      return requestJson<AgentChatSession>("/session", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ trigger_context: options?.triggerContext, topic_id: options?.topicId })
      });
    },

    async listSessions(listOptions) {
      const params = new URLSearchParams();
      if (listOptions?.purpose) params.set("purpose", listOptions.purpose);
      if (listOptions?.taskId) params.set("task_id", listOptions.taskId);
      const payload = await requestJson<{ sessions?: unknown[] }>(
        `/sessions${params.size ? `?${params.toString()}` : ""}`
      );
      return (payload.sessions ?? []).map(toSessionSummary).filter(isPresent).sort(compareSessionSummaries);
    },

    async listSessionPage(options) {
      const params = new URLSearchParams({ purpose: options?.purpose ?? "ordinary_chat", limit: String(options?.limit ?? 30) });
      if (options?.q) params.set("q", options.q);
      if (options?.topicId) params.set("topic_id", options.topicId);
      if (options?.includeCollaboration) params.set("include_collaboration", "true");
      if (options?.cursor) params.set("cursor", options.cursor);
      const payload = await requestJson<{ sessions?: unknown[]; has_more?: boolean; next_cursor?: string | null }>(
        `/sessions?${params}`, { signal: options?.signal });
      return { sessions: (payload.sessions ?? []).map(toSessionSummary).filter(isPresent),
        hasMore: payload.has_more === true, nextCursor: typeof payload.next_cursor === "string" ? payload.next_cursor : null };
    },
    async listTopics() { return (await requestJson<{ topics: AgentTopic[] }>("/topics")).topics; },
    async createTopic(name) { return requestJson<AgentTopic>("/topics", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ name }) }); },
    async renameTopic(id, name) { return requestJson<AgentTopic>(`/topics/${encodeURIComponent(id)}`, { method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ name }) }); },
    async deleteTopic(id) { await requestJson(`/topics/${encodeURIComponent(id)}`, { method: "DELETE" }); },
    async moveSessionToTopic(sessionId, topicId) { await requestJson(`/session/${encodeURIComponent(sessionId)}/topic`, {
      method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ topic_id: topicId }),
    }); },
    async loadOlderMessages(sessionId, before, signal) {
      const query = new URLSearchParams({ limit: "40", before });
      const payload = await requestJson<{ messages?: unknown[]; message_page?: unknown }>(
        `/session/${encodeURIComponent(sessionId)}/messages?${query}`, { signal });
      return { messages: payload.messages ?? [], messagePage: readMessagePagination(payload.message_page) ?? { hasMore: false, beforeCursor: null } };
    },

    async createTaskCollaborationSession(taskId) {
      return requestJson<AgentChatSession>(
        `/task/${encodeURIComponent(taskId)}/collaboration/session`,
        { method: "POST" }
      );
    },

    async createTaskExecutionDebugSession(taskId, runId, sessionId) {
      return requestJson<AgentChatSession>(
        `/task/${encodeURIComponent(taskId)}/execution-session/debug`,
        {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({ run_id: runId, session_id: sessionId })
        }
      );
    },

    async loadTaskExecutionSession(taskId, runId, sessionId, signal) {
      const query = new URLSearchParams({ run_id: runId, session_id: sessionId });
      const response = await request(
        `/task/${encodeURIComponent(taskId)}/execution-session?${query}`,
        { signal }
      );
      const text = await response.text();
      const data = text ? JSON.parse(text) : null;
      if (response.status === 404) return null;
      if (!response.ok) throw new Error(getResponseErrorMessage(data, response.status));
      return toLoadedSession(data);
    },

    async getFrontendActionRegistry() {
      return requestJson<unknown>("/frontend-action-registry");
    },

    async submitFrontendActionResult(sessionId, actionId, result) {
      await requestJson<unknown>(`/frontend-actions/${encodeURIComponent(actionId)}/result`, {
        method: "POST",
        headers: { "Content-Type": "application/json", "x-agent-session-id": sessionId },
        body: JSON.stringify(result)
      });
    },

    async loadSession(sessionId, options) {
      const query = options?.messageLimit ? `?message_limit=${options.messageLimit}` : "";
      const response = await request(`/session/${encodeURIComponent(sessionId)}${query}`, { signal: options?.signal });
      const text = await response.text();
      const data = text ? JSON.parse(text) : null;

      if (response.status === 404) {
        return null;
      }
      if (!response.ok) {
        throw new Error(getResponseErrorMessage(data, response.status));
      }

      return toLoadedSession(data);
    },

    async streamSession(sessionId, options) {
      const response = await request(
        `/session/${encodeURIComponent(sessionId)}/stream${options.messageLimit ? `?message_limit=${options.messageLimit}` : ""}`,
        { signal: options.signal }
      );

      if (!response.ok) {
        const text = await response.text();
        const data = text ? JSON.parse(text) : null;
        throw new AgentSessionStreamError(getResponseErrorMessage(data, response.status), response.status);
      }

      await readSessionSseStream(response, options.onEvent);
    },

    async listAgentMessages(sessionId, options) {
      const query = new URLSearchParams({ limit: "50" });
      if (options?.cursor) query.set("cursor", options.cursor);
      return agentMessagePageSchema.parse(await requestJson<unknown>(
        `/session/${encodeURIComponent(sessionId)}/agent-messages?${query}`, { signal: options?.signal }
      ));
    },

    async streamAgentMessages(sessionId, options) {
      const response = await request(`/session/${encodeURIComponent(sessionId)}/agent-messages/stream`, { signal: options.signal });
      if (!response.ok) throw new Error(getResponseErrorMessage(await response.json(), response.status));
      await readSessionSseStream(response, (event) => {
        if (event.type === "agent_message" && event.sessionId === sessionId) options.onMessage();
      });
    },

    async updateSessionTitle(sessionId, title, options) {
      const normalizedTitle = title.trim();
      if (!normalizedTitle) {
        return;
      }

      await requestJson<unknown>(
        `/session/${encodeURIComponent(sessionId)}/title`,
        {
          method: "PATCH",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            title: normalizedTitle,
            is_title_manually_edited: options?.isTitleManuallyEdited
          })
        }
      );
    },

    async deleteSession(sessionId) {
      await requestJson<unknown>(
        `/session/${encodeURIComponent(sessionId)}`,
        { method: "DELETE" }
      );
    },

    async getModels() {
      const payload = await requestJson<unknown>("/models");
      return toModelsResponse(payload);
    },

    async getUiRegistry() {
      return requestJson<unknown>("/ui-registry");
    },

    async resolveRenderRef(renderRef, sessionId) {
      const params = new URLSearchParams({ session_id: sessionId });
      return requestJson<unknown>(
        `/render-ref/${encodeURIComponent(renderRef)}?${params.toString()}`
      );
    },

    async replyPermission(requestId, options) {
      await requestJson<unknown>(`/permission/${encodeURIComponent(requestId)}/reply`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          session_id: options.sessionId,
          reply: options.reply,
          message: options.message
        })
      });
    },

    async getQuestionStatus(sessionId, requestId) {
      const value = await requestJson<{ status: "pending" | "answered" | "rejected" | "invalidated" }>(`/session/${encodeURIComponent(sessionId)}/questions/${encodeURIComponent(requestId)}`, { cache: "no-store" });
      if (!["pending", "answered", "rejected", "invalidated"].includes(value.status)) throw new Error("问题状态核对失败");
      return value;
    },
    async replyQuestion(requestId, options) {
      await requestJson<unknown>(`/question/${encodeURIComponent(requestId)}/reply`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          session_id: options.sessionId,
          answers: options.answers
        })
      });
    },

    async rejectQuestion(requestId, options) {
      await requestJson<unknown>(`/question/${encodeURIComponent(requestId)}/reject`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          session_id: options.sessionId
        })
      });
    },

    async refreshCredential(sessionId, requestId) {
      await options.getAccessToken?.(true);
      await requestJson(`/session/${encodeURIComponent(sessionId)}/credentials`, {
        method: "POST", headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ request_id: requestId })
      });
    },
    async abort(sessionId) {
      await requestJson<unknown>("/abort", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ session_id: sessionId })
      });
    }
  };
}

async function fetchAgent(
  baseUrl: string,
  path: string,
  init?: RequestInit,
  getAccessToken?: AccessTokenProvider,
  getProjectId?: () => Promise<string | undefined>,
  prefix = API_PATH
) {
  const accessToken = await getAccessToken?.();
  const projectId = await getProjectId?.();
  const hasContextHeaders = Boolean(accessToken || projectId);
  const headers = hasContextHeaders ? new Headers(init?.headers) : undefined;
  if (accessToken) headers?.set("Authorization", `Bearer ${accessToken}`);
  if (projectId) headers?.set("X-Project-Id", projectId);
  const requestInit = hasContextHeaders ? { ...init, headers } : init;

  return fetch(`${baseUrl}${prefix}${path}`, requestInit);
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null;
}

function isPresent<T>(value: T | null | undefined): value is T {
  return value !== null && value !== undefined;
}

function toModelsResponse(value: unknown): AgentModelsResponse {
  if (!isRecord(value)) {
    return { defaultModel: "", models: [] };
  }

  const models = Array.isArray(value.models) ? value.models.map(toModelOption).filter(isPresent) : [];
  const defaultModel = typeof value.default_model === "string" ? value.default_model : models[0]?.id ?? "";
  return {
    defaultModel,
    models
  };
}

function toModelOption(value: unknown): AgentModelOption | null {
  if (!isRecord(value) || typeof value.id !== "string") {
    return null;
  }

  const label = typeof value.label === "string" && value.label.trim() ? value.label : value.id;
  const description =
    typeof value.description === "string" && value.description.trim() ? value.description : label;
  const icon = value.icon === "bolt" || value.icon === "sparkle" ? value.icon : "sparkle";

  return {
    id: value.id,
    label,
    description,
    icon
  };
}

function getResponseErrorMessage(data: unknown, status: number) {
  return isRecord(data) && typeof data.message === "string"
    ? data.message
    : `Agent API failed with HTTP ${status}`;
}

function toMillis(value: unknown) {
  if (typeof value === "number" && Number.isFinite(value)) {
    return value;
  }
  if (typeof value === "string" && value.trim()) {
    const parsed = new Date(value).getTime();
    return Number.isFinite(parsed) ? parsed : Date.now();
  }
  return Date.now();
}

function normalizeTitle(value: unknown) {
  return typeof value === "string" && value.trim() ? value.trim() : "新对话";
}

function readRunStatus(value: unknown): AgentRunStatus | undefined {
  return value === "waiting_input" || value === "running" || value === "completed" || value === "error" || value === "aborted"
    ? value
    : undefined;
}

function readSessionPurpose(value: unknown): AgentSessionPurpose {
  return value === "task_execution" || value === "task_collaboration" ? value : "ordinary_chat";
}

function toSessionSummary(value: unknown): AgentChatSessionSummary | null {
  if (!isRecord(value)) {
    return null;
  }

  const id = typeof value.id === "string" ? value.id : typeof value.session_id === "string" ? value.session_id : "";
  if (!id) {
    return null;
  }

  return {
    id,
    title: normalizeTitle(value.title),
    topicId: typeof value.topic_id === "string" ? value.topic_id : null,
    topicName: typeof value.topic_name === "string" ? value.topic_name : undefined,
    searchSnippet: typeof value.search_snippet === "string" ? value.search_snippet : undefined,
    createdAt: toMillis(value.created_at),
    updatedAt: toMillis(value.updated_at),
    status: typeof value.status === "string" ? value.status : undefined,
    parentSessionId: typeof value.parent_session_id === "string" ? value.parent_session_id : undefined,
    isStreaming: typeof value.is_streaming === "boolean" ? value.is_streaming : undefined,
    runStatus: readRunStatus(value.run_status),
    purpose: readSessionPurpose(value.purpose),
    taskId: typeof value.task_id === "string" ? value.task_id : undefined,
    trigger: isRecord(value.trigger) && value.trigger.workflow === "water_quality_complaint" &&
      typeof value.trigger.subject_id === "string" && typeof value.trigger.occurred_at === "string" &&
      Number.isFinite(Date.parse(value.trigger.occurred_at))
      ? { subjectId: value.trigger.subject_id, workflow: "water_quality_complaint", occurredAt: value.trigger.occurred_at }
      : undefined
  };
}

function toLoadedSession(value: unknown): AgentLoadedChatSession {
  const summary = toSessionSummary(value);
  if (!summary || !isRecord(value)) {
    throw new Error("Invalid agent session payload");
  }

  return {
    ...summary,
    sessionId: typeof value.session_id === "string" ? value.session_id : summary.id,
    isTitleManuallyEdited:
      typeof value.is_title_manually_edited === "boolean" ? value.is_title_manually_edited : false,
    messages: Array.isArray(value.messages) ? value.messages : [],
    messagePage: readMessagePagination(value.message_page)
  };
}

async function readSessionSseStream(
  response: Response,
  onEvent: (event: AgentSessionStreamEvent) => void
) {
  if (!response.body) {
    return;
  }

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

  while (true) {
    const { done, value } = await reader.read();
    buffer += decoder.decode(value, { stream: !done });

    let delimiterIndex = buffer.indexOf("\n\n");
    while (delimiterIndex !== -1) {
      const rawEvent = buffer.slice(0, delimiterIndex);
      buffer = buffer.slice(delimiterIndex + 2);
      emitSessionSseEvent(rawEvent, onEvent);
      delimiterIndex = buffer.indexOf("\n\n");
    }

    if (done) {
      break;
    }
  }

  if (buffer.trim()) {
    emitSessionSseEvent(buffer, onEvent);
  }
}

function emitSessionSseEvent(
  rawEvent: string,
  onEvent: (event: AgentSessionStreamEvent) => void
) {
  const lines = rawEvent.split(/\r?\n/);
  const eventType = lines
    .find((line) => line.startsWith("event:"))
    ?.slice("event:".length)
    .trim();
  const dataText = lines
    .filter((line) => line.startsWith("data:"))
    .map((line) => line.slice("data:".length).trimStart())
    .join("\n");

  if (!eventType || !dataText) {
    return;
  }

  const data = JSON.parse(dataText) as unknown;
  if (!isRecord(data)) {
    return;
  }

  if (eventType === "state") {
    const sessionId = typeof data.session_id === "string" ? data.session_id : "";
    onEvent({
      type: "state",
      executionPlans: Array.isArray(data.execution_plans) ? data.execution_plans : undefined,
      messagePage: readMessagePagination(data.message_page),
      sessionId,
      messages: Array.isArray(data.messages) ? data.messages : [],
      isStreaming: data.is_streaming === true,
      runStatus: readRunStatus(data.run_status)
    });
    return;
  }

  if (!isSessionStreamDataEventType(eventType)) {
    return;
  }

  onEvent({
    type: eventType,
    sessionId: typeof data.session_id === "string" ? data.session_id : undefined,
    data
  });
}

function isSessionStreamDataEventType(value: string): value is AgentSessionStreamDataEventType {
  return (
    value === "final_answer" ||
    value === "token" ||
    value === "progress" ||
    value === "todo_update" ||
    value === "execution_plan" ||
    value === "permission_request" ||
    value === "permission_response" ||
    value === "run_status" ||
    value === "interaction_request" ||
    value === "question_request" ||
    value === "question_response" ||
    value === "tool_call" ||
    value === "frontend_action" ||
    value === "frontend_action_result" ||
    value === "answer_ui" ||
    value === "ui_envelope" ||
    value === "session_title" ||
    value === "done" ||
    value === "aborted" ||
    value === "error" ||
    value === "credential_refresh_required" ||
    value === "credential_refreshed" ||
    value === "credential_refresh_failed" ||
    value === "auth_required"
    || value === "agent_message"
    || value === "user_input"
  );
}

function compareSessionSummaries(left: AgentChatSessionSummary, right: AgentChatSessionSummary) {
  const createdAtDiff = right.createdAt - left.createdAt;
  if (createdAtDiff !== 0) {
    return createdAtDiff;
  }

  const updatedAtDiff = right.updatedAt - left.updatedAt;
  if (updatedAtDiff !== 0) {
    return updatedAtDiff;
  }

  return right.id.localeCompare(left.id);
}

function readMessagePagination(value: unknown): AgentMessagePagination | undefined {
  if (!isRecord(value)) return undefined;
  return { hasMore: value.has_more === true, beforeCursor: typeof value.before_cursor === "string" ? value.before_cursor : null };
}

function answerStateTokenActor(token: string | null): string {
  if (!token) return "development-context";
  try {
    const payload: unknown = JSON.parse(atob(token.split(".")[1].replaceAll("-", "+").replaceAll("_", "/")));
    if (isRecord(payload) && typeof payload.sub === "string") return JSON.stringify([payload.iss, payload.sub]);
  } catch { /* Non-JWT development credentials use the enclosing workbench owner. */ }
  return "development-context";
}