/**
 * Badge Leaderboards System
 * Leaderboards for badge collection achievements
 */

export interface BadgeLeaderboardEntry {
  rank: number;
  userId: string;
  playerName: string;
  totalBadges: number;
  legendaryBadges: number;
  epicBadges: number;
  rareBadges: number;
  commonBadges: number;
  streak: number;
  lastBadgeUnlock: Date;
}

export class BadgeLeaderboards {
  /**
   * Get most badges leaderboard
   */
  static async getMostBadgesLeaderboard(limit: number = 100): Promise<BadgeLeaderboardEntry[]> {
    // In production, query badge_leaderboard table
    return [
      {
        rank: 1,
        userId: 'user_1',
        playerName: 'BadgeHunter',
        totalBadges: 16,
        legendaryBadges: 2,
        epicBadges: 5,
        rareBadges: 6,
        commonBadges: 3,
        streak: 12,
        lastBadgeUnlock: new Date(),
      },
      {
        rank: 2,
        userId: 'user_2',
        playerName: 'CollectorPro',
        totalBadges: 14,
        legendaryBadges: 1,
        epicBadges: 4,
        rareBadges: 6,
        commonBadges: 3,
        streak: 8,
        lastBadgeUnlock: new Date(Date.now() - 2 * 24 * 60 * 60 * 1000),
      },
      {
        rank: 3,
        userId: 'user_3',
        playerName: 'AchievementSeeker',
        totalBadges: 12,
        legendaryBadges: 0,
        epicBadges: 3,
        rareBadges: 6,
        commonBadges: 3,
        streak: 5,
        lastBadgeUnlock: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000),
      },
    ].slice(0, limit);
  }

  /**
   * Get rarest badges leaderboard
   */
  static async getRarestBadgesLeaderboard(limit: number = 100): Promise<BadgeLeaderboardEntry[]> {
    // In production, query and sort by legendary/epic badge count
    return [
      {
        rank: 1,
        userId: 'user_1',
        playerName: 'LegendaryHunter',
        totalBadges: 8,
        legendaryBadges: 3,
        epicBadges: 4,
        rareBadges: 1,
        commonBadges: 0,
        streak: 15,
        lastBadgeUnlock: new Date(),
      },
      {
        rank: 2,
        userId: 'user_2',
        playerName: 'EpicCollector',
        totalBadges: 10,
        legendaryBadges: 1,
        epicBadges: 6,
        rareBadges: 2,
        commonBadges: 1,
        streak: 10,
        lastBadgeUnlock: new Date(Date.now() - 1 * 24 * 60 * 60 * 1000),
      },
    ].slice(0, limit);
  }

  /**
   * Get badge streak leaderboard
   */
  static async getBadgeStreakLeaderboard(limit: number = 100): Promise<BadgeLeaderboardEntry[]> {
    // In production, query and sort by streak count
    return [
      {
        rank: 1,
        userId: 'user_1',
        playerName: 'StreakMaster',
        totalBadges: 12,
        legendaryBadges: 1,
        epicBadges: 4,
        rareBadges: 5,
        commonBadges: 2,
        streak: 20,
        lastBadgeUnlock: new Date(),
      },
      {
        rank: 2,
        userId: 'user_2',
        playerName: 'ConsistentPlayer',
        totalBadges: 10,
        legendaryBadges: 0,
        epicBadges: 3,
        rareBadges: 5,
        commonBadges: 2,
        streak: 15,
        lastBadgeUnlock: new Date(),
      },
    ].slice(0, limit);
  }

  /**
   * Get badge collection leaderboard
   */
  static async getBadgeCollectionLeaderboard(limit: number = 100): Promise<BadgeLeaderboardEntry[]> {
    // In production, query badge_leaderboard table
    return await this.getMostBadgesLeaderboard(limit);
  }

  /**
   * Get player badge rank
   */
  static async getPlayerBadgeRank(userId: string): Promise<{
    overallRank: number;
    totalBadges: number;
    percentile: number;
  }> {
    // In production, query badge_leaderboard table
    return {
      overallRank: 42,
      totalBadges: 8,
      percentile: 75,
    };
  }

  /**
   * Get badge collection progress
   */
  static async getBadgeCollectionProgress(userId: string): Promise<{
    collected: number;
    total: number;
    percentage: number;
    nextBadge: string;
    daysToNextBadge: number;
  }> {
    // In production, calculate based on player badges and requirements
    return {
      collected: 8,
      total: 16,
      percentage: 50,
      nextBadge: 'Top 50 Player',
      daysToNextBadge: 3,
    };
  }

  /**
   * Get badge rarity distribution
   */
  static async getBadgeRarityDistribution(userId: string): Promise<{
    legendary: number;
    epic: number;
    rare: number;
    uncommon: number;
    common: number;
  }> {
    // In production, query player badges and count by rarity
    return {
      legendary: 0,
      epic: 2,
      rare: 3,
      uncommon: 2,
      common: 1,
    };
  }

  /**
   * Get trending badge collectors
   */
  static async getTrendingBadgeCollectors(limit: number = 20): Promise<BadgeLeaderboardEntry[]> {
    // In production, query players with recent badge unlocks
    return [
      {
        rank: 1,
        userId: 'user_1',
        playerName: 'RisingCollector',
        totalBadges: 6,
        legendaryBadges: 0,
        epicBadges: 2,
        rareBadges: 3,
        commonBadges: 1,
        streak: 8,
        lastBadgeUnlock: new Date(),
      },
      {
        rank: 2,
        userId: 'user_2',
        playerName: 'NewHunter',
        totalBadges: 4,
        legendaryBadges: 0,
        epicBadges: 1,
        rareBadges: 2,
        commonBadges: 1,
        streak: 4,
        lastBadgeUnlock: new Date(Date.now() - 1 * 60 * 60 * 1000),
      },
    ].slice(0, limit);
  }

  /**
   * Get badge unlock statistics
   */
  static async getBadgeUnlockStats(): Promise<{
    totalUnlocks: number;
    uniquePlayers: number;
    mostCommonBadge: string;
    rariestBadge: string;
    averageBadgesPerPlayer: number;
  }> {
    // In production, query badge statistics
    return {
      totalUnlocks: 50000,
      uniquePlayers: 5000,
      mostCommonBadge: 'Event Participant',
      rariestBadge: 'Leaderboard Champion',
      averageBadgesPerPlayer: 10,
    };
  }

  /**
   * Get badge comparison between players
   */
  static async compareBadges(userId1: string, userId2: string): Promise<{
    player1: { name: string; badges: number; rare: number };
    player2: { name: string; badges: number; rare: number };
    difference: number;
  }> {
    // In production, query both players' badges
    return {
      player1: { name: 'Player1', badges: 10, rare: 4 },
      player2: { name: 'Player2', badges: 8, rare: 3 },
      difference: 2,
    };
  }

  /**
   * Get badge milestone rewards
   */
  static getBadgeMilestoneRewards(totalBadges: number): {
    milestone: number;
    reward: string;
    cosmetics: string[];
  }[] {
    return [
      { milestone: 5, reward: '500 SC', cosmetics: ['badge_collector_5_frame'] },
      { milestone: 10, reward: '1000 SC', cosmetics: ['badge_collector_10_badge', 'badge_collector_10_title'] },
      { milestone: 16, reward: '2000 SC', cosmetics: ['badge_master_crown', 'badge_master_title', 'badge_master_frame'] },
    ].filter((m) => m.milestone <= totalBadges);
  }

  /**
   * Get next badge milestone
   */
  static getNextBadgeMilestone(totalBadges: number): { milestone: number; remaining: number; reward: string } | null {
    const milestones = [5, 10, 16];
    const next = milestones.find((m) => m > totalBadges);

    if (!next) return null;

    const rewards: Record<number, string> = {
      5: '500 SC + Cosmetic',
      10: '1000 SC + 2 Cosmetics',
      16: '2000 SC + 3 Cosmetics',
    };

    return {
      milestone: next,
      remaining: next - totalBadges,
      reward: rewards[next] || 'Reward',
    };
  }
}