Primeiro Bot Conversacional

// Função para consultar clima usando OpenWeatherMap API
async function consultarClima(cidade) {
  try {
    const API_KEY = "SUA_API_KEY_AQUI"; // Registre em openweathermap.org
    
    // Limpar nome da cidade
    const cidadeLimpa = cidade.trim().replace(/s+/g, '%20');
    
    // Fazer requisição para OpenWeather
    const response = await fetch(
      `https://api.openweathermap.org/data/2.5/weather?q=${cidadeLimpa},BR&appid=${API_KEY}&units=metric&lang=pt_br`
    );
    
    if (!response.ok) {
      throw new Error("Cidade não encontrada");
    }
    
    const data = await response.json();
    
    return {
      success: true,
      message: formatarClima(data)
    };
    
  } catch (error) {
    return {
      success: false,
      message: `❌ Não consegui encontrar informações sobre "${cidade}".\n\nTente:\n• Nome completo da cidade\n• Adicionar estado (ex: Santos, SP)\n• Verificar ortografia`
    };
  }
}

// Formatar dados do clima
function formatarClima(dados) {
  const temp = Math.round(dados.main.temp);
  const sensacao = Math.round(dados.main.feels_like);
  const descricao = dados.weather[0].description;
  const umidade = dados.main.humidity;
  const vento = dados.wind.speed;
  const cidade = dados.name;
  
  // Emoji baseado no clima
  const emojiClima = getEmojiClima(dados.weather[0].main);
  
  return `${emojiClima} **CLIMA EM ${cidade.toUpperCase()}**

🌡️ **Temperatura:** ${temp}°C (sensação ${sensacao}°C)
☁️ **Condição:** ${descricao}
💧 **Umidade:** ${umidade}%
💨 **Vento:** ${vento} m/s

${getRecomendacao(temp, descricao)}

Digite outra cidade para nova consulta!`;
}

// Emoji baseado na condição climática
function getEmojiClima(condicao) {
  const emojis = {
    'Clear': '☀️',
    'Clouds': '☁️',
    'Rain': '🌧️',
    'Drizzle': '🌦️',
    'Thunderstorm': '⛈️',
    'Snow': '❄️',
    'Mist': '🌫️',
    'Fog': '🌫️'
  };
  return emojis[condicao] || '🌤️';
}

// Recomendação baseada no clima
function getRecomendacao(temp, descricao) {
  if (temp < 15) {
    return "🧥 Recomendação: Vista roupas quentes!";
  } else if (temp > 30) {
    return "🌊 Recomendação: Hidrate-se bem e use protetor solar!";
  } else if (descricao.includes('chuva') || descricao.includes('rain')) {
    return "☔ Recomendação: Não esqueça o guarda-chuva!";
  } else {
    return "😊 Clima agradável! Aproveite o dia!";
  }
}

// Processar consulta de clima
const resultado = await consultarClima($json.message);

return {
  clima_response: resultado.message,
  clima_success: resultado.success,
  next_state: "MENU_PRINCIPAL"
};

// Sistema de captura e qualificação de leads
class LeadCapture {
  constructor() {
    this.campos_obrigatorios = ['nome', 'telefone', 'email'];
    this.campos_qualificacao = ['empresa', 'cargo', 'orcamento', 'prazo'];
    
    this.scores_qualificacao = {
      orcamento: {
        'ate_5k': 1,
        '5k_20k': 3,
        '20k_50k': 5,
        'acima_50k': 7
      },
      prazo: {
        'urgente': 5,
        'ate_30_dias': 4,
        'ate_90_dias': 2,
        'sem_pressa': 1
      },
      empresa: {
        'startup': 2,
        'pequena': 3,
        'media': 4,
        'grande': 5
      }
    };
  }
  
  // Iniciar captura de lead
  iniciarCaptura(contexto) {
    return {
      new_state: 'LEAD_NOME',
      response: `📝 **VAMOS COMEÇAR!**

Para enviar informações personalizadas, preciso de alguns dados:

👤 **Qual seu nome completo?**`,
      temp_data: {
        lead_context: contexto,
        lead_data: {},
        lead_step: 1,
        total_steps: 6
      }
    };
  }
  
  // Processar cada etapa da captura
  processarEtapaLead(estado, resposta, dadosTemp) {
    const leadData = dadosTemp.lead_data || {};
    
    switch (estado) {
      case 'LEAD_NOME':
        return this.processarNome(resposta, dadosTemp);
        
      case 'LEAD_TELEFONE':
        return this.processarTelefone(resposta, dadosTemp);
        
      case 'LEAD_EMAIL':
        return this.processarEmail(resposta, dadosTemp);
        
      case 'LEAD_EMPRESA':
        return this.processarEmpresa(resposta, dadosTemp);
        
      case 'LEAD_ORCAMENTO':
        return this.processarOrcamento(resposta, dadosTemp);
        
      case 'LEAD_PRAZO':
        return this.processarPrazo(resposta, dadosTemp);
        
      case 'LEAD_FINALIZAR':
        return this.finalizarLead(dadosTemp);
        
      default:
        return this.resetarCaptura();
    }
  }
  
  processarNome(resposta, dadosTemp) {
    const nome = resposta.trim();
    
    if (nome.length < 2) {
      return {
        new_state: 'LEAD_NOME',
        response: 'Por favor, digite seu nome completo:',
        temp_data: dadosTemp
      };
    }
    
    const novosDados = {
      ...dadosTemp,
      lead_data: { ...dadosTemp.lead_data, nome: nome },
      lead_step: 2
    };
    
    return {
      new_state: 'LEAD_TELEFONE',
      response: `Prazer, ${nome}! 👋

📞 **Agora seu telefone:** (apenas números)`,
      temp_data: novosDados
    };
  }
  
  processarTelefone(resposta, dadosTemp) {
    const telefone = resposta.replace(/D/g, '');
    
    if (telefone.length < 10 || telefone.length > 11) {
      return {
        new_state: 'LEAD_TELEFONE',
        response: 'Telefone inválido. Digite apenas números:\nExemplo: 11999999999',
        temp_data: dadosTemp
      };
    }
    
    const novosDados = {
      ...dadosTemp,
      lead_data: { ...dadosTemp.lead_data, telefone: telefone },
      lead_step: 3
    };
    
    return {
      new_state: 'LEAD_EMAIL',
      response: `📧 **Seu email:**`,
      temp_data: novosDados
    };
  }
  
  processarEmail(resposta, dadosTemp) {
    const email = resposta.trim().toLowerCase();
    const emailRegex = /^[^s@]+@[^s@]+.[^s@]+$/;
    
    if (!emailRegex.test(email)) {
      return {
        new_state: 'LEAD_EMAIL',
        response: 'Email inválido. Digite um email válido:\nExemplo: seu@email.com',
        temp_data: dadosTemp
      };
    }
    
    const novosDados = {
      ...dadosTemp,
      lead_data: { ...dadosTemp.lead_data, email: email },
      lead_step: 4
    };
    
    return {
      new_state: 'LEAD_EMPRESA',
      response: `🏢 **Qual sua empresa/negócio?**
(Se for pessoa física, digite "pessoa física")`,
      temp_data: novosDados
    };
  }
  
  processarEmpresa(resposta, dadosTemp) {
    const empresa = resposta.trim();
    
    const novosDados = {
      ...dadosTemp,
      lead_data: { ...dadosTemp.lead_data, empresa: empresa },
      lead_step: 5
    };
    
    return {
      new_state: 'LEAD_ORCAMENTO',
      response: `💰 **Qual faixa de orçamento você tem em mente?**

1️⃣ Até R$ 5.000
2️⃣ R$ 5.000 - R$ 20.000  
3️⃣ R$ 20.000 - R$ 50.000
4️⃣ Acima de R$ 50.000
5️⃣ Ainda não defini

Digite o número:`,
      temp_data: novosDados
    };
  }
  
  processarOrcamento(resposta, dadosTemp) {
    const opcao = parseInt(resposta.trim());
    
    if (opcao < 1 || opcao > 5) {
      return {
        new_state: 'LEAD_ORCAMENTO',
        response: 'Digite um número de 1 a 5:',
        temp_data: dadosTemp
      };
    }
    
    const faixas = {
      1: 'ate_5k',
      2: '5k_20k', 
      3: '20k_50k',
      4: 'acima_50k',
      5: 'nao_definido'
    };
    
    const novosDados = {
      ...dadosTemp,
      lead_data: { ...dadosTemp.lead_data, orcamento: faixas[opcao] },
      lead_step: 6
    };
    
    return {
      new_state: 'LEAD_PRAZO',
      response: `⏰ **Qual o prazo ideal para o projeto?**

1️⃣ Urgente (até 30 dias)
2️⃣ Médio prazo (30-90 dias)  
3️⃣ Longo prazo (3-6 meses)
4️⃣ Sem pressa

Digite o número:`,
      temp_data: novosDados
    };
  }
  
  processarPrazo(resposta, dadosTemp) {
    const opcao = parseInt(resposta.trim());
    
    if (opcao < 1 || opcao > 4) {
      return {
        new_state: 'LEAD_PRAZO',
        response: 'Digite um número de 1 a 4:',
        temp_data: dadosTemp
      };
    }
    
    const prazos = {
      1: 'urgente',
      2: 'medio_prazo',
      3: 'longo_prazo', 
      4: 'sem_pressa'
    };
    
    const novosDados = {
      ...dadosTemp,
      lead_data: { ...dadosTemp.lead_data, prazo: prazos[opcao] }
    };
    
    return this.finalizarLead(novosDados);
  }
  
  // Finalizar captura e calcular score
  async finalizarLead(dadosTemp) {
    try {
      const leadData = dadosTemp.lead_data;
      
      // Calcular score de qualificação
      const score = this.calcularScore(leadData);
      
      // Adicionar metadados
      const leadCompleto = {
        ...leadData,
        score_qualificacao: score.total,
        classificacao: score.classificacao,
        fonte: 'whatsapp_bot',
        data_captura: new Date().toISOString(),
        contexto: dadosTemp.lead_context
      };
      
      // Salvar no sistema
      await this.salvarLead(leadCompleto);
      
      // Gerar resposta baseada no score
      return {
        new_state: 'MENU_PRINCIPAL',
        response: this.gerarRespostaFinal(leadCompleto),
        temp_data: {} // Limpar dados temporários
      };
      
    } catch (error) {
      return {
        new_state: 'MENU_PRINCIPAL',
        response: "Erro ao processar dados. Nossa equipe entrará em contato pelo telefone informado.",
        temp_data: {}
      };
    }
  }
  
  // Calcular score de qualificação
  calcularScore(leadData) {
    let score = 0;
    
    // Score por orçamento
    if (leadData.orcamento && this.scores_qualificacao.orcamento[leadData.orcamento]) {
      score += this.scores_qualificacao.orcamento[leadData.orcamento];
    }
    
    // Score por prazo
    if (leadData.prazo && this.scores_qualificacao.prazo[leadData.prazo]) {
      score += this.scores_qualificacao.prazo[leadData.prazo];
    }
    
    // Score por empresa (baseado no nome)
    if (leadData.empresa && leadData.empresa !== 'pessoa física') {
      score += 2; // Bonus por ter empresa
    }
    
    // Classificação
    let classificacao;
    if (score >= 8) classificacao = 'HOT';
    else if (score >= 5) classificacao = 'WARM';
    else classificacao = 'COLD';
    
    return { total: score, classificacao: classificacao };
  }
  
  async salvarLead(leadData) {
    // Salvar no Google Sheets
    await googleSheets.append({
      range: 'leads!A:K',
      values: [Object.values(leadData)]
    });
    
    // Opcional: Webhook para CRM
    // await enviarParaCRM(leadData);
  }
  
  gerarRespostaFinal(lead) {
    const classificacao = lead.classificacao;
    
    let resposta = `✅ **DADOS REGISTRADOS COM SUCESSO!**

📝 Obrigado pelas informações, ${lead.nome}!
📊 **Status:** Lead ${classificacao}`;
    
    if (classificacao === 'HOT') {
      resposta += `

🔥 **ATENÇÃO PRIORITÁRIA!**
Nossa equipe comercial entrará em contato ainda hoje!
📞 Ligação em até 2 horas
📧 Proposta personalizada em 24h`;
    } else if (classificacao === 'WARM') {
      resposta += `

📞 Nossa equipe entrará em contato em até 24h
📧 Materiais personalizados serão enviados`;
    } else {
      resposta += `

📧 Materiais informativos foram enviados
📞 Contato em até 48h úteis`;
    }
    
    resposta += `

🎯 Enquanto isso, posso ajudar com mais alguma coisa?`;
    
    return resposta;
  }
  
  resetarCaptura() {
    return {
      new_state: 'MENU_PRINCIPAL',
      response: 'Ops! Algo deu errado na captura. Vamos voltar ao menu.',
      temp_data: {}
    };
  }
}

return { LeadCapture };