import { service as http, API_BASE_URL } from "@/utils/request";
import type { AxiosPromise } from "axios";

// Helper to get token for Authorization header
function getToken(): string {
  return localStorage.getItem("auth_token") || "";
}

function authHeaders(): { Authorization?: string } {
  const t = getToken();
  return t ? { Authorization: `Bearer ${t}` } : {};
}

/** ---------------- Codex Session API ---------------- **/

/**
 * 会话开始结果
 */
export interface StartResult {
  status: "active" | "starting" | "queued" | "unavailable" | "forbidden";
  position?: number;
  sessionId?: number;
}

/**
 * 开始会话请求
 */
export interface StartSessionRequest {
  fileIds: number[];
}

/**
 * 开始会话
 * POST /api/codex/session/start
 */
export function startSession(
  payload: StartSessionRequest,
): AxiosPromise<StartResult> {
  return http.post("/codex/session/start", payload);
}

/**
 * 添加文件到会话请求
 */
export interface AddFileToSessionRequest {
  sessionId: number;
  fileIds: number[];
}

/**
 * 添加文件到会话
 * POST /api/codex/session/add-file
 */
export function addFileToSession(
  payload: AddFileToSessionRequest,
): AxiosPromise<{ message: string }> {
  return http.post("/codex/session/add-file", payload);
}

/**
 * 从会话中删除文件请求
 */
export interface RemoveFileFromSessionRequest {
  sessionId: number;
  fileIds: number[];
}

/**
 * 从会话中删除文件
 * POST /api/codex/session/remove-file
 */
export function removeFileFromSession(
  payload: RemoveFileFromSessionRequest,
): AxiosPromise<{ message: string }> {
  return http.post("/codex/session/remove-file", payload);
}

/**
 * 会话列表项
 */
export interface CodexSessionItem {
  id: number;
  userId: number;
  status: string;
  createdAt: string;
  updatedAt?: string;
  [key: string]: any;
}

/**
 * 分页响应
 */
export interface PageResponse<T> {
  content: T[];
  totalElements: number;
  totalPages: number;
  size: number;
  number: number;
  [key: string]: any;
}

/**
 * 列出会话（分页）
 * GET /api/codex/session
 */
export function listSessions(params?: {
  page?: number;
  size?: number;
}): AxiosPromise<PageResponse<CodexSessionItem>> {
  return http.get("/codex/session", {
    params: {
      page: params?.page ?? 0,
      size: params?.size ?? 20,
    },
  });
}

/**
 * 重启会话
 * POST /api/codex/session/restart
 */
export function restartSession(sessionId: number): AxiosPromise<StartResult> {
  return http.post("/codex/session/restart", null, {
    params: { sessionId },
  });
}

/**
 * 回合响应
 */
export interface TurnResponse {
  status: "starting" | "started" | "queue" | "failed";
  pos?: number;
}

/**
 * 用户输入请求
 */
export interface TurnRequest {
  sessionId: number;
  input: string;
  /** null: 沿用会话范围；[]: 清空；[...]: 本轮覆盖（若后端支持） */
  fileIds?: number[] | null;
}

/**
 * 用户输入内容（开启一轮会话turn）
 * POST /api/codex/session/turn
 */
export function startTurn(payload: TurnRequest): AxiosPromise<TurnResponse> {
  return http.post("/codex/session/turn", payload);
}

/**
 * 停止会话
 * DELETE /api/codex/session
 */
export function stopSession(): AxiosPromise<{ message: string }> {
  return http.delete("/codex/session");
}

/**
 * 删除单个会话
 * DELETE /api/codex/session
 */
export function deleteSession(sessionId: number | string): AxiosPromise<any> {
  return http.delete("/codex/session", {
    params: { sessionId },
  });
}

/**
 * Codex 回合数据（后端实际返回的结构）
 */
export interface CodexTurn {
  id: number;
  sessionId: number;
  role: string; // "user" | "assistant"
  inputType: string; // "turn/start" 等
  contentJson: string; // JSON 字符串
  createdAt: string;
  reply: string; // 包含多行响应数据
  codexTurnId?: number;
  [key: string]: any;
}

/**
 * 获取会话回合列表
 * GET /api/codex/session/turns
 */
export function listTurns(sessionId: number): AxiosPromise<CodexTurn[]> {
  return http.get("/codex/session/turns", {
    params: { sessionId },
  });
}

/**
 * 下载工作区文件内容
 * GET /api/codex/workspace/download
 */
export function downloadWorkspaceFile(path: string): AxiosPromise<Blob> {
  return http.get("/codex/workspace/download", {
    params: { path },
    responseType: "blob",
  });
}

/**
 * SSE 流式事件选项
 */
export interface StreamOptions {
  sessionId: number;
  onMessage?: (chunk: string | object) => void;
  onOpen?: () => void;
  onError?: (err: any) => void;
  onEnd?: () => void;
  signal?: AbortSignal;
}

/**
 * 建立与前端的SSE流连接
 * GET /api/codex/session/stream
 */
export function streamSession({
  sessionId,
  onMessage,
  onOpen,
  onError,
  onEnd,
  signal,
}: StreamOptions): { close: () => void } {
  const url = `${API_BASE_URL}/codex/session/stream?sessionId=${encodeURIComponent(sessionId)}`;

  const controller = new AbortController();
  let closed = false;

  if (signal) {
    if (signal.aborted) controller.abort();
    else
      signal.addEventListener("abort", () => controller.abort(), {
        once: true,
      });
  }

  (async () => {
    let reader: ReadableStreamDefaultReader | undefined;
    const decoder = new TextDecoder("utf-8");
    let buf = "";

    try {
      const extraHeaders = authHeaders();

      const res = await fetch(url, {
        method: "GET",
        headers: {
          Accept: "text/event-stream",
          "X-Accel-Buffering": "no",
          ...extraHeaders,
        },
        credentials: "include",
        signal: controller.signal,
      });

      if (!res.ok || !res.body)
        throw new Error(`SSE failed: ${res.status} ${res.statusText}`);

      onOpen && onOpen();

      reader = res.body.getReader();

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

        let idx;
        while ((idx = buf.indexOf("\n\n")) !== -1) {
          const chunk = buf.slice(0, idx);
          buf = buf.slice(idx + 2);

          if (chunk.startsWith(":")) continue;

          const data = chunk
            .split("\n")
            .filter((l) => l.startsWith("data:"))
            .map((l) => l.replace(/^data:\s?/, ""))
            .join("\n");

          if (data) {
            let payload: string | object = data;
            try {
              payload = JSON.parse(data);
            } catch (_) {}
            onMessage && onMessage(payload);
          }
        }
      }

      if (buf.trim()) {
        const data = buf
          .split("\n")
          .filter((l) => l.startsWith("data:"))
          .map((l) => l.replace(/^data:\s?/, ""))
          .join("\n");
        if (data) {
          let payload: string | object = data;
          try {
            payload = JSON.parse(data);
          } catch (_) {}
          onMessage && onMessage(payload);
        }
      }

      onEnd && onEnd();
    } catch (err: any) {
      const msg = (err && (err.name || err.message || ""))
        .toString()
        .toLowerCase();
      const isAbort =
        err?.name === "AbortError" ||
        msg.includes("aborted") ||
        msg.includes("bodystreambuffer") ||
        closed;

      if (isAbort) {
        onEnd && onEnd();
      } else {
        onError && onError(err);
      }
    } finally {
      try {
        reader && reader.releaseLock && reader.releaseLock();
      } catch {}
    }
  })();

  return {
    close: () => {
      closed = true;
      controller.abort();
    },
  };
}

/** ---------------- Codex Approval API ---------------- **/

/**
 * 命令决策请求
 */
export interface CommandDecisionRequest {
  approvalId: number;
  decision: "approved" | "approved_for_session" | "denied" | "abort";
}

/**
 * 提交命令决策
 * POST /api/codex/approval/commandDecision
 */
export function submitCommandDecision(
  payload: CommandDecisionRequest,
): AxiosPromise<{ message: string }> {
  return http.post("/codex/approval/commandDecision", payload);
}

/**
 * 补丁决策请求
 */
export interface PatchDecisionRequest {
  approvalId: number;
  decision: "approved" | "denied";
  fileChangeId?: number;
}

/**
 * 提交补丁决策
 * POST /api/codex/approval/patchDecision
 */
export function submitPatchDecision(
  payload: PatchDecisionRequest,
): AxiosPromise<{ message: string }> {
  return http.post("/codex/approval/patchDecision", payload);
}

/** ---------------- Export Default ---------------- **/

export default {
  // Session APIs
  startSession,
  addFileToSession,
  removeFileFromSession,
  listSessions,
  restartSession,
  startTurn,
  stopSession,
  listTurns,
  streamSession,
  deleteSession,
  downloadWorkspaceFile,
  // Approval APIs
  submitCommandDecision,
  submitPatchDecision,
  submitFileDecision,
};

/**
 * 文件处理决策请求
 */
export interface FileDecisionRequest {
  sessionId: number;
  tmpPath: string;
  /**
   * 父文件夹ID（可选，null/undefined 表示保存到根目录）
   * 后端为 Long 类型，这里使用 number | null 与其他文件相关 API 对齐
   */
  parentId?: number | null;
}

/**
 * 提交文件处理决策
 * POST /api/codex/session/file-decision
 */
export function submitFileDecision(
  payload: FileDecisionRequest,
): AxiosPromise<{ message: string }> {
  return http.post("/codex/session/file-decision", payload);
}