/**
 * Leaderboard Badges System
 * Cosmetic badges for leaderboard achievements
 */

export interface Badge {
  id: string;
  name: string;
  description: string;
  icon: string;
  rarity: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
  category: 'achievement' | 'ranking' | 'event' | 'seasonal';
  requirement: {
    type: 'rank' | 'wins' | 'spins' | 'wagered' | 'event' | 'milestone';
    value: number;
    gameId?: string;
    eventId?: string;
  };
  unlockedAt?: Date;
  displayOrder: number;
}

export class LeaderboardBadges {
  private static badges: Map<string, Badge> = new Map();

  /**
   * Initialize preset badges
   */
  static initializePresetBadges(): void {
    // Ranking Badges
    this.createBadge({
      name: 'Top 100 Player',
      description: 'Reached top 100 on global leaderboard',
      icon: '🥉',
      rarity: 'uncommon',
      category: 'ranking',
      requirement: { type: 'rank', value: 100 },
      displayOrder: 1,
    });

    this.createBadge({
      name: 'Top 50 Player',
      description: 'Reached top 50 on global leaderboard',
      icon: '🥈',
      rarity: 'rare',
      category: 'ranking',
      requirement: { type: 'rank', value: 50 },
      displayOrder: 2,
    });

    this.createBadge({
      name: 'Top 10 Elite',
      description: 'Reached top 10 on global leaderboard',
      icon: '🥇',
      rarity: 'epic',
      category: 'ranking',
      requirement: { type: 'rank', value: 10 },
      displayOrder: 3,
    });

    this.createBadge({
      name: 'Leaderboard Champion',
      description: 'Reached #1 on global leaderboard',
      icon: '👑',
      rarity: 'legendary',
      category: 'ranking',
      requirement: { type: 'rank', value: 1 },
      displayOrder: 4,
    });

    // Achievement Badges
    this.createBadge({
      name: 'Big Winner',
      description: 'Won $1,000 in a single spin',
      icon: '💰',
      rarity: 'rare',
      category: 'achievement',
      requirement: { type: 'wins', value: 1000 },
      displayOrder: 5,
    });

    this.createBadge({
      name: 'Mega Winner',
      description: 'Won $5,000 in a single spin',
      icon: '💎',
      rarity: 'epic',
      category: 'achievement',
      requirement: { type: 'wins', value: 5000 },
      displayOrder: 6,
    });

    this.createBadge({
      name: 'Spin Master',
      description: 'Completed 1,000 spins',
      icon: '🎯',
      rarity: 'uncommon',
      category: 'achievement',
      requirement: { type: 'spins', value: 1000 },
      displayOrder: 7,
    });

    this.createBadge({
      name: 'Spin Legend',
      description: 'Completed 10,000 spins',
      icon: '⚡',
      rarity: 'epic',
      category: 'achievement',
      requirement: { type: 'spins', value: 10000 },
      displayOrder: 8,
    });

    this.createBadge({
      name: 'High Roller',
      description: 'Wagered $10,000 total',
      icon: '💵',
      rarity: 'rare',
      category: 'achievement',
      requirement: { type: 'wagered', value: 10000 },
      displayOrder: 9,
    });

    this.createBadge({
      name: 'VIP Roller',
      description: 'Wagered $50,000 total',
      icon: '💳',
      rarity: 'epic',
      category: 'achievement',
      requirement: { type: 'wagered', value: 50000 },
      displayOrder: 10,
    });

    // Event Badges
    this.createBadge({
      name: 'Summer Champion',
      description: 'Won Summer Spin Challenge',
      icon: '☀️',
      rarity: 'epic',
      category: 'event',
      requirement: { type: 'event', value: 1, eventId: 'event_summer_2026' },
      displayOrder: 11,
    });

    this.createBadge({
      name: 'Holiday Winner',
      description: 'Won Holiday Jackpot Blitz',
      icon: '🎄',
      rarity: 'epic',
      category: 'event',
      requirement: { type: 'event', value: 1, eventId: 'event_holiday_2026' },
      displayOrder: 12,
    });

    this.createBadge({
      name: 'Spring Bloomer',
      description: 'Won Spring Mega Spin',
      icon: '🌸',
      rarity: 'rare',
      category: 'event',
      requirement: { type: 'event', value: 1, eventId: 'event_spring_2026' },
      displayOrder: 13,
    });

    this.createBadge({
      name: 'Fall Festival Winner',
      description: 'Won Fall Festival',
      icon: '🍂',
      rarity: 'rare',
      category: 'event',
      requirement: { type: 'event', value: 1, eventId: 'event_fall_2026' },
      displayOrder: 14,
    });

    // Seasonal Badges
    this.createBadge({
      name: 'Event Participant',
      description: 'Participated in a seasonal event',
      icon: '🎪',
      rarity: 'common',
      category: 'seasonal',
      requirement: { type: 'event', value: 1 },
      displayOrder: 15,
    });

    this.createBadge({
      name: 'Multi-Event Champion',
      description: 'Won 3 seasonal events',
      icon: '🏆',
      rarity: 'legendary',
      category: 'seasonal',
      requirement: { type: 'event', value: 3 },
      displayOrder: 16,
    });
  }

  /**
   * Create badge
   */
  private static createBadge(badge: Omit<Badge, 'id'>): Badge {
    const id = `badge_${badge.name.toLowerCase().replace(/\s+/g, '_')}`;
    const fullBadge: Badge = { ...badge, id };
    this.badges.set(id, fullBadge);
    return fullBadge;
  }

  /**
   * Get all badges
   */
  static getAllBadges(): Badge[] {
    return Array.from(this.badges.values()).sort((a, b) => a.displayOrder - b.displayOrder);
  }

  /**
   * Get badge by ID
   */
  static getBadge(badgeId: string): Badge | null {
    return this.badges.get(badgeId) || null;
  }

  /**
   * Get badges by category
   */
  static getBadgesByCategory(category: string): Badge[] {
    return Array.from(this.badges.values())
      .filter((b) => b.category === category)
      .sort((a, b) => a.displayOrder - b.displayOrder);
  }

  /**
   * Get badges by rarity
   */
  static getBadgesByRarity(rarity: string): Badge[] {
    return Array.from(this.badges.values())
      .filter((b) => b.rarity === rarity)
      .sort((a, b) => a.displayOrder - b.displayOrder);
  }

  /**
   * Check if player earned badge
   */
  static async checkBadgeEarned(userId: string, badgeId: string): Promise<boolean> {
    // In production, query player_badges table
    return false;
  }

  /**
   * Award badge to player
   */
  static async awardBadge(userId: string, badgeId: string): Promise<void> {
    const badge = this.getBadge(badgeId);
    if (!badge) return;

    // In production, insert into player_badges table
    console.log(`[Badge] Awarded ${badge.name} to player ${userId}`);
  }

  /**
   * Get player badges
   */
  static async getPlayerBadges(userId: string): Promise<Badge[]> {
    // In production, query player_badges table
    return [];
  }

  /**
   * Get badge progress for player
   */
  static async getBadgeProgress(userId: string, badgeId: string): Promise<{ current: number; required: number; percentage: number }> {
    const badge = this.getBadge(badgeId);
    if (!badge) return { current: 0, required: 0, percentage: 0 };

    // In production, calculate based on player stats
    return {
      current: 0,
      required: badge.requirement.value,
      percentage: 0,
    };
  }

  /**
   * Get badge rarity color
   */
  static getRarityColor(rarity: string): string {
    switch (rarity) {
      case 'common':
        return '#808080';
      case 'uncommon':
        return '#00AA00';
      case 'rare':
        return '#0055FF';
      case 'epic':
        return '#AA00FF';
      case 'legendary':
        return '#FFAA00';
      default:
        return '#FFFFFF';
    }
  }

  /**
   * Get badge rarity name
   */
  static getRarityName(rarity: string): string {
    return rarity.charAt(0).toUpperCase() + rarity.slice(1);
  }
}

// Initialize badges on module load
LeaderboardBadges.initializePresetBadges();