/**
 * Battle Pass Service
 * Manages seasonal battle pass progression and rewards
 */

export interface BattlePassTier {
  tier: number;
  name: string;
  description: string;
  requiredXP: number;
  freeReward: string;
  premiumReward: string;
}

export interface BattlePassChallenge {
  id: string;
  name: string;
  description: string;
  type: 'daily' | 'weekly';
  target: number;
  reward: number;
}

export interface PlayerBattlePassProgress {
  userId: number;
  eventId: string;
  currentTier: number;
  currentXP: number;
  totalXP: number;
  isPremium: boolean;
  completedChallenges: string[];
  claimedRewards: number[];
}

// Battle pass tiers (50 tiers total)
const BATTLE_PASS_TIERS: BattlePassTier[] = Array.from({ length: 50 }, (_, i) => ({
  tier: i + 1,
  name: `Tier ${i + 1}`,
  description: `Reach tier ${i + 1}`,
  requiredXP: (i + 1) * 1000,
  freeReward: `${(i + 1) * 100} SC`,
  premiumReward: `${(i + 1) * 500} SC`,
}));

// Daily challenges
const DAILY_CHALLENGES: BattlePassChallenge[] = [
  {
    id: 'daily_spins',
    name: 'Daily Spinner',
    description: 'Play 20 spins',
    type: 'daily',
    target: 20,
    reward: 100,
  },
  {
    id: 'daily_wins',
    name: 'Lucky Wins',
    description: 'Win 5 games',
    type: 'daily',
    target: 5,
    reward: 150,
  },
  {
    id: 'daily_streak',
    name: 'Win Streak',
    description: 'Get a 3-win streak',
    type: 'daily',
    target: 3,
    reward: 200,
  },
];

// Weekly challenges
const WEEKLY_CHALLENGES: BattlePassChallenge[] = [
  {
    id: 'weekly_wins',
    name: 'Weekly Champion',
    description: 'Reach 50 total wins',
    type: 'weekly',
    target: 50,
    reward: 500,
  },
  {
    id: 'weekly_bonus',
    name: 'Bonus Multiplier',
    description: 'Earn 5000 SC from bonuses',
    type: 'weekly',
    target: 5000,
    reward: 750,
  },
  {
    id: 'weekly_events',
    name: 'Event Participation',
    description: 'Complete 3 seasonal event challenges',
    type: 'weekly',
    target: 3,
    reward: 600,
  },
];

/**
 * Get all battle pass tiers
 */
export function getAllBattlePassTiers(): BattlePassTier[] {
  return BATTLE_PASS_TIERS;
}

/**
 * Get battle pass tier by number
 */
export function getBattlePassTier(tierNumber: number): BattlePassTier | undefined {
  return BATTLE_PASS_TIERS.find((t) => t.tier === tierNumber);
}

/**
 * Get all daily challenges
 */
export function getDailyChallenges(): BattlePassChallenge[] {
  return DAILY_CHALLENGES;
}

/**
 * Get all weekly challenges
 */
export function getWeeklyChallenges(): BattlePassChallenge[] {
  return WEEKLY_CHALLENGES;
}

/**
 * Calculate XP required for a tier
 */
export function getXPRequiredForTier(tierNumber: number): number {
  const tier = getBattlePassTier(tierNumber);
  return tier?.requiredXP || 0;
}

/**
 * Calculate total XP needed to reach a tier
 */
export function getTotalXPForTier(tierNumber: number): number {
  let totalXP = 0;
  for (let i = 1; i <= tierNumber; i++) {
    totalXP += getXPRequiredForTier(i);
  }
  return totalXP;
}

/**
 * Calculate tier from total XP
 */
export function calculateTierFromXP(totalXP: number): number {
  let currentTier = 1;
  let accumulatedXP = 0;

  for (let tier = 1; tier <= 50; tier++) {
    const tierXP = getXPRequiredForTier(tier);
    if (accumulatedXP + tierXP <= totalXP) {
      accumulatedXP += tierXP;
      currentTier = tier;
    } else {
      break;
    }
  }

  return Math.min(currentTier, 50);
}

/**
 * Get XP progress in current tier
 */
export function getCurrentTierXP(totalXP: number): number {
  const currentTier = calculateTierFromXP(totalXP);
  let accumulatedXP = 0;

  for (let tier = 1; tier < currentTier; tier++) {
    accumulatedXP += getXPRequiredForTier(tier);
  }

  return totalXP - accumulatedXP;
}

/**
 * Get XP needed for next tier
 */
export function getXPForNextTier(totalXP: number): number {
  const currentTier = calculateTierFromXP(totalXP);
  if (currentTier >= 50) return 0;

  return getXPRequiredForTier(currentTier + 1);
}

/**
 * Add XP to player progress
 */
export function addXPToProgress(progress: PlayerBattlePassProgress, xpAmount: number): PlayerBattlePassProgress {
  const multiplier = progress.isPremium ? 2 : 1;
  const actualXP = xpAmount * multiplier;

  return {
    ...progress,
    totalXP: progress.totalXP + actualXP,
    currentTier: calculateTierFromXP(progress.totalXP + actualXP),
    currentXP: getCurrentTierXP(progress.totalXP + actualXP),
  };
}

/**
 * Complete a challenge
 */
export function completeChallenge(
  progress: PlayerBattlePassProgress,
  challengeId: string
): PlayerBattlePassProgress {
  if (progress.completedChallenges.includes(challengeId)) {
    return progress;
  }

  const challenge = [...DAILY_CHALLENGES, ...WEEKLY_CHALLENGES].find((c) => c.id === challengeId);
  if (!challenge) return progress;

  const updatedProgress = {
    ...progress,
    completedChallenges: [...progress.completedChallenges, challengeId],
  };

  return addXPToProgress(updatedProgress, challenge.reward);
}

/**
 * Claim reward for a tier
 */
export function claimTierReward(progress: PlayerBattlePassProgress, tierNumber: number): boolean {
  if (progress.claimedRewards.includes(tierNumber)) {
    return false; // Already claimed
  }

  if (progress.currentTier < tierNumber) {
    return false; // Tier not reached
  }

  return true;
}

/**
 * Get unclaimed rewards
 */
export function getUnclaimedRewards(progress: PlayerBattlePassProgress): number[] {
  const unclaimed: number[] = [];

  for (let tier = 1; tier <= progress.currentTier; tier++) {
    if (!progress.claimedRewards.includes(tier)) {
      unclaimed.push(tier);
    }
  }

  return unclaimed;
}

/**
 * Calculate battle pass completion percentage
 */
export function getCompletionPercentage(progress: PlayerBattlePassProgress): number {
  return (progress.currentTier / 50) * 100;
}

/**
 * Check if battle pass is completed
 */
export function isBattlePassCompleted(progress: PlayerBattlePassProgress): boolean {
  return progress.currentTier >= 50;
}

/**
 * Get premium benefits multiplier
 */
export function getPremiumMultiplier(isPremium: boolean): number {
  return isPremium ? 2 : 1;
}

/**
 * Calculate total rewards value
 */
export function calculateRewardsValue(
  progress: PlayerBattlePassProgress,
  claimedTiers: number[]
): { SC: number; cosmetics: number } {
  let scTotal = 0;
  let cosmeticCount = 0;

  for (const tier of claimedTiers) {
    const tierData = getBattlePassTier(tier);
    if (!tierData) continue;

    // Parse SC rewards (simple parsing for demo)
    const freeMatch = tierData.freeReward.match(/(\d+)\s*SC/);
    if (freeMatch) {
      scTotal += parseInt(freeMatch[1]);
    }

    if (progress.isPremium) {
      const premiumMatch = tierData.premiumReward.match(/(\d+)\s*SC/);
      if (premiumMatch) {
        scTotal += parseInt(premiumMatch[1]);
      } else if (tierData.premiumReward.includes('cosmetic') || tierData.premiumReward.includes('Avatar')) {
        cosmeticCount++;
      }
    }
  }

  return { SC: scTotal, cosmetics: cosmeticCount };
}