Aula 3: Agentes Inteligentes e Memória

// Schema do banco de dados para memória conversacional
const MEMORY_SCHEMA = {
  // Perfil base do usuário
  user_profiles: {
    phone: 'string PRIMARY KEY',
    name: 'string',
    email: 'string',
    created_at: 'timestamp',
    last_interaction: 'timestamp',
    interaction_count: 'integer',
    satisfaction_score: 'float', // 0-5
    profile_completeness: 'float', // 0-1
    preferred_language: 'string',
    timezone: 'string'
  },

  // Memória de trabalho (contexto atual)
  working_memory: {
    session_id: 'string PRIMARY KEY',
    user_phone: 'string FOREIGN KEY',
    created_at: 'timestamp',
    expires_at: 'timestamp',
    current_state: 'string',
    context_data: 'jsonb',
    recent_messages: 'jsonb[]',
    active_entities: 'jsonb',
    conversation_summary: 'text'
  },

  // Memória episódica (histórico de conversas)
  conversation_episodes: {
    episode_id: 'string PRIMARY KEY',
    user_phone: 'string FOREIGN KEY',
    start_time: 'timestamp',
    end_time: 'timestamp',
    message_count: 'integer',
    topics: 'string[]',
    sentiment_overall: 'string',
    resolution_status: 'string',
    satisfaction_rating: 'integer',
    key_outcomes: 'jsonb',
    conversation_summary: 'text',
    learned_preferences: 'jsonb'
  },

  // Base de conhecimento semântico
  semantic_knowledge: {
    knowledge_id: 'string PRIMARY KEY',
    user_phone: 'string FOREIGN KEY',
    knowledge_type: 'string', // preference, behavior, demographic
    category: 'string',
    key: 'string',
    value: 'jsonb',
    confidence: 'float', // 0-1
    source: 'string', // stated, inferred, observed
    created_at: 'timestamp',
    updated_at: 'timestamp',
    relevance_score: 'float'
  },

  // Histórico detalhado de mensagens
  message_history: {
    message_id: 'string PRIMARY KEY',
    episode_id: 'string FOREIGN KEY',
    user_phone: 'string',
    timestamp: 'timestamp',
    direction: 'string', // inbound, outbound
    content: 'text',
    message_type: 'string', // text, image, audio, document
    nlp_analysis: 'jsonb',
    agent_response_data: 'jsonb'
  }
};

// services/memory-manager.js
export class MemoryManager {
  constructor() {
    this.db = new DatabaseConnection();
    this.workingMemoryTTL = 30 * 60 * 1000; // 30 minutos
    this.compressionThreshold = 50; // compactar após 50 mensagens
  }

  async initializeUserMemory(userPhone) {
    // Verificar se usuário já existe
    let profile = await this.db.query(
      'SELECT * FROM user_profiles WHERE phone = ?', 
      [userPhone]
    );

    if (!profile.length) {
      // Criar novo perfil
      profile = await this.createNewUserProfile(userPhone);
    }

    // Carregar memória de trabalho ativa
    const workingMemory = await this.loadWorkingMemory(userPhone);
    
    // Carregar resumo de conhecimento semântico
    const semanticSummary = await this.loadSemanticSummary(userPhone);
    
    return {
      profile: profile[0],
      workingMemory,
      semanticSummary
    };
  }

  async storeMessage(userPhone, message, direction, analysis) {
    const timestamp = new Date();
    
    // 1. Salvar na mensagem no histórico
    const messageId = await this.saveMessage({
      userPhone,
      message,
      direction,
      timestamp,
      analysis
    });

    // 2. Atualizar memória de trabalho
    await this.updateWorkingMemory(userPhone, {
      messageId,
      message,
      direction,
      timestamp,
      analysis
    });

    // 3. Extrair conhecimento semântico se aplicável
    if (analysis.entities || analysis.preferences) {
      await this.extractSemanticKnowledge(userPhone, analysis);
    }

    // 4. Verificar se precisa compactar memória
    await this.checkMemoryCompression(userPhone);

    return messageId;
  }

  async loadWorkingMemory(userPhone) {
    const session = await this.db.query(
      `SELECT * FROM working_memory 
       WHERE user_phone = ? AND expires_at > NOW()
       ORDER BY created_at DESC LIMIT 1`,
      [userPhone]
    );

    if (!session.length) {
      return await this.createNewWorkingMemory(userPhone);
    }

    const workingMemory = session[0];
    
    // Carregar mensagens recentes
    workingMemory.recentMessages = await this.db.query(
      `SELECT * FROM message_history 
       WHERE user_phone = ? 
       ORDER BY timestamp DESC LIMIT 20`,
      [userPhone]
    );

    return workingMemory;
  }

  async updateWorkingMemory(userPhone, messageData) {
    const { messageId, message, direction, analysis } = messageData;

    // Atualizar contexto da sessão
    await this.db.query(
      `UPDATE working_memory 
       SET 
         context_data = context_data || ?::jsonb,
         recent_messages = recent_messages || ?::jsonb,
         expires_at = NOW() + INTERVAL '30 minutes'
       WHERE user_phone = ?`,
      [
        JSON.stringify({
          lastMessage: message,
          lastDirection: direction,
          lastAnalysis: analysis
        }),
        JSON.stringify([{
          messageId,
          message: message.substring(0, 200), // Limitar tamanho
          direction,
          timestamp: new Date(),
          key_entities: analysis.entities || []
        }]),
        userPhone
      ]
    );

    // Manter apenas últimas 20 mensagens na memória de trabalho
    await this.trimWorkingMemory(userPhone);
  }

  async extractSemanticKnowledge(userPhone, analysis) {
    const learnings = [];

    // Extrair preferências de produtos
    if (analysis.entities) {
      for (const entity of analysis.entities) {
        if (entity.type === 'PRODUTO') {
          learnings.push({
            type: 'preference',
            category: 'product_interest',
            key: 'mentioned_products',
            value: entity.value,
            confidence: entity.confidence,
            source: 'stated'
          });
        }
      }
    }

    // Extrair padrões comportamentais
    if (analysis.sentiment) {
      learnings.push({
        type: 'behavior',
        category: 'communication_style',
        key: 'sentiment_tendency',
        value: analysis.sentiment.label,
        confidence: analysis.sentiment.confidence,
        source: 'observed'
      });
    }

    // Salvar conhecimentos extraídos
    for (const learning of learnings) {
      await this.saveSemanticKnowledge(userPhone, learning);
    }
  }

  async saveSemanticKnowledge(userPhone, learning) {
    // Verificar se já existe conhecimento similar
    const existing = await this.db.query(
      `SELECT * FROM semantic_knowledge 
       WHERE user_phone = ? AND knowledge_type = ? 
       AND category = ? AND key = ?`,
      [userPhone, learning.type, learning.category, learning.key]
    );

    if (existing.length) {
      // Atualizar confiança usando média ponderada
      const currentConfidence = existing[0].confidence;
      const newConfidence = (currentConfidence + learning.confidence) / 2;
      
      await this.db.query(
        `UPDATE semantic_knowledge 
         SET value = ?, confidence = ?, updated_at = NOW()
         WHERE knowledge_id = ?`,
        [learning.value, newConfidence, existing[0].knowledge_id]
      );
    } else {
      // Inserir novo conhecimento
      await this.db.query(
        `INSERT INTO semantic_knowledge 
         (user_phone, knowledge_type, category, key, value, confidence, source)
         VALUES (?, ?, ?, ?, ?, ?, ?)`,
        [
          userPhone,
          learning.type,
          learning.category,
          learning.key,
          JSON.stringify(learning.value),
          learning.confidence,
          learning.source
        ]
      );
    }
  }
}

// services/memory-retrieval.js
export class MemoryRetrieval {
  constructor(memoryManager) {
    this.memory = memoryManager;
  }

  async getRelevantContext(userPhone, currentMessage, nlpAnalysis) {
    const context = {
      workingMemory: {},
      relevantEpisodes: [],
      semanticKnowledge: {},
      personalizations: {}
    };

    // 1. Carregar memória de trabalho
    context.workingMemory = await this.memory.loadWorkingMemory(userPhone);

    // 2. Buscar episódios relevantes baseado no tópico atual
    if (nlpAnalysis.entities) {
      context.relevantEpisodes = await this.findRelevantEpisodes(
        userPhone, 
        nlpAnalysis.entities
      );
    }

    // 3. Recuperar conhecimento semântico relacionado
    context.semanticKnowledge = await this.getRelevantSemanticKnowledge(
      userPhone,
      nlpAnalysis
    );

    // 4. Determinar personalizações apropriadas
    context.personalizations = await this.generatePersonalizations(
      userPhone,
      context.semanticKnowledge
    );

    return context;
  }

  async findRelevantEpisodes(userPhone, entities) {
    const relevantEpisodes = [];

    // Buscar por entidades similares em episódios passados
    for (const entity of entities) {
      const episodes = await this.memory.db.query(
        `SELECT * FROM conversation_episodes 
         WHERE user_phone = ? 
         AND (topics @> ?::jsonb OR key_outcomes @> ?::jsonb)
         ORDER BY end_time DESC LIMIT 3`,
        [
          userPhone,
          JSON.stringify([entity.value]),
          JSON.stringify({ entities: [entity.value] })
        ]
      );

      relevantEpisodes.push(...episodes);
    }

    // Remover duplicatas e ordenar por relevância
    const uniqueEpisodes = this.removeDuplicateEpisodes(relevantEpisodes);
    return this.rankEpisodesByRelevance(uniqueEpisodes, entities);
  }

  async getRelevantSemanticKnowledge(userPhone, nlpAnalysis) {
    const knowledge = {
      preferences: {},
      behaviors: {},
      demographics: {}
    };

    // Buscar preferências relacionadas ao contexto atual
    if (nlpAnalysis.intent) {
      const preferences = await this.memory.db.query(
        `SELECT * FROM semantic_knowledge 
         WHERE user_phone = ? AND knowledge_type = 'preference'
         ORDER BY confidence DESC, updated_at DESC`,
        [userPhone]
      );

      knowledge.preferences = this.organizeKnowledgeByCategory(preferences);
    }

    // Buscar padrões comportamentais
    const behaviors = await this.memory.db.query(
      `SELECT * FROM semantic_knowledge 
       WHERE user_phone = ? AND knowledge_type = 'behavior'
       ORDER BY relevance_score DESC`,
      [userPhone]
    );

    knowledge.behaviors = this.organizeKnowledgeByCategory(behaviors);

    return knowledge;
  }

  async generatePersonalizations(userPhone, semanticKnowledge) {
    const personalizations = {
      communicationStyle: 'neutral',
      productRecommendations: [],
      responseTemplate: 'standard',
      priority: 'normal'
    };

    // Determinar estilo de comunicação
    if (semanticKnowledge.behaviors.communication_style) {
      const style = semanticKnowledge.behaviors.communication_style;
      if (style.sentiment_tendency === 'FORMAL') {
        personalizations.communicationStyle = 'formal';
      } else if (style.sentiment_tendency === 'CASUAL') {
        personalizations.communicationStyle = 'casual';
      }
    }

    // Gerar recomendações baseadas em preferências
    if (semanticKnowledge.preferences.product_interest) {
      personalizations.productRecommendations = 
        await this.generateProductRecommendations(
          semanticKnowledge.preferences.product_interest
        );
    }

    // Determinar prioridade baseada em histórico
    const userProfile = await this.memory.db.query(
      'SELECT * FROM user_profiles WHERE phone = ?',
      [userPhone]
    );

    if (userProfile.length && userProfile[0].satisfaction_score < 3) {
      personalizations.priority = 'high';
      personalizations.responseTemplate = 'empathetic';
    }

    return personalizations;
  }

  organizeKnowledgeByCategory(knowledgeArray) {
    const organized = {};
    
    for (const item of knowledgeArray) {
      if (!organized[item.category]) {
        organized[item.category] = {};
      }
      
      organized[item.category][item.key] = {
        value: JSON.parse(item.value),
        confidence: item.confidence,
        lastUpdated: item.updated_at
      };
    }

    return organized;
  }

  rankEpisodesByRelevance(episodes, currentEntities) {
    // Algoritmo de ranking baseado em:
    // 1. Sobreposição de entidades
    // 2. Recência do episódio
    // 3. Resultado positivo do episódio

    return episodes.sort((a, b) => {
      const scoreA = this.calculateEpisodeRelevance(a, currentEntities);
      const scoreB = this.calculateEpisodeRelevance(b, currentEntities);
      return scoreB - scoreA;
    });
  }

  calculateEpisodeRelevance(episode, currentEntities) {
    let score = 0;

    // Pontuação por sobreposição de entidades (0-50 pontos)
    const entityOverlap = this.calculateEntityOverlap(
      episode.topics || [],
      currentEntities.map(e => e.value)
    );
    score += entityOverlap * 50;

    // Pontuação por recência (0-30 pontos)
    const daysSince = (Date.now() - new Date(episode.end_time)) / (1000 * 60 * 60 * 24);
    const recencyScore = Math.max(0, 30 - daysSince);
    score += recencyScore;

    // Pontuação por resultado positivo (0-20 pontos)
    if (episode.resolution_status === 'resolved' && episode.satisfaction_rating >= 4) {
      score += 20;
    }

    return score;
  }

  calculateEntityOverlap(episodeTopics, currentEntities) {
    const overlap = episodeTopics.filter(topic => 
      currentEntities.some(entity => 
        entity.toLowerCase().includes(topic.toLowerCase()) ||
        topic.toLowerCase().includes(entity.toLowerCase())
      )
    );

    return overlap.length / Math.max(episodeTopics.length, currentEntities.length);
  }
}

// services/context-analyzer.js
export class ContextAnalyzer {
  constructor(memoryRetrieval) {
    this.memory = memoryRetrieval;
  }

  async analyzeCurrentContext(userPhone, currentMessage, nlpAnalysis) {
    // Recuperar contexto completo da memória
    const memoryContext = await this.memory.getRelevantContext(
      userPhone, 
      currentMessage, 
      nlpAnalysis
    );

    // Analisar diferentes dimensões do contexto
    const analysis = {
      temporal: await this.analyzeTemporalPatterns(memoryContext),
      behavioral: await this.analyzeBehavioralPatterns(memoryContext),
      relational: await this.analyzeRelationalContext(memoryContext),
      situational: await this.analyzeSituationalContext(currentMessage, nlpAnalysis),
      opportunity: await this.identifyOpportunities(memoryContext, nlpAnalysis)
    };

    // Calcular score geral de contexto
    analysis.contextScore = this.calculateContextScore(analysis);
    
    return analysis;
  }

  async analyzeTemporalPatterns(memoryContext) {
    const now = new Date();
    const dayOfWeek = now.getDay();
    const hourOfDay = now.getHours();
    
    const patterns = {
      currentTiming: {
        dayOfWeek,
        hourOfDay,
        isWeekend: dayOfWeek === 0 || dayOfWeek === 6,
        isBusinessHours: hourOfDay >= 9 && hourOfDay <= 18
      },
      userPatterns: {},
      predictedBehavior: {}
    };

    // Analisar padrões históricos do usuário
    if (memoryContext.relevantEpisodes.length > 0) {
      const episodeTimes = memoryContext.relevantEpisodes.map(ep => 
        new Date(ep.start_time)
      );

      patterns.userPatterns = {
        preferredHours: this.findPreferredHours(episodeTimes),
        preferredDays: this.findPreferredDays(episodeTimes),
        averageSessionDuration: this.calculateAverageSessionDuration(
          memoryContext.relevantEpisodes
        ),
        responseTimePattern: this.analyzeResponseTimes(episodeTimes)
      };
    }

    // Predições baseadas em padrões
    patterns.predictedBehavior = {
      likelyToRespond: this.predictResponseLikelihood(patterns),
      urgencyLevel: this.assessTimeBasedUrgency(patterns),
      optimalResponseTime: this.calculateOptimalResponseTime(patterns)
    };

    return patterns;
  }

  async analyzeBehavioralPatterns(memoryContext) {
    const patterns = {
      communicationStyle: 'neutral',
      decisionMakingPattern: 'unknown',
      engagementLevel: 'medium',
      purchaseReadiness: 'unknown'
    };

    if (memoryContext.semanticKnowledge.behaviors) {
      const behaviors = memoryContext.semanticKnowledge.behaviors;

      // Estilo de comunicação
      if (behaviors.communication_style) {
        patterns.communicationStyle = behaviors.communication_style.sentiment_tendency;
      }

      // Padrão de tomada de decisão
      patterns.decisionMakingPattern = this.inferDecisionPattern(
        memoryContext.relevantEpisodes
      );

      // Nível de engajamento
      patterns.engagementLevel = this.calculateEngagementLevel(
        memoryContext.workingMemory,
        memoryContext.relevantEpisodes
      );
    }

    // Analisar prontidão para compra
    patterns.purchaseReadiness = this.assessPurchaseReadiness(
      memoryContext.relevantEpisodes,
      memoryContext.semanticKnowledge
    );

    return patterns;
  }

  async analyzeRelationalContext(memoryContext) {
    const context = {
      relationshipStage: 'new',
      trustLevel: 'building',
      satisfactionTrend: 'neutral',
      issueHistory: [],
      loyaltyIndicators: []
    };

    // Determinar estágio do relacionamento
    const interactionCount = memoryContext.relevantEpisodes.length;
    if (interactionCount === 0) {
      context.relationshipStage = 'new';
    } else if (interactionCount <= 3) {
      context.relationshipStage = 'building';
    } else if (interactionCount <= 10) {
      context.relationshipStage = 'established';
    } else {
      context.relationshipStage = 'mature';
    }

    // Calcular nível de confiança
    context.trustLevel = this.calculateTrustLevel(
      memoryContext.relevantEpisodes
    );

    // Analisar tendência de satisfação
    context.satisfactionTrend = this.analyzeSatisfactionTrend(
      memoryContext.relevantEpisodes
    );

    // Identificar histórico de problemas
    context.issueHistory = this.extractIssueHistory(
      memoryContext.relevantEpisodes
    );

    return context;
  }

  async analyzeSituationalContext(currentMessage, nlpAnalysis) {
    const context = {
      immediateNeed: 'unknown',
      urgencyLevel: 'normal',
      complexityLevel: 'simple',
      emotionalState: 'neutral',
      actionRequired: []
    };

    // Determinar necessidade imediata
    if (nlpAnalysis.intent) {
      context.immediateNeed = nlpAnalysis.intent.label;
    }

    // Avaliar urgência
    if (nlpAnalysis.sentiment && nlpAnalysis.sentiment.urgent) {
      context.urgencyLevel = 'high';
    }

    // Avaliar complexidade
    context.complexityLevel = this.assessMessageComplexity(
      currentMessage,
      nlpAnalysis
    );

    // Estado emocional
    if (nlpAnalysis.sentiment) {
      context.emotionalState = nlpAnalysis.sentiment.label;
    }

    // Ações necessárias
    context.actionRequired = this.determineRequiredActions(
      context.immediateNeed,
      context.urgencyLevel,
      nlpAnalysis.entities
    );

    return context;
  }

  async identifyOpportunities(memoryContext, nlpAnalysis) {
    const opportunities = {
      upsell: [],
      crossSell: [],
      retention: [],
      satisfaction: [],
      referral: []
    };

    // Identificar oportunidades de upsell
    if (memoryContext.semanticKnowledge.preferences) {
      opportunities.upsell = this.identifyUpsellOpportunities(
        memoryContext.semanticKnowledge.preferences,
        nlpAnalysis
      );
    }

    // Identificar oportunidades de cross-sell
    opportunities.crossSell = this.identifyCrossSellOpportunities(
      memoryContext.relevantEpisodes,
      nlpAnalysis.entities
    );

    // Identificar necessidades de retenção
    opportunities.retention = this.identifyRetentionOpportunities(
      memoryContext.relevantEpisodes
    );

    return opportunities;
  }

  calculateContextScore(analysis) {
    let score = 0;
    const weights = {
      temporal: 0.2,
      behavioral: 0.3,
      relational: 0.3,
      situational: 0.2
    };

    // Score temporal (0-100)
    if (analysis.temporal.userPatterns.preferredHours) {
      const currentHour = new Date().getHours();
      const preferredHours = analysis.temporal.userPatterns.preferredHours;
      const hourMatch = preferredHours.includes(currentHour) ? 100 : 50;
      score += hourMatch * weights.temporal;
    }

    // Score comportamental (0-100)
    const engagementScore = this.engagementToScore(
      analysis.behavioral.engagementLevel
    );
    score += engagementScore * weights.behavioral;

    // Score relacional (0-100)
    const trustScore = this.trustToScore(analysis.relational.trustLevel);
    score += trustScore * weights.relational;

    // Score situacional (0-100)
    const urgencyScore = analysis.situational.urgencyLevel === 'high' ? 100 : 70;
    score += urgencyScore * weights.situational;

    return Math.round(score);
  }
}

// services/contextual-response-generator.js
export class ContextualResponseGenerator {
  constructor() {
    this.templateEngine = new ResponseTemplateEngine();
    this.personalizationEngine = new PersonalizationEngine();
  }

  async generateContextualResponse(userPhone, message, nlpAnalysis, contextAnalysis) {
    // 1. Determinar estratégia de resposta
    const responseStrategy = this.determineResponseStrategy(
      contextAnalysis,
      nlpAnalysis
    );

    // 2. Selecionar template base
    const baseTemplate = await this.selectResponseTemplate(
      responseStrategy,
      contextAnalysis.relational.relationshipStage
    );

    // 3. Personalizar conteúdo
    const personalizedContent = await this.personalizeContent(
      baseTemplate,
      contextAnalysis,
      nlpAnalysis
    );

    // 4. Adicionar elementos proativos
    const proactiveElements = await this.addProactiveElements(
      personalizedContent,
      contextAnalysis.opportunity
    );

    // 5. Ajustar tom e estilo
    const finalResponse = await this.adjustToneAndStyle(
      proactiveElements,
      contextAnalysis.behavioral.communicationStyle,
      contextAnalysis.relational.trustLevel
    );

    return {
      content: finalResponse.text,
      type: finalResponse.type,
      actions: finalResponse.suggestedActions,
      priority: responseStrategy.priority,
      followUp: finalResponse.followUpStrategy,
      metadata: {
        strategy: responseStrategy,
        personalizationLevel: finalResponse.personalizationLevel,
        contextScore: contextAnalysis.contextScore
      }
    };
  }

  determineResponseStrategy(contextAnalysis, nlpAnalysis) {
    const strategy = {
      approach: 'standard',
      priority: 'normal',
      tone: 'professional',
      personalizationLevel: 'medium'
    };

    // Ajustar baseado no relacionamento
    switch (contextAnalysis.relational.relationshipStage) {
      case 'new':
        strategy.approach = 'welcoming';
        strategy.tone = 'friendly';
        break;
      case 'building':
        strategy.approach = 'educational';
        strategy.personalizationLevel = 'high';
        break;
      case 'established':
        strategy.approach = 'consultative';
        strategy.personalizationLevel = 'high';
        break;
      case 'mature':
        strategy.approach = 'partnership';
        strategy.tone = 'familiar';
        strategy.personalizationLevel = 'very_high';
        break;
    }

    // Ajustar baseado na situação
    if (contextAnalysis.situational.urgencyLevel === 'high') {
      strategy.priority = 'urgent';
      strategy.approach = 'solution_focused';
    }

    // Ajustar baseado no estado emocional
    if (contextAnalysis.situational.emotionalState === 'NEGATIVO') {
      strategy.tone = 'empathetic';
      strategy.approach = 'problem_solving';
    }

    return strategy;
  }

  async selectResponseTemplate(strategy, relationshipStage) {
    const templates = {
      welcoming: {
        greeting: "Olá! {name}, é um prazer falar com você.",
        body: "Como posso ajudar você hoje?",
        closing: "Estou aqui para tornar sua experiência excelente!"
      },
      educational: {
        greeting: "Oi {name}!",
        body: "Vi que você tem interesse em {topic}. Com base no que conversamos antes, acredito que {suggestion} seria perfeito para você.",
        closing: "Quer que eu explique os detalhes?"
      },
      consultative: {
        greeting: "Olá {name}, como está?",
        body: "Lembro que você estava interessado em {topic}. Temos algumas novidades que podem interessar você: {personalized_recommendations}",
        closing: "Baseado no seu perfil, qual dessas opções faz mais sentido?"
      },
      partnership: {
        greeting: "Oi {name}! 😊",
        body: "Como sempre, estou aqui para ajudar. Sobre {topic}, consegui {specific_solution} especialmente para você.",
        closing: "Você sabe que pode contar comigo para qualquer coisa!"
      }
    };

    return templates[strategy.approach] || templates.welcoming;
  }

  async personalizeContent(template, contextAnalysis, nlpAnalysis) {
    const personalizations = {};

    // Nome personalizado
    if (contextAnalysis.relational.relationshipStage !== 'new') {
      personalizations.name = await this.getUserName(contextAnalysis);
    } else {
      personalizations.name = '';
    }

    // Tópico baseado no contexto
    if (nlpAnalysis.entities && nlpAnalysis.entities.length > 0) {
      personalizations.topic = nlpAnalysis.entities[0].value;
    }

    // Sugestões baseadas em histórico
    personalizations.suggestion = await this.generatePersonalizedSuggestion(
      contextAnalysis.opportunity,
      nlpAnalysis
    );

    // Recomendações personalizadas
    personalizations.personalized_recommendations = 
      await this.generatePersonalizedRecommendations(
        contextAnalysis.opportunity
      );

    // Solução específica
    personalizations.specific_solution = 
      await this.generateSpecificSolution(
        contextAnalysis,
        nlpAnalysis
      );

    // Aplicar personalizações ao template
    return this.applyPersonalizations(template, personalizations);
  }

  async addProactiveElements(content, opportunities) {
    const proactiveElements = [];

    // Adicionar upsell se apropriado
    if (opportunities.upsell && opportunities.upsell.length > 0) {
      proactiveElements.push(
        `\n\n💡 Aproveitando que você está interessado nisso, que tal dar uma olhada em ${opportunities.upsell[0]}? Muitos clientes com seu perfil adoraram!`
      );
    }

    // Adicionar retenção se necessário
    if (opportunities.retention && opportunities.retention.length > 0) {
      proactiveElements.push(
        `\n\n🎁 Aliás, preparei algo especial para você como cliente fidelão!`
      );
    }

    // Adicionar cross-sell se relevante
    if (opportunities.crossSell && opportunities.crossSell.length > 0) {
      proactiveElements.push(
        `\n\nE já que estamos falando sobre isso, você conhece ${opportunities.crossSell[0]}? Combina perfeito!`
      );
    }

    return {
      ...content,
      text: content.text + proactiveElements.join(''),
      proactiveOffers: proactiveElements.length
    };
  }

  async adjustToneAndStyle(content, communicationStyle, trustLevel) {
    // Ajustar formalidade
    let adjustedText = content.text;

    if (communicationStyle === 'FORMAL') {
      adjustedText = this.makeMoreFormal(adjustedText);
    } else if (communicationStyle === 'CASUAL') {
      adjustedText = this.makeMoreCasual(adjustedText);
    }

    // Ajustar baseado no nível de confiança
    if (trustLevel === 'low') {
      adjustedText = this.addTrustBuilders(adjustedText);
    }

    // Determinar ações sugeridas
    const suggestedActions = this.generateSuggestedActions(
      content,
      communicationStyle
    );

    return {
      text: adjustedText,
      type: 'contextual',
      suggestedActions,
      personalizationLevel: content.proactiveOffers > 0 ? 'high' : 'medium',
      followUpStrategy: this.determineFollowUpStrategy(trustLevel)
    };
  }

  makeMoreFormal(text) {
    return text
      .replace(/Oi!/g, 'Olá,')
      .replace(/😊/g, '')
      .replace(/que tal/g, 'gostaria de considerar')
      .replace(/adoraram/g, 'avaliaram positivamente');
  }

  makeMoreCasual(text) {
    return text
      .replace(/Olá,/g, 'Oi! 😊')
      .replace(/gostaria de considerar/g, 'que tal')
      .replace(/avaliaram positivamente/g, 'adoraram');
  }

  addTrustBuilders(text) {
    const trustElements = [
      '✅ Garantia de satisfação',
      '🔒 Compra 100% segura',
      '📞 Suporte dedicado'
    ];

    return text + `\n\n${trustElements.join(' | ')}`;
  }
}

// services/intelligent-decision-engine.js
export class IntelligentDecisionEngine {
  constructor() {
    this.decisionRules = new DecisionRuleEngine();
    this.escalationManager = new EscalationManager();
    this.opportunityScorer = new OpportunityScorer();
  }

  async makeIntelligentDecision(userPhone, contextAnalysis, nlpAnalysis) {
    const decision = {
      primaryAction: null,
      secondaryActions: [],
      escalationNeeded: false,
      priority: 'normal',
      reasoning: '',
      confidence: 0
    };

    // 1. Avaliar se precisa escalação
    const escalationAssessment = await this.assessEscalationNeed(
      contextAnalysis,
      nlpAnalysis
    );

    if (escalationAssessment.needed) {
      decision.escalationNeeded = true;
      decision.primaryAction = {
        type: 'escalate',
        target: escalationAssessment.target,
        reason: escalationAssessment.reason,
        urgency: escalationAssessment.urgency
      };
      decision.confidence = escalationAssessment.confidence;
      return decision;
    }

    // 2. Determinar ação principal baseada no contexto
    decision.primaryAction = await this.determinePrimaryAction(
      contextAnalysis,
      nlpAnalysis
    );

    // 3. Identificar ações secundárias
    decision.secondaryActions = await this.identifySecondaryActions(
      contextAnalysis,
      decision.primaryAction
    );

    // 4. Calcular prioridade
    decision.priority = this.calculatePriority(
      contextAnalysis,
      nlpAnalysis
    );

    // 5. Gerar explicação da decisão
    decision.reasoning = this.generateDecisionReasoning(
      decision,
      contextAnalysis
    );

    // 6. Calcular confiança da decisão
    decision.confidence = this.calculateDecisionConfidence(
      contextAnalysis,
      nlpAnalysis
    );

    return decision;
  }

  async assessEscalationNeed(contextAnalysis, nlpAnalysis) {
    const assessment = {
      needed: false,
      target: null,
      reason: '',
      urgency: 'normal',
      confidence: 0
    };

    const escalationTriggers = [];

    // Trigger 1: Frustração alta ou múltiplas reclamações
    if (contextAnalysis.relational.satisfactionTrend === 'declining') {
      const recentIssues = contextAnalysis.relational.issueHistory
        .filter(issue => 
          new Date(issue.date) > new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
        );

      if (recentIssues.length >= 2) {
        escalationTriggers.push({
          reason: 'multiple_recent_issues',
          weight: 0.8,
          target: 'senior_support'
        });
      }
    }

    // Trigger 2: Problema técnico complexo
    if (contextAnalysis.situational.complexityLevel === 'complex') {
      const technicalEntities = nlpAnalysis.entities?.filter(e => 
        ['ERRO', 'PROBLEMA_TECNICO', 'BUG'].includes(e.type)
      ) || [];

      if (technicalEntities.length > 0) {
        escalationTriggers.push({
          reason: 'technical_complexity',
          weight: 0.7,
          target: 'technical_support'
        });
      }
    }

    // Trigger 3: Cliente VIP com urgência
    if (contextAnalysis.behavioral.purchaseReadiness === 'high' && 
        contextAnalysis.situational.urgencyLevel === 'high') {
      escalationTriggers.push({
        reason: 'vip_urgent_request',
        weight: 0.9,
        target: 'vip_support'
      });
    }

    // Trigger 4: Solicitação explícita para falar com humano
    if (nlpAnalysis.intent?.label === 'SOLICITAR_CONTATO') {
      escalationTriggers.push({
        reason: 'explicit_human_request',
        weight: 1.0,
        target: 'general_support'
      });
    }

    // Avaliar triggers
    if (escalationTriggers.length > 0) {
      const maxWeightTrigger = escalationTriggers.reduce((max, trigger) => 
        trigger.weight > max.weight ? trigger : max
      );

      if (maxWeightTrigger.weight >= 0.7) {
        assessment.needed = true;
        assessment.target = maxWeightTrigger.target;
        assessment.reason = maxWeightTrigger.reason;
        assessment.confidence = maxWeightTrigger.weight;
        assessment.urgency = maxWeightTrigger.weight >= 0.9 ? 'high' : 'normal';
      }
    }

    return assessment;
  }

  async determinePrimaryAction(contextAnalysis, nlpAnalysis) {
    const actions = [];

    // Ação baseada na intenção identificada
    if (nlpAnalysis.intent) {
      switch (nlpAnalysis.intent.label) {
        case 'CONSULTAR_PEDIDO':
          actions.push({
            type: 'order_lookup',
            confidence: nlpAnalysis.intent.confidence,
            context: 'intent_based'
          });
          break;

        case 'SOLICITAR_ORCAMENTO':
          actions.push({
            type: 'generate_quote',
            confidence: nlpAnalysis.intent.confidence,
            context: 'intent_based'
          });
          break;

        case 'RECLAMACAO':
          actions.push({
            type: 'handle_complaint',
            confidence: nlpAnalysis.intent.confidence,
            context: 'intent_based',
            empathy_level: contextAnalysis.situational.emotionalState === 'NEGATIVO' ? 'high' : 'medium'
          });
          break;

        case 'ELOGIAR':
          actions.push({
            type: 'acknowledge_praise',
            confidence: nlpAnalysis.intent.confidence,
            context: 'intent_based',
            opportunity: 'referral_request'
          });
          break;
      }
    }

    // Ações baseadas em oportunidades identificadas
    if (contextAnalysis.opportunity.upsell.length > 0) {
      actions.push({
        type: 'present_upsell',
        confidence: 0.7,
        context: 'opportunity_based',
        products: contextAnalysis.opportunity.upsell
      });
    }

    // Ações baseadas no relacionamento
    if (contextAnalysis.relational.relationshipStage === 'new') {
      actions.push({
        type: 'onboarding_experience',
        confidence: 0.8,
        context: 'relationship_based'
      });
    }

    // Selecionar ação com maior confiança
    return actions.length > 0 
      ? actions.reduce((max, action) => 
          action.confidence > max.confidence ? action : max
        )
      : {
          type: 'general_assistance',
          confidence: 0.5,
          context: 'fallback'
        };
  }

  async identifySecondaryActions(contextAnalysis, primaryAction) {
    const secondaryActions = [];

    // Se ação principal é vendas, adicionar confiança
    if (['generate_quote', 'present_upsell'].includes(primaryAction.type)) {
      secondaryActions.push({
        type: 'build_trust',
        elements: ['testimonial', 'guarantee', 'support_info']
      });
    }

    // Se ação principal é suporte, adicionar follow-up
    if (['handle_complaint', 'order_lookup'].includes(primaryAction.type)) {
      secondaryActions.push({
        type: 'schedule_followup',
        timeframe: '24_hours'
      });
    }

    // Ações baseadas em oportunidades secundárias
    if (contextAnalysis.opportunity.crossSell.length > 0) {
      secondaryActions.push({
        type: 'suggest_complementary',
        products: contextAnalysis.opportunity.crossSell.slice(0, 2)
      });
    }

    // Ação de retenção se aplicável
    if (contextAnalysis.opportunity.retention.length > 0) {
      secondaryActions.push({
        type: 'retention_offer',
        offers: contextAnalysis.opportunity.retention
      });
    }

    return secondaryActions;
  }

  calculatePriority(contextAnalysis, nlpAnalysis) {
    let priorityScore = 0;

    // Urgência situacional
    if (contextAnalysis.situational.urgencyLevel === 'high') {
      priorityScore += 40;
    }

    // Estado emocional negativo
    if (contextAnalysis.situational.emotionalState === 'NEGATIVO') {
      priorityScore += 30;
    }

    // Relacionamento em risco
    if (contextAnalysis.relational.satisfactionTrend === 'declining') {
      priorityScore += 25;
    }

    // Cliente de alto valor
    if (contextAnalysis.behavioral.purchaseReadiness === 'high') {
      priorityScore += 20;
    }

    // Múltiplas oportunidades
    const totalOpportunities = 
      contextAnalysis.opportunity.upsell.length +
      contextAnalysis.opportunity.crossSell.length +
      contextAnalysis.opportunity.retention.length;

    if (totalOpportunities >= 2) {
      priorityScore += 15;
    }

    // Converter score em categoria
    if (priorityScore >= 70) return 'urgent';
    if (priorityScore >= 40) return 'high';
    if (priorityScore >= 20) return 'medium';
    return 'normal';
  }

  generateDecisionReasoning(decision, contextAnalysis) {
    const reasons = [];

    if (decision.escalationNeeded) {
      reasons.push(`Escalação necessária: ${decision.primaryAction.reason}`);
    } else {
      reasons.push(`Ação principal: ${decision.primaryAction.type} (contexto: ${decision.primaryAction.context})`);
    }

    if (contextAnalysis.contextScore >= 80) {
      reasons.push('Alto contexto disponível para personalização');
    }

    if (decision.secondaryActions.length > 0) {
      reasons.push(`${decision.secondaryActions.length} oportunidades secundárias identificadas`);
    }

    return reasons.join('; ');
  }

  calculateDecisionConfidence(contextAnalysis, nlpAnalysis) {
    let confidence = 0.5; // Base

    // Confiança do NLP
    if (nlpAnalysis.intent?.confidence) {
      confidence += nlpAnalysis.intent.confidence * 0.3;
    }

    // Qualidade do contexto
    confidence += (contextAnalysis.contextScore / 100) * 0.4;

    // Clareza da situação
    if (contextAnalysis.situational.immediateNeed !== 'unknown') {
      confidence += 0.2;
    }

    // Histórico disponível
    if (contextAnalysis.relational.relationshipStage !== 'new') {
      confidence += 0.1;
    }

    return Math.min(confidence, 0.95); // Cap em 95%
  }
}

// services/learning-feedback-collector.js
export class FeedbackCollector {
  constructor() {
    this.db = new DatabaseConnection();
    this.metricsProcessor = new MetricsProcessor();
  }

  async collectInteractionFeedback(messageId, userPhone, response, userReaction) {
    const feedback = {
      messageId,
      userPhone,
      timestamp: new Date(),
      response_data: response,
      user_reaction: userReaction,
      feedback_signals: {}
    };

    // 1. Coletar sinais explícitos
    feedback.feedback_signals.explicit = this.extractExplicitFeedback(userReaction);

    // 2. Coletar sinais comportamentais
    feedback.feedback_signals.behavioral = await this.extractBehavioralSignals(
      userPhone, 
      response, 
      userReaction
    );

    // 3. Coletar sinais emocionais
    feedback.feedback_signals.emotional = this.extractEmotionalSignals(userReaction);

    // 4. Coletar sinais de conversão
    feedback.feedback_signals.conversion = await this.trackConversionSignals(
      userPhone, 
      response
    );

    // 5. Salvar feedback estruturado
    await this.saveFeedback(feedback);

    // 6. Processar aprendizados imediatos
    await this.processImmediateLearning(feedback);

    return feedback;
  }

  extractExplicitFeedback(userReaction) {
    const explicit = {
      satisfaction_keywords: [],
      dissatisfaction_keywords: [],
      gratitude_expressions: [],
      complaint_indicators: []
    };

    const message = userReaction.message?.toLowerCase() || '';

    // Palavras de satisfação
    const satisfactionWords = ['obrigado', 'perfeito', 'excelente', 'ótimo', 'adorei', 'ajudou muito'];
    explicit.satisfaction_keywords = satisfactionWords.filter(word => 
      message.includes(word)
    );

    // Palavras de insatisfação
    const dissatisfactionWords = ['ruim', 'não ajudou', 'complicado', 'confuso', 'demora'];
    explicit.dissatisfaction_keywords = dissatisfactionWords.filter(word => 
      message.includes(word)
    );

    // Expressões de gratidão
    const gratitudeExpressions = ['obrigad', 'valeu', 'agradeço', 'muito bom'];
    explicit.gratitude_expressions = gratitudeExpressions.filter(expr => 
      message.includes(expr)
    );

    return explicit;
  }

  async extractBehavioralSignals(userPhone, response, userReaction) {
    const behavioral = {
      response_time: null,
      conversation_continuation: false,
      engagement_level: 'low',
      follow_through: false
    };

    // Tempo de resposta do usuário
    if (response.timestamp && userReaction.timestamp) {
      behavioral.response_time = new Date(userReaction.timestamp) - new Date(response.timestamp);
    }

    // Continuação da conversa
    const recentMessages = await this.getRecentMessages(userPhone, 5);
    behavioral.conversation_continuation = recentMessages.length > 2;

    // Nível de engajamento baseado na extensão da resposta
    const messageLength = userReaction.message?.length || 0;
    if (messageLength > 100) {
      behavioral.engagement_level = 'high';
    } else if (messageLength > 30) {
      behavioral.engagement_level = 'medium';
    }

    // Follow-through (executou ação sugerida)
    if (response.suggestedActions) {
      behavioral.follow_through = await this.checkActionCompletion(
        userPhone, 
        response.suggestedActions,
        userReaction
      );
    }

    return behavioral;
  }

  async trackConversionSignals(userPhone, response) {
    const conversion = {
      sale_initiated: false,
      information_request: false,
      escalation_accepted: false,
      recommendation_followed: false
    };

    // Verificar se iniciou processo de compra
    if (response.primaryAction?.type === 'generate_quote') {
      const recentOrders = await this.checkRecentOrderActivity(userPhone);
      conversion.sale_initiated = recentOrders.length > 0;
    }

    // Verificar pedidos de informação
    if (response.content.includes('mais detalhes') || response.content.includes('informações')) {
      conversion.information_request = true;
    }

    return conversion;
  }

  async processImmediateLearning(feedback) {
    // Aprendizado imediato para ajustes rápidos
    const learnings = [];

    // Se feedback muito positivo, reforçar estratégia
    if (feedback.feedback_signals.explicit.satisfaction_keywords.length >= 2) {
      learnings.push({
        type: 'strategy_reinforcement',
        strategy: feedback.response_data.metadata?.strategy,
        confidence_boost: 0.1
      });
    }

    // Se feedback negativo, penalizar estratégia
    if (feedback.feedback_signals.explicit.dissatisfaction_keywords.length >= 1) {
      learnings.push({
        type: 'strategy_penalty',
        strategy: feedback.response_data.metadata?.strategy,
        confidence_reduction: 0.15
      });
    }

    // Aplicar aprendizados
    for (const learning of learnings) {
      await this.applyLearning(learning);
    }
  }

  async saveFeedback(feedback) {
    await this.db.query(
      `INSERT INTO interaction_feedback 
       (message_id, user_phone, timestamp, response_data, feedback_signals)
       VALUES (?, ?, ?, ?, ?)`,
      [
        feedback.messageId,
        feedback.userPhone,
        feedback.timestamp,
        JSON.stringify(feedback.response_data),
        JSON.stringify(feedback.feedback_signals)
      ]
    );
  }
}

// services/pattern-analyzer.js
export class PatternAnalyzer {
  constructor() {
    this.db = new DatabaseConnection();
    this.statisticsEngine = new StatisticsEngine();
  }

  async analyzePatterns() {
    const patterns = {
      temporal: await this.analyzeTemporalPatterns(),
      linguistic: await this.analyzeLinguisticPatterns(),
      behavioral: await this.analyzeBehavioralPatterns(),
      contextual: await this.analyzeContextualPatterns()
    };

    // Gerar insights acionáveis
    const insights = await this.generateActionableInsights(patterns);
    
    // Salvar padrões descobertos
    await this.saveDiscoveredPatterns(patterns, insights);
    
    return { patterns, insights };
  }

  async analyzeTemporalPatterns() {
    // Buscar dados dos últimos 30 dias
    const interactions = await this.db.query(
      `SELECT 
         EXTRACT(HOUR FROM timestamp) as hour,
         EXTRACT(DOW FROM timestamp) as day_of_week,
         feedback_signals,
         response_data
       FROM interaction_feedback 
       WHERE timestamp > NOW() - INTERVAL '30 days'`
    );

    const patterns = {
      optimal_hours: [],
      optimal_days: [],
      response_time_patterns: {},
      conversion_timing: {}
    };

    // Analisar horários com melhor performance
    const hourlyPerformance = {};
    interactions.forEach(interaction => {
      const hour = interaction.hour;
      if (!hourlyPerformance[hour]) {
        hourlyPerformance[hour] = { total: 0, positive: 0, conversions: 0 };
      }
      
      hourlyPerformance[hour].total++;
      
      const signals = JSON.parse(interaction.feedback_signals);
      if (signals.explicit?.satisfaction_keywords?.length > 0) {
        hourlyPerformance[hour].positive++;
      }
      
      if (signals.conversion?.sale_initiated) {
        hourlyPerformance[hour].conversions++;
      }
    });

    // Identificar horários ótimos (>70% satisfação)
    patterns.optimal_hours = Object.entries(hourlyPerformance)
      .filter(([hour, data]) => data.positive / data.total > 0.7)
      .map(([hour, data]) => ({
        hour: parseInt(hour),
        satisfaction_rate: data.positive / data.total,
        conversion_rate: data.conversions / data.total
      }))
      .sort((a, b) => b.satisfaction_rate - a.satisfaction_rate);

    return patterns;
  }

  async analyzeLinguisticPatterns() {
    const messages = await this.db.query(
      `SELECT response_data, feedback_signals 
       FROM interaction_feedback 
       WHERE timestamp > NOW() - INTERVAL '30 days'`
    );

    const patterns = {
      effective_words: [],
      ineffective_words: [],
      tone_effectiveness: {},
      length_optimization: {}
    };

    const wordPerformance = {};
    const tonePerformance = {};

    messages.forEach(msg => {
      const response = JSON.parse(msg.response_data);
      const signals = JSON.parse(msg.feedback_signals);
      
      const isPositive = signals.explicit?.satisfaction_keywords?.length > 0;
      const words = response.content?.split(' ') || [];
      
      // Analisar performance de palavras
      words.forEach(word => {
        const cleanWord = word.toLowerCase().replace(/[^a-z]/g, '');
        if (cleanWord.length > 3) {
          if (!wordPerformance[cleanWord]) {
            wordPerformance[cleanWord] = { total: 0, positive: 0 };
          }
          wordPerformance[cleanWord].total++;
          if (isPositive) wordPerformance[cleanWord].positive++;
        }
      });

      // Analisar performance de tom
      const strategy = response.metadata?.strategy;
      if (strategy) {
        if (!tonePerformance[strategy]) {
          tonePerformance[strategy] = { total: 0, positive: 0 };
        }
        tonePerformance[strategy].total++;
        if (isPositive) tonePerformance[strategy].positive++;
      }
    });

    // Identificar palavras mais eficazes (>75% sucesso, min 10 usos)
    patterns.effective_words = Object.entries(wordPerformance)
      .filter(([word, data]) => data.total >= 10 && data.positive / data.total > 0.75)
      .map(([word, data]) => ({
        word,
        success_rate: data.positive / data.total,
        usage_count: data.total
      }))
      .sort((a, b) => b.success_rate - a.success_rate);

    // Identificar palavras problemáticas (<40% sucesso, min 10 usos)
    patterns.ineffective_words = Object.entries(wordPerformance)
      .filter(([word, data]) => data.total >= 10 && data.positive / data.total < 0.4)
      .map(([word, data]) => ({
        word,
        success_rate: data.positive / data.total,
        usage_count: data.total
      }))
      .sort((a, b) => a.success_rate - b.success_rate);

    return patterns;
  }

  async generateActionableInsights(patterns) {
    const insights = [];

    // Insights temporais
    if (patterns.temporal.optimal_hours.length > 0) {
      const bestHour = patterns.temporal.optimal_hours[0];
      insights.push({
        type: 'temporal_optimization',
        priority: 'high',
        insight: `Horário ${bestHour.hour}h tem ${(bestHour.satisfaction_rate * 100).toFixed(1)}% de satisfação`,
        action: `Priorizar respostas proativas neste horário`,
        expected_impact: 'Aumento de 15-25% na satisfação'
      });
    }

    // Insights linguísticos
    if (patterns.linguistic.effective_words.length > 0) {
      const topWords = patterns.linguistic.effective_words.slice(0, 3);
      insights.push({
        type: 'linguistic_enhancement',
        priority: 'medium',
        insight: `Palavras "${topWords.map(w => w.word).join(', ')}" têm alta eficácia`,
        action: 'Incorporar estas palavras em templates padrão',
        expected_impact: 'Melhoria de 10-15% no engajamento'
      });
    }

    if (patterns.linguistic.ineffective_words.length > 0) {
      const badWords = patterns.linguistic.ineffective_words.slice(0, 3);
      insights.push({
        type: 'linguistic_warning',
        priority: 'high',
        insight: `Palavras "${badWords.map(w => w.word).join(', ')}" reduzem satisfação`,
        action: 'Evitar ou substituir estas palavras',
        expected_impact: 'Redução de 20-30% em feedback negativo'
      });
    }

    return insights;
  }

  async saveDiscoveredPatterns(patterns, insights) {
    await this.db.query(
      `INSERT INTO discovered_patterns (timestamp, patterns, insights, status)
       VALUES (NOW(), ?, ?, 'active')`,
      [JSON.stringify(patterns), JSON.stringify(insights)]
    );
  }
}

// services/ab-testing-engine.js
export class ABTestingEngine {
  constructor() {
    this.db = new DatabaseConnection();
    this.statisticalAnalyzer = new StatisticalAnalyzer();
  }

  async createExperiment(config) {
    const experiment = {
      name: config.name,
      description: config.description,
      variants: config.variants,
      target_audience: config.target_audience,
      success_metrics: config.success_metrics,
      traffic_split: config.traffic_split || { A: 50, B: 50 },
      start_date: new Date(),
      planned_duration: config.duration || 14, // dias
      status: 'active',
      statistical_power: 0.8,
      significance_level: 0.05
    };

    // Validar configuração
    this.validateExperimentConfig(experiment);

    // Salvar experimento
    const experimentId = await this.saveExperiment(experiment);

    // Configurar rastreamento
    await this.setupExperimentTracking(experimentId, experiment);

    return experimentId;
  }

  async assignVariant(experimentId, userPhone, context) {
    // Verificar se usuário já tem variante atribuída
    const existingAssignment = await this.db.query(
      'SELECT variant FROM experiment_assignments WHERE experiment_id = ? AND user_phone = ?',
      [experimentId, userPhone]
    );

    if (existingAssignment.length > 0) {
      return existingAssignment[0].variant;
    }

    // Buscar configuração do experimento
    const experiment = await this.getExperiment(experimentId);
    
    if (!experiment || experiment.status !== 'active') {
      return 'control'; // Fallback para controle
    }

    // Verificar se usuário está no público-alvo
    if (!this.isInTargetAudience(userPhone, context, experiment.target_audience)) {
      return 'control';
    }

    // Atribuir variante baseado em hash determinístico
    const variant = this.deterministicVariantAssignment(
      userPhone, 
      experimentId,
      experiment.traffic_split
    );

    // Salvar atribuição
    await this.saveVariantAssignment(experimentId, userPhone, variant);

    return variant;
  }

  async trackExperimentEvent(experimentId, userPhone, eventType, eventData) {
    const event = {
      experiment_id: experimentId,
      user_phone: userPhone,
      event_type: eventType,
      event_data: eventData,
      timestamp: new Date()
    };

    // Buscar variante do usuário
    const assignment = await this.db.query(
      'SELECT variant FROM experiment_assignments WHERE experiment_id = ? AND user_phone = ?',
      [experimentId, userPhone]
    );

    if (assignment.length === 0) return; // Usuário não está no experimento

    event.variant = assignment[0].variant;

    // Salvar evento
    await this.db.query(
      `INSERT INTO experiment_events 
       (experiment_id, user_phone, variant, event_type, event_data, timestamp)
       VALUES (?, ?, ?, ?, ?, ?)`,
      [
        event.experiment_id,
        event.user_phone,
        event.variant,
        event.event_type,
        JSON.stringify(event.event_data),
        event.timestamp
      ]
    );

    // Verificar se deve analisar resultados
    await this.checkExperimentCompletion(experimentId);
  }

  async analyzeExperimentResults(experimentId) {
    const experiment = await this.getExperiment(experimentId);
    const events = await this.getExperimentEvents(experimentId);

    const analysis = {
      experiment_id: experimentId,
      total_participants: 0,
      variant_performance: {},
      statistical_significance: false,
      confidence_interval: null,
      recommendation: 'continue',
      insights: []
    };

    // Agrupar eventos por variante
    const variantData = {};
    events.forEach(event => {
      if (!variantData[event.variant]) {
        variantData[event.variant] = {
          participants: new Set(),
          events: [],
          conversions: 0,
          satisfaction_sum: 0,
          satisfaction_count: 0
        };
      }

      variantData[event.variant].participants.add(event.user_phone);
      variantData[event.variant].events.push(event);

      // Contar conversões
      if (event.event_type === 'conversion') {
        variantData[event.variant].conversions++;
      }

      // Agregar satisfação
      if (event.event_type === 'satisfaction_rating') {
        const eventData = JSON.parse(event.event_data);
        variantData[event.variant].satisfaction_sum += eventData.rating;
        variantData[event.variant].satisfaction_count++;
      }
    });

    // Calcular métricas por variante
    Object.entries(variantData).forEach(([variant, data]) => {
      const participants = data.participants.size;
      analysis.total_participants += participants;

      analysis.variant_performance[variant] = {
        participants: participants,
        conversion_rate: data.conversions / participants,
        average_satisfaction: data.satisfaction_count > 0 
          ? data.satisfaction_sum / data.satisfaction_count 
          : null,
        total_events: data.events.length
      };
    });

    // Análise estatística
    if (Object.keys(variantData).length === 2) {
      const variants = Object.keys(variantData);
      const variantA = analysis.variant_performance[variants[0]];
      const variantB = analysis.variant_performance[variants[1]];

      const statisticalTest = this.statisticalAnalyzer.zTest(
        variantA.conversion_rate,
        variantA.participants,
        variantB.conversion_rate,
        variantB.participants
      );

      analysis.statistical_significance = statisticalTest.pValue < 0.05;
      analysis.confidence_interval = statisticalTest.confidenceInterval;

      // Gerar recomendação
      if (analysis.statistical_significance) {
        const winner = variantA.conversion_rate > variantB.conversion_rate ? variants[0] : variants[1];
        analysis.recommendation = `implement_${winner}`;
        analysis.insights.push({
          type: 'statistical_winner',
          message: `Variante ${winner} é significativamente melhor`,
          confidence: (1 - statisticalTest.pValue) * 100
        });
      } else {
        analysis.recommendation = 'continue';
        analysis.insights.push({
          type: 'inconclusive',
          message: 'Resultados ainda não são estatisticamente significativos',
          needed_sample_size: this.calculateRequiredSampleSize(variantA, variantB)
        });
      }
    }

    // Salvar análise
    await this.saveExperimentAnalysis(experimentId, analysis);

    return analysis;
  }

  deterministicVariantAssignment(userPhone, experimentId, trafficSplit) {
    // Hash determinístico baseado no telefone + experiment ID
    const hashInput = `${userPhone}-${experimentId}`;
    const hash = this.simpleHash(hashInput);
    const percentage = (hash % 100) + 1;

    let cumulativePercentage = 0;
    for (const [variant, allocation] of Object.entries(trafficSplit)) {
      cumulativePercentage += allocation;
      if (percentage <= cumulativePercentage) {
        return variant;
      }
    }

    return 'control'; // Fallback
  }

  simpleHash(str) {
    let hash = 0;
    for (let i = 0; i < str.length; i++) {
      const char = str.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash; // Convert to 32-bit integer
    }
    return Math.abs(hash);
  }
}

// services/intelligent-agent.js
export class IntelligentAgent {
  constructor() {
    // Sistemas de base
    this.nlpOrchestrator = new NLPOrchestrator();
    this.memoryManager = new MemoryManager();
    this.contextAnalyzer = new ContextAnalyzer();
    this.decisionEngine = new IntelligentDecisionEngine();
    this.personalizationEngine = new AdvancedPersonalizationEngine();
    this.responseGenerator = new ContextualResponseGenerator();
    this.learningSystem = new ContinuousLearningSystem();
    
    // Sistemas de apoio
    this.analytics = new AgentAnalytics();
    this.security = new SecurityManager();
    this.rateLimiter = new RateLimiter();
    
    // Cache para performance
    this.cache = new Redis({
      host: process.env.REDIS_HOST,
      port: process.env.REDIS_PORT
    });
  }

  async processMessage(messageData) {
    const startTime = Date.now();
    const { message, userPhone, messageId, metadata } = messageData;

    try {
      // 1. Validações de segurança e rate limiting
      await this.validateMessage(messageData);
      
      // 2. Inicializar contexto de execução
      const executionContext = await this.initializeExecutionContext(userPhone, messageId);

      // 3. Análise NLP da mensagem atual
      const nlpAnalysis = await this.nlpOrchestrator.processMessage(message);

      // 4. Carregar e analisar contexto completo
      const contextAnalysis = await this.contextAnalyzer.analyzeCurrentContext(
        userPhone, 
        message, 
        nlpAnalysis
      );

      // 5. Gerar experiência personalizada
      const personalizedExperience = await this.personalizationEngine.generatePersonalizedExperience(
        userPhone,
        { nlpAnalysis, contextAnalysis }
      );

      // 6. Tomar decisão inteligente
      const decision = await this.decisionEngine.makeIntelligentDecision(
        userPhone,
        contextAnalysis,
        nlpAnalysis
      );

      // 7. Gerar resposta contextualizada
      const response = await this.responseGenerator.generateResponse({
        userPhone,
        message,
        nlpAnalysis,
        contextAnalysis,
        personalizedExperience,
        decision
      });

      // 8. Executar ações definidas
      const actionResults = await this.executeActions(decision, response, executionContext);

      // 9. Salvar interação na memória
      await this.memoryManager.storeInteraction({
        userPhone,
        message,
        nlpAnalysis,
        contextAnalysis,
        decision,
        response,
        actionResults,
        executionContext
      });

      // 10. Feedback para aprendizado contínuo
      await this.learningSystem.processFeedback({
        userPhone,
        messageId,
        response,
        decision,
        contextAnalysis
      });

      // 11. Métricas e analytics
      await this.analytics.trackInteraction({
        userPhone,
        processingTime: Date.now() - startTime,
        decision,
        response,
        success: true
      });

      return {
        success: true,
        response: response.content,
        metadata: {
          processingTime: Date.now() - startTime,
          confidence: decision.confidence,
          personalizationLevel: personalizedExperience.level,
          actions: actionResults
        }
      };

    } catch (error) {
      // Tratamento de erro com fallback inteligente
      return await this.handleError(error, messageData, executionContext);
    }
  }

  async initializeExecutionContext(userPhone, messageId) {
    return {
      sessionId: `session_${userPhone}_${Date.now()}`,
      messageId,
      userPhone,
      startTime: new Date(),
      experiments: await this.getActiveExperiments(userPhone),
      userSegment: await this.getUserSegment(userPhone),
      systemLoad: await this.getSystemLoad()
    };
  }

  async executeActions(decision, response, context) {
    const results = [];

    // Ação principal
    if (decision.primaryAction) {
      const result = await this.executeAction(decision.primaryAction, context);
      results.push(result);
    }

    // Ações secundárias
    for (const action of decision.secondaryActions || []) {
      const result = await this.executeAction(action, context);
      results.push(result);
    }

    // Escalação se necessária
    if (decision.escalationNeeded) {
      const escalationResult = await this.escalateToHuman(decision, context);
      results.push(escalationResult);
    }

    return results;
  }

  async executeAction(action, context) {
    const actionExecutors = {
      'order_lookup': this.executeOrderLookup,
      'generate_quote': this.executeGenerateQuote,
      'handle_complaint': this.executeHandleComplaint,
      'present_upsell': this.executePresentUpsell,
      'schedule_followup': this.executeScheduleFollowup,
      'escalate': this.executeEscalation
    };

    const executor = actionExecutors[action.type];
    if (!executor) {
      throw new Error(`Unknown action type: ${action.type}`);
    }

    return await executor.call(this, action, context);
  }

  async executeOrderLookup(action, context) {
    // Implementar busca de pedido
    const orderNumber = action.orderNumber || await this.extractOrderFromContext(context);
    
    if (!orderNumber) {
      return {
        type: 'order_lookup',
        success: false,
        reason: 'order_number_not_found',
        fallback_action: 'request_order_number'
      };
    }

    const order = await this.orderService.getOrder(orderNumber);
    
    if (!order) {
      return {
        type: 'order_lookup',
        success: false,
        reason: 'order_not_found',
        fallback_action: 'verify_order_details'
      };
    }

    // Verificar se pedido pertence ao usuário
    if (!this.validateOrderOwnership(order, context.userPhone)) {
      return {
        type: 'order_lookup',
        success: false,
        reason: 'unauthorized_access',
        fallback_action: 'request_verification'
      };
    }

    return {
      type: 'order_lookup',
      success: true,
      data: {
        order: order,
        status: order.status,
        tracking: order.tracking_code,
        estimated_delivery: order.estimated_delivery
      }
    };
  }

  async handleError(error, messageData, context) {
    console.error('Agent Error:', error);

    // Classificar tipo de erro
    const errorType = this.classifyError(error);
    
    // Gerar resposta de fallback
    const fallbackResponse = await this.generateFallbackResponse(errorType, messageData);
    
    // Notificar sistema de monitoramento
    await this.analytics.trackError({
      error: error.message,
      type: errorType,
      userPhone: messageData.userPhone,
      context
    });

    return {
      success: false,
      response: fallbackResponse,
      error: errorType,
      metadata: {
        processingTime: Date.now() - (context?.startTime || Date.now()),
        fallback: true
      }
    };
  }

  classifyError(error) {
    if (error.message.includes('timeout')) return 'timeout';
    if (error.message.includes('rate_limit')) return 'rate_limit';
    if (error.message.includes('unauthorized')) return 'auth_error';
    if (error.message.includes('quota')) return 'quota_exceeded';
    return 'system_error';
  }

  async generateFallbackResponse(errorType, messageData) {
    const fallbackResponses = {
      timeout: 'Desculpe, tive um pequeno atraso no processamento. Pode repetir sua mensagem?',
      rate_limit: 'Recebemos muitas mensagens. Vou responder em instantes, obrigado pela paciência!',
      auth_error: 'Para sua segurança, preciso verificar alguns dados. Um especialista irá ajudar.',
      quota_exceeded: 'Sistema temporariamente indisponível. Retornando em breve com atendimento humano.',
      system_error: 'Tive uma dificuldade técnica. Um atendente humano irá ajudar você agora.'
    };

    return fallbackResponses[errorType] || fallbackResponses.system_error;
  }
}

// N8N Main Workflow - Intelligent Agent Integration
const webhookData = $json;
const intelligentAgent = new IntelligentAgent();

// Extrair dados da mensagem do WhatsApp
const messageData = {
  message: webhookData.entry?.[0]?.changes?.[0]?.value?.messages?.[0]?.text?.body,
  userPhone: webhookData.entry?.[0]?.changes?.[0]?.value?.messages?.[0]?.from,
  messageId: webhookData.entry?.[0]?.changes?.[0]?.value?.messages?.[0]?.id,
  timestamp: webhookData.entry?.[0]?.changes?.[0]?.value?.messages?.[0]?.timestamp,
  type: webhookData.entry?.[0]?.changes?.[0]?.value?.messages?.[0]?.type || 'text',
  metadata: {
    webhook_id: webhookData.entry?.[0]?.id,
    raw_data: webhookData
  }
};

// Validar dados da mensagem
if (!messageData.message || !messageData.userPhone) {
  return [{
    json: {
      error: 'Invalid message data',
      success: false
    }
  }];
}

try {
  // Processar mensagem com agente inteligente
  const result = await intelligentAgent.processMessage(messageData);
  
  if (!result.success) {
    // Log error mas não falha o workflow
    console.error('Agent processing failed:', result.error);
  }

  // Preparar resposta para WhatsApp
  const whatsappResponse = {
    messaging_product: 'whatsapp',
    to: messageData.userPhone,
    type: 'text',
    text: {
      body: result.response
    }
  };

  // Adicionar elementos interativos se necessário
  if (result.metadata?.actions?.length > 0) {
    whatsappResponse.type = 'interactive';
    whatsappResponse.interactive = {
      type: 'button',
      body: {
        text: result.response
      },
      action: {
        buttons: result.metadata.actions.slice(0, 3).map((action, index) => ({
          type: 'reply',
          reply: {
            id: `action_${index}`,
            title: action.title || action.type
          }
        }))
      }
    };
  }

  // Retornar resposta para ser enviada
  return [{
    json: {
      whatsapp_response: whatsappResponse,
      processing_metadata: {
        success: result.success,
        processing_time: result.metadata?.processingTime,
        confidence: result.metadata?.confidence,
        personalization_level: result.metadata?.personalizationLevel,
        timestamp: new Date().toISOString()
      },
      analytics_data: {
        user_phone: messageData.userPhone,
        message_type: messageData.type,
        response_type: whatsappResponse.type,
        success: result.success
      }
    }
  }];

} catch (error) {
  console.error('Workflow error:', error);
  
  // Resposta de emergência
  return [{
    json: {
      whatsapp_response: {
        messaging_product: 'whatsapp',
        to: messageData.userPhone,
        type: 'text',
        text: {
          body: 'Desculpe, tive uma dificuldade técnica. Um atendente humano irá ajudar você em instantes. 🤖'
        }
      },
      error: true,
      error_message: error.message,
      fallback: true
    }
  }];
}

// services/agent-analytics.js
export class AgentAnalytics {
  constructor() {
    this.metricsCollector = new MetricsCollector();
    this.dashboard = new DashboardManager();
    this.alertManager = new AlertManager();
  }

  async trackInteraction(interactionData) {
    const metrics = {
      timestamp: new Date(),
      user_phone: interactionData.userPhone,
      processing_time: interactionData.processingTime,
      success: interactionData.success,
      confidence: interactionData.decision?.confidence,
      personalization_level: interactionData.response?.personalizationLevel,
      actions_executed: interactionData.response?.actions?.length || 0,
      escalated: interactionData.decision?.escalationNeeded || false
    };

    // Salvar métricas básicas
    await this.metricsCollector.collect('agent_interaction', metrics);

    // Calcular métricas agregadas em tempo real
    await this.updateRealTimeMetrics(metrics);

    // Verificar alertas
    await this.checkAlerts(metrics);
  }

  async updateRealTimeMetrics(metrics) {
    const key = `metrics_${new Date().toISOString().substring(0, 13)}`; // Por hora
    
    await this.cache.hincrby(key, 'total_interactions', 1);
    await this.cache.hincrby(key, 'total_processing_time', metrics.processing_time);
    
    if (metrics.success) {
      await this.cache.hincrby(key, 'successful_interactions', 1);
    }
    
    if (metrics.escalated) {
      await this.cache.hincrby(key, 'escalated_interactions', 1);
    }

    await this.cache.expire(key, 86400); // 24 horas
  }

  async generateDailyReport() {
    const today = new Date().toISOString().substring(0, 10);
    
    const metrics = await this.db.query(
      `SELECT 
         COUNT(*) as total_interactions,
         AVG(processing_time) as avg_processing_time,
         AVG(confidence) as avg_confidence,
         COUNT(CASE WHEN success THEN 1 END) as successful_interactions,
         COUNT(CASE WHEN escalated THEN 1 END) as escalated_interactions,
         COUNT(DISTINCT user_phone) as unique_users
       FROM agent_interactions 
       WHERE DATE(timestamp) = ?`,
      [today]
    );

    const report = {
      date: today,
      ...metrics[0],
      success_rate: metrics[0].successful_interactions / metrics[0].total_interactions,
      escalation_rate: metrics[0].escalated_interactions / metrics[0].total_interactions,
      avg_processing_time_ms: Math.round(metrics[0].avg_processing_time)
    };

    // Comparar com dia anterior
    const yesterday = new Date(Date.now() - 24*60*60*1000).toISOString().substring(0, 10);
    const yesterdayMetrics = await this.getDateMetrics(yesterday);
    
    report.trends = {
      interactions_change: this.calculateChange(report.total_interactions, yesterdayMetrics.total_interactions),
      success_rate_change: this.calculateChange(report.success_rate, yesterdayMetrics.success_rate),
      avg_processing_time_change: this.calculateChange(report.avg_processing_time_ms, yesterdayMetrics.avg_processing_time_ms)
    };

    return report;
  }

  async checkAlerts(metrics) {
    // Alert: Tempo de processamento muito alto
    if (metrics.processing_time > 5000) { // 5 segundos
      await this.alertManager.trigger({
        type: 'high_processing_time',
        severity: 'warning',
        message: `Processing time: ${metrics.processing_time}ms`,
        data: metrics
      });
    }

    // Alert: Confidence baixa
    if (metrics.confidence < 0.5) {
      await this.alertManager.trigger({
        type: 'low_confidence',
        severity: 'info',
        message: `Low confidence: ${metrics.confidence}`,
        data: metrics
      });
    }

    // Alert: Taxa de sucesso baixa (calculada por hora)
    const hourlySuccessRate = await this.getHourlySuccessRate();
    if (hourlySuccessRate < 0.8) {
      await this.alertManager.trigger({
        type: 'low_success_rate',
        severity: 'critical',
        message: `Hourly success rate: ${(hourlySuccessRate * 100).toFixed(1)}%`,
        data: { hourlySuccessRate, currentMetrics: metrics }
      });
    }
  }

  async getSystemHealth() {
    const health = {
      status: 'healthy',
      checks: {
        database: await this.checkDatabase(),
        redis: await this.checkRedis(),
        nlp_service: await this.checkNLPService(),
        memory_usage: await this.checkMemoryUsage(),
        response_time: await this.checkResponseTime()
      },
      metrics: {
        last_hour: await this.getHourlyMetrics(),
        last_24h: await this.getDailyMetrics(),
        system_load: await this.getSystemLoad()
      }
    };

    // Determinar status geral
    const failedChecks = Object.values(health.checks).filter(check => check.status !== 'ok');
    if (failedChecks.length > 0) {
      health.status = failedChecks.some(check => check.severity === 'critical') ? 'critical' : 'warning';
    }

    return health;
  }
}