import { apiService } from "./api";

export interface AreaItem {
  id: string;
  nome: string;
  descricao: string;
  created_at: string;
  updated_at: string;
}

export interface CriarAreaRequest {
  nome: string;
  descricao: string;
}

export interface CriarAreaSuccessResponse {
  success: true;
  id: string;
  nome: string;
  descricao: string;
}

export interface CriarAreaErrorResponse {
  success: false;
  message: string;
}

export type CriarAreaResponse = CriarAreaSuccessResponse | CriarAreaErrorResponse;

export interface EditarAreaBody {
  nome: string;
  descricao: string;
}

export interface EditarAreaSuccessResponse {
  success: true;
  id: string;
  nome: string;
  descricao: string;
}

export interface EditarAreaErrorResponse {
  success: false;
  message: string;
}

export interface DeletarAreaSuccessResponse {
  success: true;
  message: string;
}

export interface DeletarAreaErrorResponse {
  success: false;
  message: string;
}

export interface ListarAreasParams {
  nome?: string;
  page: number;
  per_page: number;
}

export interface ListarAreasResponseBody {
  success: true;
  total_registros: number;
  total_paginas: number;
  per_page: number;
  pagina_atual: number;
  data: AreaItem[];
}

class AreasService {
  async criar(nome: string, descricao: string): Promise<CriarAreaSuccessResponse> {
    const body: CriarAreaRequest = {
      nome: nome.trim(),
      descricao: (descricao ?? "").trim(),
    };

    const response = await apiService.post<CriarAreaResponse>(
      "https://prod-hgtx-intelligence-n8n.hgtx.com.br/webhook/codex/parecer/criar-area",
      body
    );

    if (response.data.success === false) {
      throw new Error(response.data.message ?? "Erro ao criar área");
    }

    return response.data as CriarAreaSuccessResponse;
  }

  async listar(params: ListarAreasParams): Promise<ListarAreasResponseBody> {
    const { page, per_page, nome } = params;

    const response = await apiService.get<ListarAreasResponseBody[]>(
      "https://prod-hgtx-intelligence-n8n.hgtx.com.br/webhook/codex/parecer/listar-areas",
      {
        params: {
          ...(nome != null && nome.trim() !== "" ? { nome: nome.trim() } : {}),
          page,
          per_page,
        },
      }
    );

    const first = Array.isArray(response.data) ? response.data[0] : response.data;

    if (!first || first.success !== true) {
      throw new Error("Resposta inválida ao listar áreas");
    }

    return first;
  }

  async listarTotal(): Promise<AreaItem[]> {
    interface ListarAreasTotalResponseItem {
      success: true;
      data: AreaItem[];
    }

    const response = await apiService.get<ListarAreasTotalResponseItem[]>(
      "https://prod-hgtx-intelligence-n8n.hgtx.com.br/webhook/codex/parecer/listar-areas-total"
    );

    const first = Array.isArray(response.data) ? response.data[0] : response.data;

    if (!first || first.success !== true || !Array.isArray(first.data)) {
      throw new Error("Resposta inválida ao listar áreas");
    }

    return first.data;
  }

  async editar(id: string, nome: string, descricao: string): Promise<EditarAreaSuccessResponse> {
    if (!id?.trim()) {
      throw new Error("ID da área é obrigatório");
    }

    const idEnc = encodeURIComponent(id.trim());
    const body: EditarAreaBody = {
      nome: nome.trim(),
      descricao: (descricao ?? "").trim(),
    };

    /** Mesmo prefixo de webhook que o fluxo n8n (UUID) usado nos endpoints de "parecer/areas". */
    const url = `https://prod-hgtx-intelligence-n8n.hgtx.com.br/webhook/fd073ec0-81ab-4681-8acd-b0da71f6ad30/codex/parecer/area/${idEnc}`;

    const response = await apiService.put<
      EditarAreaSuccessResponse | EditarAreaErrorResponse | (EditarAreaSuccessResponse | EditarAreaErrorResponse)[]
    >(
      url,
      body
    );

    const raw = response.data;
    const data = Array.isArray(raw) ? raw[0] : raw;

    if (!data || typeof data !== "object" || !("success" in data)) {
      throw new Error("Resposta inválida ao editar área");
    }

    if (data.success === false) {
      throw new Error((data as EditarAreaErrorResponse).message ?? "Erro ao editar área");
    }

    return data as EditarAreaSuccessResponse;
  }

  async deletar(id: string): Promise<DeletarAreaSuccessResponse> {
    if (!id?.trim()) {
      throw new Error("ID da área é obrigatório");
    }

    const idEnc = encodeURIComponent(id.trim());
    /** Mesmo prefixo de webhook que `parecerApi.excluir` (fluxo n8n com UUID). */
    const url = `https://prod-hgtx-intelligence-n8n.hgtx.com.br/webhook/4e6c2374-9c22-4c81-b558-45f0cfefa5c3/codex/parecer/areas/deletar/${idEnc}`;

    const response = await apiService.delete<
      DeletarAreaSuccessResponse | DeletarAreaErrorResponse | (DeletarAreaSuccessResponse | DeletarAreaErrorResponse)[]
    >(url);

    const raw = response.data;
    const data = Array.isArray(raw) ? raw[0] : raw;

    if (!data || typeof data !== "object" || !("success" in data)) {
      throw new Error("Resposta inválida ao excluir área");
    }

    if (data.success === false) {
      throw new Error((data as DeletarAreaErrorResponse).message ?? "Erro ao excluir área");
    }

    return data as DeletarAreaSuccessResponse;
  }
}

export const areasService = new AreasService();
