import { apiService } from "./api";
import { GlobalFunctions, TransferAreaProperties } from "@/GlobalFunctions";

export interface GerarParecerParams {
  titulo: string;
  area_id: string;
  prompt_id?: string;
  prompt: string;
  instrucao?: string;
  anexo?: File | null;
}

export interface GerarParecerSuccessResponse {
  success: true;
  id: string;
  titulo: string;
  conteudo_gerado: string;
  status: string;
}

export interface GerarParecerErrorResponse {
  success: false;
  message?: string;
}

export type GerarParecerResponse = GerarParecerSuccessResponse | GerarParecerErrorResponse;

const PARECER_WEBHOOK_BASE = "https://prod-hgtx-intelligence-n8n.hgtx.com.br/webhook/codex/parecer";

/** GET por id (detalhe / edição visualização) */
const PARECER_DETALHE_URL = (id: string) =>
  `https://prod-hgtx-intelligence-n8n.hgtx.com.br/webhook/2299acaf-70ee-47e3-a6fc-56dcc678d651/codex/parecer/${encodeURIComponent(id)}`;

const PARECER_CHAT_URL = (parecerId: string) =>
  `${PARECER_DETALHE_URL(parecerId)}/chat`;

const PARECER_CHAT_ENVIAR_URL = (parecerId: string) =>
  `https://prod-hgtx-intelligence-n8n.hgtx.com.br/webhook/1ce1f771-fe6c-4905-9dbb-a69826d72632/codex/parecer/chat/${encodeURIComponent(parecerId)}`;

const PARECER_CHAT_MSG_HISTORICO_URL = (messageId: string) =>
  `https://prod-hgtx-intelligence-n8n.hgtx.com.br/webhook/2299acaf-70ee-47e3-a6fc-56dcc678d651/codex/parecer/chat/${encodeURIComponent(messageId)}/historico`;

export interface ParecerChatHistoricoItem {
  id: string;
  parecer_id: string;
  role: string;
  parecer_anterior: string;
  parecer_atual: string;
  created_at: string;
}

export interface ParecerChatMessage {
  id: string;
  parecer_id: string;
  user_email: string;
  role: "user" | "assistant";
  content: string;
  created_at: string;
  tipo_resposta?: "chat" | "agente" | null;
}

export type ParecerChatModo = "chat" | "agente";

export type EnviarMensagemChatResposta =
  | { message: string }
  | { conteudo_gerado: string };

export interface ParecerDetalhe {
  id: string;
  estabelecimento_id: number;
  user_email: string;
  titulo: string;
  area_id: string;
  /** Nome da área vindo da API (evita depender só do cache de áreas no front). */
  area_nome?: string | null;
  prompt_id?: string | null;
  prompt_conteudo: string;
  instrucao: string;
  conteudo_gerado: string;
  anexo_url: string | null;
  anexo_nome: string | null;
  status: string;
  created_at: string;
  updated_at: string;
  criado_por: string | null;
  atualizado_por: string | null;
}

/** Extrai o objeto de detalhe quando a API devolve array, objeto com `data`, ou mistura. */
function extrairParecerDetalheRaw(raw: unknown): Record<string, unknown> | null {
  if (raw == null) return null;

  if (Array.isArray(raw)) {
    const first = raw[0];
    if (first == null) return null;
    if (typeof first === "object" && !Array.isArray(first)) {
      const o = first as Record<string, unknown>;
      if (Array.isArray(o.data)) {
        const row = o.data[0];
        return row && typeof row === "object" && !Array.isArray(row) ? (row as Record<string, unknown>) : null;
      }
      if ("id" in o) return o;
    }
    return null;
  }

  if (typeof raw === "object") {
    const o = raw as Record<string, unknown>;
    if (Array.isArray(o.data)) {
      const row = o.data[0];
      return row && typeof row === "object" && !Array.isArray(row) ? (row as Record<string, unknown>) : null;
    }
    if (o.data != null && typeof o.data === "object" && !Array.isArray(o.data) && "id" in (o.data as object)) {
      return o.data as Record<string, unknown>;
    }
    if ("id" in o) return o;
  }

  return null;
}

function normalizarParecerDetalhe(row: Record<string, unknown>): ParecerDetalhe {
  return {
    id: String(row.id ?? ""),
    estabelecimento_id: Number(row.estabelecimento_id ?? 0),
    user_email: String(row.user_email ?? ""),
    titulo: String(row.titulo ?? ""),
    area_id: String(row.area_id ?? ""),
    area_nome: row.area_nome != null ? String(row.area_nome) : null,
    prompt_id: row.prompt_id != null ? String(row.prompt_id) : null,
    prompt_conteudo: String(row.prompt_conteudo ?? ""),
    instrucao: String(row.instrucao ?? ""),
    conteudo_gerado: String(row.conteudo_gerado ?? ""),
    anexo_url: row.anexo_url != null ? String(row.anexo_url) : null,
    anexo_nome: row.anexo_nome != null ? String(row.anexo_nome) : null,
    status: String(row.status ?? ""),
    created_at: String(row.created_at ?? ""),
    updated_at: String(row.updated_at ?? ""),
    criado_por: row.criado_por != null ? String(row.criado_por) : null,
    atualizado_por: row.atualizado_por != null ? String(row.atualizado_por) : null,
  };
}

export interface EditarParecerTituloAreaBody {
  titulo: string;
  area_id: string;
}

export interface EditarParecerTituloAreaSuccessResponse {
  success: true;
  id: string;
  titulo: string;
  area_id: string;
}

export interface EditarParecerTituloAreaErrorResponse {
  success: false;
  message?: string;
}

export type ParecerStatus = "processando" | "concluido" | "erro";

export interface ParecerListItem {
  id: string;
  titulo: string;
  prompt_id: string;
  area_id: string;
  status: string;
  area_nome: string;
  prompt_nome: string;
  criado_por: string | null;
  created_at: string;
  updated_at: string;
}

export interface ListarParecerParams {
  titulo?: string;
  page?: number;
  per_page?: number;
  area_id?: string;
  status?: ParecerStatus;
}

export interface ListarParecerResponse {
  success: boolean;
  total_registros: number;
  total_paginas: number;
  per_page: number;
  pagina_atual: number;
  data: ParecerListItem[];
}

class ParecerService {
  async gerar(params: GerarParecerParams): Promise<GerarParecerSuccessResponse> {
    if (!params.titulo?.trim()) {
      throw new Error("Título é obrigatório");
    }

    if (!params.area_id?.trim()) {
      throw new Error("Área é obrigatória");
    }

    if (!params.prompt?.trim()) {
      throw new Error("Prompt é obrigatório");
    }

    const userEmail = GlobalFunctions.getTransferProperty(
      TransferAreaProperties.UsuarioEmail
    );
    const estabelecimentoId = GlobalFunctions.getTransferProperty(
      TransferAreaProperties.EstabelecimentoCodigo
    );

    if (!userEmail) {
      throw new Error("Usuário não identificado (user_email)");
    }

    if (!estabelecimentoId) {
      throw new Error("Estabelecimento não identificado (estabelecimento_id)");
    }

    const form = new FormData();
    form.append("user_email", String(userEmail));
    form.append("estabelecimento_id", String(estabelecimentoId));
    form.append("titulo", params.titulo.trim());
    form.append("area_id", params.area_id.trim());
    if (params.prompt_id?.trim()) {
      form.append("prompt_id", params.prompt_id.trim());
    }
    form.append("prompt", params.prompt.trim());
    form.append("instrucao", (params.instrucao ?? "").trim());

    if (params.anexo) {
      form.append("anexo", params.anexo);
    }

    // Sem limite de tempo: a geração pode levar vários minutos até o webhook responder.
    const response = await apiService.postFormData<GerarParecerResponse>(
      `${PARECER_WEBHOOK_BASE}/gerar`,
      form,
      { timeout: 0 }
    );

    if (response.data.success === false) {
      throw new Error(
        (response.data as GerarParecerErrorResponse).message ?? "Erro ao gerar parecer"
      );
    }

    const data = response.data as GerarParecerSuccessResponse;
    if (data.status !== "concluido") {
      throw new Error(
        "A geração do parecer ainda não foi concluída. Tente novamente em instantes."
      );
    }

    return data;
  }

  async listar(params: ListarParecerParams = {}): Promise<ListarParecerResponse> {
    const query: Record<string, string | number> = {};
    if (params.titulo?.trim()) query.titulo = params.titulo.trim();
    if (params.page != null) query.page = params.page;
    if (params.per_page != null) query.per_page = params.per_page;
    if (params.area_id?.trim()) query.area_id = params.area_id.trim();
    if (params.status?.trim()) query.status = params.status;

    const response = await apiService.get<ListarParecerResponse[] | ListarParecerResponse>(
      `${PARECER_WEBHOOK_BASE}/listar`,
      { params: query }
    );

    // API retorna um array cujo primeiro elemento é o objeto { success, total_registros, data, ... }
    const raw = response.data;
    const payload = Array.isArray(raw) ? raw[0] : raw;

    if (!payload || !(payload as ListarParecerResponse).success) {
      throw new Error("Erro ao listar pareceres");
    }
    return payload as ListarParecerResponse;
  }

  async buscarPorId(id: string): Promise<ParecerDetalhe> {
    if (!id?.trim()) {
      throw new Error("ID do parecer é obrigatório");
    }
    const response = await apiService.get<unknown>(PARECER_DETALHE_URL(id));
    const row = extrairParecerDetalheRaw(response.data);
    if (!row?.id) {
      throw new Error("Parecer não encontrado");
    }
    return normalizarParecerDetalhe(row);
  }

  async enviarMensagemChat(
    parecerId: string,
    messageText: string,
    modo: ParecerChatModo = "agente"
  ): Promise<EnviarMensagemChatResposta> {
    const userEmail = GlobalFunctions.getTransferProperty(TransferAreaProperties.UsuarioEmail);
    if (!userEmail) {
      throw new Error("Usuário não identificado (user_email)");
    }
    if (!parecerId?.trim()) {
      throw new Error("ID do parecer é obrigatório");
    }
    if (!messageText?.trim()) {
      throw new Error("Digite uma mensagem");
    }
    type ChatPostPayload = { success: boolean; conteudo_gerado?: string; message?: string };
    const response = await apiService.post<ChatPostPayload[] | ChatPostPayload>(
      PARECER_CHAT_ENVIAR_URL(parecerId),
      { user_email: String(userEmail), message: messageText.trim(), modo },
      { timeout: 0, headers: { "Content-Type": "application/json" } }
    );
    const raw = response.data;
    const payload = Array.isArray(raw) ? raw[0] : raw;

    if (!payload?.success) {
      throw new Error(payload?.message ?? "Erro ao processar a mensagem do chat");
    }

    if (modo === "chat") {
      if (typeof payload.message !== "string") {
        throw new Error(payload?.message ?? "Erro ao processar resposta do chat");
      }
      return { message: payload.message };
    }

    // modo === "agente"
    if (typeof payload.conteudo_gerado !== "string") {
      throw new Error(payload?.message ?? "Erro ao processar atualização do parecer");
    }
    return { conteudo_gerado: payload.conteudo_gerado };
  }

  async listarChat(parecerId: string): Promise<ParecerChatMessage[]> {
    if (!parecerId?.trim()) {
      return [];
    }
    const response = await apiService.get<
      Array<{ success: boolean; data?: ParecerChatMessage[] }> | { success: boolean; data?: ParecerChatMessage[] }
    >(PARECER_CHAT_URL(parecerId));
    const raw = response.data;
    const payload = Array.isArray(raw) ? raw[0] : raw;
    if (!payload?.success || !Array.isArray(payload.data)) {
      return [];
    }
    return payload.data;
  }

  async buscarHistoricoChatMensagem(messageId: string): Promise<ParecerChatHistoricoItem> {
    if (!messageId?.trim()) {
      throw new Error("ID da mensagem é obrigatório");
    }
    const response = await apiService.get<
      Array<{ success: boolean; data?: ParecerChatHistoricoItem[] }> | { success: boolean; data?: ParecerChatHistoricoItem[] }
    >(PARECER_CHAT_MSG_HISTORICO_URL(messageId));
    const raw = response.data;
    const payload = Array.isArray(raw) ? raw[0] : raw;
    const item = payload?.data?.[0];
    if (!payload?.success || !item) {
      throw new Error("Não foi possível carregar o histórico desta resposta.");
    }
    return item;
  }

  async editarTituloArea(
    parecerId: string,
    body: EditarParecerTituloAreaBody
  ): Promise<EditarParecerTituloAreaSuccessResponse> {
    if (!parecerId?.trim()) {
      throw new Error("ID do parecer é obrigatório");
    }
    if (!body?.titulo?.trim()) {
      throw new Error("Título é obrigatório");
    }
    if (!body?.area_id?.trim()) {
      throw new Error("Área é obrigatória");
    }

    const url = `https://prod-hgtx-intelligence-n8n.hgtx.com.br/webhook/fd073ec0-81ab-4681-8acd-b0da71f6ad30/codex/parecer/${encodeURIComponent(
      parecerId
    )}/editar`;

    const response = await apiService.put<
      | EditarParecerTituloAreaSuccessResponse
      | EditarParecerTituloAreaErrorResponse
      | (EditarParecerTituloAreaSuccessResponse | EditarParecerTituloAreaErrorResponse)[]
    >(url, {
      titulo: body.titulo.trim(),
      area_id: body.area_id.trim(),
    });

    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 o parecer");
    }

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

    return data as EditarParecerTituloAreaSuccessResponse;
  }

  async excluir(id: string): Promise<{ message: string }> {
    if (!id?.trim()) {
      throw new Error("ID do parecer é obrigatório");
    }
    const url = `https://prod-hgtx-intelligence-n8n.hgtx.com.br/webhook/4e6c2374-9c22-4c81-b558-45f0cfefa5c3/codex/parecer/deletar/${encodeURIComponent(id)}`;
    const response = await apiService.delete<{ success: boolean; message?: string }>(url);
    const body = response.data;
    if (!body?.success) {
      throw new Error(body?.message ?? "Erro ao excluir parecer");
    }
    return { message: body.message ?? "Parecer excluído com sucesso." };
  }
}

export const parecerService = new ParecerService();
