interface RemixChain {
  originalTemplateId: string;
  originalAuthorId: string;
  parentProjectId?: string;
  depth: number; // 衍生深度
}

class RemixEngine {
  private db: Database;

  async createRemix(
    userId: string,
    sourceProjectId: string,
    modifications: ProjectModification
  ): Promise<Project> {
    const source = await this.db.projects.get(sourceProjectId);
    if (!source) throw new Error('Source project not found');

    // 创建新项目，复制源项目资源
    const newProject = await this.db.projects.create({
      ownerId: userId,
      name: `${source.name} (Remix)`,
      sourceCode: modifications.applyTo(source.sourceCode),
      assets: { ...source.assets, ...modifications.newAssets },
      remixInfo: {
        originalTemplateId: source.remixInfo?.originalTemplateId || source.id,
        originalAuthorId: source.remixInfo?.originalAuthorId || source.ownerId,
        parentProjectId: source.id,
        depth: (source.remixInfo?.depth || 0) + 1,
      },
    });

    // 记录 Remix 关系
    await this.db.remixLinks.create({
      fromProjectId: sourceProjectId,
      toProjectId: newProject.id,
      createdAt: Date.now(),
    });

    // 给原作者发送通知
    await this.notifyRemix(source.ownerId, {
      sourceProject: source.name,
      remixAuthor: userId,
      remixProject: newProject.id,
    });

    return newProject;
  }

  // 获取 Remix 传播树
  async getRemixTree(projectId: string): Promise<RemixTreeNode> {
    const project = await this.db.projects.get(projectId);
    const children = await this.db.remixLinks
      .where('fromProjectId').equals(projectId)
      .toArray();

    return {
      projectId,
      authorId: project.ownerId,
      children: await Promise.all(
        children.map(c => this.getRemixTree(c.toProjectId))
      ),
    };
  }

  // 计算 Remix 带来的回流价值
  async calculateRemixValue(projectId: string): Promise<{
    totalRemixes: number;
    uniqueRemixers: number;
    depth: number;
    referralSignups: number; // 通过 Remix 链接注册的新用户
  }> {
    const tree = await this.getRemixTree(projectId);
    const stats = this.aggregateTree(tree);
    return stats;
  }

  private aggregateTree(node: RemixTreeNode): any {
    let totalRemixes = 0;
    let uniqueRemixers = new Set<string>();
    let maxDepth = 0;

    for (const child of node.children) {
      totalRemixes++;
      uniqueRemixers.add(child.authorId);
      const childStats = this.aggregateTree(child);
      totalRemixes += childStats.totalRemixes;
      childStats.uniqueRemixers.forEach((u: string) => uniqueRemixers.add(u));
      maxDepth = Math.max(maxDepth, childStats.maxDepth + 1);
    }

    return { totalRemixes, uniqueRemixers, depth: maxDepth };
  }
}

interface ReferralProgram {
  referrerCode: string;
  referrerId: string;
  rewards: {
    referrer: Reward[];
    referee: Reward[];
  };
  milestones: MilestoneReward[];
}

class ReferralSystem {
  private referrals = new Map<string, string>(); // code -> referrerId

  generateCode(userId: string): string {
    const code = `MP${userId.slice(0, 6).toUpperCase()}`;
    this.referrals.set(code, userId);
    return code;
  }

  async trackReferral(code: string, newUserId: string): Promise<void> {
    const referrerId = this.referrals.get(code);
    if (!referrerId || referrerId === newUserId) return;

    await this.db.referrals.create({
      referrerId,
      refereeId: newUserId,
      code,
      status: 'pending',
      createdAt: Date.now(),
    });
  }

  async checkMilestones(userId: string): Promise<MilestoneReward[]> {
    const referrals = await this.db.referrals
      .where('referrerId').equals(userId)
      .toArray();

    const activated = referrals.filter(r => r.status === 'activated');
    const rewards: MilestoneReward[] = [];

    // 里程碑奖励
    if (activated.length >= 3) rewards.push({ type: 'badge', name: 'recruiter', icon: '🎯' });
    if (activated.length >= 10) rewards.push({ type: 'credits', amount: 500 });
    if (activated.length >= 50) rewards.push({ type: 'feature', name: 'verified_creator' });

    return rewards;
  }
}

interface MilestoneReward {
  type: 'badge' | 'credits' | 'feature';
  name?: string;
  amount?: number;
  icon?: string;
}

interface GameJamEvent {
  id: string;
  name: string;
  theme: string;
  startTime: number;
  duration: number; // hours
  phases: JamPhase[];
  prizes: Prize[];
  judges: Judge[];
}

interface JamPhase {
  name: string;
  start: number;
  end: number;
  activities: Activity[];
}

const GAMEJAM_SOP: Record<string, string[]> = {
  'preparation': [
    '确定主题（开放/半开放/固定）',
    '设定规则（团队人数、引擎限制、资产来源）',
    '准备奖品（现金 + 平台积分 + 周边）',
    '邀请评委（知名开发者 + 平台运营）',
    '搭建报名页面（ itch.io / 自建）',
  ],
  'kickoff': [
    '直播公布主题（B站/抖音/YouTube）',
    '发送 starter kit（模板 + 教程）',
    'Discord 频道开放实时答疑',
    '每小时进度播报 + 鼓励',
  ],
  'voting': [
    '公众投票（创意/完成度/美术/音效）',
    '评委评分（权重 60%）',
    '观众投票（权重 40%）',
  ],
  'post-jam': [
    '获奖作品 Spotlight 展示',
    '邀请获奖者分享开发经验',
    '优秀作品签约入驻官方模板库',
  ],
};

interface EducationPartnership {
  university: string;
  department: string;
  type: 'course' | 'lab' | 'club' | 'competition';
  status: 'proposed' | 'active' | 'renewing';
  terms: {
    freeLicenses: number;
    duration: string;
    supportLevel: 'self-service' | 'email' | 'dedicated';
  };
  kpis: {
    studentsReached: number;
    projectsCreated: number;
    conversionToPaid: number;
  };
}

const EDU_TEMPLATES = {
  'intro_course': {
    name: '游戏开发入门',
    weeks: 12,
    syllabus: [
      { week: 1, topic: '平台介绍 + 第一个小游戏', assignment: 'Hello World Game' },
      { week: 2, topic: 'ECS 架构基础', assignment: '实体组件系统练习' },
      { week: 3, topic: '物理与碰撞', assignment: '平台跳跃原型' },
      { week: 4, topic: 'AI 辅助开发', assignment: '用文字生成关卡' },
      { week: 5, topic: '渲染与特效', assignment: '粒子系统实践' },
      { week: 6, topic: '跨平台发布', assignment: '微信小游戏发布' },
      { week: 7, topic: '商业化入门', assignment: '添加广告与 IAP' },
      { week: 8, topic: '期中项目', assignment: '完整小游戏 v0.5' },
      { week: 9, topic: '多人协作', assignment: '团队项目组建' },
      { week: 10, topic: '性能优化', assignment: 'Profiling 与优化' },
      { week: 11, topic: '发布准备', assignment: '最终打磨' },
      { week: 12, topic: '期末展示', assignment: '作品展示与评选' },
    ],
  },
};

interface CampusAmbassador {
  studentId: string;
  university: string;
  enrollmentDate: number;
  activities: Activity[];
  rewards: AmbassadorReward[];
}

type AmbassadorReward =
  | { type: 'certificate'; name: string }
  | { type: 'internship_offer'; department: string }
  | { type: 'credits'; amount: number }
  | { type: 'merchandise'; item: string };

const AMBASSADOR_TASKS = [
  { task: '组织一次 Workshop', points: 100 },
  { task: '发布一篇教程文章', points: 50 },
  { task: '邀请 5 位同学注册', points: 30 },
  { task: '帮助 3 位同学解决问题', points: 20 },
  { task: '在社交媒体分享平台', points: 10 },
];

interface ASOConfig {
  title: string;       // 含核心关键词，12 字以内
  subtitle: string;    // 补充描述，20 字以内
  keywords: string[];  // 隐藏关键词
  description: string; // 前 50 字最关键
  screenshots: Screenshot[];
  videoPreview?: string;
}

const ASO_BEST_PRACTICES = {
  title: 'MiniPlay - AI小游戏引擎',
  keywords: ['小游戏', '游戏引擎', '游戏开发', 'AI游戏', 'H5游戏'],
  description: `MiniPlay 是一款 AI 驱动的 H5 小游戏创作平台。

特色功能：
• 自然语言生成游戏关卡
• 一键发布到微信/抖音/快手
• 内置广告变现系统
• 海量模板与素材

零基础也能 7 天做出可上线的小游戏！`,
};

const WEEKLY_CONTENT_CALENDAR = {
  monday: { type: 'tutorial', title: '技术教程' },
  tuesday: { type: 'showcase', title: '作品 Spotlight' },
  wednesday: { type: 'ama', title: 'Ask Me Anything' },
  thursday: { type: 'changelog', title: '更新日志' },
  friday: { type: 'challenge', title: '周末挑战' },
  saturday: { type: 'community', title: '社区分享' },
  sunday: { type: 'newsletter', title: '周报' },
};

interface UserSegment {
  name: string;
  criteria: (user: UserProfile) => boolean;
  actions: SegmentAction[];
}

const USER_SEGMENTS: UserSegment[] = [
  {
    name: '沉睡用户',
    criteria: (u) => u.daysSinceLastActive > 7 && u.projectsCreated === 0,
    actions: [
      { type: 'email', content: '我们为您准备了一个入门模板' },
      { type: 'in_app', content: '完成首作获得 100 积分' },
    ],
  },
  {
    name: '活跃创作者',
    criteria: (u) => u.projectsCreated >= 3 && u.daysSinceLastActive <= 3,
    actions: [
      { type: 'email', content: '您有新模板推荐位资格' },
      { type: 'feature', content: 'unlock_advanced_analytics' },
    ],
  },
  {
    name: '高价值创作者',
    criteria: (u) => u.monthlyGMV > 1000,
    actions: [
      { type: 'email', content: '专属客户成功经理联系您' },
      { type: 'feature', content: 'priority_support' },
      { type: 'event', content: '邀请参加闭门分享会' },
    ],
  },
];

interface CohortData {
  cohortDate: string; // YYYY-MM-DD
  cohortSize: number;
  retention: number[]; // index 0 = Day 1, index 6 = Day 7, etc.
}

class CohortAnalyzer {
  analyze(data: CohortData[]): CohortReport {
    const avgRetention: number[] = [];
    const cohortCount = data.length;

    for (let day = 0; day < 30; day++) {
      let sum = 0;
      let count = 0;
      for (const cohort of data) {
        if (day < cohort.retention.length) {
          sum += cohort.retention[day];
          count++;
        }
      }
      avgRetention[day] = count > 0 ? sum / count : 0;
    }

    return {
      avgRetention,
      trends: this.detectTrends(data),
      bestCohort: this.findBestCohort(data),
      worstCohort: this.findWorstCohort(data),
    };
  }

  private detectTrends(data: CohortData[]): string[] {
    const trends: string[] = [];
    const recent = data.slice(-4); // 最近 4 个 cohort
    const older = data.slice(0, 4); // 最早 4 个 cohort

    const recentD7 = recent.reduce((s, c) => s + (c.retention[6] || 0), 0) / recent.length;
    const olderD7 = older.reduce((s, c) => s + (c.retention[6] || 0), 0) / older.length;

    if (recentD7 < olderD7 * 0.8) {
      trends.push(`⚠️ Day-7 retention declining: ${(olderD7 * 100).toFixed(1)}% → ${(recentD7 * 100).toFixed(1)}%`);
    }

    return trends;
  }

  private findBestCohort(data: CohortData[]): CohortData | null {
    return data.reduce((best, current) => {
      const bestD7 = best?.retention[6] || 0;
      const currentD7 = current.retention[6] || 0;
      return currentD7 > bestD7 ? current : best;
    }, null as CohortData | null);
  }

  private findWorstCohort(data: CohortData[]): CohortData | null {
    return data.reduce((worst, current) => {
      const worstD7 = worst?.retention[6] || 1;
      const currentD7 = current.retention[6] || 1;
      return currentD7 < worstD7 ? current : worst;
    }, null as CohortData | null);
  }
}

interface CohortReport {
  avgRetention: number[];
  trends: string[];
  bestCohort: CohortData | null;
  worstCohort: CohortData | null;
}