import { useState, useCallback } from 'react';
import { rhService } from '../services/rhService';
import { useRhFeedback } from '../components/RhFeedbackNotification';

/**
 * Hook customizado para cálculos trabalhistas (INSS, IRRF, FGTS, Recisão)
 */
export const useCalculos = () => {
  const [calculos, setCalculos] = useState([]);
  const [tabelas, setTabelas] = useState(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);
  const { success, error: notifyError, handleBackendError } = useRhFeedback();

  /**
   * Calcular INSS
   */
  const calcularINSS = useCallback(async (payload) => {
    setLoading(true);
    setError(null);
    try {
      const response = await rhService.calcularINSS(payload);
      return response;
    } catch (err) {
      handleBackendError(err);
      throw err;
    } finally {
      setLoading(false);
    }
  }, []);

  /**
   * Calcular IRRF
   */
  const calcularIRRF = useCallback(async (payload) => {
    setLoading(true);
    setError(null);
    try {
      const response = await rhService.calcularIRRF(payload);
      return response;
    } catch (err) {
      handleBackendError(err);
      throw err;
    } finally {
      setLoading(false);
    }
  }, []);

  /**
   * Calcular FGTS
   */
  const calcularFGTS = useCallback(async (payload) => {
    setLoading(true);
    setError(null);
    try {
      const response = await rhService.calcularFGTS(payload);
      return response;
    } catch (err) {
      handleBackendError(err);
      throw err;
    } finally {
      setLoading(false);
    }
  }, []);

  /**
   * Calcular recisão
   */
  const calcularRecisao = useCallback(async (payload) => {
    setLoading(true);
    setError(null);
    try {
      const response = await rhService.calcularRecisao(payload);
      return response;
    } catch (err) {
      handleBackendError(err);
      throw err;
    } finally {
      setLoading(false);
    }
  }, []);

  /**
   * Calcular completo (INSS, IRRF, FGTS)
   */
  const calcularCompleto = useCallback(async (payload) => {
    setLoading(true);
    setError(null);
    try {
      const response = await rhService.calcularCompleto(payload);
      return response;
    } catch (err) {
      handleBackendError(err);
      throw err;
    } finally {
      setLoading(false);
    }
  }, []);

  /**
   * Salvar cálculo no banco
   */
  const salvarCalculo = useCallback(async (payload) => {
    setLoading(true);
    setError(null);
    try {
      const response = await rhService.salvarCalculo(payload);
      success('Cálculo Salvo', 'As informações da folha foram registradas com sucesso.');
      return response;
    } catch (err) {
      handleBackendError(err);
      throw err;
    } finally {
      setLoading(false);
    }
  }, []);

  /**
   * Buscar cálculos por colaborador
   */
  const fetchCalculosByColaborador = useCallback(async (idcolaborador, params = {}) => {
    setLoading(true);
    setError(null);
    try {
      const response = await rhService.getCalculosByColaborador(idcolaborador, params);
      const calculosList = response?.calculos || response?.data || [];
      setCalculos(calculosList);
      return response;
    } catch (err) {
      handleBackendError(err);
      return null;
    } finally {
      setLoading(false);
    }
  }, []);

  /**
   * Listar todos os cálculos
   */
  const fetchAllCalculos = useCallback(async (params = {}) => {
    setLoading(true);
    setError(null);
    try {
      const response = await rhService.getAllCalculos(params);
      const calculosList = response?.calculos || response?.data || [];
      setCalculos(calculosList);
      return response;
    } catch (err) {
      handleBackendError(err);
      return null;
    } finally {
      setLoading(false);
    }
  }, []);

  /**
   * Atualizar cálculo
   */
  const updateCalculo = useCallback(async (idcalculo, payload) => {
    setLoading(true);
    setError(null);
    try {
      const response = await rhService.updateCalculo(idcalculo, payload);
      success('Cálculo Atualizado', 'As alterações foram salvas com sucesso.');
      return response;
    } catch (err) {
      handleBackendError(err);
      throw err;
    } finally {
      setLoading(false);
    }
  }, []);

  /**
   * Obter tabelas de referência
   */
  const fetchTabelas = useCallback(async () => {
    setLoading(true);
    setError(null);
    try {
      const response = await rhService.getTabelasCalculos();
      const tabelasData = response?.tabelas || response?.data || response;
      setTabelas(tabelasData);
      return tabelasData;
    } catch (err) {
      handleBackendError(err);
      return null;
    } finally {
      setLoading(false);
    }
  }, []);

  return {
    calculos,
    tabelas,
    loading,
    error,
    calcularINSS,
    calcularIRRF,
    calcularFGTS,
    calcularRecisao,
    calcularCompleto,
    salvarCalculo,
    fetchCalculosByColaborador,
    fetchAllCalculos,
    updateCalculo,
    fetchTabelas
  };
};
