Aula 2: Processamento de Linguagem Natural

// Função para classificar intenção usando GPT
async function classificarIntencao(mensagem) {
  const prompt = `
Analise a mensagem e classifique a intenção:

INTENÇÕES DISPONÍVEIS:
1. CONSULTAR_PEDIDO - Quer saber status/tracking
2. CANCELAR_PEDIDO - Quer cancelar compra
3. SOLICITAR_ORCAMENTO - Quer preços/orçamento  
4. TIRAR_DUVIDA - Tem dúvidas sobre produto/serviço
5. RECLAMAR - Está insatisfeito/reclamando
6. ELOGIAR - Está satisfeito/elogiando
7. SOLICITAR_CONTATO - Quer falar com humano
8. CONSULTAR_HORARIO - Quer saber horários
9. OUTROS - Não se encaixa nas anteriores

Mensagem: "${mensagem}"

Responda APENAS com:
{
  "intencao": "NOME_DA_INTENCAO",
  "confianca": 0.95,
  "motivo": "Breve explicação"
}
`;

  const response = await openai.chat.completions.create({
    model: "gpt-4-turbo",
    messages: [{ role: "user", content: prompt }],
    temperature: 0.1, // Baixa para consistência
    max_tokens: 150
  });

  return JSON.parse(response.choices[0].message.content);
}

async function analisarSentimento(mensagem) {
  const prompt = `
Analise o sentimento da mensagem abaixo e classifique:

ESCALAS DE SENTIMENTO:
1. POSITIVO (1-5): 1=Levemente positivo, 5=Extremamente positivo
2. NEGATIVO (1-5): 1=Levemente negativo, 5=Extremamente negativo  
3. NEUTRO: Sem carga emocional
4. URGENTE (1-3): 1=Pressa normal, 3=Emergência

INDICADORES IMPORTANTES:
- MAIÚSCULAS = intensidade alta
- Emojis = reforçam sentimento
- Palavras-chave: urgente, rápido, imediato, agora
- Xingamentos/frustração = negativo alto

Mensagem: "${mensagem}"

Responda APENAS com JSON:
{
  "sentimento_principal": "POSITIVO|NEGATIVO|NEUTRO|URGENTE",
  "intensidade": 1-5,
  "confianca": 0.95,
  "emocoes_detectadas": ["feliz", "ansioso"],
  "palavras_chave": ["adorei", "rápido"],
  "recomendacao_resposta": "empática|neutra|entusiasmada|prioritária"
}
`;

  const response = await openai.chat.completions.create({
    model: "gpt-4-turbo",
    messages: [{ role: "user", content: prompt }],
    temperature: 0.2,
    max_tokens: 300
  });

  return JSON.parse(response.choices[0].message.content);
}

function gerarRespostaEmpatica(sentimento, mensagemOriginal) {
  const templates = {
    NEGATIVO_ALTO: {
      intro: "Entendo sua frustração e peço desculpas pelo inconveniente.",
      corpo: "Vou resolver isso para você com a máxima prioridade.",
      acao: "Já estou verificando e retorno em até 2 minutos."
    },
    URGENTE: {
      intro: "Entendi a urgência da sua solicitação!",
      corpo: "Vou processar isso AGORA mesmo.",
      acao: "Acompanhe em tempo real:"
    },
    POSITIVO: {
      intro: "Que alegria receber seu feedback! 😊",
      corpo: "Ficamos muito felizes em ter superado suas expectativas.",
      acao: "Gostaria de compartilhar sua experiência? Ou posso ajudar com mais alguma coisa?"
    },
    NEUTRO: {
      intro: "Olá! Posso ajudá-lo com isso.",
      corpo: "Vou verificar as informações para você.",
      acao: "Um momento, por favor."
    }
  };

  const template = templates[sentimento.sentimento_principal] || templates.NEUTRO;
  
  return `${template.intro}

${template.corpo}

${template.acao}`;
}

// Função principal de extração de entidades
async function extrairEntidades(mensagem) {
  const prompt = `
Extraia TODAS as entidades encontradas na mensagem abaixo:

TIPOS DE ENTIDADES A EXTRAIR:
- PESSOA: Nomes completos ou apenas primeiros nomes
- EMAIL: Endereços de email válidos  
- TELEFONE: Números de telefone (qualquer formato)
- PRODUTO: Nomes de produtos ou serviços mencionados
- PEDIDO: Números de pedido, códigos, referências
- DATA: Datas em qualquer formato (relativas ou absolutas)
- HORARIO: Horários mencionados
- VALOR: Preços, valores monetários
- QUANTIDADE: Números + unidades
- LOCAL: Cidades, estados, endereços

Mensagem: "${mensagem}"

Responda APENAS com JSON:
{
  "entidades": [
    {
      "tipo": "PESSOA",
      "valor": "João Silva",
      "confianca": 0.95,
      "posicao": "início da mensagem"
    }
  ],
  "contexto": "breve descrição do que foi encontrado"
}
`;

  const response = await openai.chat.completions.create({
    model: "gpt-4-turbo",
    messages: [{ role: "user", content: prompt }],
    temperature: 0.1,
    max_tokens: 500
  });

  return JSON.parse(response.choices[0].message.content);
}

// Funções de validação específicas por tipo
function validarEntidades(entidades) {
  return entidades.map(entidade => {
    switch(entidade.tipo) {
      case 'EMAIL':
        return validarEmail(entidade);
      case 'TELEFONE':
        return formatarTelefone(entidade);
      case 'DATA':
        return normalizarData(entidade);
      case 'VALOR':
        return formatarValor(entidade);
      default:
        return entidade;
    }
  });
}

function validarEmail(entidade) {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  const isValid = emailRegex.test(entidade.valor);
  
  return {
    ...entidade,
    valido: isValid,
    valorFormatado: isValid ? entidade.valor.toLowerCase() : null
  };
}

function formatarTelefone(entidade) {
  // Remove caracteres não numéricos
  const apenasNumeros = entidade.valor.replace(/\D/g, '');
  
  // Formata para padrão brasileiro
  let formatado = apenasNumeros;
  if (apenasNumeros.length === 11) {
    formatado = `(${apenasNumeros.substr(0,2)}) ${apenasNumeros.substr(2,5)}-${apenasNumeros.substr(7)}`;
  }
  
  return {
    ...entidade,
    valorFormatado: formatado,
    valorNumerico: apenasNumeros
  };
}

function normalizarData(entidade) {
  const hoje = new Date();
  let dataProcessada;
  
  // Processa datas relativas
  if (entidade.valor.includes('amanhã')) {
    dataProcessada = new Date(hoje.getTime() + 24*60*60*1000);
  } else if (entidade.valor.includes('hoje')) {
    dataProcessada = hoje;
  } else {
    // Tenta fazer parse da data
    dataProcessada = new Date(entidade.valor);
  }
  
  return {
    ...entidade,
    valorFormatado: dataProcessada.toISOString(),
    dataLegivel: dataProcessada.toLocaleDateString('pt-BR')
  };
}

// N8N Function Node - Processamento de Entidades
const message = $json.message;
const userPhone = $json.from;

// 1. Extrair entidades da mensagem
const extractionResult = await extrairEntidades(message);

// 2. Validar e formatar entidades
const validatedEntities = validarEntidades(extractionResult.entidades);

// 3. Categorizar por relevância
const relevantEntities = validatedEntities.filter(e => e.confianca > 0.7);

// 4. Construir contexto do usuário
const userContext = {
  phone: userPhone,
  extractedData: {},
  message: message,
  timestamp: new Date().toISOString()
};

// 5. Mapear entidades para contexto
relevantEntities.forEach(entity => {
  switch(entity.tipo) {
    case 'PESSOA':
      userContext.extractedData.nome = entity.valorFormatado || entity.valor;
      break;
    case 'EMAIL':
      if (entity.valido) {
        userContext.extractedData.email = entity.valorFormatado;
      }
      break;
    case 'TELEFONE':
      userContext.extractedData.telefone = entity.valorFormatado;
      break;
    case 'PRODUTO':
      userContext.extractedData.produtoInteresse = entity.valor;
      break;
    case 'PEDIDO':
      userContext.extractedData.numeroPedido = entity.valor;
      break;
    case 'DATA':
      userContext.extractedData.dataDesejada = entity.valorFormatado;
      break;
  }
});

// 6. Determinar próximas ações baseado nas entidades
let nextActions = [];

if (userContext.extractedData.numeroPedido) {
  nextActions.push('CONSULTAR_PEDIDO');
}

if (userContext.extractedData.email && userContext.extractedData.nome) {
  nextActions.push('IDENTIFICAR_CLIENTE');
}

if (userContext.extractedData.produtoInteresse) {
  nextActions.push('MOSTRAR_PRODUTO');
}

// 7. Retornar dados estruturados
return [{
  json: {
    original_message: message,
    user_context: userContext,
    extracted_entities: relevantEntities,
    suggested_actions: nextActions,
    confidence_score: relevantEntities.length > 0 ? 
      relevantEntities.reduce((sum, e) => sum + e.confianca, 0) / relevantEntities.length : 0,
    needs_more_info: relevantEntities.length < 2
  }
}];

// Sistema principal que escolhe a melhor API
class NLPOrchestrator {
  constructor() {
    this.providers = {
      openai: new OpenAIProvider(),
      google: new GoogleNLPProvider(),
      azure: new AzureProvider(),
      local: new LocalNLPProvider()
    };
    
    this.fallbackChain = ['openai', 'google', 'azure', 'local'];
    this.costLimits = {
      daily: 50.00,     // Limite diário em USD
      monthly: 1200.00  // Limite mensal em USD
    };
  }

  async processMessage(message, options = {}) {
    const analysis = await this.analyzeMessage(message);
    const bestProvider = this.selectProvider(analysis, options);
    
    try {
      return await this.executeWithFallback(bestProvider, message, analysis);
    } catch (error) {
      console.error(`NLP processing failed: ${error.message}`);
      return this.getDefaultResponse(message);
    }
  }

  selectProvider(analysis, options) {
    // Lógica de seleção baseada em complexidade e custo
    if (analysis.complexity === 'high' && !this.nearCostLimit()) {
      return 'openai';  // GPT-4 para casos complexos
    }
    
    if (analysis.type === 'entity_extraction') {
      return 'google';  // Google NLP é excelente para entidades
    }
    
    if (analysis.sentiment && analysis.intent) {
      return 'azure';   // Azure Text Analytics é eficiente
    }
    
    return 'local';     // Fallback local para casos simples
  }
}

class OpenAIProvider {
  constructor() {
    this.client = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY,
      timeout: 10000,
      maxRetries: 2
    });
    
    this.models = {
      fast: 'gpt-3.5-turbo',      // Custo baixo, resposta rápida
      balanced: 'gpt-4-turbo',     // Balanceado custo/qualidade
      premium: 'gpt-4'             // Máxima qualidade
    };
  }

  async processNLP(message, type, options = {}) {
    const model = this.selectModel(type, options);
    const prompt = this.buildPrompt(message, type);
    
    try {
      const response = await this.client.chat.completions.create({
        model: model,
        messages: [{ role: 'user', content: prompt }],
        temperature: type === 'classification' ? 0.1 : 0.3,
        max_tokens: this.getMaxTokens(type),
        timeout: 15000
      });

      const result = this.parseResponse(response, type);
      await this.logUsage(model, response.usage);
      
      return result;
    } catch (error) {
      if (error.code === 'rate_limit_exceeded') {
        throw new Error('RATE_LIMIT');
      } else if (error.code === 'insufficient_quota') {
        throw new Error('QUOTA_EXCEEDED');
      }
      throw error;
    }
  }

  buildPrompt(message, type) {
    const prompts = {
      intent: `Classifique a intenção: ${message}
Resposta em JSON.`,
      sentiment: `Analise o sentimento: ${message}
Escala 1-5 em JSON.`,
      entities: `Extraia entidades: ${message}
Lista em JSON.`,
      complete: `Análise completa de NLP para: ${message}
JSON com intent, sentiment, entities.`
    };
    
    return prompts[type] || prompts.complete;
  }

  selectModel(type, options) {
    if (options.priority === 'cost') return this.models.fast;
    if (options.priority === 'quality') return this.models.premium;
    
    // Seleção baseada no tipo de análise
    return type === 'complete' ? this.models.balanced : this.models.fast;
  }
}

class GoogleNLPProvider {
  constructor() {
    this.language = new LanguageServiceClient({
      keyFilename: process.env.GOOGLE_APPLICATION_CREDENTIALS,
      projectId: process.env.GOOGLE_PROJECT_ID
    });
  }

  async processNLP(message, type) {
    const document = {
      content: message,
      type: 'PLAIN_TEXT'
    };

    try {
      const results = await Promise.all([
        this.analyzeSentiment(document),
        this.extractEntities(document),
        this.classifyText(document)
      ]);

      return {
        sentiment: results[0],
        entities: results[1],
        classification: results[2],
        provider: 'google',
        confidence: this.calculateOverallConfidence(results)
      };
    } catch (error) {
      throw new Error(`Google NLP failed: ${error.message}`);
    }
  }

  async analyzeSentiment(document) {
    const [result] = await this.language.analyzeSentiment({
      document: document
    });

    const sentiment = result.documentSentiment;
    return {
      score: sentiment.score,        // -1 a 1
      magnitude: sentiment.magnitude, // 0 a infinito
      label: this.sentimentToLabel(sentiment.score),
      confidence: Math.abs(sentiment.score)
    };
  }

  async extractEntities(document) {
    const [result] = await this.language.analyzeEntities({
      document: document
    });

    return result.entities.map(entity => ({
      name: entity.name,
      type: entity.type,
      salience: entity.salience,
      mentions: entity.mentions.map(mention => ({
        text: mention.text.content,
        type: mention.type
      }))
    }));
  }

  async classifyText(document) {
    try {
      const [result] = await this.language.classifyText({
        document: document
      });

      return result.categories.map(category => ({
        name: category.name,
        confidence: category.confidence
      }));
    } catch (error) {
      // Classificação pode falhar para textos curtos
      return [];
    }
  }

  sentimentToLabel(score) {
    if (score > 0.3) return 'POSITIVO';
    if (score < -0.3) return 'NEGATIVO';
    return 'NEUTRO';
  }
}

class LocalNLPProvider {
  constructor() {
    this.sentimentWords = {
      positive: ['bom', 'ótimo', 'excelente', 'adorei', 'perfeito', 'maravilhoso'],
      negative: ['ruim', 'péssimo', 'horrível', 'terrível', 'odeio', 'detesto'],
      urgent: ['urgente', 'emergência', 'rápido', 'já', 'agora', 'imediatamente']
    };
    
    this.intentPatterns = {
      consultar_pedido: /\b(pedido|status|onde está|rastrear|tracking)\b/i,
      cancelar: /\b(cancelar|cancela|desistir|não quero)\b/i,
      reclamar: /\b(reclamação|problema|insatisfeito|ruim)\b/i,
      elogiar: /\b(parabéns|excelente|adorei|muito bom)\b/i,
      suporte: /\b(ajuda|suporte|dúvida|não sei)\b/i
    };
    
    this.entityPatterns = {
      email: /[\w.-]+@[\w.-]+\.\w+/g,
      phone: /\(?\d{2}\)?\s?\d{4,5}-?\d{4}/g,
      cpf: /\d{3}\.?\d{3}\.?\d{3}-?\d{2}/g,
      order: /#?\d{4,}/g
    };
  }

  async processNLP(message) {
    const normalized = message.toLowerCase();
    
    return {
      sentiment: this.analyzeSentimentLocal(normalized),
      intent: this.classifyIntentLocal(normalized),
      entities: this.extractEntitiesLocal(message),
      provider: 'local',
      confidence: 0.7  // Confiança moderada para fallback
    };
  }

  analyzeSentimentLocal(text) {
    let score = 0;
    let isUrgent = false;
    
    // Verificar palavras positivas
    this.sentimentWords.positive.forEach(word => {
      if (text.includes(word)) score += 1;
    });
    
    // Verificar palavras negativas
    this.sentimentWords.negative.forEach(word => {
      if (text.includes(word)) score -= 1;
    });
    
    // Verificar urgência
    this.sentimentWords.urgent.forEach(word => {
      if (text.includes(word)) isUrgent = true;
    });
    
    return {
      score: Math.max(-1, Math.min(1, score * 0.3)),
      label: score > 0 ? 'POSITIVO' : score < 0 ? 'NEGATIVO' : 'NEUTRO',
      urgent: isUrgent,
      confidence: 0.7
    };
  }

  classifyIntentLocal(text) {
    const matches = [];
    
    Object.entries(this.intentPatterns).forEach(([intent, pattern]) => {
      if (pattern.test(text)) {
        matches.push({
          intent: intent.toUpperCase(),
          confidence: 0.8
        });
      }
    });
    
    return matches.length > 0 ? matches[0] : {
      intent: 'OUTROS',
      confidence: 0.5
    };
  }

  extractEntitiesLocal(text) {
    const entities = [];
    
    Object.entries(this.entityPatterns).forEach(([type, pattern]) => {
      const matches = text.match(pattern);
      if (matches) {
        matches.forEach(match => {
          entities.push({
            type: type.toUpperCase(),
            value: match.trim(),
            confidence: 0.8
          });
        });
      }
    });
    
    return entities;
  }
}

// config/nlp-config.js
export const NLP_CONFIG = {
  providers: {
    openai: {
      apiKey: process.env.OPENAI_API_KEY,
      baseUrl: 'https://api.openai.com/v1',
      models: {
        fast: 'gpt-3.5-turbo',
        balanced: 'gpt-4-turbo',
        premium: 'gpt-4'
      },
      maxTokens: {
        intent: 100,
        sentiment: 150,
        entities: 200,
        complete: 500
      }
    },
    
    google: {
      keyFile: process.env.GOOGLE_APPLICATION_CREDENTIALS,
      projectId: process.env.GOOGLE_PROJECT_ID
    },
    
    fallback: {
      enabled: true,
      confidence_threshold: 0.7
    }
  },
  
  costs: {
    daily_limit: 50.00,
    monthly_limit: 1200.00,
    alert_threshold: 0.8
  },
  
  cache: {
    enabled: true,
    ttl: 3600, // 1 hora
    redis_url: process.env.REDIS_URL
  },
  
  business_rules: {
    priority_keywords: ['urgente', 'emergência', 'problema grave'],
    vip_customers: [], // Lista de telefones VIP
    working_hours: {
      start: '08:00',
      end: '18:00',
      timezone: 'America/Sao_Paulo'
    }
  }
};

// Estrutura base do banco de dados
const DATABASE_SCHEMA = {
  conversations: {
    id: 'string',
    user_phone: 'string',
    created_at: 'timestamp',
    updated_at: 'timestamp',
    status: 'active|resolved|escalated',
    priority: 'low|medium|high|urgent'
  },
  
  messages: {
    id: 'string',
    conversation_id: 'string',
    content: 'text',
    sender: 'user|bot|agent',
    nlp_analysis: 'json',
    timestamp: 'timestamp'
  },
  
  customer_data: {
    phone: 'string',
    name: 'string',
    email: 'string',
    preferences: 'json',
    purchase_history: 'json',
    satisfaction_score: 'float'
  }
};

// services/nlp-service.js
import { NLPOrchestrator } from './nlp-orchestrator.js';
import { CustomerService } from './customer-service.js';
import { CacheService } from './cache-service.js';

export class WhatsAppNLPService {
  constructor() {
    this.nlp = new NLPOrchestrator();
    this.customer = new CustomerService();
    this.cache = new CacheService();
    this.responseGenerator = new ResponseGenerator();
  }

  async processIncomingMessage(messageData) {
    const { message, phone, messageId } = messageData;
    
    try {
      // 1. Verificar cache primeiro
      const cacheKey = this.generateCacheKey(message);
      let analysis = await this.cache.get(cacheKey);
      
      if (!analysis) {
        // 2. Análise NLP completa
        analysis = await this.nlp.analyzeMessage(message);
        await this.cache.set(cacheKey, analysis, 3600);
      }
      
      // 3. Enriquecer com dados do cliente
      const customerData = await this.customer.getCustomerData(phone);
      const enrichedAnalysis = await this.enrichAnalysis(analysis, customerData);
      
      // 4. Determinar ação baseada em regras de negócio
      const action = this.determineAction(enrichedAnalysis, customerData);
      
      // 5. Executar ação determinada
      const response = await this.executeAction(action, enrichedAnalysis, customerData);
      
      // 6. Salvar no histórico
      await this.saveInteraction(phone, message, enrichedAnalysis, response);
      
      return response;
      
    } catch (error) {
      console.error('NLP Processing Error:', error);
      return this.getErrorResponse(error, messageData);
    }
  }

  async enrichAnalysis(analysis, customerData) {
    // Adicionar contexto do cliente à análise
    const enriched = { ...analysis };
    
    // Verificar se é cliente VIP
    enriched.isVIP = this.customer.isVIPCustomer(customerData);
    
    // Adicionar histórico de sentimentos
    enriched.sentimentHistory = customerData.sentimentHistory || [];
    
    // Verificar padrões comportamentais
    enriched.behaviorPattern = this.customer.analyzeBehavior(customerData);
    
    // Adicionar contexto de compras
    if (enriched.entities) {
      enriched.entities = await this.enrichEntitiesWithProducts(enriched.entities);
    }
    
    return enriched;
  }

  determineAction(analysis, customerData) {
    const { intent, sentiment, entities, isVIP } = analysis;
    
    // Lógica de priorização
    if (sentiment.urgent || isVIP) {
      return { type: 'PRIORITY_RESPONSE', priority: 'high' };
    }
    
    // Lógica baseada em intenção
    switch (intent.label) {
      case 'CONSULTAR_PEDIDO':
        return entities.some(e => e.type === 'PEDIDO') 
          ? { type: 'ORDER_STATUS', orderNumber: this.extractOrderNumber(entities) }
          : { type: 'REQUEST_ORDER_NUMBER' };
          
      case 'CANCELAR_PEDIDO':
        return { type: 'CANCEL_ORDER', requireConfirmation: true };
        
      case 'RECLAMACAO':
        return { type: 'HANDLE_COMPLAINT', escalate: sentiment.score < -0.5 };
        
      case 'SOLICITAR_ORCAMENTO':
        return { type: 'GENERATE_QUOTE', products: this.extractProducts(entities) };
        
      default:
        return { type: 'GENERAL_RESPONSE' };
    }
  }

  async executeAction(action, analysis, customerData) {
    switch (action.type) {
      case 'ORDER_STATUS':
        return await this.handleOrderStatus(action.orderNumber, customerData);
        
      case 'CANCEL_ORDER':
        return await this.handleOrderCancellation(analysis, customerData);
        
      case 'HANDLE_COMPLAINT':
        return await this.handleComplaint(analysis, customerData, action.escalate);
        
      case 'GENERATE_QUOTE':
        return await this.generateQuote(action.products, customerData);
        
      case 'PRIORITY_RESPONSE':
        return await this.generatePriorityResponse(analysis, customerData);
        
      default:
        return await this.generateGeneralResponse(analysis, customerData);
    }
  }
}

// Implementação de casos de uso específicos
class SpecificUseCases {
  
  async handleOrderStatus(orderNumber, customerData) {
    try {
      // Consultar status do pedido
      const order = await this.orderService.getOrder(orderNumber);
      
      if (!order) {
        return {
          type: 'text',
          content: `Não encontrei o pedido ${orderNumber}. Você pode verificar o número e tentar novamente?`,
          suggestions: ['Digitar novamente', 'Falar com atendente']
        };
      }
      
      // Verificar se pedido pertence ao cliente
      if (order.customerPhone !== customerData.phone && !order.alternativeContacts?.includes(customerData.phone)) {
        return {
          type: 'text',
          content: 'Para consultar este pedido, preciso confirmar alguns dados. Qual seu email ou CPF?',
          requiresVerification: true
        };
      }
      
      // Gerar resposta contextual baseada no status
      const response = this.generateOrderStatusResponse(order);
      
      // Se há atraso, ser proativo
      if (order.isDelayed) {
        response.content += '\n\n⚠️ Notei que há um pequeno atraso. Posso verificar o que aconteceu e dar um desconto no seu próximo pedido como desculpa.';
        response.actions = ['Verificar atraso', 'Aplicar desconto'];
      }
      
      return response;
      
    } catch (error) {
      return this.getErrorResponse('Erro ao consultar pedido', error);
    }
  }

  async handleComplaint(analysis, customerData, shouldEscalate) {
    const { sentiment, entities, originalMessage } = analysis;
    
    // Resposta empática baseada no nível de insatisfação
    let empathyLevel;
    if (sentiment.score < -0.7) empathyLevel = 'high';
    else if (sentiment.score < -0.3) empathyLevel = 'medium';
    else empathyLevel = 'low';
    
    const response = {
      type: 'complaint_response',
      empathy_level: empathyLevel,
      content: this.generateEmpathicResponse(empathyLevel, analysis),
      priority: shouldEscalate ? 'urgent' : 'high'
    };
    
    // Identificar produto/serviço da reclamação
    const complainedProduct = entities.find(e => e.type === 'PRODUTO');
    if (complainedProduct) {
      response.product = complainedProduct.value;
      response.content += `\n\nVi que sua reclamação é sobre ${complainedProduct.value}. Vou verificar imediatamente o que aconteceu.`;
    }
    
    // Oferecer compensação proativa
    if (empathyLevel === 'high') {
      response.content += '\n\n🎁 Como forma de desculpa, gostaria de oferecer um desconto especial no seu próximo pedido. Posso ajudar com isso?';
      response.actions = ['Aceitar desconto', 'Falar com gerente', 'Resolver problema'];
    }
    
    // Agendar follow-up
    await this.scheduleFollowUp(customerData.phone, 24); // 24 horas
    
    return response;
  }

  async generateQuote(products, customerData) {
    if (!products || products.length === 0) {
      return {
        type: 'text',
        content: 'Para fazer um orçamento preciso, que tipo de produto você está procurando?',
        suggestions: ['Eletrônicos', 'Roupas', 'Casa e jardim', 'Falar com vendedor']
      };
    }
    
    const quotes = [];
    
    for (const product of products) {
      const productInfo = await this.productService.findProduct(product);
      
      if (productInfo) {
        // Aplicar desconto baseado no histórico do cliente
        const discount = this.calculatePersonalizedDiscount(customerData);
        const finalPrice = productInfo.price * (1 - discount);
        
        quotes.push({
          name: productInfo.name,
          originalPrice: productInfo.price,
          finalPrice: finalPrice,
          discount: discount * 100,
          availability: productInfo.stock > 0 ? 'Em estoque' : 'Sob consulta'
        });
      }
    }
    
    if (quotes.length === 0) {
      return {
        type: 'text',
        content: 'Não encontrei os produtos específicos que você mencionou. Posso ajudar você a encontrar algo similar?',
        actions: ['Ver catálogo', 'Falar com vendedor']
      };
    }
    
    // Gerar mensagem de orçamento
    let quoteMessage = '💰 **Seu Orçamento Personalizado:**\n\n';
    
    quotes.forEach((quote, index) => {
      quoteMessage += `${index + 1}. **${quote.name}**\n`;
      quoteMessage += `   Preço: ~~R$ ${quote.originalPrice.toFixed(2)}~~ **R$ ${quote.finalPrice.toFixed(2)}**\n`;
      if (quote.discount > 0) {
        quoteMessage += `   💚 Desconto especial: ${quote.discount.toFixed(0)}%\n`;
      }
      quoteMessage += `   📦 ${quote.availability}\n\n`;
    });
    
    const totalSavings = quotes.reduce((sum, q) => sum + (q.originalPrice - q.finalPrice), 0);
    if (totalSavings > 0) {
      quoteMessage += `🎉 **Você economiza: R$ ${totalSavings.toFixed(2)}**\n\n`;
    }
    
    quoteMessage += 'Quer finalizar a compra ou tem alguma dúvida?';
    
    return {
      type: 'quote',
      content: quoteMessage,
      quotes: quotes,
      actions: ['Finalizar compra', 'Ver mais produtos', 'Falar com vendedor'],
      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000) // 24 horas
    };
  }
}

// N8N Workflow - Nó Principal
const webhookData = $json;
const message = webhookData.message;
const userPhone = webhookData.from;
const messageId = webhookData.id;

// Inicializar serviços
const nlpService = new WhatsAppNLPService();
const startTime = Date.now();

try {
  // 1. Processar mensagem com NLP
  const response = await nlpService.processIncomingMessage({
    message,
    phone: userPhone,
    messageId
  });
  
  // 2. Preparar dados para envio
  const responseData = {
    to: userPhone,
    type: response.type || 'text',
    message: response.content,
    processingTime: Date.now() - startTime,
    confidence: response.confidence || 1.0,
    nlpAnalysis: response.analysis
  };
  
  // 3. Adicionar ações sugeridas se existirem
  if (response.actions) {
    responseData.interactive = {
      type: 'button',
      body: { text: response.content },
      action: {
        buttons: response.actions.map((action, index) => ({
          type: 'reply',
          reply: {
            id: `action_${index}`,
            title: action
          }
        }))
      }
    };
  }
  
  // 4. Adicionar sugestões se existirem
  if (response.suggestions) {
    responseData.interactive = {
      type: 'list',
      body: { text: response.content },
      action: {
        button: 'Ver opções',
        sections: [{
          title: 'Como posso ajudar?',
          rows: response.suggestions.map((suggestion, index) => ({
            id: `suggestion_${index}`,
            title: suggestion,
            description: ''
          }))
        }]
      }
    };
  }
  
  // 5. Verificar se precisa escalação
  if (response.escalate) {
    // Notificar equipe de atendimento
    await notifySupport({
      phone: userPhone,
      message: message,
      reason: response.escalationReason,
      priority: response.priority || 'medium'
    });
    
    responseData.message += '\n\n👨‍💼 Um especialista irá entrar em contato em breve.';
  }
  
  // 6. Agendar follow-up se necessário
  if (response.scheduleFollowUp) {
    await scheduleFollowUp({
      phone: userPhone,
      delay: response.scheduleFollowUp,
      type: response.followUpType || 'satisfaction'
    });
  }
  
  // 7. Retornar resposta para webhook WhatsApp
  return [{
    json: responseData
  }];
  
} catch (error) {
  console.error('Workflow Error:', error);
  
  // Resposta de erro amigável
  return [{
    json: {
      to: userPhone,
      type: 'text',
      message: 'Desculpe, tive uma dificuldade técnica. Um atendente humano irá ajudar você em instantes. 🤖',
      error: true,
      errorDetails: error.message
    }
  }];
}

// Função auxiliar para notificar suporte
async function notifySupport(data) {
  // Webhook para equipe ou integração com CRM
  const supportNotification = {
    type: 'escalation',
    customer_phone: data.phone,
    message: data.message,
    priority: data.priority,
    timestamp: new Date().toISOString(),
    reason: data.reason
  };
  
  // Enviar para canal do Slack, Teams ou sistema de tickets
  await fetch(process.env.SUPPORT_WEBHOOK_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(supportNotification)
  });
}

// Função para agendar follow-up
async function scheduleFollowUp(data) {
  const followUpData = {
    phone: data.phone,
    scheduledFor: new Date(Date.now() + data.delay * 60 * 60 * 1000),
    type: data.type,
    status: 'pending'
  };
  
  // Salvar no banco para processamento posterior
  await saveToDatabase('scheduled_followups', followUpData);
}