import type { Model3DTaskStatus } from "@/services/canvas";

type ApiResponse<T = any> = {
  success: boolean;
  data?: T;
  error?: string;
};

export type AiCadProviderStatus = {
  configured: boolean;
  source: "provider" | "env" | "none";
  providerName?: string | null;
  baseUrl?: string | null;
};

export type AiCadWorkspaceSummary = {
  id: string;
  name: string;
  generationProvider: "kittycad-cad" | "tripo-3d";
  versionCount: number;
  completedCount: number;
  hasPendingTasks: boolean;
  latestPrompt?: string | null;
  createdAt?: string | null;
  updatedAt?: string | null;
};

export type AiCadWorkspaceDocument = {
  id: string;
  name: string;
  prompt: string;
  generationProvider: "kittycad-cad" | "tripo-3d";
  modelVersion: string;
  viewerSettings: Record<string, unknown>;
  messages: Record<string, unknown>[];
  versions: Record<string, unknown>[];
  activeVersionId?: string | null;
  createdAt?: string | null;
  updatedAt?: string | null;
};

export type AiCadModelingSession = {
  sessionId: string;
  createdAt?: string | null;
};

export type AiCadModelingCommandPayload = {
  requestId?: string | null;
  responseType?: string | null;
  responseData?: Record<string, any> | null;
  snapshotUrl?: string | null;
  snapshotError?: string | null;
  raw?: any;
};

export const aiCadGenerationService = {
  async listWorkspaces(): Promise<ApiResponse<AiCadWorkspaceSummary[]>> {
    try {
      const response = await fetch("/api/ai-cad/workspaces");
      const data = await response.json();
      return data;
    } catch (_error) {
      return { success: false, error: "读取 AI-CAD 工作台列表失败" };
    }
  },

  async createWorkspace(params?: {
    name?: string;
  }): Promise<ApiResponse<AiCadWorkspaceSummary>> {
    try {
      const response = await fetch("/api/ai-cad/workspaces", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(params || {}),
      });
      const data = await response.json();
      return data;
    } catch (_error) {
      return { success: false, error: "创建 AI-CAD 工作台失败" };
    }
  },

  async getWorkspace(
    workspaceId: string
  ): Promise<ApiResponse<AiCadWorkspaceDocument | null>> {
    try {
      const response = await fetch(`/api/ai-cad/workspaces/${workspaceId}`);
      const data = await response.json();
      return data;
    } catch (_error) {
      return { success: false, error: "读取 AI-CAD 工作台失败" };
    }
  },

  async saveWorkspace(
    workspaceId: string,
    params: {
      name?: string;
      prompt: string;
      generationProvider: "kittycad-cad" | "tripo-3d";
      modelVersion: string;
      viewerSettings: Record<string, unknown>;
      messages: Record<string, unknown>[];
      versions: Record<string, unknown>[];
      activeVersionId?: string | null;
    }
  ): Promise<
    ApiResponse<{
      id: string;
      name: string;
      updatedAt?: string | null;
      summary?: AiCadWorkspaceSummary;
    }>
  > {
    try {
      const response = await fetch(`/api/ai-cad/workspaces/${workspaceId}`, {
        method: "PUT",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(params),
      });
      const data = await response.json();
      return data;
    } catch (_error) {
      return { success: false, error: "保存 AI-CAD 工作台失败" };
    }
  },

  async deleteWorkspace(
    workspaceId: string
  ): Promise<ApiResponse<{ id: string }>> {
    try {
      const response = await fetch(`/api/ai-cad/workspaces/${workspaceId}`, {
        method: "DELETE",
      });
      const data = await response.json();
      return data;
    } catch (_error) {
      return { success: false, error: "删除 AI-CAD 工作台失败" };
    }
  },

  async getProviderStatus(): Promise<ApiResponse<AiCadProviderStatus>> {
    try {
      const response = await fetch("/api/ai-cad/provider");
      const data = await response.json();
      return data;
    } catch (_error) {
      return { success: false, error: "读取 AI-CAD 提供商状态失败" };
    }
  },

  async createTask(params: {
    prompt?: string;
    outputFormat?: string;
    projectName?: string;
    iterationSourceTaskId?: string;
    sourceCode?: string;
    sourceRanges?: Record<string, unknown>[];
  }): Promise<
    ApiResponse<{
      taskId: string;
      status: Model3DTaskStatus;
      conversationId?: string | null;
      modelVersion?: string | null;
      outputFormat?: string | null;
      generationMode?: "create" | "iterate";
      sourceTaskId?: string | null;
      raw?: any;
    }>
  > {
    try {
      const response = await fetch("/api/ai-cad/tasks", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(params),
      });
      const data = await response.json();
      return data;
    } catch (_error) {
      return { success: false, error: "创建 AI-CAD 任务失败" };
    }
  },

  async createModelingSession(): Promise<ApiResponse<AiCadModelingSession>> {
    try {
      const response = await fetch("/api/ai-cad/modeling/session", {
        method: "POST",
      });
      const data = await response.json();
      return data;
    } catch (_error) {
      return { success: false, error: "创建官方建模会话失败" };
    }
  },

  async closeModelingSession(
    sessionId: string
  ): Promise<ApiResponse<{ sessionId: string }>> {
    try {
      const response = await fetch(
        `/api/ai-cad/modeling/session/${encodeURIComponent(sessionId)}`,
        {
          method: "DELETE",
        }
      );
      const data = await response.json();
      return data;
    } catch (_error) {
      return { success: false, error: "关闭官方建模会话失败" };
    }
  },

  async sendModelingCommand(params: {
    sessionId: string;
    cmd: Record<string, unknown>;
    cmdId?: string;
    captureSnapshot?: boolean;
    snapshotFormat?: "jpeg" | "png";
  }): Promise<ApiResponse<AiCadModelingCommandPayload>> {
    try {
      const response = await fetch("/api/ai-cad/modeling/command", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(params),
      });
      const data = await response.json();
      return data;
    } catch (_error) {
      return { success: false, error: "发送官方建模命令失败" };
    }
  },

  async getTask(taskId: string): Promise<
    ApiResponse<{
      taskId: string;
      type: string;
      status: Model3DTaskStatus;
      progress?: number | null;
      output?: Record<string, any>;
      modelUrl?: string | null;
      previewImageUrl?: string | null;
      errorMessage?: string | null;
      conversationId?: string | null;
      modelVersion?: string | null;
      outputFormat?: string | null;
      codeUrl?: string | null;
      downloadUrls?: Record<string, string>;
    }>
  > {
    try {
      const response = await fetch(`/api/ai-cad/tasks/${taskId}`);
      const data = await response.json();
      return data;
    } catch (_error) {
      return { success: false, error: "查询 AI-CAD 任务失败" };
    }
  },
};