/**
 * DocuAgro - Serviço de IA (OpenAI gpt-4o-mini)
 * Processa mensagens do produtor e gera respostas inteligentes
 */

const OpenAI = require('openai');
const { gerarPrompt, ORDEM_COLETA, TIPOS_DOCUMENTO } = require('./system-prompt');
const db = require('./database');

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
});

const MODEL = process.env.OPENAI_MODEL || 'gpt-4o-mini';

/**
 * Processa mensagem de texto do produtor e retorna resposta da IA
 */
async function processarMensagem(produtor, mensagemTexto, documentos) {
  try {
    // Gera prompt com contexto atual
    const systemPrompt = gerarPrompt(produtor, documentos, produtor?.etapa_atual);
    
    // Busca histórico recente da conversa
    const historico = produtor ? db.buscarHistorico(produtor.id, 10) : [];
    
    // Monta mensagens para a API
    const messages = [
      { role: 'system', content: systemPrompt }
    ];
    
    // Adiciona histórico
    for (const msg of historico) {
      messages.push({
        role: msg.role,
        content: msg.conteudo
      });
    }
    
    // Adiciona mensagem atual
    messages.push({
      role: 'user',
      content: mensagemTexto
    });
    
    // Chama a API
    const completion = await openai.chat.completions.create({
      model: MODEL,
      messages,
      temperature: 0.7,
      max_tokens: 800,
      presence_penalty: 0.1,
      frequency_penalty: 0.1
    });
    
    const resposta = completion.choices[0]?.message?.content || 'Desculpa, tive um problema aqui. Pode repetir?';
    
    // Salva no histórico
    if (produtor) {
      db.salvarMensagem(produtor.id, produtor.telegram_chat_id, 'user', mensagemTexto);
      db.salvarMensagem(produtor.id, produtor.telegram_chat_id, 'assistant', resposta);
    }
    
    // Detecta se precisa atualizar etapa/dados baseado na resposta
    await detectarAtualizacoes(produtor, mensagemTexto, resposta);
    
    return resposta;
    
  } catch (erro) {
    console.error('❌ Erro na IA:', erro.message);
    return 'Ops, tive um probleminha técnico. Pode mandar de novo daqui a pouquinho? 🔧';
  }
}

/**
 * Processa documento recebido (foto/PDF)
 */
async function processarDocumento(produtor, tipoDoc, descricaoArquivo) {
  try {
    const systemPrompt = gerarPrompt(produtor, db.buscarDocumentos(produtor.id), produtor.etapa_atual);
    
    const messages = [
      { role: 'system', content: systemPrompt },
      {
        role: 'user',
        content: `Acabei de enviar um arquivo que deveria ser o documento: ${TIPOS_DOCUMENTO[tipoDoc]?.nome || tipoDoc}. Informações do arquivo: ${descricaoArquivo}`
      }
    ];
    
    const completion = await openai.chat.completions.create({
      model: MODEL,
      messages,
      temperature: 0.5,
      max_tokens: 500
    });
    
    return completion.choices[0]?.message?.content || '✅ Recebi o documento! Estou analisando.';
    
  } catch (erro) {
    console.error('❌ Erro ao processar documento:', erro.message);
    return '✅ Recebi o documento! Vou analisar e te aviso o resultado.';
  }
}

/**
 * Detecta se precisa atualizar dados do produtor baseado na conversa
 * Usa a IA para extrair informações estruturadas
 */
async function detectarAtualizacoes(produtor, mensagemUsuario, respostaIA) {
  if (!produtor) return;
  
  // Se está no onboarding, tenta extrair dados pessoais
  if (produtor.etapa_atual === 'onboarding') {
    try {
      const extraction = await openai.chat.completions.create({
        model: MODEL,
        messages: [
          {
            role: 'system',
            content: `Extraia dados estruturados da mensagem do produtor rural. Responda APENAS com JSON válido.
Se a informação não estiver na mensagem, use null.
Campos possíveis: nome, cpf_cnpj, propriedade_nome, propriedade_municipio, propriedade_estado, propriedade_area_ha, cultura_principal.
Exemplo: {"nome": "João Silva", "cpf_cnpj": null, "propriedade_nome": null}`
          },
          { role: 'user', content: mensagemUsuario }
        ],
        temperature: 0,
        max_tokens: 200
      });
      
      const texto = extraction.choices[0]?.message?.content || '{}';
      // Tenta extrair JSON da resposta
      const match = texto.match(/\{[^}]+\}/);
      if (match) {
        const dados = JSON.parse(match[0]);
        const atualizacao = {};
        
        for (const [chave, valor] of Object.entries(dados)) {
          if (valor !== null && valor !== undefined && valor !== '') {
            atualizacao[chave] = valor;
          }
        }
        
        if (Object.keys(atualizacao).length > 0) {
          db.atualizarProdutor(produtor.id, atualizacao);
          console.log(`📝 Dados atualizados para ${produtor.id}:`, atualizacao);
        }
        
        // Verifica se onboarding está completo (tem pelo menos nome e município)
        const produtorAtual = db.buscarProdutorPorId(produtor.id);
        if (produtorAtual.nome && produtorAtual.nome !== 'Novo Produtor' && 
            produtorAtual.propriedade_municipio) {
          db.atualizarProdutor(produtor.id, { etapa_atual: 'coleta_car' });
          console.log(`✅ Onboarding completo para ${produtor.id}, indo para coleta`);
        }
      }
    } catch (e) {
      // Erro na extração não é crítico
      console.log('⚠️ Erro na extração de dados:', e.message);
    }
  }
}

/**
 * Determina qual tipo de documento o produtor está enviando
 * baseado na etapa atual
 */
function determinarTipoDocumento(produtor) {
  if (!produtor || !produtor.etapa_atual) return null;
  
  const etapa = produtor.etapa_atual;
  
  // Mapeia etapa para tipo de documento
  const mapa = {
    'coleta_car': 'car',
    'coleta_ccir': 'ccir',
    'coleta_itr': 'itr',
    'coleta_geo': 'georreferenciamento',
    'coleta_licenca': 'licenca_ambiental',
    'coleta_contrato': 'contrato_arrendamento',
    'coleta_nf': 'nota_fiscal',
    'coleta_declaracao': 'declaracao_desmatamento'
  };
  
  return mapa[etapa] || null;
}

/**
 * Avança para o próximo documento na sequência de coleta
 */
function avancarEtapa(produtor) {
  const docs = db.buscarDocumentos(produtor.id);
  const tiposEnviados = docs.filter(d => ['enviado', 'aprovado', 'validando'].includes(d.status)).map(d => d.tipo);
  
  const proximo = ORDEM_COLETA.find(t => !tiposEnviados.includes(t));
  
  if (proximo) {
    const novaEtapa = TIPOS_DOCUMENTO[proximo].etapa;
    db.atualizarProdutor(produtor.id, { etapa_atual: novaEtapa });
    return novaEtapa;
  } else {
    db.atualizarProdutor(produtor.id, { etapa_atual: 'completo', status: 'completo' });
    return 'completo';
  }
}

module.exports = {
  processarMensagem,
  processarDocumento,
  detectarAtualizacoes,
  determinarTipoDocumento,
  avancarEtapa
};
