Bildirim Analitikleri ve Performans Optimizasyonu: A/B Testleri, Metrikler ve Ölçekte Ayarlama

interface NotificationAnalytics {
  // Katman 1: Teslimat Temelleri
  delivery: {
    sent: number;
    delivered: number;
    failed: number;
    bounced: number;
    deliveryRate: number;
    avgDeliveryTime: number;
  };
  
  // Katman 2: Kullanıcı Etkileşimi
  engagement: {
    opened: number;
    clicked: number;
    dismissed: number;
    actioned: number; // Kullanıcı hedeflenen aksiyonu yaptı
    openRate: number;
    clickThroughRate: number;
    conversionRate: number; // Aksiyon tamamlama oranı
  };
  
  // Katman 3: İş Etkisi
  businessImpact: {
    revenueGenerated: number;
    userRetention: number;
    featureAdoption: number;
    supportTicketReduction: number;
    userLifetimeValue: number;
  };
  
  // Katman 4: Sistem Performansı
  performance: {
    processingLatency: number;
    queueDepth: number;
    resourceUtilization: number;
    costPerNotification: number;
    errorRates: Record<string, number>;
  };
}

class NotificationAnalyticsEngine {
  private eventStore: EventStore;
  private metricsAggregator: MetricsAggregator;
  private cohortAnalyzer: CohortAnalyzer;

  async trackNotificationEvent(event: NotificationAnalyticsEvent): Promise<void> {
    // Ham eventi sakla
    await this.eventStore.store(event);
    
    // Dashboard'lar için gerçek zamanlı toplama
    await this.metricsAggregator.update(event);
    
    // Derin içgörüler için cohort analizi
    if (event.type === 'user_action') {
      await this.cohortAnalyzer.processUserAction(event);
    }
    
    // Anomali tespitini tetikle
    await this.checkForAnomalies(event);
  }

  async generateInsights(
    dateRange: DateRange,
    segmentBy?: string[]
  ): Promise<NotificationInsights> {
    const baseMetrics = await this.getBaseMetrics(dateRange);
    const segmentedAnalysis = segmentBy ? 
      await this.getSegmentedAnalysis(dateRange, segmentBy) : null;
    
    const insights: NotificationInsights = {
      summary: baseMetrics,
      segments: segmentedAnalysis,
      trends: await this.getTrendAnalysis(dateRange),
      anomalies: await this.getAnomalies(dateRange),
      recommendations: await this.generateRecommendations(baseMetrics)
    };
    
    return insights;
  }

  private async generateRecommendations(
    metrics: NotificationMetrics
  ): Promise<OptimizationRecommendation[]> {
    const recommendations: OptimizationRecommendation[] = [];
    
    // Teslimat optimizasyonu
    if (metrics.delivery.deliveryRate &lt;0.95) {
      recommendations.push({
        type: 'delivery',
        priority: 'high',
        description: 'Düşük teslimat oranı tespit edildi',
        suggestedActions: [
          'Email kimlik doğrulama ayarlarını gözden geçir',
          'Gönderici itibarını kontrol et',
          'Suppression listesini denetle'
        ],
        expectedImpact: 'Teslimat oranını %5-10 artırır'
      });
    }
    
    // Etkileşim optimizasyonu
    if (metrics.engagement.openRate &lt;0.20) {
      recommendations.push({
        type: 'engagement', 
        priority: 'medium',
        description: 'Ortalamanın altında açılma oranı',
        suggestedActions: [
          'Konu satırlarını A/B test et',
          'Gönderim zamanı optimizasyonunu gözden geçir',
          'Gönderici adı etkisini analiz et'
        ],
        expectedImpact: 'Açılma oranında potansiyel %15-25 iyileşme'
      });
    }
    
    // Performans optimizasyonu
    if (metrics.performance.avgLatency > 5000) {
      recommendations.push({
        type: 'performance',
        priority: 'high', 
        description: 'Yüksek işleme gecikmesi',
        suggestedActions: [
          'Template rendering performansını gözden geçir',
          'Veritabanı sorgularını optimize et',
          'Cache katmanı implementasyonunu düşün'
        ],
        expectedImpact: 'Gecikmeyi %40-60 azaltır'
      });
    }
    
    return recommendations;
  }
}

interface UserNotificationJourney {
  userId: string;
  journeyType: string; // 'onboarding', 'feature_adoption', 'retention'
  startedAt: Date;
  currentStep: number;
  totalSteps: number;
  events: NotificationJourneyEvent[];
  outcome?: JourneyOutcome;
  dropOffReason?: string;
}

class NotificationJourneyTracker {
  async trackJourneyEvent(
    userId: string,
    journeyType: string,
    event: NotificationJourneyEvent
  ): Promise<void> {
    const journey = await this.getOrCreateJourney(userId, journeyType);
    
    journey.events.push({
      ...event,
      timestamp: new Date(),
      stepNumber: journey.currentStep
    });
    
    // Event'e göre yolculuk durumunu güncelle
    await this.updateJourneyState(journey, event);
    
    // Yolculuk tamamlanması veya terk edilmesi için kontrol et
    await this.evaluateJourneyStatus(journey);
    
    await this.saveJourney(journey);
  }

  async analyzeJourneyPerformance(
    journeyType: string,
    dateRange: DateRange
  ): Promise<JourneyAnalytics> {
    const journeys = await this.getJourneys(journeyType, dateRange);
    
    const stepConversionRates = this.calculateStepConversions(journeys);
    const dropOffPoints = this.identifyDropOffPoints(journeys);
    const timeToComplete = this.calculateCompletionTimes(journeys);
    
    return {
      totalJourneys: journeys.length,
      completionRate: journeys.filter(j => j.outcome === 'completed').length / journeys.length,
      stepConversionRates,
      dropOffPoints,
      averageTimeToComplete: timeToComplete.average,
      medianTimeToComplete: timeToComplete.median,
      recommendations: this.generateJourneyOptimizations(stepConversionRates, dropOffPoints)
    };
  }

  private generateJourneyOptimizations(
    conversionRates: Record<number, number>,
    dropOffPoints: DropOffAnalysis[]
  ): JourneyOptimization[] {
    const optimizations: JourneyOptimization[] = [];
    
    // Düşük dönüşüm oranlarına sahip adımları bul
    Object.entries(conversionRates).forEach(([step, rate]) => {
      if (rate &lt;0.7) { // %70'den az dönüşüm
        optimizations.push({
          stepNumber: parseInt(step),
          type: 'low_conversion',
          currentRate: rate,
          suggestions: [
            'Gerekli aksiyonu basitleştir',
            'Bildirim metni netliğini artır',
            'İlerleme göstergeleri ekle',
            'Bağlamsal yardım sağla'
          ]
        });
      }
    });
    
    // Büyük düşüş noktalarını analiz et
    dropOffPoints.forEach(dropOff => {
      if (dropOff.dropOffRate > 0.3) { // %30'dan fazla düşüş
        optimizations.push({
          stepNumber: dropOff.stepNumber,
          type: 'high_dropoff',
          currentRate: 1 - dropOff.dropOffRate,
          suggestions: [
            'Bildirim zamanlamasını gözden geçir',
            'Mesaj alakalılığını kontrol et', 
            'Farklı harekete geçirici ifadeler test et',
            'Adımı küçük aksiyonlara bölebilir'
          ]
        });
      }
    });
    
    return optimizations;
  }
}

interface NotificationExperiment {
  id: string;
  name: string;
  type: ExperimentType; // 'subject_line', 'timing', 'content', 'frequency', 'channel'
  status: ExperimentStatus;
  hypothesis: string;
  variants: ExperimentVariant[];
  targetAudience: AudienceDefinition;
  trafficAllocation: number; // Uygun kullanıcıların yüzdesi
  primaryMetric: string;
  secondaryMetrics: string[];
  minimumDetectableEffect: number;
  significanceLevel: number;
  powerLevel: number;
  startDate: Date;
  endDate?: Date;
  results?: ExperimentResults;
}

class NotificationExperimentManager {
  private statisticalEngine: StatisticalEngine;
  private userSegmenter: UserSegmenter;
  private safetyMonitor: SafetyMonitor;

  async createExperiment(
    experimentConfig: ExperimentConfig
  ): Promise<NotificationExperiment> {
    // Gerekli örneklem boyutunu hesapla
    const sampleSize = this.statisticalEngine.calculateSampleSize(
      experimentConfig.minimumDetectableEffect,
      experimentConfig.significanceLevel,
      experimentConfig.powerLevel,
      experimentConfig.baselineConversionRate
    );
    
    // Deneyim güvenliğini doğrula
    const safetyCheck = await this.safetyMonitor.validateExperiment(experimentConfig);
    if (!safetyCheck.isSafe) {
      throw new Error(`Experiment failed safety check: ${safetyCheck.reasons.join(', ')}`);
    }
    
    // Kullanıcı segmentasyonunu kur
    const audience = await this.userSegmenter.defineAudience(
      experimentConfig.targetCriteria,
      sampleSize
    );
    
    const experiment: NotificationExperiment = {
      id: this.generateExperimentId(),
      name: experimentConfig.name,
      type: experimentConfig.type,
      status: 'draft',
      hypothesis: experimentConfig.hypothesis,
      variants: experimentConfig.variants,
      targetAudience: audience,
      trafficAllocation: experimentConfig.trafficAllocation,
      primaryMetric: experimentConfig.primaryMetric,
      secondaryMetrics: experimentConfig.secondaryMetrics,
      minimumDetectableEffect: experimentConfig.minimumDetectableEffect,
      significanceLevel: experimentConfig.significanceLevel,
      powerLevel: experimentConfig.powerLevel,
      startDate: experimentConfig.startDate
    };
    
    await this.saveExperiment(experiment);
    return experiment;
  }

  async assignUserToExperiment(
    userId: string,
    experimentId: string
  ): Promise<ExperimentAssignment> {
    const experiment = await this.getExperiment(experimentId);
    
    if (experiment.status !== 'running') {
      return { variant: 'control', reason: 'experiment_not_running' };
    }
    
    // Kullanıcının hedef kitlede olup olmadığını kontrol et
    const isEligible = await this.userSegmenter.isUserEligible(
      userId,
      experiment.targetAudience
    );
    
    if (!isEligible) {
      return { variant: 'control', reason: 'not_in_target_audience' };
    }
    
    // Trafik tahsisini kontrol et
    const userHash = this.hashUserId(userId, experiment.id);
    const trafficBucket = userHash % 100;
    
    if (trafficBucket >= experiment.trafficAllocation) {
      return { variant: 'control', reason: 'traffic_allocation' };
    }
    
    // Hash'e göre varyanta ata
    const variantIndex = Math.floor(
      (userHash / 100) * experiment.variants.length
    );
    const assignedVariant = experiment.variants[variantIndex];
    
    // Tutarlılık için atamayı sakla
    await this.storeUserAssignment(userId, experimentId, assignedVariant.id);
    
    return {
      variant: assignedVariant.id,
      experimentId,
      assignedAt: new Date()
    };
  }

  async analyzeExperimentResults(
    experimentId: string
  ): Promise<ExperimentAnalysis> {
    const experiment = await this.getExperiment(experimentId);
    const rawData = await this.getExperimentData(experimentId);
    
    // İstatistiksel anlamlılık testi
    const primaryResults = await this.statisticalEngine.performTest(
      rawData,
      experiment.primaryMetric,
      experiment.significanceLevel
    );
    
    // İkincil metrik analizi
    const secondaryResults = await Promise.all(
      experiment.secondaryMetrics.map(metric =>
        this.statisticalEngine.performTest(rawData, metric, 0.05)
      )
    );
    
    // Etki büyüklüğü hesaplama
    const effectSize = this.statisticalEngine.calculateEffectSize(
      primaryResults,
      experiment.minimumDetectableEffect
    );
    
    // İş etkisi tahmini
    const businessImpact = await this.estimateBusinessImpact(
      primaryResults,
      experiment
    );
    
    return {
      experiment,
      primaryResults,
      secondaryResults,
      effectSize,
      businessImpact,
      recommendation: this.generateRecommendation(
        primaryResults,
        secondaryResults,
        businessImpact
      ),
      confidenceLevel: primaryResults.confidenceLevel
    };
  }
}

class ExperimentSafetyMonitor {
  private alerting: AlertingService;
  private metrics: MetricsService;

  async monitorExperimentSafety(experimentId: string): Promise<SafetyStatus> {
    const experiment = await this.getExperiment(experimentId);
    const safetyChecks = await Promise.all([
      this.checkDeliveryRates(experiment),
      this.checkEngagementMetrics(experiment),
      this.checkUserComplaintsRate(experiment),
      this.checkBusinessMetricImpact(experiment),
      this.checkSystemPerformance(experiment)
    ]);
    
    const criticalIssues = safetyChecks.filter(check => check.severity === 'critical');
    const warnings = safetyChecks.filter(check => check.severity === 'warning');
    
    if (criticalIssues.length > 0) {
      await this.triggerExperimentPause(experimentId, criticalIssues);
      await this.alerting.sendCriticalAlert({
        type: 'experiment_safety_violation',
        experimentId,
        issues: criticalIssues
      });
    }
    
    return {
      status: criticalIssues.length > 0 ? 'critical' : 
              warnings.length > 0 ? 'warning' : 'healthy',
      checks: safetyChecks,
      lastChecked: new Date()
    };
  }

  private async checkDeliveryRates(experiment: NotificationExperiment): Promise<SafetyCheck> {
    const deliveryRates = await this.getVariantDeliveryRates(experiment.id);
    
    for (const [variantId, rate] of Object.entries(deliveryRates)) {
      if (rate &lt;0.90) { // %90'dan az teslimat oranı
        return {
          checkType: 'delivery_rate',
          severity: 'critical',
          message: `Varyant ${variantId} teslimat oranı ${rate * 100}%`,
          threshold: 0.90,
          actualValue: rate,
          recommendation: 'Deneyi duraklat ve teslimat sorunlarını araştır'
        };
      }
    }
    
    return {
      checkType: 'delivery_rate',
      severity: 'healthy',
      message: 'Tüm varyantlar kabul edilebilir teslimat oranlarına sahip'
    };
  }

  private async checkUserComplaintsRate(experiment: NotificationExperiment): Promise<SafetyCheck> {
    const complaintRates = await this.getVariantComplaintRates(experiment.id);
    
    for (const [variantId, rate] of Object.entries(complaintRates)) {
      if (rate > 0.01) { // %1'den fazla şikayet oranı
        return {
          checkType: 'user_complaints',
          severity: 'critical',
          message: `Varyant ${variantId} şikayet oranı ${rate * 100}%`,
          threshold: 0.01,
          actualValue: rate,
          recommendation: 'Deneyi hemen duraklat - yüksek şikayet oranı kötü kullanıcı deneyimi gösteriyor'
        };
      }
    }
    
    return {
      checkType: 'user_complaints', 
      severity: 'healthy',
      message: 'Şikayet oranları kabul edilebilir aralıkta'
    };
  }

  private async triggerExperimentPause(
    experimentId: string,
    reasons: SafetyCheck[]
  ): Promise<void> {
    await this.updateExperimentStatus(experimentId, 'paused_for_safety');
    
    // Duraklatma nedenini logla
    await this.logExperimentEvent(experimentId, {
      type: 'safety_pause',
      timestamp: new Date(),
      reasons: reasons.map(r => r.message),
      autoResumeEligible: reasons.every(r => r.severity === 'warning')
    });
    
    // Deneyim sahiplerini bilgilendir
    await this.notifyExperimentOwners(experimentId, reasons);
  }
}

class OptimizedTemplateRenderer {
  private templateCache: LRUCache<string, CompiledTemplate>;
  private dataPreloader: DataPreloader;
  private renderPool: WorkerPool;

  constructor() {
    this.templateCache = new LRUCache({ max: 1000, ttl: 1000 * 60 * 60 }); // 1 saat
    this.renderPool = new WorkerPool({
      size: 10,
      taskTimeout: 5000
    });
  }

  async renderTemplate(
    templateId: string,
    userData: any,
    notificationData: any
  ): Promise<RenderedContent> {
    // Derlenmiş template cache'ini kullan
    let template = this.templateCache.get(templateId);
    
    if (!template) {
      const templateSource = await this.getTemplateSource(templateId);
      template = await this.compileTemplate(templateSource);
      this.templateCache.set(templateId, template);
    }
    
    // N+1 sorguları önlemek için yaygın gereken veriyi ön-yükle
    const preloadedData = await this.dataPreloader.preloadForTemplate(
      template.requiredData,
      userData.userId
    );
    
    const renderContext = {
      ...userData,
      ...notificationData,
      ...preloadedData
    };
    
    // CPU-yoğun rendering için worker pool kullan
    const renderTask = {
      templateId,
      template: template.compiled,
      context: renderContext
    };
    
    try {
      const result = await this.renderPool.execute(renderTask);
      
      // Rendering performansını takip et
      await this.trackRenderingMetrics(templateId, result.renderTime, true);
      
      return result.content;
    } catch (error) {
      await this.trackRenderingMetrics(templateId, 0, false);
      
      // Basit template'e fallback
      return await this.renderFallbackTemplate(templateId, renderContext);
    }
  }
}

class DataPreloader {
  private queryBatcher: QueryBatcher;
  private dataCache: Cache;

  async preloadForTemplate(
    requiredData: string[],
    userId: string
  ): Promise<Record<string, any>> {
    const preloadPromises: Promise<any>[] = [];
    const preloadedData: Record<string, any> = {};
    
    if (requiredData.includes('user_projects')) {
      preloadPromises.push(
        this.queryBatcher.batch('user_projects', userId)
          .then(data => preloadedData.projects = data)
      );
    }
    
    if (requiredData.includes('user_activities')) {
      preloadPromises.push(
        this.queryBatcher.batch('user_activities', userId)
          .then(data => preloadedData.recentActivities = data)
      );
    }
    
    if (requiredData.includes('user_settings')) {
      preloadPromises.push(
        this.queryBatcher.batch('user_settings', userId)
          .then(data => preloadedData.settings = data)
      );
    }
    
    await Promise.all(preloadPromises);
    return preloadedData;
  }
}

class QueryBatcher {
  private batches: Map<string, BatchQuery> = new Map();
  private batchTimeout = 50; // 50ms batch penceresi
  
  async batch<T>(queryType: string, param: any): Promise<T> {
    return new Promise((resolve, reject) => {
      if (!this.batches.has(queryType)) {
        this.batches.set(queryType, {
          params: [],
          promises: [],
          timeoutId: setTimeout(() => this.executeBatch(queryType), this.batchTimeout)
        });
      }
      
      const batch = this.batches.get(queryType)!;
      batch.params.push(param);
      batch.promises.push({ resolve, reject });
    });
  }
  
  private async executeBatch(queryType: string): Promise<void> {
    const batch = this.batches.get(queryType);
    if (!batch) return;
    
    this.batches.delete(queryType);
    clearTimeout(batch.timeoutId);
    
    try {
      const results = await this.executeQuery(queryType, batch.params);
      
      batch.promises.forEach((promise, index) => {
        promise.resolve(results[index]);
      });
    } catch (error) {
      batch.promises.forEach(promise => {
        promise.reject(error);
      });
    }
  }
}

class OptimizedNotificationQueries {
  private readReplica: Database;
  private writeDatabase: Database;
  private queryCache: Redis;

  async getUserNotificationPreferences(
    userId: string
  ): Promise<NotificationPreferences> {
    // Tercih lookupları için read replica kullan
    const cacheKey = `prefs:${userId}`;
    
    // Önce cache'i dene
    const cached = await this.queryCache.get(cacheKey);
    if (cached) {
      return JSON.parse(cached);
    }
    
    // Tüm tercihleri almak için tek sorgu
    const preferences = await this.readReplica.query(`
      SELECT 
        np.notification_type,
        np.channel,
        np.enabled,
        np.frequency,
        np.quiet_hours_start,
        np.quiet_hours_end,
        u.timezone,
        u.locale
      FROM notification_preferences np
      JOIN users u ON u.id = np.user_id
      WHERE np.user_id = $1
    `, [userId]);
    
    const structured = this.structurePreferences(preferences);
    
    // 5 dakika cache'le
    await this.queryCache.setex(cacheKey, 300, JSON.stringify(structured));
    
    return structured;
  }

  async getBatchUserData(userIds: string[]): Promise<Map<string, UserData>> {
    // N bireysel sorgu yerine batch sorgusu
    const userData = await this.readReplica.query(`
      SELECT 
        u.id,
        u.email,
        u.locale,
        u.timezone,
        u.email_enabled,
        u.sms_enabled,
        u.push_enabled,
        array_agg(pt.token) as push_tokens,
        array_agg(pt.platform) as push_platforms
      FROM users u
      LEFT JOIN push_tokens pt ON pt.user_id = u.id AND pt.is_active = true
      WHERE u.id = ANY($1)
      GROUP BY u.id, u.email, u.locale, u.timezone, u.email_enabled, u.sms_enabled, u.push_enabled
    `, [userIds]);
    
    const userMap = new Map<string, UserData>();
    
    userData.forEach(row => {
      userMap.set(row.id, {
        id: row.id,
        email: row.email,
        locale: row.locale,
        timezone: row.timezone,
        emailEnabled: row.email_enabled,
        smsEnabled: row.sms_enabled,
        pushEnabled: row.push_enabled,
        pushTokens: row.push_tokens?.filter(Boolean) || [],
        pushPlatforms: row.push_platforms?.filter(Boolean) || []
      });
    });
    
    return userMap;
  }

  async getNotificationAnalytics(
    dateRange: DateRange,
    filters?: AnalyticsFilters
  ): Promise<NotificationAnalytics> {
    // Analitik sorguları için materialized view kullan
    let query = `
      SELECT 
        notification_type,
        channel,
        date_trunc('day', created_at) as date,
        COUNT(*) as total_sent,
        COUNT(*) FILTER (WHERE status = 'delivered') as delivered,
        COUNT(*) FILTER (WHERE status = 'opened') as opened,
        COUNT(*) FILTER (WHERE status = 'clicked') as clicked,
        COUNT(*) FILTER (WHERE status = 'failed') as failed,
        AVG(EXTRACT(EPOCH FROM (delivered_at - created_at))) as avg_delivery_time
      FROM notification_metrics_daily
      WHERE created_at >= $1 AND created_at <= $2
    `;
    
    const params = [dateRange.start, dateRange.end];
    
    if (filters?.notificationType) {
      query += ` AND notification_type = $${params.length + 1}`;
      params.push(filters.notificationType);
    }
    
    if (filters?.channel) {
      query += ` AND channel = $${params.length + 1}`;
      params.push(filters.channel);
    }
    
    query += `
      GROUP BY notification_type, channel, date_trunc('day', created_at)
      ORDER BY date DESC
    `;
    
    const results = await this.readReplica.query(query, params);
    return this.aggregateAnalytics(results);
  }
}

class CostOptimizedNotificationSystem {
  private costTracker: CostTracker;
  private resourceAllocator: ResourceAllocator;

  async processNotificationWithCostOptimization(
    notification: NotificationEvent
  ): Promise<void> {
    const costAnalysis = await this.analyzeCost(notification);
    
    // Maliyet-fayda temelinde işleme stratejisi seç
    if (costAnalysis.highValue && costAnalysis.lowCost) {
      // Yüksek değerli, düşük maliyetli bildirimler için premium işleme
      await this.processPremium(notification);
    } else if (costAnalysis.highValue && costAnalysis.highCost) {
      // Yüksek değerli, yüksek maliyetli bildirimler için optimize işleme
      await this.processOptimized(notification);
    } else if (costAnalysis.lowValue && costAnalysis.lowCost) {
      // Düşük değerli, düşük maliyetli bildirimler için batch işleme
      await this.queueForBatchProcessing(notification);
    } else {
      // Bildirimin gönderilip gönderilmeyeceğini değerlendir
      const shouldSend = await this.evaluateROI(notification, costAnalysis);
      if (shouldSend) {
        await this.processEconomical(notification);
      }
    }
  }

  private async analyzeCost(notification: NotificationEvent): Promise<CostAnalysis> {
    const channels = await this.getTargetChannels(notification.userId, notification.type);
    
    let totalCost = 0;
    let estimatedValue = 0;
    
    for (const channel of channels) {
      const channelCost = await this.costTracker.getChannelCost(channel);
      const channelValue = await this.estimateChannelValue(notification, channel);
      
      totalCost += channelCost;
      estimatedValue += channelValue;
    }
    
    return {
      totalCost,
      estimatedValue,
      roi: estimatedValue / totalCost,
      highValue: estimatedValue > 5.0, // $5 tahmini değer
      lowCost: totalCost &lt;0.10,       // 10 cent
      highCost: totalCost > 1.0        // $1
    };
  }

  private async evaluateROI(
    notification: NotificationEvent,
    costAnalysis: CostAnalysis
  ): Promise<boolean> {
    // Negatif ROI'li bildirimleri gönderme
    if (costAnalysis.roi &lt;1.0) {
      await this.trackSkippedNotification(notification, 'negative_roi');
      return false;
    }
    
    // Marjinal ROI için kullanıcı etkileşim geçmişini düşün
    if (costAnalysis.roi &lt;1.5) {
      const userEngagement = await this.getUserEngagementScore(notification.userId);
      if (userEngagement &lt;0.1) { // Çok düşük etkileşim
        await this.trackSkippedNotification(notification, 'low_engagement_roi');
        return false;
      }
    }
    
    return true;
  }
}