Advanced Segmentation Strategies for Popup Email Capture

// Intent signal detection example
const detectPurchaseIntent = (visitorData) => {
  const signals = {
    viewedPricing: visitorData.pagesVisited.includes('/pricing'),
    checkedShipping: visitorData.pagesVisited.includes('/shipping'),
    viewedReviews: visitorData.pagesVisited.includes('/reviews'),
    cartActivity: visitorData.cartInteractions > 0,
    timeOnProduct: visitorData.avgTimeOnProductPage > 120, // seconds
    returnVisitor: visitorData.sessionCount > 1
  };

  const intentScore = Object.values(signals).filter(Boolean).length;
  return {
    score: intentScore,
    level: intentScore >= 4 ? 'high' : intentScore >= 2 ? 'medium' : 'low',
    signals: signals
  };
};

// Dynamic segmentation logic
class DynamicSegmentManager {
  constructor() {
    this.segments = new Map();
    this.visitorData = new Map();
  }

  updateVisitorSegment(visitorId, behaviorData) {
    const currentData = this.visitorData.get(visitorId) || {};
    const updatedData = { ...currentData, ...behaviorData };
    this.visitorData.set(visitorId, updatedData);

    // Recalculate segment
    const segment = this.calculateSegment(updatedData);

    // Trigger appropriate popup campaign
    if (segment.hasChanged) {
      this.triggerCampaign(visitorId, segment);
    }
  }

  calculateSegment(data) {
    // Implementation of segmentation logic
    const rules = [
      { condition: data.intentScore >= 4, segment: 'hot-lead' },
      { condition: data.cartValue > 100, segment: 'high-value' },
      { condition: data.visitCount > 3, segment: 'returning' },
      // ... more rules
    ];

    return rules.find(rule => rule.condition) || { segment: 'general' };
  }
}

// RFM Recency scoring
const calculateRecencyScore = (daysSinceLastPurchase) => {
  if (daysSinceLastPurchase <= 30) return 5; // Champions
  if (daysSinceLastPurchase <= 60) return 4; // Loyal customers
  if (daysSinceLastPurchase <= 90) return 3; // Potential loyalists
  if (daysSinceLastPurchase <= 180) return 2; // At risk
  return 1; // Lost
};

// Popup strategy based on recency
const getPopupStrategy = (recencyScore) => {
  const strategies = {
    5: { // Recent purchasers
      popup: 'exclusive-access',
      offer: 'early-access-to-new-products',
      timing: 'on-entry'
    },
    3: { // Potential loyalists
      popup: 'loyalty-program',
      offer: 'join-loyalty-program',
      timing: 'exit-intent'
    },
    1: { // Lost customers
      popup: 'win-back',
      offer: 'special-discount',
      timing: 'time-delay'
    }
  };

  return strategies[recencyScore] || strategies[3];
};

// Demographic-based popup content
const getDemographicContent = (demographics) => {
  const content = {
    age: {
      '18-24': { style: 'modern', offer: 'student-discount', tone: 'casual' },
      '25-34': { style: 'professional', offer: 'career-growth', tone: 'inspirational' },
      '35-44': { style: 'family', offer: 'family-bundles', tone: 'practical' },
      '45+': { style: 'classic', offer: 'quality-focus', tone: 'respectful' }
    },
    interests: {
      'technology': { content: 'tech-guides', timing: 'immediate' },
      'fashion': { content: 'style-tips', timing: 'scroll-depth' },
      'fitness': { content: 'workout-plans', timing: 'time-delay' }
    }
  };

  return { ...content.age[demographics.age], ...content.interests[demographics.primaryInterest] };
};

// Time-based segmentation logic
const getTimeBasedSegment = (hour, dayOfWeek) => {
  const segments = {
    weekday: {
      morning: { // 6AM - 12PM
        offer: 'coffee-break-special',
        urgency: 'limited-time-morning',
        tone: 'energetic'
      },
      afternoon: { // 12PM - 6PM
        offer: 'lunch-deal',
        urgency: 'today-only',
        tone: 'professional'
      },
      evening: { // 6PM - 11PM
        offer: 'after-work-special',
        urgency: 'tonight-only',
        tone: 'relaxed'
      }
    },
    weekend: {
      morning: {
        offer: 'weekend-brunch-special',
        urgency: 'weekend-only',
        tone: 'casual'
      },
      evening: {
        offer: 'saturday-night-special',
        urgency: 'tonight-only',
        tone: 'celebratory'
      }
    }
  };

  const timeOfDay = hour < 12 ? 'morning' : hour < 18 ? 'afternoon' : 'evening';
  const dayType = dayOfWeek >= 6 ? 'weekend' : 'weekday';

  return segments[dayType][timeOfDay];
};

// ESP integration example (Klaviyo)
class KlaviyoSegmentIntegration {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://a.klaviyo.com/api';
  }

  async updateProfileSegment(email, segmentData) {
    const profileData = {
      email: email,
      properties: {
        popup_segment: segmentData.segment,
        intent_score: segmentData.intentScore,
        last_visit: new Date().toISOString(),
        device_type: segmentData.device,
        location: segmentData.location
      }
    };

    try {
      const response = await fetch(`${this.baseUrl}/profiles/`, {
        method: 'POST',
        headers: {
          'Authorization': `Klaviyo-API-Key ${this.apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          data: {
            type: 'profile',
            attributes: profileData
          }
        })
      });

      return await response.json();
    } catch (error) {
      console.error('Klaviyo integration error:', error);
      throw error;
    }
  }

  async addToSegment(email, segmentId) {
    // Add profile to specific segment in Klaviyo
    const segmentData = {
      profile_ids: [email],
      segment_ids: [segmentId]
    };

    // Implementation for segment membership
  }
}

// Privacy-conscious segmentation
class PrivacySegmentManager {
  constructor() {
    this.consentLevel = this.getCookieConsent();
    this.anonymousId = this.generateAnonymousId();
  }

  createBehavioralSegment(behaviorData) {
    // Use only behavioral data, no personal information
    const segment = {
      id: this.anonymousId,
      pageViews: behaviorData.pageViews,
      timeOnSite: behaviorData.timeOnSite,
      cartActivity: behaviorData.cartActivity,
      deviceType: behaviorData.deviceType,
      // No personal data stored
    };

    return this.hashSegmentData(segment);
  }

  hashSegmentData(segment) {
    // Create anonymous segment identifier
    const segmentString = JSON.stringify(segment);
    return btoa(segmentString).substring(0, 12);
  }

  getCookieConsent() {
    // Check user consent preferences
    return localStorage.getItem('cookie-consent') || 'none';
  }
}

// Segmentation A/B test framework
class SegmentationTestFramework {
  constructor() {
    this.tests = new Map();
    this.results = new Map();
  }

  createTest(testConfig) {
    const test = {
      id: this.generateTestId(),
      name: testConfig.name,
      hypothesis: testConfig.hypothesis,
      segments: testConfig.segments,
      trafficSplit: testConfig.trafficSplit || 50/50,
      startDate: new Date(),
      endDate: testConfig.endDate,
      metrics: testConfig.metrics
    };

    this.tests.set(test.id, test);
    return test;
  }

  assignVisitorToTest(visitorId, testId) {
    const test = this.tests.get(testId);
    const hash = this.hashVisitorTest(visitorId, testId);
    const segment = hash < 0.5 ? test.segments.control : test.segments.variant;

    return {
      testId: testId,
      segment: segment,
      assignment: hash < 0.5 ? 'control' : 'variant'
    };
  }

  recordConversion(testId, segment, conversionData) {
    if (!this.results.has(testId)) {
      this.results.set(testId, { control: [], variant: [] });
    }

    const testResults = this.results.get(testId);
    testResults[segment].push(conversionData);
  }

  analyzeTestResults(testId) {
    const results = this.results.get(testId);
    // Statistical analysis implementation
    return this.calculateStatisticalSignificance(results);
  }
}

// Continuous optimization loop
class SegmentationOptimizer {
  constructor() {
    this.performanceHistory = [];
    this.optimizationSchedule = new Map();
  }

  async analyzePerformance() {
    const currentPerformance = await this.gatherMetrics();
    const historicalData = this.getHistoricalData();

    const analysis = {
      trends: this.identifyTrends(historicalData),
      opportunities: this.findOpportunities(currentPerformance),
      issues: this.detectProblems(currentPerformance)
    };

    return analysis;
  }

  generateOptimizations(analysis) {
    const optimizations = [];

    if (analysis.trends.conversionRateDecline) {
      optimizations.push({
        type: 'segment-refinement',
        action: 'merge-low-performing-segments',
        priority: 'high'
      });
    }

    if (analysis.opportunities.newBehaviorPatterns) {
      optimizations.push({
        type: 'segment-creation',
        action: 'create-behavioral-segments',
        priority: 'medium'
      });
    }

    return optimizations;
  }

  async implementOptimizations(optimizations) {
    for (const optimization of optimizations) {
      try {
        await this.applyOptimization(optimization);
        this.trackOptimizationImpact(optimization);
      } catch (error) {
        console.error('Optimization failed:', optimization, error);
      }
    }
  }
}