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

/**
 * Hook para gestão de aniversariantes
 * Integra todas as rotas de aniversariantes da API
 */
export const useAniversariantes = () => {
  const [aniversariantes, setAniversariantes] = useState([]);
  const [aniversariantesHoje, setAniversariantesHoje] = useState([]);
  const [aniversariantesMesAtual, setAniversariantesMesAtual] = useState([]);
  const [aniversariantesProximosMeses, setAniversariantesProximosMeses] = useState([]);
  const [aniversariantesProximosMesesPorMes, setAniversariantesProximosMesesPorMes] = useState({}); // Dados organizados por mês para o modal
  const [quantitativo, setQuantitativo] = useState(null);
  const [estatisticas, setEstatisticas] = useState(null);
  const [loading, setLoading] = useState(false);
  const [loadingHoje, setLoadingHoje] = useState(false);
  const [loadingMesAtual, setLoadingMesAtual] = useState(false);
  const [loadingProximosMeses, setLoadingProximosMeses] = useState(false);
  const [loadingQuantitativo, setLoadingQuantitativo] = useState(false);
  const [loadingEstatisticas, setLoadingEstatisticas] = useState(false);
  const [filters, setFilters] = useState({
    search: '',
    mes: null
  });

  /**
   * Processa dados de aniversariantes para incluir informações calculadas
   */
  const processarAniversariantes = useCallback((data) => {
    if (!data || !Array.isArray(data)) {
      return [];
    }
    
    const hoje = new Date();
    return data.map(item => {
      // Converter data_nascimento de formato DD/MM/YYYY para Date
      let dataNascimento = null;
      if (item.data_nascimento) {
        if (typeof item.data_nascimento === 'string' && item.data_nascimento.includes('/')) {
          // Formato DD/MM/YYYY
          const [dia, mes, ano] = item.data_nascimento.split('/');
          dataNascimento = new Date(parseInt(ano), parseInt(mes) - 1, parseInt(dia));
        } else {
          dataNascimento = new Date(item.data_nascimento);
        }
      }
      
      let diaAniversario = item.dia || null;
      // Usar mes da API se disponível, senão calcular
      let mesAniversario = item.mes || null;
      let idade = item.idade || null;

      if (dataNascimento && !isNaN(dataNascimento.getTime())) {
        if (!diaAniversario) {
          diaAniversario = dataNascimento.getDate();
        }
        // Se não tiver mes da API, calcular da data_nascimento
        if (!mesAniversario) {
          mesAniversario = dataNascimento.getMonth() + 1;
        }
        
        // Calcular idade se não vier da API
        if (!idade) {
          let idadeCalculada = hoje.getFullYear() - dataNascimento.getFullYear();
          const mesAtual = hoje.getMonth() + 1;
          const diaAtual = hoje.getDate();
          
          if (mesAtual < mesAniversario || (mesAtual === mesAniversario && diaAtual < diaAniversario)) {
            idadeCalculada--;
          }
          
          idade = idadeCalculada;
        }
      } else if (item.dia) {
        // Se tiver dia mas não data_nascimento válida, usar o mês da API ou atual
        if (!mesAniversario) {
          mesAniversario = hoje.getMonth() + 1;
        }
      }

      return {
        ...item,
        dia_aniversario: diaAniversario,
        mes_aniversario: mesAniversario,
        mes: mesAniversario, // Preservar também como 'mes' para compatibilidade
        idade: idade,
        status: item.status_contrato || item.status || 'Ativo'
      };
    });
  }, []);

  /**
   * Buscar todos os aniversariantes
   */
  const fetchGestaoAniversariantes = useCallback(async () => {
    setLoading(true);
    try {
      const response = await rhService.getAniversariantes();
      // A API retorna { data: [...], ... }
      const dataArray = Array.isArray(response?.data) ? response.data : (Array.isArray(response) ? response : []);
      const aniversariantesProcessados = processarAniversariantes(dataArray);
      setAniversariantes(aniversariantesProcessados);
    } catch (error) {
      console.error('Erro ao buscar aniversariantes:', error);
      setAniversariantes([]);
    } finally {
      setLoading(false);
    }
  }, [processarAniversariantes]);

  /**
   * Buscar aniversariantes de hoje
   */
  const fetchAniversariantesHoje = useCallback(async () => {
    setLoadingHoje(true);
    try {
      const response = await rhService.getAniversariantesHoje();
      // A API retorna { aniversariantes: [], ... }
      const dataArray = Array.isArray(response?.aniversariantes) ? response.aniversariantes : [];
      const aniversariantesProcessados = processarAniversariantes(dataArray);
      setAniversariantesHoje(aniversariantesProcessados);
    } catch (error) {
      console.error('Erro ao buscar aniversariantes de hoje:', error);
      setAniversariantesHoje([]);
    } finally {
      setLoadingHoje(false);
    }
  }, [processarAniversariantes]);

  /**
   * Buscar aniversariantes do mês atual
   */
  const fetchAniversariantesMesAtual = useCallback(async () => {
    setLoadingMesAtual(true);
    try {
      const response = await rhService.getAniversariantesMesAtual();
      // A API retorna { data: [...], ... }
      const dataArray = Array.isArray(response?.data) ? response.data : (Array.isArray(response) ? response : []);
      const aniversariantesProcessados = processarAniversariantes(dataArray);
      setAniversariantesMesAtual(aniversariantesProcessados);
    } catch (error) {
      console.error('Erro ao buscar aniversariantes do mês atual:', error);
      setAniversariantesMesAtual([]);
    } finally {
      setLoadingMesAtual(false);
    }
  }, [processarAniversariantes]);

  /**
   * Buscar aniversariantes dos próximos meses
   */
  const fetchAniversariantesProximosMeses = useCallback(async () => {
    setLoadingProximosMeses(true);
    try {
      const response = await rhService.getAniversariantesProximosMeses();
      // handleRequest retorna response.data se existir, senão retorna response
      // A estrutura da API é: { data: { "2026-01": { aniversariantes: [...] }, ... }, total_geral: 53 }
      // Após handleRequest, response pode ser o objeto data OU o objeto completo
      let dataArray = [];
      
      // Primeiro, tentar acessar response.data (caso handleRequest não tenha extraído)
      let mesesData = response?.data || response;
      
      // Se mesesData é um objeto com chaves de data (ex: "2026-01", "2026-02")
      if (mesesData && typeof mesesData === 'object' && !Array.isArray(mesesData)) {
        // Verificar se tem a estrutura esperada (chaves como "2026-01")
        const hasMonthKeys = Object.keys(mesesData).some(key => /^\d{4}-\d{2}$/.test(key));
        
        if (hasMonthKeys) {
          // Manter os dados organizados por mês para o modal
          const dadosPorMes = {};
          // Iterar sobre cada mês e extrair os aniversariantes
          Object.entries(mesesData).forEach(([key, mesData]) => {
            if (mesData?.aniversariantes && Array.isArray(mesData.aniversariantes)) {
              dataArray = dataArray.concat(mesData.aniversariantes);
              // Armazenar dados do mês com a chave sendo o número do mês
              dadosPorMes[mesData.mes] = {
                ...mesData,
                aniversariantes: processarAniversariantes(mesData.aniversariantes)
              };
            }
          });
          setAniversariantesProximosMesesPorMes(dadosPorMes);
        } else {
          // Pode ser um objeto simples, tentar acessar diretamente
          console.warn('[useAniversariantes] Estrutura inesperada em próximos meses:', mesesData);
        }
      } else if (Array.isArray(mesesData)) {
        dataArray = mesesData;
      }
      
      const aniversariantesProcessados = processarAniversariantes(dataArray);
      setAniversariantesProximosMeses(aniversariantesProcessados);
    } catch (error) {
      console.error('Erro ao buscar aniversariantes dos próximos meses:', error);
      setAniversariantesProximosMeses([]);
    } finally {
      setLoadingProximosMeses(false);
    }
  }, [processarAniversariantes]);

  /**
   * Buscar quantitativo de aniversariantes
   */
  const fetchQuantitativo = useCallback(async () => {
    setLoadingQuantitativo(true);
    try {
      const response = await rhService.getAniversariantesQuantitativo();
      // A API retorna { quantitativo_por_mes: [...], ... }
      setQuantitativo(response?.quantitativo_por_mes || response || null);
    } catch (error) {
      console.error('Erro ao buscar quantitativo:', error);
      setQuantitativo(null);
    } finally {
      setLoadingQuantitativo(false);
    }
  }, []);

  /**
   * Buscar estatísticas de aniversariantes
   */
  const fetchEstatisticas = useCallback(async () => {
    setLoadingEstatisticas(true);
    try {
      const response = await rhService.getAniversariantesEstatisticas();
      // A API retorna { data: {...}, ... }
      setEstatisticas(response?.data || response || null);
    } catch (error) {
      console.error('Erro ao buscar estatísticas:', error);
      setEstatisticas(null);
    } finally {
      setLoadingEstatisticas(false);
    }
  }, []);

  /**
   * Buscar todos os dados de uma vez
   */
  const fetchAll = useCallback(async () => {
    await Promise.all([
      fetchGestaoAniversariantes(),
      fetchAniversariantesHoje(),
      fetchAniversariantesMesAtual(),
      fetchAniversariantesProximosMeses(),
      fetchQuantitativo(),
      fetchEstatisticas()
    ]);
  }, [
    fetchGestaoAniversariantes,
    fetchAniversariantesHoje,
    fetchAniversariantesMesAtual,
    fetchAniversariantesProximosMeses,
    fetchQuantitativo,
    fetchEstatisticas
  ]);

  const updateFilters = useCallback((newFilters) => {
    setFilters(prev => ({ ...prev, ...newFilters }));
  }, []);

  return {
    // Dados
    aniversariantes,
    aniversariantesHoje,
    aniversariantesMesAtual,
    aniversariantesProximosMeses,
    aniversariantesProximosMesesPorMes, // Dados organizados por mês para o modal
    quantitativo,
    estatisticas,
    
    // Estados de loading
    loading,
    loadingHoje,
    loadingMesAtual,
    loadingProximosMeses,
    loadingQuantitativo,
    loadingEstatisticas,
    
    // Filtros
    filters,
    setFilters: updateFilters,
    
    // Funções de fetch
    fetchGestaoAniversariantes,
    fetchAniversariantesHoje,
    fetchAniversariantesMesAtual,
    fetchAniversariantesProximosMeses,
    fetchQuantitativo,
    fetchEstatisticas,
    fetchAll
  };
};
