// 特性开关管理模块示例 (简化版)
class FeatureFlagService {
  constructor() {
    // 可从远程配置中心或初始化时注入实验配置
    this.flags = {
      'new-lazy-load-strategy': {
        enabled: true,
        // 可能包含受众规则，如：用户ID在实验组B
        audienceRule: (userId) => this.isUserInExperimentGroupB(userId)
      },
      'optimized-data-fetch': {
        enabled: false
      }
    };
  }

  isEnabled(flagName, context = {}) {
    const flag = this.flags[flagName];
    if (!flag) return false;
    if (flag.audienceRule) {
      return flag.enabled && flag.audienceRule(context.userId);
    }
    return flag.enabled;
  }

  isUserInExperimentGroupB(userId) {
    // 简单的确定性哈希分桶算法，确保同一用户始终在同一分组
    const hash = this.stringToHash(userId);
    return hash % 100 < 10; // 假设10%的用户进入实验组B
  }

  stringToHash(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; // 转换为32位整数
    }
    return Math.abs(hash);
  }
}

// 在图片懒加载组件中使用特性开关
const featureFlag = new FeatureFlagService();
const userId = getCurrentUserId(); // 获取当前用户ID

if (featureFlag.isEnabled('new-lazy-load-strategy', { userId })) {
  // 使用新的自适应懒加载逻辑
  initAdaptiveLazyLoad();
} else {
  // 使用原有的懒加载逻辑
  initTraditionalLazyLoad();
}

// 性能指标收集与上报示例
class ExperimentMetricsCollector {
  constructor(experimentId, variant) {
    this.experimentId = experimentId; // 实验唯一标识
    this.variant = variant; // 'control' 或 'treatment-B'
    this.metrics = {};
  }

  // 标记实验开始
  markStart() {
    performance.mark(`exp-${this.experimentId}-start`);
    this.reportEvent('experiment_impression', { variant: this.variant });
  }

  // 收集LCP
  trackLCP() {
    const observer = new PerformanceObserver((entryList) => {
      const entries = entryList.getEntries();
      const lastEntry = entries[entries.length - 1];
      this.metrics.lcp = lastEntry.startTime;
      this.reportMetric('lcp', lastEntry.startTime);

      // 同时上报实验上下文
      this.reportEvent('lcp_measured', {
        value: lastEntry.startTime,
        variant: this.variant
      });
    });
    observer.observe({ type: 'largest-contentful-paint', buffered: true });
  }

  // 收集自定义首屏图片加载时间
  trackFirstScreenImages() {
    const firstScreenImages = Array.from(document.images).filter(img => {
      const rect = img.getBoundingClientRect();
      return rect.top < window.innerHeight && rect.left < window.innerWidth;
    });

    const loadPromises = firstScreenImages.map(img => {
      if (img.complete) return Promise.resolve();
      return new Promise(resolve => {
        img.addEventListener('load', resolve);
        img.addEventListener('error', resolve); // 错误也算加载结束
      });
    });

    Promise.all(loadPromises).then(() => {
      const loadTime = performance.now();
      this.metrics.firstScreenImageLoad = loadTime;
      this.reportMetric('first_screen_image_load', loadTime);
    });
  }

  reportMetric(name, value) {
    // 上报到数据分析平台，需携带实验ID和变体信息
    const data = {
      experiment_id: this.experimentId,
      variant: this.variant,
      metric_name: name,
      metric_value: value,
      timestamp: Date.now()
    };
    console.log('[Metric Reported]', data);
    // 实际使用中替换为真实的上报API，如 navigator.sendBeacon
    // analyticsSDK.send('metric', data);
  }

  reportEvent(eventName, properties) {
    // 上报事件
    const eventData = {
      event: eventName,
      properties: { ...properties, experiment_id: this.experimentId },
      timestamp: Date.now()
    };
    console.log('[Event Reported]', eventData);
    // analyticsSDK.send('event', eventData);
  }
}

// 在页面初始化时启动收集器
const collector = new ExperimentMetricsCollector('lazy_load_v2', 'treatment-B');
collector.markStart();
collector.trackLCP();
collector.trackFirstScreenImages();