Best Crazy Egg Website Optimization Phone Validation API & Email Verification Integration 2025

// Enhanced Crazy Egg integration with 1lookup validation
// Initialize Crazy Egg tracking
(function(i,s,o,g,r,a,m){i['CrazyEggObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//script.crazyegg.com/pages/scripts/YOUR_ACCOUNT_ID/YOUR_PAGE_ID.js','CE');

// Enhanced user identification with contact validation for website optimization
window.identifyCrazyEggUserWithValidation = async function(userId, userAttributes) {
  try {
    // Validate user contact information if present
    if (userAttributes.email || userAttributes.phone) {
      const validationData = await validateUserContactForCrazyEgg({
        phone: userAttributes.phone,
        email: userAttributes.email
      });
      
      // Enhance user attributes with validation results
      const enhancedAttributes = {
        ...userAttributes,
        // Phone validation attributes
        phone_validation_status: validationData.phone?.is_valid ? 'valid' : 'invalid',
        phone_carrier: validationData.phone?.carrier_details?.name || '',
        phone_line_type: validationData.phone?.carrier_details?.type || '',
        phone_country: validationData.phone?.location_details?.country || '',
        phone_region: validationData.phone?.location_details?.region || '',
        phone_risk_level: validationData.phone?.risk_assessment?.risk_level || '',
        // Email validation attributes
        email_validation_status: validationData.email?.is_valid ? 'valid' : 'invalid',
        email_deliverability: validationData.email?.deliverability?.status || '',
        email_domain_type: validationData.email?.domain_details?.type || '',
        email_risk_level: validationData.email?.risk_assessment?.risk_level || '',
        // Website optimization specific enhancements
        user_optimization_quality: calculateOptimizationUserQuality(validationData),
        user_optimization_tier: determineOptimizationUserTier(validationData),
        is_verified_optimization_user: isVerifiedOptimizationUser(validationData),
        heatmap_validation_timestamp: new Date().toISOString(),
        // Crazy Egg-specific attributes
        crazyegg_user_validation_version: '2025.1',
        optimization_research_segment: determineOptimizationResearchSegment(validationData),
        heatmap_analysis_priority: calculateHeatmapAnalysisPriority(validationData)
      };
      
      // Set enhanced user attributes in Crazy Egg
      CE('identify', userId, enhancedAttributes);
      
      // Set custom variables for heatmap segmentation
      CE('set', 'userQuality', enhancedAttributes.user_optimization_quality);
      CE('set', 'userTier', enhancedAttributes.user_optimization_tier);
      CE('set', 'validationStatus', enhancedAttributes.is_verified_optimization_user ? 'verified' : 'unverified');
      CE('set', 'heatmapPriority', enhancedAttributes.heatmap_analysis_priority);
      
      // Track validation event for optimization analytics
      CE('track', 'User Contact Validated', {
        validation_type: 'optimization_enhancement',
        phone_valid: validationData.phone?.is_valid,
        email_valid: validationData.email?.is_valid,
        quality_score: enhancedAttributes.user_optimization_quality,
        optimization_segment: enhancedAttributes.optimization_research_segment
      });
      
    } else {
      // Standard identification without validation
      CE('identify', userId, userAttributes);
    }
    
  } catch (error) {
    console.error('Crazy Egg user validation error:', error);
    // Fallback to standard identification
    CE('identify', userId, {
      ...userAttributes,
      validation_error: true,
      validation_error_message: error.message
    });
  }
};

// Contact validation function optimized for website optimization
async function validateUserContactForCrazyEgg(contactData) {
  const response = await fetch('https://app.1lookup.io/api/v1/validate', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_1LOOKUP_API_KEY',
      'Content-Type': 'application/json',
      'X-Integration': 'crazy-egg-optimization'
    },
    body: JSON.stringify({
      ...contactData,
      include_carrier_details: true,
      include_location_details: true,
      include_risk_assessment: true,
      website_optimization_context: true
    })
  });
  
  if (!response.ok) {
    throw new Error(`Website optimization validation failed: ${response.status}`);
  }
  
  return await response.json();
}

// Calculate website optimization-specific user quality score
function calculateOptimizationUserQuality(validationData) {
  let score = 0;
  
  // Email scoring for website optimization
  if (validationData.email?.is_valid) score += 40;
  if (validationData.email?.deliverability?.status === 'deliverable') score += 15;
  
  // Phone scoring for website optimization
  if (validationData.phone?.is_valid) score += 35;
  if (validationData.phone?.risk_assessment?.risk_level === 'low') score += 10;
  
  return Math.min(100, score);
}

// Determine website optimization user tier
function determineOptimizationUserTier(validationData) {
  const qualityScore = calculateOptimizationUserQuality(validationData);
  
  if (qualityScore >= 80) return 'premium_optimization_user';
  if (qualityScore >= 60) return 'high_value_optimization_user';
  if (qualityScore >= 40) return 'standard_optimization_user';
  return 'basic_optimization_user';
}

// Calculate heatmap analysis priority based on user quality
function calculateHeatmapAnalysisPriority(validationData) {
  const qualityScore = calculateOptimizationUserQuality(validationData);
  
  if (qualityScore >= 80) return 'high';
  if (qualityScore >= 60) return 'medium';
  return 'standard';
}

// Enhanced Crazy Egg server-side integration with contact validation
const axios = require('axios');

class CrazyEggOptimizationValidator {
  constructor(accountId, lookupApiKey) {
    this.accountId = accountId;
    this.lookupApiKey = lookupApiKey;
    this.baseUrl = 'https://api.crazyegg.com/v1';
    this.userOptimizationCache = new Map();
  }
  
  async trackOptimizationEventWithValidation(userId, eventName, eventProperties, userContext) {
    try {
      // Get or validate user contact data
      let userValidation = this.userOptimizationCache.get(userId);
      if (!userValidation) {
        userValidation = await this.validateUserForOptimization(userContext);
        this.userOptimizationCache.set(userId, userValidation);
      }
      
      // Calculate optimization event quality
      const eventQuality = this.calculateOptimizationEventQuality(
        eventName,
        eventProperties,
        userValidation
      );
      
      // Enhanced website optimization event properties
      const enhancedEventProperties = {
        ...eventProperties,
        // User validation context
        user_optimization_quality: userValidation.quality_score,
        user_optimization_tier: userValidation.tier,
        user_verification_status: userValidation.verification_status,
        // Event quality metrics
        event_optimization_quality: eventQuality.score,
        event_reliability: eventQuality.reliability,
        optimization_value_tier: eventQuality.value_tier,
        is_high_value_optimization_event: eventQuality.is_high_value,
        // Website optimization insights
        heatmap_analysis_weight: eventQuality.heatmap_weight,
        ab_testing_confidence: eventQuality.ab_testing_confidence,
        conversion_optimization_potential: eventQuality.conversion_potential,
        // User quality insights
        user_conversion_likelihood: eventQuality.conversion_likelihood,
        user_engagement_score: eventQuality.engagement_score,
        website_optimization_priority: eventQuality.optimization_priority,
        // Geographic and behavioral context
        user_geographic_region: userValidation.region,
        device_optimization_trust: eventQuality.device_trust,
        optimization_anomaly_score: eventQuality.anomaly_score,
        // Crazy Egg-specific enhancements
        heatmap_segment: this.determineHeatmapSegment(userValidation),
        ab_test_reliability: eventQuality.ab_test_reliability,
        conversion_tracking_weight: eventQuality.conversion_weight
      };
      
      // Track enhanced optimization event
      await this.sendCrazyEggOptimizationEvent(userId, eventName, enhancedEventProperties);
      
      // Track optimization quality analytics
      await this.sendCrazyEggOptimizationEvent(userId, 'Optimization Quality Analytics', {
        original_event: eventName,
        quality_score: eventQuality.score,
        user_tier: userValidation.tier,
        optimization_value: eventQuality.optimization_value
      });
      
      // Update user optimization profile
      await this.updateUserOptimizationProfile(userId, eventQuality, userValidation);
      
      return { success: true, eventQuality, userValidation };
      
    } catch (error) {
      console.error('Website optimization event validation error:', error);
      
      // Fallback tracking
      await this.sendCrazyEggOptimizationEvent(userId, eventName, {
        ...eventProperties,
        validation_error: true,
        error_type: 'optimization_validation_failed'
      });
      
      return { success: false, error: error.message };
    }
  }
  
  async validateUserForOptimization(userContext) {
    try {
      const contactData = {
        phone: userContext.phone,
        email: userContext.email
      };
      
      if (!contactData.phone && !contactData.email) {
        return this.getDefaultOptimizationValidation();
      }
      
      const response = await axios.post('https://app.1lookup.io/api/v1/validate', contactData, {
        headers: {
          'Authorization': `Bearer ${this.lookupApiKey}`,
          'Content-Type': 'application/json',
          'X-Integration': 'crazy-egg-server'
        }
      });
      
      const validation = response.data;
      
      return {
        quality_score: this.calculateWebsiteOptimizationQualityScore(validation),
        tier: this.determineWebsiteOptimizationTier(validation),
        verification_status: this.getOptimizationVerificationStatus(validation),
        phone_verified: validation.phone?.is_valid,
        email_verified: validation.email?.is_valid,
        fraud_risk_level: validation.fraud_risk_level,
        country: validation.phone?.location_details?.country,
        region: validation.phone?.location_details?.region,
        carrier_type: validation.phone?.carrier_details?.type,
        optimization_segment: this.determineOptimizationSegment(validation),
        conversion_reliability: this.calculateConversionReliability(validation)
      };
      
    } catch (error) {
      console.error('User optimization validation error:', error);
      return this.getDefaultOptimizationValidation();
    }
  }
  
  calculateOptimizationEventQuality(eventName, eventProperties, userValidation) {
    let score = 0;
    let reliability = 0;
    let optimizationValue = 0;
    
    // Base score from user validation
    const userQuality = userValidation.quality_score || 0;
    score = userQuality * 0.5; // 50% weight from user quality
    
    // Event-specific scoring for website optimization
    const optimizationEventMultipliers = {
      'click': 1.2,
      'scroll': 0.8,
      'hover': 0.6,
      'form_interaction': 1.5,
      'button_click': 1.4,
      'link_click': 1.1,
      'form_submission': 1.8,
      'page_view': 1.0,
      'conversion_event': 2.0
    };
    
    score *= (optimizationEventMultipliers[eventName] || 1.0);
    
    // Website optimization value calculation
    optimizationValue = this.calculateEventOptimizationValue(eventName, eventProperties, userValidation);
    
    // Reliability scoring for optimization
    reliability = this.calculateEventOptimizationReliability(userValidation, eventProperties);
    
    return {
      score: Math.min(100, score),
      reliability: Math.min(100, reliability),
      value_tier: this.determineOptimizationValueTier(optimizationValue),
      is_high_value: score >= 70 && reliability >= 80,
      heatmap_weight: this.calculateHeatmapWeight(userValidation),
      ab_testing_confidence: this.calculateABTestingConfidence(userValidation, eventProperties),
      conversion_potential: this.calculateConversionPotential(userValidation, eventName),
      conversion_likelihood: this.calculateConversionLikelihood(userValidation, eventName),
      engagement_score: this.calculateEngagementScore(userValidation, eventProperties),
      optimization_priority: this.calculateOptimizationPriority(score, reliability),
      device_trust: this.calculateDeviceTrust(eventProperties, userValidation),
      anomaly_score: this.calculateOptimizationAnomalyScore(eventProperties),
      ab_test_reliability: this.calculateABTestReliability(userValidation),
      conversion_weight: this.calculateConversionWeight(userValidation),
      optimization_value: optimizationValue
    };
  }
  
  async sendCrazyEggOptimizationEvent(userId, eventName, properties) {
    // Note: Crazy Egg doesn't have a direct server API for events
    // This would typically be implemented through custom JavaScript or data layer
    try {
      // Store event data for analysis
      const eventData = {
        user_id: userId,
        event_name: eventName,
        properties: properties,
        timestamp: new Date().toISOString()
      };
      
      // Log for internal tracking or send to custom analytics endpoint
      console.log('Crazy Egg optimization event:', eventData);
      
      // Optionally send to custom analytics endpoint for server-side processing
      if (this.customAnalyticsEndpoint) {
        await axios.post(this.customAnalyticsEndpoint, eventData);
      }
      
    } catch (error) {
      console.error('Crazy Egg optimization event error:', error);
      throw error;
    }
  }
  
  calculateEventOptimizationValue(eventName, eventProperties, userValidation) {
    let baseValue = 0;
    
    // Event value mapping for website optimization
    const eventValues = {
      'click': 2,
      'scroll': 1,
      'hover': 0.5,
      'form_interaction': 8,
      'button_click': 5,
      'link_click': 3,
      'form_submission': 15,
      'page_view': 1,
      'conversion_event': 25
    };
    
    baseValue = eventValues[eventName] || 1;
    
    // User quality multiplier
    const qualityMultiplier = userValidation.quality_score / 100;
    
    // Revenue-based adjustment if available
    if (eventProperties.revenue) {
      baseValue += parseFloat(eventProperties.revenue) * 0.1;
    }
    
    return Math.round(baseValue * qualityMultiplier * 100) / 100;
  }
  
  determineHeatmapSegment(userValidation) {
    const qualityScore = userValidation.quality_score || 0;
    const verificationStatus = userValidation.verification_status || 'unverified';
    
    if (qualityScore >= 80 && verificationStatus === 'verified') {
      return 'premium_heatmap_users';
    } else if (qualityScore >= 60) {
      return 'high_value_heatmap_users';
    } else if (qualityScore >= 40) {
      return 'standard_heatmap_users';
    } else {
      return 'basic_heatmap_users';
    }
  }
  
  calculateHeatmapWeight(userValidation) {
    let weight = 1.0;
    
    if (userValidation.phone_verified) weight += 0.3;
    if (userValidation.email_verified) weight += 0.3;
    if (userValidation.fraud_risk_level === 'low') weight += 0.4;
    
    return Math.min(2.0, weight);
  }
  
  calculateABTestingConfidence(userValidation, eventProperties) {
    let confidence = 50; // Base confidence
    
    // User quality impact on A/B testing confidence
    const qualityScore = userValidation.quality_score || 0;
    confidence += qualityScore * 0.4; // Up to 40 points from quality
    
    // Verification status impact
    if (userValidation.phone_verified) confidence += 5;
    if (userValidation.email_verified) confidence += 5;
    
    return Math.min(100, confidence);
  }
}

// Advanced heatmap optimization with user quality segmentation
class CrazyEggHeatmapOptimizer {
  constructor(lookupApiKey) {
    this.lookupApiKey = lookupApiKey;
    this.heatmapSegments = new Map();
    this.optimizationMetrics = new Map();
  }
  
  async optimizeHeatmapWithUserQuality(pageId, heatmapData, userInteractions) {
    try {
      // Enhance user interactions with validation data
      const enhancedInteractions = await this.enhanceInteractionsWithValidation(userInteractions);
      
      // Perform quality-segmented heatmap analysis
      const segmentedHeatmapAnalysis = this.performSegmentedHeatmapAnalysis(
        enhancedInteractions,
        heatmapData
      );
      
      // Calculate optimization opportunities
      const optimizationOpportunities = this.identifyHeatmapOptimizationOpportunities(
        segmentedHeatmapAnalysis
      );
      
      // Generate comprehensive heatmap insights
      const heatmapOptimizationInsights = {
        page_id: pageId,
        analysis_timestamp: new Date().toISOString(),
        total_interactions: enhancedInteractions.length,
        // Quality segment breakdown
        quality_segments: segmentedHeatmapAnalysis.segments,
        interaction_patterns: segmentedHeatmapAnalysis.patterns,
        quality_weighted_clicks: segmentedHeatmapAnalysis.weighted_clicks,
        // Heatmap analysis
        hotspot_analysis: segmentedHeatmapAnalysis.hotspots,
        click_distribution: segmentedHeatmapAnalysis.click_distribution,
        quality_based_hotspots: segmentedHeatmapAnalysis.quality_hotspots,
        // Optimization insights
        optimization_opportunities: optimizationOpportunities,
        recommended_changes: this.generateOptimizationRecommendations(segmentedHeatmapAnalysis),
        expected_improvement: this.calculateExpectedImprovement(optimizationOpportunities),
        // Data quality metrics
        analysis_confidence: segmentedHeatmapAnalysis.confidence_score,
        data_reliability: segmentedHeatmapAnalysis.reliability_score,
        user_quality_distribution: segmentedHeatmapAnalysis.quality_distribution
      };
      
      // Store heatmap optimization insights
      this.optimizationMetrics.set(pageId, heatmapOptimizationInsights);
      
      return heatmapOptimizationInsights;
      
    } catch (error) {
      console.error('Heatmap optimization error:', error);
      return { error: error.message, page_id: pageId };
    }
  }
  
  async enhanceInteractionsWithValidation(userInteractions) {
    const enhancedInteractions = [];
    
    for (const interaction of userInteractions) {
      try {
        // Extract user contact information from interaction
        const userContact = this.extractContactFromInteraction(interaction);
        
        if (userContact.phone || userContact.email) {
          // Validate user contact
          const validation = await this.validateInteractionUser(userContact);
          
          // Enhance interaction with validation data
          const enhancedInteraction = {
            ...interaction,
            // User quality metrics
            user_quality_score: this.calculateInteractionUserQuality(validation),
            user_quality_segment: this.determineInteractionQualitySegment(validation),
            user_verification_status: this.getInteractionVerificationStatus(validation),
            // Contact validation details
            phone_validated: validation.phone?.is_valid,
            email_validated: validation.email?.is_valid,
            contact_risk_level: this.getInteractionContactRisk(validation),
            // Interaction quality indicators
            interaction_authenticity: this.calculateInteractionAuthenticity(validation, interaction),
            click_reliability: this.calculateClickReliability(validation, interaction),
            heatmap_value: this.calculateHeatmapValue(validation, interaction),
            // Optimization context
            optimization_weight: this.calculateOptimizationWeight(validation),
            ab_testing_weight: this.calculateABTestingWeight(validation),
            conversion_indicator: this.calculateConversionIndicator(validation, interaction),
            // Geographic and behavioral context
            user_country: validation.phone?.location_details?.country,
            user_region: validation.phone?.location_details?.region,
            carrier_type: validation.phone?.carrier_details?.type
          };
          
          enhancedInteractions.push(enhancedInteraction);
        } else {
          // Add interaction without validation
          enhancedInteractions.push({
            ...interaction,
            user_quality_score: 0,
            user_quality_segment: 'unverified',
            user_verification_status: 'no_contact_info'
          });
        }
        
      } catch (error) {
        console.error('Interaction enhancement error:', error);
        // Add interaction with error flag
        enhancedInteractions.push({
          ...interaction,
          validation_error: true,
          user_quality_score: 0,
          user_quality_segment: 'error'
        });
      }
    }
    
    return enhancedInteractions;
  }
  
  performSegmentedHeatmapAnalysis(enhancedInteractions, heatmapData) {
    const segments = {
      premium: { interactions: [], hotspots: [], click_weights: [] },
      high: { interactions: [], hotspots: [], click_weights: [] },
      standard: { interactions: [], hotspots: [], click_weights: [] },
      basic: { interactions: [], hotspots: [], click_weights: [] }
    };
    
    // Segment interactions by quality
    enhancedInteractions.forEach(interaction => {
      const segment = this.mapQualityToSegment(interaction.user_quality_score);
      if (segments[segment]) {
        segments[segment].interactions.push(interaction);
        segments[segment].click_weights.push(interaction.optimization_weight || 1.0);
      }
    });
    
    // Analyze each segment
    Object.keys(segments).forEach(segmentKey => {
      const segment = segments[segmentKey];
      
      if (segment.interactions.length > 0) {
        // Calculate segment hotspots
        segment.hotspots = this.calculateSegmentHotspots(segment.interactions);
        
        // Calculate weighted click distribution
        segment.weighted_distribution = this.calculateWeightedDistribution(
          segment.interactions,
          segment.click_weights
        );
        
        // Identify segment-specific optimization opportunities
        segment.optimization_opportunities = this.identifySegmentOptimizations(segment);
      }
    });
    
    // Calculate cross-segment insights
    const qualityHotspots = this.identifyQualityBasedHotspots(segments);
    const clickDistribution = this.calculateOverallClickDistribution(segments);
    const qualityDistribution = this.calculateQualityDistribution(enhancedInteractions);
    
    return {
      segments: segments,
      patterns: this.identifyInteractionPatterns(segments),
      weighted_clicks: this.calculateQualityWeightedClicks(segments),
      hotspots: qualityHotspots,
      click_distribution: clickDistribution,
      quality_hotspots: this.identifyHighQualityHotspots(segments),
      confidence_score: this.calculateHeatmapAnalysisConfidence(enhancedInteractions),
      reliability_score: this.calculateHeatmapAnalysisReliability(segments),
      quality_distribution: qualityDistribution
    };
  }
  
  identifyHeatmapOptimizationOpportunities(segmentedAnalysis) {
    const opportunities = [];
    
    // High-quality user friction points
    const premiumSegment = segmentedAnalysis.segments.premium;
    if (premiumSegment.interactions.length > 0) {
      const frictionPoints = this.identifySegmentFrictionPoints(premiumSegment);
      if (frictionPoints.length > 0) {
        opportunities.push({
          type: 'premium_user_friction',
          priority: 'high',
          description: 'Friction points affecting premium quality users',
          affected_segment: 'premium',
          friction_points: frictionPoints,
          estimated_impact: 'high',
          recommended_actions: this.generateFrictionOptimizations(frictionPoints)
        });
      }
    }
    
    // Quality-based click pattern differences
    const clickPatternDifferences = this.analyzeQualityClickPatterns(segmentedAnalysis.segments);
    if (clickPatternDifferences.significant_differences.length > 0) {
      opportunities.push({
        type: 'quality_click_pattern_optimization',
        priority: 'medium',
        description: 'Different click patterns between user quality segments',
        patterns: clickPatternDifferences,
        recommended_actions: ['Optimize for high-quality user patterns', 'Test segment-specific designs']
      });
    }
    
    // Conversion optimization opportunities
    const conversionOpportunities = this.identifyConversionOptimizations(segmentedAnalysis);
    opportunities.push(...conversionOpportunities);
    
    return opportunities;
  }
}

// Advanced A/B testing enhancement with user quality intelligence for Crazy Egg
class CrazyEggABTestOptimizer {
  constructor(accountId, lookupApiKey) {
    this.accountId = accountId;
    this.lookupApiKey = lookupApiKey;
    this.testResults = new Map();
    this.userSegments = {
      premium: { weight: 2.0, confidence_threshold: 95 },
      high: { weight: 1.6, confidence_threshold: 90 },
      standard: { weight: 1.2, confidence_threshold: 85 },
      basic: { weight: 1.0, confidence_threshold: 80 }
    };
  }
  
  async runQualitySegmentedABTest(testId, testVariants, participantData) {
    try {
      // Enhance participants with validation data
      const enhancedParticipants = await this.enhanceParticipantsWithValidation(participantData);
      
      // Segment participants by quality
      const qualitySegmentedParticipants = this.segmentParticipantsByQuality(enhancedParticipants);
      
      // Run A/B test analysis for each quality segment
      const segmentedTestResults = await this.runSegmentedABTestAnalysis(
        testId,
        testVariants,
        qualitySegmentedParticipants
      );
      
      // Calculate quality-weighted test results
      const qualityWeightedResults = this.calculateQualityWeightedResults(segmentedTestResults);
      
      // Generate comprehensive A/B test insights
      const abTestInsights = {
        test_id: testId,
        test_variants: testVariants,
        analysis_timestamp: new Date().toISOString(),
        total_participants: enhancedParticipants.length,
        // Quality segment results
        segment_results: segmentedTestResults,
        quality_weighted_results: qualityWeightedResults,
        overall_winner: qualityWeightedResults.winning_variant,
        // Statistical analysis
        statistical_significance: qualityWeightedResults.significance,
        confidence_level: qualityWeightedResults.confidence,
        quality_adjusted_confidence: qualityWeightedResults.adjusted_confidence,
        // Optimization insights
        quality_based_insights: this.generateQualityBasedInsights(segmentedTestResults),
        segment_specific_winners: this.identifySegmentWinners(segmentedTestResults),
        optimization_recommendations: this.generateABTestOptimizations(segmentedTestResults),
        // Data quality metrics
        test_reliability_score: qualityWeightedResults.reliability_score,
        participant_quality_distribution: this.calculateParticipantQualityDistribution(enhancedParticipants),
        validation_confidence: qualityWeightedResults.validation_confidence
      };
      
      // Store A/B test insights
      this.testResults.set(testId, abTestInsights);
      
      // Track A/B test completion in Crazy Egg
      CE('track', 'Quality Segmented AB Test Completed', {
        test_id: testId,
        total_participants: abTestInsights.total_participants,
        winning_variant: abTestInsights.overall_winner,
        statistical_significance: abTestInsights.statistical_significance,
        quality_confidence: abTestInsights.quality_adjusted_confidence
      });
      
      return abTestInsights;
      
    } catch (error) {
      console.error('A/B test optimization error:', error);
      return { error: error.message, test_id: testId };
    }
  }
  
  async enhanceParticipantsWithValidation(participantData) {
    const enhancedParticipants = [];
    
    for (const participant of participantData) {
      try {
        // Extract contact information from participant
        const contactInfo = {
          phone: participant.phone,
          email: participant.email
        };
        
        if (contactInfo.phone || contactInfo.email) {
          // Validate participant contact
          const validation = await this.validateParticipantContact(contactInfo);
          
          // Enhance participant with validation data
          const enhancedParticipant = {
            ...participant,
            // User quality metrics
            user_quality_score: this.calculateParticipantQuality(validation),
            user_quality_tier: this.determineParticipantTier(validation),
            user_verification_status: this.getParticipantVerificationStatus(validation),
            // Contact validation details
            phone_validated: validation.phone?.is_valid,
            email_validated: validation.email?.is_valid,
            contact_risk_level: this.getParticipantContactRisk(validation),
            // A/B testing specific metrics
            test_participation_weight: this.calculateTestWeight(validation),
            result_confidence_contribution: this.calculateConfidenceContribution(validation),
            statistical_reliability: this.calculateStatisticalReliability(validation),
            // Behavioral quality indicators
            interaction_authenticity: this.calculateParticipantAuthenticity(validation),
            conversion_potential: this.calculateParticipantConversionPotential(validation),
            test_engagement_quality: this.calculateTestEngagementQuality(validation),
            // Geographic and demographic context
            participant_country: validation.phone?.location_details?.country,
            participant_region: validation.phone?.location_details?.region,
            carrier_type: validation.phone?.carrier_details?.type
          };
          
          enhancedParticipants.push(enhancedParticipant);
        } else {
          // Add participant without validation
          enhancedParticipants.push({
            ...participant,
            user_quality_score: 0,
            user_quality_tier: 'unverified',
            test_participation_weight: 0.5 // Lower weight for unverified
          });
        }
        
      } catch (error) {
        console.error('Participant enhancement error:', error);
        // Add participant with error flag
        enhancedParticipants.push({
          ...participant,
          validation_error: true,
          user_quality_score: 0,
          test_participation_weight: 0.3 // Lowest weight for errors
        });
      }
    }
    
    return enhancedParticipants;
  }
  
  calculateQualityWeightedResults(segmentedTestResults) {
    let overallConversionRates = {};
    let weightedSignificance = 0;
    let weightedConfidence = 0;
    let totalWeight = 0;
    
    // Calculate weighted results across all segments
    Object.keys(segmentedTestResults).forEach(segment => {
      const segmentResult = segmentedTestResults[segment];
      const segmentWeight = this.userSegments[segment]?.weight || 1.0;
      
      // Weight conversion rates by segment quality
      Object.keys(segmentResult.conversion_rates).forEach(variant => {
        if (!overallConversionRates[variant]) {
          overallConversionRates[variant] = 0;
        }
        overallConversionRates[variant] += 
          segmentResult.conversion_rates[variant] * segmentWeight * segmentResult.participant_count;
      });
      
      // Weight statistical metrics
      weightedSignificance += segmentResult.statistical_significance * segmentWeight;
      weightedConfidence += segmentResult.confidence_level * segmentWeight;
      totalWeight += segmentWeight;
    });
    
    // Normalize weighted results
    Object.keys(overallConversionRates).forEach(variant => {
      overallConversionRates[variant] = overallConversionRates[variant] / totalWeight;
    });
    
    weightedSignificance = weightedSignificance / totalWeight;
    weightedConfidence = weightedConfidence / totalWeight;
    
    // Determine winning variant
    const winningVariant = Object.keys(overallConversionRates).reduce((a, b) =>
      overallConversionRates[a] > overallConversionRates[b] ? a : b
    );
    
    return {
      conversion_rates: overallConversionRates,
      winning_variant: winningVariant,
      significance: Math.round(weightedSignificance * 100) / 100,
      confidence: Math.round(weightedConfidence * 100) / 100,
      adjusted_confidence: this.calculateAdjustedConfidence(weightedConfidence, segmentedTestResults),
      reliability_score: this.calculateTestReliabilityScore(segmentedTestResults),
      validation_confidence: this.calculateValidationConfidence(segmentedTestResults)
    };
  }
}