interface AdSource {
  name: string;
  platform: PlatformName;
  adUnitId: string;
  type: 'reward' | 'interstitial' | 'banner' | 'fullscreen';
  priority: number; // Waterfall 优先级
  timeout: number;  // 超时时间 ms
  minECPM?: number; // Header Bidding 最低出价
}

interface BidResponse {
  source: string;
  bidPrice: number; // eCPM
  currency: string;
  ttl: number;      // 出价有效期
  adPayload?: any;  // 广告素材
}

class AdMediator {
  private sources: AdSource[] = [];
  private cache = new Map<string, { ad: any; expiry: number }>();
  private profile: PlatformProfile;

  constructor(profile: PlatformProfile) {
    this.profile = profile;
    this.initDefaultSources();
  }

  private initDefaultSources(): void {
    // 根据平台动态选择广告源
    if (this.profile.name === 'wechat') {
      this.sources = [
        { name: 'wechat_reward', platform: 'wechat', adUnitId: 'ad_xxx1', type: 'reward', priority: 1, timeout: 3000 },
        { name: 'gdt_reward', platform: 'wechat', adUnitId: 'ad_xxx2', type: 'reward', priority: 2, timeout: 3000 },
      ];
    } else if (this.profile.name === 'tiktok') {
      this.sources = [
        { name: 'pangle_reward', platform: 'tiktok', adUnitId: 'ad_yyy1', type: 'reward', priority: 1, timeout: 3000 },
      ];
    }
    // Web 环境使用 AdSense / AdMob
  }

  // 核心：混合出价
  async fetchAd(adType: 'reward' | 'interstitial'): Promise<any> {
    // Phase 1: Header Bidding（并行竞价）
    const hbSources = this.sources.filter(s => s.type === adType && s.minECPM);
    const bids = await Promise.all(
      hbSources.map(s => this.fetchBid(s).catch(() => null))
    );
    const validBids = bids.filter(Boolean) as BidResponse[];

    if (validBids.length > 0) {
      validBids.sort((a, b) => b.bidPrice - a.bidPrice);
      const winner = validBids[0];
      console.log(`[AdMediator] Header Bidding winner: ${winner.source} @ ${winner.bidPrice}`);
      return this.loadAdFromBid(winner);
    }

    // Phase 2: Waterfall（串行回退）
    const wfSources = this.sources
      .filter(s => s.type === adType)
      .sort((a, b) => a.priority - b.priority);

    for (const source of wfSources) {
      try {
        const ad = await this.loadAdWithTimeout(source);
        if (ad) {
          console.log(`[AdMediator] Waterfall filled by: ${source.name}`);
          return ad;
        }
      } catch (e) {
        console.warn(`[AdMediator] ${source.name} failed:`, e);
      }
    }

    throw new Error('No ad available from all sources');
  }

  private async fetchBid(source: AdSource): Promise<BidResponse | null> {
    // 调用各平台 bidding SDK
    switch (source.platform) {
      case 'wechat':
        return this.fetchWeChatBid(source);
      case 'tiktok':
        return this.fetchPangleBid(source);
      default:
        return null;
    }
  }

  private async fetchWeChatBid(source: AdSource): Promise<BidResponse | null> {
    // 微信不支持真正的 Header Bidding，模拟基于历史 eCPM 预估
    const historicalECPM = this.getHistoricalECPM(source.name);
    if (historicalECPM < (source.minECPM || 0)) return null;

    return {
      source: source.name,
      bidPrice: historicalECPM,
      currency: 'CNY',
      ttl: 30000,
    };
  }

  private async loadAdWithTimeout(source: AdSource): Promise<any> {
    const adapter = PlatformAdapterFactory.create();
    // 使用统一的 PlatformAdapter 接口加载广告
    switch (source.type) {
      case 'reward':
        return adapter.showRewardAd({ adUnitId: source.adUnitId });
      case 'interstitial':
        return adapter.showInterstitialAd({ adUnitId: source.adUnitId });
      default:
        return null;
    }
  }

  private getHistoricalECPM(sourceName: string): number {
    // 从本地存储或后端获取历史 eCPM
    const history = JSON.parse(localStorage.getItem(`ecpm_${sourceName}`) || '[]');
    if (history.length === 0) return 50;
    return history.reduce((s: number, v: number) => s + v, 0) / history.length;
  }

  // 展示频率控制
  private impressionCounters = new Map<string, { count: number; date: string }>();

  canShow(adType: string, userId: string): boolean {
    const key = `${userId}_${adType}`;
    const today = new Date().toISOString().slice(0, 10);
    const counter = this.impressionCounters.get(key);

    if (!counter || counter.date !== today) {
      this.impressionCounters.set(key, { count: 0, date: today });
      return true;
    }

    // 每日频次上限
    const limits: Record<string, number> = {
      reward: 8,
      interstitial: 12,
      banner: 999,
    };

    return counter.count < (limits[adType] || 10);
  }
}

interface AdPlacement {
  id: string;
  type: 'reward' | 'interstitial' | 'banner';
  trigger: 'user_action' | 'level_complete' | 'game_over' | 'natural_break' | 'continuous';
  cooldown: number; // 两次展示间隔（秒）
  dailyCap: number;
  eCPMTarget: number;
}

const AD_PLACEMENTS: AdPlacement[] = [
  { id: 'reward_revive', type: 'reward', trigger: 'user_action', cooldown: 0, dailyCap: 10, eCPMTarget: 120 },
  { id: 'reward_double_coin', type: 'reward', trigger: 'user_action', cooldown: 0, dailyCap: 20, eCPMTarget: 100 },
  { id: 'interstitial_level_complete', type: 'interstitial', trigger: 'level_complete', cooldown: 60, dailyCap: 8, eCPMTarget: 50 },
  { id: 'interstitial_game_over', type: 'interstitial', trigger: 'game_over', cooldown: 30, dailyCap: 6, eCPMTarget: 40 },
  { id: 'banner_bottom', type: 'banner', trigger: 'continuous', cooldown: 0, dailyCap: 999, eCPMTarget: 10 },
];

type ProductType = 'consumable' | 'non-consumable' | 'subscription' | 'battle-pass';

interface Product {
  id: string;
  type: ProductType;
  name: string;
  description: string;
  price: number;
  currency: 'CNY' | 'USD';
  icon: string;
  rewards: Reward[];
  // 订阅特有
  subscriptionInfo?: {
    interval: 'week' | 'month' | 'year';
    trialDays: number;
    benefits: string[];
  };
  // 战令特有
  battlePassInfo?: {
    season: number;
    durationDays: number;
    tiers: BattlePassTier[];
  };
}

interface Reward {
  type: 'coin' | 'gem' | 'item' | 'skin' | 'boost';
  id: string;
  quantity: number;
}

interface BattlePassTier {
  level: number;
  freeReward?: Reward;
  premiumReward: Reward;
}

class IAPManager {
  private inventory = new Map<string, number>(); // productId -> 拥有数量
  private subscriptions = new Map<string, { expiry: number }>();
  private battlePassProgress = new Map<number, { tier: number; premium: boolean }>();
  private adapter: PlatformAdapter;

  constructor() {
    this.adapter = PlatformAdapterFactory.create();
    this.loadInventory();
  }

  async purchase(product: Product): Promise<PurchaseResult> {
    // 验证：订阅检查是否已有活跃订阅
    if (product.type === 'subscription') {
      const existing = this.subscriptions.get(product.id);
      if (existing && existing.expiry > Date.now()) {
        return { success: false, error: 'Already subscribed' };
      }
    }

    // 调用平台支付
    const order: IAPOrder = {
      orderId: `ord_${Date.now()}`,
      productId: product.id,
      quantity: 1,
    };

    const receipt = await this.adapter.purchase(order);
    if (!receipt.success) {
      return { success: false, error: receipt.error?.message };
    }

    // 发放奖励
    await this.deliverProduct(product, receipt);

    return { success: true, receipt };
  }

  private async deliverProduct(product: Product, receipt: IAPReceipt): Promise<void> {
    switch (product.type) {
      case 'consumable':
        for (const reward of product.rewards) {
          const current = this.inventory.get(reward.id) || 0;
          this.inventory.set(reward.id, current + reward.quantity);
        }
        break;

      case 'non-consumable':
        this.inventory.set(product.id, 1);
        break;

      case 'subscription':
        const days = product.subscriptionInfo!.interval === 'month' ? 30 : 365;
        this.subscriptions.set(product.id, {
          expiry: Date.now() + days * 24 * 60 * 60 * 1000,
        });
        break;

      case 'battle-pass':
        this.battlePassProgress.set(product.battlePassInfo!.season, {
          tier: 0,
          premium: true,
        });
        break;
    }

    await this.saveInventory();
  }

  hasSubscription(productId: string): boolean {
    const sub = this.subscriptions.get(productId);
    return !!sub && sub.expiry > Date.now();
  }

  getBattlePassProgress(season: number): { tier: number; premium: boolean } | null {
    return this.battlePassProgress.get(season) || null;
  }

  async saveInventory(): Promise<void> {
    const data = {
      inventory: Object.fromEntries(this.inventory),
      subscriptions: Object.fromEntries(this.subscriptions),
      battlePass: Object.fromEntries(this.battlePassProgress),
    };
    localStorage.setItem('iap_inventory', JSON.stringify(data));
  }

  private loadInventory(): void {
    const raw = localStorage.getItem('iap_inventory');
    if (!raw) return;
    try {
      const data = JSON.parse(raw);
      this.inventory = new Map(Object.entries(data.inventory || {}));
      this.subscriptions = new Map(Object.entries(data.subscriptions || {}));
      this.battlePassProgress = new Map(Object.entries(data.battlePass || {}));
    } catch {}
  }
}

interface PurchaseResult {
  success: boolean;
  receipt?: IAPReceipt;
  error?: string;
}

interface RetentionCurve {
  day1: number;   // 首日留存率
  day7: number;
  day14: number;
  day30: number;
  day60: number;
  day90: number;
}

class LTVEstimator {
  // 基于留存曲线估算 LTV
  estimateLTV(
    arpdau: number, // 每活跃用户日均收入
    retention: RetentionCurve
  ): number {
    // 简单积分法：假设 180 天生命周期
    const dailyRetentions = this.interpolateRetention(retention);
    let ltv = 0;
    for (let day = 1; day <= 180; day++) {
      const retentionRate = dailyRetentions[day] || 0;
      ltv += arpdau * retentionRate;
    }
    return ltv;
  }

  // 留存曲线插值
  private interpolateRetention(curve: RetentionCurve): number[] {
    const points = [
      { day: 1, val: curve.day1 },
      { day: 7, val: curve.day7 },
      { day: 14, val: curve.day14 },
      { day: 30, val: curve.day30 },
      { day: 60, val: curve.day60 },
      { day: 90, val: curve.day90 },
    ];

    const result: number[] = [0]; // day 0
    for (let i = 0; i < points.length - 1; i++) {
      const start = points[i];
      const end = points[i + 1];
      for (let day = start.day; day < end.day; day++) {
        const t = (day - start.day) / (end.day - start.day);
        // 对数衰减插值
        const logStart = Math.log(start.val + 0.01);
        const logEnd = Math.log(end.val + 0.01);
        result[day] = Math.exp(logStart + t * (logEnd - logStart)) - 0.01;
      }
    }
    // 90 天后指数衰减
    for (let day = 90; day <= 180; day++) {
      result[day] = result[day - 1] * 0.995;
    }

    return result;
  }

  // 基于首日行为的分群 LTV 预测
  estimateByCohort(cohort: UserCohort): number {
    const baseARPDAU = 0.5; // 基准
    const multiplier =
      (cohort.day1SessionCount * 0.1) +
      (cohort.day1AdViews * 0.02) +
      (cohort.hasIAP ? 2.0 : 0) +
      (cohort.socialShares * 0.15);

    const arpdau = baseARPDAU * (1 + multiplier);
    return this.estimateLTV(arpdau, cohort.retention);
  }
}

interface UserCohort {
  cohortDate: string;
  size: number;
  day1SessionCount: number;
  day1AdViews: number;
  hasIAP: boolean;
  socialShares: number;
  retention: RetentionCurve;
}

class CACCalculator {
  // CAC = 总营销支出 / 新增用户数
  calculateCAC(spend: MarketingSpend, newUsers: number): number {
    const totalSpend =
      spend.paidAds +
      spend.influencer +
      spend.contentMarketing +
      spend.events +
      spend.other;
    return totalSpend / newUsers;
  }

  // LTV / CAC 比率
  getUnitEconomics(ltv: number, cac: number): {
    ratio: number;
    paybackPeriod: number; // 月
    isHealthy: boolean;
  } {
    const ratio = ltv / cac;
    // 假设 ARPU 线性增长，回收期 = CAC / 月 ARPU
    const monthlyARPU = ltv / 6; // 简化：LTV 约等于 6 个月 ARPU
    const paybackPeriod = cac / monthlyARPU;

    return {
      ratio,
      paybackPeriod,
      isHealthy: ratio >= 3 && paybackPeriod <= 12,
    };
  }
}

interface MarketingSpend {
  paidAds: number;
  influencer: number;
  contentMarketing: number;
  events: number;
  other: number;
}

interface AnalyticsEvent {
  event: string;
  userId: string;
  timestamp: number;
  properties: Record<string, any>;
}

class MonetizationAnalytics {
  private events: AnalyticsEvent[] = [];
  private flushThreshold = 50;

  track(event: string, properties: Record<string, any>): void {
    this.events.push({
      event,
      userId: this.getUserId(),
      timestamp: Date.now(),
      properties,
    });

    if (this.events.length >= this.flushThreshold) {
      this.flush();
    }
  }

  // 预置追踪事件
  trackAdImpression(adType: string, source: string, eCPM: number): void {
    this.track('ad_impression', { adType, source, eCPM });
  }

  trackAdClick(adType: string, source: string): void {
    this.track('ad_click', { adType, source });
  }

  trackPurchase(productId: string, revenue: number, currency: string): void {
    this.track('purchase', { productId, revenue, currency });
  }

  trackLevelStart(level: number): void {
    this.track('level_start', { level });
  }

  trackLevelComplete(level: number, score: number): void {
    this.track('level_complete', { level, score });
  }

  private flush(): void {
    // 发送到分析后端（如 Mixpanel、Amplitude、自建）
    const batch = this.events.splice(0, this.flushThreshold);
    fetch('/api/analytics/events', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(batch),
      keepalive: true,
    }).catch(() => {
      // 失败时重新入队
      this.events.unshift(...batch);
    });
  }

  private getUserId(): string {
    let id = localStorage.getItem('user_id');
    if (!id) {
      id = 'u_' + Math.random().toString(36).slice(2) + Date.now().toString(36);
      localStorage.setItem('user_id', id);
    }
    return id;
  }
}

interface FraudSignals {
  deviceId: string;
  ip: string;
  adViewsPerHour: number;
  adCompletionRate: number;
  timeToComplete: number; // 激励视频从 show 到 close 的时间
  deviceFarmIndicators: boolean;
  vpnUsage: boolean;
}

class FraudDetector {
  private rules: FraudRule[] = [
    {
      name: 'excessive_ad_views',
      check: (s: FraudSignals) => s.adViewsPerHour > 20,
      score: 30,
    },
    {
      name: 'impossible_completion_time',
      check: (s: FraudSignals) => s.timeToComplete < 3000, // < 3 秒不可能看完
      score: 50,
    },
    {
      name: 'abnormal_completion_rate',
      check: (s: FraudSignals) => s.adCompletionRate > 0.98 || s.adCompletionRate < 0.3,
      score: 20,
    },
    {
      name: 'device_farm',
      check: (s: FraudSignals) => s.deviceFarmIndicators,
      score: 80,
    },
    {
      name: 'vpn_spoofing',
      check: (s: FraudSignals) => s.vpnUsage,
      score: 15,
    },
  ];

  evaluate(signals: FraudSignals): FraudVerdict {
    let score = 0;
    const triggered: string[] = [];

    for (const rule of this.rules) {
      if (rule.check(signals)) {
        score += rule.score;
        triggered.push(rule.name);
      }
    }

    if (score >= 80) return { action: 'block', score, triggered };
    if (score >= 50) return { action: 'review', score, triggered };
    if (score >= 20) return { action: 'warn', score, triggered };
    return { action: 'allow', score, triggered };
  }
}

interface FraudRule {
  name: string;
  check: (signals: FraudSignals) => boolean;
  score: number;
}

interface FraudVerdict {
  action: 'allow' | 'warn' | 'review' | 'block';
  score: number;
  triggered: string[];
}

const DASHBOARD_METRICS = {
  // 广告
  adRequests: '广告请求数',
  adFillRate: '填充率',
  adImpressions: '展示数',
  adClicks: '点击数',
  adCTR: '点击率',
  adECPM: '千次展示收入',
  adRevenue: '广告收入',

  // IAP
  iapTransactions: '内购笔数',
  iapRevenue: '内购收入',
  iapARPU: '每用户平均收入',
  iapARPPU: '每付费用户平均收入',
  iapConversionRate: '付费转化率',

  // 综合
  dau: '日活跃用户',
  mau: '月活跃用户',
  retention: '留存率',
  ltv: '生命周期价值',
  cac: '获客成本',
  ltvCacRatio: 'LTV/CAC',
};