import { useState } from "react";
import api from "../services/api";

/**
 * Hook para gerenciar operações de custas processuais
 */
export const useCustasProcessuais = (processoId: string) => {
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  /**
   * Adiciona uma nova custa processual
   */
  const addCusta = async (data: any) => {
    setIsLoading(true);
    setError(null);

    try {
      // Validações
      if (!data.tipo) throw new Error("Tipo da custa é obrigatório");
      if (!data.descricao) throw new Error("Descrição da custa é obrigatória");
      if (!data.valor) throw new Error("Valor da custa é obrigatório");

      // Preparar dados
      const payload = {
        processoId,
        tipo: data.tipo,
        descricao: data.descricao,
        valor: Number(data.valor),
        percentual: data.percentual ? Number(data.percentual) : null,
        status: data.status || "PENDENTE",
        vencimento: data.vencimento || null,
        dataPagamento: data.dataPagamento || null,
        observacoes: data.observacoes || null,
        numeroParcelas: Number(data.numeroParcelas || 1),
        parcelaAtual: Number(data.parcelaAtual || 1),
        comprovante: data.comprovante || null,
      };

      // Fazer requisição
      const response = await api.post(
        `/processos/${processoId}/custas`,
        payload,
      );
      return response.data;
    } catch (err: any) {
      const errorMsg =
        err.response?.data?.details ||
        err.response?.data?.error ||
        err.message ||
        "Erro ao adicionar custa processual";
      setError(errorMsg);
      throw new Error(errorMsg);
    } finally {
      setIsLoading(false);
    }
  };

  /**
   * Atualiza uma custa processual existente
   */
  const updateCusta = async ({ id, data }: { id: string; data: any }) => {
    setIsLoading(true);
    setError(null);

    try {
      // Preparar dados
      const payload = {
        tipo: data.tipo,
        descricao: data.descricao,
        valor: Number(data.valor),
        percentual: data.percentual ? Number(data.percentual) : null,
        status: data.status,
        vencimento: data.vencimento,
        dataPagamento: data.dataPagamento,
        observacoes: data.observacoes,
        numeroParcelas: Number(data.numeroParcelas || 1),
        parcelaAtual: Number(data.parcelaAtual || 1),
        comprovante: data.comprovante,
      };

      // Fazer requisição
      const response = await api.put(`/custas/${id}`, payload);
      return response.data;
    } catch (err: any) {
      const errorMsg =
        err.response?.data?.error ||
        err.message ||
        "Erro ao atualizar custa processual";
      setError(errorMsg);
      throw new Error(errorMsg);
    } finally {
      setIsLoading(false);
    }
  };

  /**
   * Remove uma custa processual
   */
  const deleteCusta = async (id: string) => {
    setIsLoading(true);
    setError(null);

    try {
      await api.delete(`/custas/${id}`);
    } catch (err: any) {
      const errorMsg =
        err.response?.data?.error ||
        err.message ||
        "Erro ao excluir custa processual";
      setError(errorMsg);
      throw new Error(errorMsg);
    } finally {
      setIsLoading(false);
    }
  };

  /**
   * Busca todas as custas do processo
   */
  const getCustas = async () => {
    setIsLoading(true);
    setError(null);

    try {
      const response = await api.get(`/processos/${processoId}/custas`);
      return response.data;
    } catch (err: any) {
      const errorMsg =
        err.response?.data?.error ||
        err.message ||
        "Erro ao buscar custas processuais";
      setError(errorMsg);
      throw new Error(errorMsg);
    } finally {
      setIsLoading(false);
    }
  };

  return {
    addCusta,
    updateCusta,
    deleteCusta,
    getCustas,
    isLoading,
    error,
  };
};