/**
 * Ideas API client
 * Used for conversation persistence
 */

import { apiGet, apiPost, apiPatch } from "./client";

export enum IdeaStatus {
  CAPTURED = "CAPTURED",
  REVIEWING = "REVIEWING",
  APPROVED = "APPROVED",
  IN_PROGRESS = "IN_PROGRESS",
  COMPLETED = "COMPLETED",
  ARCHIVED = "ARCHIVED",
}

export interface Idea {
  id: string;
  workspaceId: string;
  domainId?: string | null;
  projectId?: string | null;
  title?: string | null;
  content: string;
  status: IdeaStatus;
  priority: string;
  category?: string | null;
  tags: string[];
  metadata: Record<string, unknown>;
  creatorId: string;
  createdAt: string;
  updatedAt: string;
}

export interface CreateIdeaRequest {
  title?: string;
  content: string;
  domainId?: string;
  projectId?: string;
  status?: IdeaStatus;
  priority?: string;
  category?: string;
  tags?: string[];
  metadata?: Record<string, unknown>;
}

export interface UpdateIdeaRequest {
  title?: string;
  content?: string;
  domainId?: string;
  projectId?: string;
  status?: IdeaStatus;
  priority?: string;
  category?: string;
  tags?: string[];
  metadata?: Record<string, unknown>;
}

export interface QueryIdeasRequest {
  page?: number;
  limit?: number;
  status?: IdeaStatus;
  domainId?: string;
  projectId?: string;
  category?: string;
  search?: string;
}

export interface QueryIdeasResponse {
  data: Idea[];
  meta: {
    total: number;
    page: number;
    limit: number;
    totalPages: number;
  };
}

/**
 * Create a new idea (conversation)
 */
export async function createIdea(request: CreateIdeaRequest): Promise<Idea> {
  return apiPost<Idea>("/api/ideas", request);
}

/**
 * Quick capture an idea
 */
export async function captureIdea(content: string, title?: string): Promise<Idea> {
  return apiPost<Idea>("/api/ideas/capture", { content, title });
}

/**
 * Get all ideas with optional filters
 */
export async function queryIdeas(params: QueryIdeasRequest = {}): Promise<QueryIdeasResponse> {
  const queryParams = new URLSearchParams();

  if (params.page) queryParams.set("page", params.page.toString());
  if (params.limit) queryParams.set("limit", params.limit.toString());
  if (params.status) queryParams.set("status", params.status);
  if (params.domainId) queryParams.set("domainId", params.domainId);
  if (params.projectId) queryParams.set("projectId", params.projectId);
  if (params.category) queryParams.set("category", params.category);
  if (params.search) queryParams.set("search", params.search);

  const query = queryParams.toString();
  const endpoint = query ? `/api/ideas?${query}` : "/api/ideas";

  return apiGet<QueryIdeasResponse>(endpoint);
}

/**
 * Get a single idea by ID
 */
export async function getIdea(id: string): Promise<Idea> {
  return apiGet<Idea>(`/api/ideas/${id}`);
}

/**
 * Update an idea
 */
export async function updateIdea(id: string, request: UpdateIdeaRequest): Promise<Idea> {
  return apiPatch<Idea>(`/api/ideas/${id}`, request);
}

/**
 * Get conversations (ideas with category='conversation')
 */
export async function getConversations(
  params: Omit<QueryIdeasRequest, "category"> = {}
): Promise<QueryIdeasResponse> {
  return queryIdeas({ ...params, category: "conversation" });
}

/**
 * Create a conversation
 */
export async function createConversation(
  title: string,
  content: string,
  projectId?: string
): Promise<Idea> {
  return createIdea({
    title,
    content,
    ...(projectId !== undefined && { projectId }),
    category: "conversation",
    tags: ["chat"],
    metadata: { conversationType: "chat" },
  });
}

/**
 * Update conversation content
 */
export async function updateConversation(
  id: string,
  content: string,
  title?: string
): Promise<Idea> {
  return updateIdea(id, {
    content,
    ...(title !== undefined && { title }),
  });
}