import { PrismaClient, Decimal } from '@prisma/client';
import axios from 'axios';
import { v4 as uuidv4 } from 'uuid'; // Importar uuid para gerar IDs
import { prisma } from '../prismaClient';
import { Decimal } from '@prisma/client/runtime/library';

const prisma = new PrismaClient();

export class IndiceMonetarioService {
  /**
   * Adiciona um novo índice monetário
   */
  async adicionarIndice(data: {
    nome: string;
    mesReferencia: number;
    anoReferencia: number;
    valor: number;
    dataPublicacao?: Date;
    fonte?: string;
  }) {
    try {
      // Verificar se já existe
      const existente = await prisma.indiceMonetario.findFirst({
        where: {
          nome: data.nome,
          mesReferencia: data.mesReferencia,
          anoReferencia: data.anoReferencia,
        }
      });

      if (existente) {
        // Atualizar o existente
        return await prisma.indiceMonetario.update({
          where: { id: existente.id },
          data: {
            valor: new Decimal(data.valor),
            dataPublicacao: data.dataPublicacao,
            fonte: data.fonte,
            atualizadoEm: new Date()
          }
        });
      }

      // Criar novo
      return await prisma.indiceMonetario.create({
        data: {
          id: uuidv4(), // Gerar ID UUID explicitamente
          nome: data.nome,
          mesReferencia: data.mesReferencia,
          anoReferencia: data.anoReferencia,
          valor: new Decimal(data.valor),
          dataPublicacao: data.dataPublicacao,
          fonte: data.fonte
        }
      });
    } catch (error) {
      console.error('Erro ao adicionar índice monetário:', error);
      throw new Error(`Falha ao adicionar índice: ${error.message}`);
    }
  }

  /**
   * Lista índices monetários com filtros
   */
  async listarIndices(filtros?: {
    nome?: string;
    anoReferencia?: number;
    fonte?: string;
  }) {
    try {
      const where: any = {};

      if (filtros) {
        if (filtros.nome) {
          where.nome = filtros.nome;
        }

        if (filtros.anoReferencia) {
          where.anoReferencia = filtros.anoReferencia;
        }

        if (filtros.fonte) {
          where.fonte = { contains: filtros.fonte };
        }
      }

      return await prisma.indiceMonetario.findMany({
        where,
        orderBy: [
          { anoReferencia: 'desc' },
          { mesReferencia: 'desc' },
          { nome: 'asc' }
        ]
      });
    } catch (error) {
      console.error('Erro ao listar índices monetários:', error);
      throw new Error(`Falha ao listar índices: ${error.message}`);
    }
  }

  /**
   * Busca um índice específico
   */
  async buscarIndice(data: {
    nome: string;
    mesReferencia: number;
    anoReferencia: number;
  }) {
    try {
      return await prisma.indiceMonetario.findFirst({
        where: {
          nome: data.nome,
          mesReferencia: data.mesReferencia,
          anoReferencia: data.anoReferencia
        }
      });
    } catch (error) {
      console.error('Erro ao buscar índice monetário:', error);
      throw new Error(`Falha ao buscar índice: ${error.message}`);
    }
  }

  /**
   * Remove um índice monetário
   */
  async removerIndice(id: string) {
    try {
      return await prisma.indiceMonetario.delete({
        where: { id }
      });
    } catch (error) {
      console.error('Erro ao remover índice monetário:', error);
      throw new Error(`Falha ao remover índice: ${error.message}`);
    }
  }

  /**
   * Importa índices INPC do IBGE
   */
  async importarIndicesINPC() {
    try {
      console.log('Iniciando importação de índices INPC...');
      // Buscar últimos 120 meses
      const url = 'https://servicodados.ibge.gov.br/api/v3/agregados/1736/periodos/-120/variaveis/44?localidades=N1[all]';
      
      const response = await axios.get(url);
      const data = response.data[0];

      if (!data?.resultados?.[0]?.series?.[0]?.serie) {
        throw new Error('Formato de resposta inválido do IBGE');
      }

      const indices = data.resultados[0].series[0].serie;
      
      // Processar e salvar os índices
      for (const [periodo, valor] of Object.entries(indices)) {
        const ano = parseInt(periodo.substring(0, 4));
        const mes = parseInt(periodo.substring(4));
        const valorNumerico = parseFloat(String(valor).replace(',', '.'));

        if (!isNaN(ano) && !isNaN(mes) && !isNaN(valorNumerico)) {
          await prisma.indiceMonetario.upsert({
            where: {
              nome_mesReferencia_anoReferencia: {
                nome: 'INPC',
                mesReferencia: mes,
                anoReferencia: ano
              }
            },
            update: {
              valor: valorNumerico,
              dataPublicacao: new Date(),
              fonte: 'IBGE'
            },
            create: {
              nome: 'INPC',
              mesReferencia: mes,
              anoReferencia: ano,
              valor: valorNumerico,
              dataPublicacao: new Date(),
              fonte: 'IBGE'
            }
          });

          console.log(`Índice importado: ${mes}/${ano} = ${valorNumerico}%`);
        }
      }

      console.log('Importação concluída com sucesso');
    } catch (error) {
      console.error('Erro ao importar índices:', error);
      throw new Error('Falha ao importar índices do IBGE');
    }
  }

  /**
   * Importa índices SELIC do Banco Central
   */
  async importarIndicesSELIC() {
    try {
      // Usar a API do Banco Central em vez de CSV
      const hoje = new Date();
      const dataFim = `${hoje.getFullYear()}-${String(hoje.getMonth() + 1).padStart(2, '0')}-${String(hoje.getDate()).padStart(2, '0')}`;
      
      // Pegar dados do último ano
      const dataInicio = `${hoje.getFullYear() - 1}-${String(hoje.getMonth() + 1).padStart(2, '0')}-${String(hoje.getDate()).padStart(2, '0')}`;
      
      const url = `https://api.bcb.gov.br/dados/serie/bcdata.sgs.11/dados?formato=json&dataInicial=${dataInicio}&dataFinal=${dataFim}`;
      const response = await axios.get(url);
      
      if (!Array.isArray(response.data)) {
        throw new Error('Formato de resposta da API do Banco Central inválido');
      }
      
      const indices = [];
      
      for (const item of response.data) {
        // Tratar a data (formato DD/MM/YYYY)
        const dataParts = item.data.split('/');
        const ano = parseInt(dataParts[2]);
        const mes = parseInt(dataParts[1]);
        const valorNumerico = parseFloat(item.valor);
        
        if (!isNaN(ano) && !isNaN(mes) && !isNaN(valorNumerico)) {
          await this.adicionarIndice({
            nome: 'SELIC',
            mesReferencia: mes,
            anoReferencia: ano,
            valor: valorNumerico / 100, // Converter para decimal (ex: 13.25% vira 0.1325)
            dataPublicacao: new Date(),
            fonte: 'BACEN'
          });
          
          indices.push({
            nome: 'SELIC',
            mesReferencia: mes,
            anoReferencia: ano,
            valor: valorNumerico / 100
          });
        }
      }
      
      return {
        success: true,
        message: `Importados ${indices.length} índices SELIC`,
        indices
      };
    } catch (error) {
      console.error('Erro ao importar índices SELIC:', error);
      throw new Error(`Falha ao importar índices SELIC: ${error.message}`);
    }
  }

  /**
   * Calcula o fator de correção entre duas datas para um índice
   */
  async calcularFatorCorrecao(data: {
    indice: string;
    dataInicial: Date;
    dataFinal: Date;
  }) {
    try {
      const { indice, dataInicial, dataFinal } = data;
      
      // Obter o mês/ano das datas
      const mesInicial = dataInicial.getMonth() + 1; // getMonth retorna 0-11
      const anoInicial = dataInicial.getFullYear();
      const mesFinal = dataFinal.getMonth() + 1;
      const anoFinal = dataFinal.getFullYear();
      
      // Buscar todos os índices necessários para o período
      const indices = await prisma.indiceMonetario.findMany({
        where: {
          nome: indice,
          OR: [
            // Índices do ano inicial
            {
              anoReferencia: anoInicial,
              mesReferencia: { gte: mesInicial }
            },
            // Anos intermediários (se houver)
            {
              anoReferencia: { gt: anoInicial, lt: anoFinal }
            },
            // Índices do ano final
            {
              anoReferencia: anoFinal,
              mesReferencia: { lte: mesFinal }
            }
          ]
        },
        orderBy: [
          { anoReferencia: 'asc' },
          { mesReferencia: 'asc' }
        ]
      });
      
      // Se não houver índices suficientes, usar uma estimativa
      if (indices.length === 0) {
        const mesesDiferenca = 
          (anoFinal - anoInicial) * 12 + (mesFinal - mesInicial);
        
        // Taxa média mensal estimada (usar 0.5% ao mês como estimativa conservadora)
        const taxaMediaMensal = 0.005;
        return new Decimal(Math.pow(1 + taxaMediaMensal, mesesDiferenca));
      }
      
      // Calcular o fator de correção acumulado
      let fatorAcumulado = new Decimal(1);
      
      for (const indice of indices) {
        // Somar 1 ao valor do índice (ex: índice de 0.0082 vira fator de 1.0082)
        const fator = new Decimal(1).add(indice.valor);
        fatorAcumulado = fatorAcumulado.mul(fator);
      }
      
      return fatorAcumulado;
    } catch (error) {
      console.error('Erro ao calcular fator de correção:', error);
      throw new Error(`Falha ao calcular fator de correção: ${error.message}`);
    }
  }
}

// Função para baixar índices do IBGE
export async function atualizarIndicesINPC() {
  try {
    console.log('Iniciando atualização dos índices INPC...');

    // Definir período de busca (5 anos para trás)
    const hoje = new Date();
    const anoInicial = hoje.getFullYear() - 5;
    
    // Buscar último índice no banco
    const ultimoIndice = await prisma.indiceMonetario.findFirst({
      orderBy: [
        { anoReferencia: 'desc' },
        { mesReferencia: 'desc' }
      ]
    });

    // URL da API do IBGE para INPC (últimos 120 meses = 10 anos)
    const url = 'https://servicodados.ibge.gov.br/api/v3/agregados/1736/periodos/-120/variaveis/44?localidades=N1[all]';
    
    console.log('Buscando índices desde:', anoInicial);
    const response = await axios.get(url);
    
    if (!response.data?.[0]?.resultados?.[0]?.series?.[0]?.serie) {
      throw new Error('Formato de resposta inválido do IBGE');
    }

    const indices = response.data[0].resultados[0].series[0].serie;
    let totalIndices = 0;

    // Processar cada índice
    for (const [periodo, valor] of Object.entries(indices)) {
      const ano = parseInt(periodo.substring(0, 4));
      const mes = parseInt(periodo.substring(4));
      const valorNumerico = parseFloat(String(valor).replace(',', '.'));

      // Verificar se é um índice válido
      if (!isNaN(ano) && !isNaN(mes) && !isNaN(valorNumerico)) {
        await prisma.indiceMonetario.upsert({
          where: {
            nome_mesReferencia_anoReferencia: {
              nome: 'INPC',
              mesReferencia: mes,
              anoReferencia: ano
            }
          },
          update: {
            valor: valorNumerico,
            dataPublicacao: new Date(),
            fonte: 'IBGE'
          },
          create: {
            nome: 'INPC',
            mesReferencia: mes,
            anoReferencia: ano,
            valor: valorNumerico,
            dataPublicacao: new Date(),
            fonte: 'IBGE'
          }
        });

        totalIndices++;
        console.log(`Índice atualizado: ${mes}/${ano} = ${valorNumerico}%`);
      }
    }

    console.log(`Atualização concluída. Total de índices: ${totalIndices}`);
    return true;
  } catch (error) {
    console.error('Erro ao atualizar índices INPC:', error);
    throw error;
  }
}

// Função para verificar se os índices existem para um período
export async function verificarIndicesDisponiveis(dataInicial: Date, dataFinal: Date): Promise<boolean> {
  try {
    const indices = await prisma.indiceMonetario.findFirst({
      where: {
        nome: 'INPC',
        AND: [
          {
            anoReferencia: dataInicial.getFullYear(),
            mesReferencia: dataInicial.getMonth() + 1
          }
        ]
      }
    });

    // Se não encontrar índices, tenta atualizar
    if (!indices) {
      console.log('Índices não encontrados. Iniciando atualização...');
      await atualizarIndicesINPC();
      return true;
    }

    return true;
  } catch (error) {
    console.error('Erro ao verificar índices:', error);
    return false;
  }
}

export async function getIndicesParaPeriodo({
  indice,
  dataInicial,
  dataFinal
}: {
  indice: string;
  dataInicial: Date;
  dataFinal: Date;
}) {
  try {
    // Buscar índices no período
    let indices = await prisma.indiceMonetario.findMany({
      where: {
        nome: indice,
        AND: [
          {
            anoReferencia: {
              gte: dataInicial.getFullYear(),
              lte: dataFinal.getFullYear()
            }
          },
          {
            OR: [
              // Índices do primeiro ano
              {
                anoReferencia: dataInicial.getFullYear(),
                mesReferencia: {
                  gte: dataInicial.getMonth() + 1
                }
              },
              // Índices do último ano
              {
                anoReferencia: dataFinal.getFullYear(),
                mesReferencia: {
                  lte: dataFinal.getMonth() + 1
                }
              },
              // Índices dos anos intermediários
              {
                anoReferencia: {
                  gt: dataInicial.getFullYear(),
                  lt: dataFinal.getFullYear()
                }
              }
            ]
          }
        ]
      },
      orderBy: [
        { anoReferencia: 'asc' },
        { mesReferencia: 'asc' }
      ]
    });

    // Se não encontrar índices, tentar importar
    if (!indices || indices.length === 0) {
      console.log('Índices não encontrados. Iniciando importação...');
      await importarIndicesINPC();
      
      // Buscar novamente após importação
      indices = await prisma.indiceMonetario.findMany({
        where: {
          nome: indice,
          AND: [
            {
              anoReferencia: {
                gte: dataInicial.getFullYear(),
                lte: dataFinal.getFullYear()
              }
            },
            {
              OR: [
                // Índices do primeiro ano
                {
                  anoReferencia: dataInicial.getFullYear(),
                  mesReferencia: {
                    gte: dataInicial.getMonth() + 1
                  }
                },
                // Índices do último ano
                {
                  anoReferencia: dataFinal.getFullYear(),
                  mesReferencia: {
                    lte: dataFinal.getMonth() + 1
                  }
                },
                // Índices dos anos intermediários
                {
                  anoReferencia: {
                    gt: dataInicial.getFullYear(),
                    lt: dataFinal.getFullYear()
                  }
                }
              ]
            }
          ]
        },
        orderBy: [
          { anoReferencia: 'asc' },
          { mesReferencia: 'asc' }
        ]
      });
    }

    if (!indices.length) {
      throw new Error('Não foram encontrados índices para o período');
    }

    return indices;
  } catch (error) {
    console.error('Erro ao buscar/importar índices:', error);
    throw error;
  }
}

export async function importarIndicesINPC() {
  try {
    // API do IBGE para INPC
    const url = 'https://servicodados.ibge.gov.br/api/v3/agregados/1736/periodos/-120/variaveis/44?localidades=N1[all]';
    
    console.log('Buscando índices do IBGE...');
    const response = await axios.get(url);
    
    if (!response.data || !response.data[0] || !response.data[0].resultados) {
      throw new Error('Formato de resposta inválido da API do IBGE');
    }

    const dados = response.data[0].resultados[0].series[0].serie;
    
    // Processar e salvar os índices
    for (const [periodo, valor] of Object.entries(dados)) {
      const ano = parseInt(periodo.substring(0, 4));
      const mes = parseInt(periodo.substring(4));
      const valorNumerico = parseFloat(String(valor).replace(',', '.'));

      if (!isNaN(ano) && !isNaN(mes) && !isNaN(valorNumerico)) {
        await prisma.indiceMonetario.upsert({
          where: {
            nome_mesReferencia_anoReferencia: {
              nome: 'INPC',
              mesReferencia: mes,
              anoReferencia: ano
            }
          },
          update: {
            valor: valorNumerico / 100 + 1, // Converter para fator (ex: 1.0053 para 0.53%)
            dataPublicacao: new Date(),
            fonte: 'IBGE'
          },
          create: {
            nome: 'INPC',
            mesReferencia: mes,
            anoReferencia: ano,
            valor: valorNumerico / 100 + 1,
            dataPublicacao: new Date(),
            fonte: 'IBGE'
          }
        });
      }
    }
    
    console.log('Índices INPC importados com sucesso');
    return true;
  } catch (error) {
    console.error('Erro ao importar índices INPC:', error);
    throw error;
  }
}

async function obterIndicesNecessarios(dataInicial: Date, dataFinal: Date) {
  try {
    // 1. Verificar índices existentes no banco
    const indicesExistentes = await prisma.indiceMonetario.findMany({
      where: {
        nome: 'INPC',
        AND: [
          {
            OR: [
              {
                anoReferencia: {
                  gte: dataInicial.getFullYear(),
                  lte: dataFinal.getFullYear(),
                },
              },
            ],
          },
        ],
      },
      orderBy: [
        { anoReferencia: 'asc' },
        { mesReferencia: 'asc' },
      ],
    });

    // 2. Criar mapa dos índices existentes para fácil verificação
    const mapaIndices = new Map();
    indicesExistentes.forEach(indice => {
      const chave = `${indice.anoReferencia}-${indice.mesReferencia.toString().padStart(2, '0')}`;
      mapaIndices.set(chave, indice);
    });

    // 3. Verificar quais meses estão faltando
    const mesesFaltantes: { ano: number; mes: number }[] = [];
    let dataAtual = new Date(dataInicial);
    
    while (dataAtual <= dataFinal) {
      const chave = `${dataAtual.getFullYear()}-${(dataAtual.getMonth() + 1).toString().padStart(2, '0')}`;
      
      if (!mapaIndices.has(chave)) {
        mesesFaltantes.push({
          ano: dataAtual.getFullYear(),
          mes: dataAtual.getMonth() + 1
        });
      }
      
      // Avançar para o próximo mês
      dataAtual.setMonth(dataAtual.getMonth() + 1);
    }

    // 4. Se houver meses faltantes, buscar da API
    if (mesesFaltantes.length > 0) {
      console.log(`Buscando ${mesesFaltantes.length} índices faltantes do IBGE...`);
      
      // Calcular o número de meses entre a data mais antiga e mais recente necessária
      const mesesTotal = Math.ceil(
        (dataFinal.getTime() - dataInicial.getTime()) / (1000 * 60 * 60 * 24 * 30.44)
      );

      // Buscar um período maior que o necessário para garantir
      const periodoAPI = Math.max(mesesTotal + 12, 120); // Mínimo de 120 meses (10 anos)
      
      const url = `https://servicodados.ibge.gov.br/api/v3/agregados/1736/periodos/-${periodoAPI}/variaveis/44?localidades=N1[all]`;
      
      const response = await axios.get(url);
      const data = response.data[0];

      if (!data?.resultados?.[0]?.series?.[0]?.serie) {
        throw new Error('Formato de resposta inválido do IBGE');
      }

      const indices = data.resultados[0].series[0].serie;
      
      // Criar os índices faltantes
      for (const [periodo, valor] of Object.entries(indices)) {
        const ano = parseInt(periodo.substring(0, 4));
        const mes = parseInt(periodo.substring(4));
        const valorNumerico = parseFloat(String(valor).replace(',', '.'));

        if (!isNaN(ano) && !isNaN(mes) && !isNaN(valorNumerico)) {
          // Verificar se este índice é necessário
          const chave = `${ano}-${mes.toString().padStart(2, '0')}`;
          if (!mapaIndices.has(chave) && 
              ano >= dataInicial.getFullYear() && 
              ano <= dataFinal.getFullYear()) {
            
            await prisma.indiceMonetario.upsert({
              where: {
                nome_mesReferencia_anoReferencia: {
                  nome: 'INPC',
                  mesReferencia: mes,
                  anoReferencia: ano
                }
              },
              update: {
                valor: valorNumerico,
                dataPublicacao: new Date(),
                fonte: 'IBGE'
              },
              create: {
                nome: 'INPC',
                mesReferencia: mes,
                anoReferencia: ano,
                valor: valorNumerico,
                dataPublicacao: new Date(),
                fonte: 'IBGE'
              }
            });
            
            console.log(`Índice criado: ${mes}/${ano} = ${valorNumerico}%`);
          }
        }
      }
    }

    // 5. Retornar todos os índices necessários
    return await prisma.indiceMonetario.findMany({
      where: {
        nome: 'INPC',
        AND: [
          {
            OR: [
              {
                anoReferencia: {
                  gte: dataInicial.getFullYear(),
                  lte: dataFinal.getFullYear(),
                },
              },
            ],
          },
        ],
      },
      orderBy: [
        { anoReferencia: 'asc' },
        { mesReferencia: 'asc' },
      ],
    });

  } catch (error) {
    console.error('Erro ao obter índices:', error);
    throw error;
  }
}

// Atualizar a função principal para usar a nova função de obtenção de índices
export async function calcularFatorCorrecaoTotal({
  dataInicial,
  dataFinal,
  indice
}: {
  dataInicial: Date;
  dataFinal: Date;
  indice: string;
}): Promise<Decimal> {
  try {
    // Buscar ou criar todos os índices necessários
    const indices = await obterIndicesNecessarios(dataInicial, dataFinal);

    if (!indices.length) {
      throw new Error('Não foram encontrados índices para o período mesmo após tentativa de atualização');
    }

    // Calcular fator acumulado
    let fatorAcumulado = new Decimal(1);
    for (const indice of indices) {
      fatorAcumulado = fatorAcumulado.mul(new Decimal(1 + indice.valor / 100));
    }

    console.log('Fator de correção calculado:', {
      periodo: `${dataInicial.toISOString()} até ${dataFinal.toISOString()}`,
      indices: indices.length,
      primeiro: indices[0],
      ultimo: indices[indices.length - 1],
      fatorAcumulado: fatorAcumulado.toFixed(6)
    });

    return fatorAcumulado;
  } catch (error) {
    console.error('Erro ao calcular fator de correção:', error);
    throw error;
  }
}

export async function buscarIndicesParaPeriodo(dataInicial: Date, dataFinal: Date) {
  console.log(`Buscando índices para o período de ${dataInicial.toISOString()} até ${dataFinal.toISOString()}`);

  try {
    // Primeiro verificar quais meses já temos
    const indicesExistentes = await prisma.indiceMonetario.findMany({
      where: {
        nome: 'INPC',
        OR: [
          {
            anoReferencia: {
              gte: dataInicial.getFullYear(),
              lte: dataFinal.getFullYear()
            }
          }
        ]
      },
      orderBy: [
        { anoReferencia: 'asc' },
        { mesReferencia: 'asc' }
      ]
    });

    console.log(`Encontrados ${indicesExistentes.length} índices no banco`);

    // Se não houver índices suficientes, buscar da API do IBGE
    if (indicesExistentes.length === 0) {
      console.log('Buscando índices do IBGE...');
      
      // Configurar timeout maior para a requisição
      const axiosInstance = axios.create({
        timeout: 30000 // 30 segundos
      });

      // Fazer múltiplas requisições em paralelo para diferentes períodos
      const promises = [];
      let anoAtual = dataInicial.getFullYear();
      const anoFinal = dataFinal.getFullYear();

      while (anoAtual <= anoFinal) {
        const url = `https://servicodados.ibge.gov.br/api/v3/agregados/1736/periodos/${anoAtual}/variaveis/44?localidades=N1[all]`;
        promises.push(axiosInstance.get(url));
        anoAtual++;
      }

      console.log(`Fazendo ${promises.length} requisições ao IBGE...`);

      const responses = await Promise.allSettled(promises);
      
      // Processar cada resposta
      for (const response of responses) {
        if (response.status === 'fulfilled' && response.value.data?.[0]?.resultados?.[0]?.series?.[0]?.serie) {
          const indices = response.value.data[0].resultados[0].series[0].serie;
          
          for (const [periodo, valor] of Object.entries(indices)) {
            const ano = parseInt(periodo.substring(0, 4));
            const mes = parseInt(periodo.substring(4));
            const valorNumerico = parseFloat(String(valor).replace(',', '.'));

            if (!isNaN(ano) && !isNaN(mes) && !isNaN(valorNumerico)) {
              await prisma.indiceMonetario.upsert({
                where: {
                  nome_mesReferencia_anoReferencia: {
                    nome: 'INPC',
                    mesReferencia: mes,
                    anoReferencia: ano
                  }
                },
                update: {
                  valor: valorNumerico,
                  dataPublicacao: new Date(),
                  fonte: 'IBGE'
                },
                create: {
                  nome: 'INPC',
                  mesReferencia: mes,
                  anoReferencia: ano,
                  valor: valorNumerico,
                  dataPublicacao: new Date(),
                  fonte: 'IBGE'
                }
              });

              console.log(`Índice salvo: ${mes}/${ano} = ${valorNumerico}%`);
            }
          }
        }
      }

      // Buscar novamente após importação
      return await prisma.indiceMonetario.findMany({
        where: {
          nome: 'INPC',
          OR: [
            {
              anoReferencia: {
                gte: dataInicial.getFullYear(),
                lte: dataFinal.getFullYear()
              }
            }
          ]
        },
        orderBy: [
          { anoReferencia: 'asc' },
          { mesReferencia: 'asc' }
        ]
      });
    }

    return indicesExistentes;
  } catch (error) {
    console.error('Erro ao buscar índices:', error);
    throw new Error(`Falha ao buscar índices monetários: ${error.message}`);
  }
}

// Atualizar a função principal para usar o novo método
export async function calcularFatorCorrecaoTotal({
  dataInicial,
  dataFinal,
  indice
}: {
  dataInicial: Date;
  dataFinal: Date;
  indice: string;
}): Promise<Decimal> {
  try {
    const indices = await buscarIndicesParaPeriodo(dataInicial, dataFinal);

    if (!indices.length) {
      throw new Error('Não foram encontrados índices para o período informado');
    }

    // Calcular fator acumulado
    let fatorAcumulado = new Decimal(1);
    for (const indice of indices) {
      fatorAcumulado = fatorAcumulado.mul(new Decimal(1 + indice.valor / 100));
    }

    console.log('Fator de correção calculado:', {
      indices: indices.length,
      primeiro: indices[0],
      ultimo: indices[indices.length - 1],
      fatorAcumulado: fatorAcumulado.toString()
    });

    return fatorAcumulado;
  } catch (error) {
    console.error('Erro ao calcular fator de correção:', error);
    throw error;
  }
}