/**
 * VIP Tier System
 * Manages player VIP levels with exclusive perks and rewards
 */

export type VIPTier = 'bronze' | 'silver' | 'gold' | 'platinum' | 'diamond' | 'elite';

export interface VIPTierConfig {
  tier: VIPTier;
  minSpend: number;
  maxSpend: number;
  bonusPercentage: number;
  cashbackPercentage: number;
  freeSpinsPerMonth: number;
  prioritySupport: boolean;
  exclusiveGames: boolean;
  birthdayBonus: number;
  monthlyBonus: number;
  vipBadge: boolean;
  customAvatarFrame: boolean;
  leaderboardMultiplier: number;
  withdrawalLimit: number;
  depositBonus: number;
}

export interface PlayerVIPStatus {
  userId: number;
  currentTier: VIPTier;
  totalSpend: number;
  monthlySpend: number;
  points: number;
  promotedAt: Date;
  nextTierProgress: number;
  perks: string[];
  activeRewards: VIPReward[];
}

export interface VIPReward {
  id: string;
  type: 'bonus' | 'freespins' | 'cashback' | 'multiplier';
  amount: number;
  expiresAt: Date;
  claimed: boolean;
  claimedAt?: Date;
}

/**
 * VIP Tier Configurations
 */
export const VIP_TIERS: Record<VIPTier, VIPTierConfig> = {
  bronze: {
    tier: 'bronze',
    minSpend: 0,
    maxSpend: 499,
    bonusPercentage: 5,
    cashbackPercentage: 0.5,
    freeSpinsPerMonth: 10,
    prioritySupport: false,
    exclusiveGames: false,
    birthdayBonus: 25,
    monthlyBonus: 50,
    vipBadge: true,
    customAvatarFrame: false,
    leaderboardMultiplier: 1,
    withdrawalLimit: 5000,
    depositBonus: 10,
  },
  silver: {
    tier: 'silver',
    minSpend: 500,
    maxSpend: 1499,
    bonusPercentage: 10,
    cashbackPercentage: 1,
    freeSpinsPerMonth: 25,
    prioritySupport: true,
    exclusiveGames: false,
    birthdayBonus: 50,
    monthlyBonus: 100,
    vipBadge: true,
    customAvatarFrame: true,
    leaderboardMultiplier: 1.1,
    withdrawalLimit: 10000,
    depositBonus: 15,
  },
  gold: {
    tier: 'gold',
    minSpend: 1500,
    maxSpend: 4999,
    bonusPercentage: 15,
    cashbackPercentage: 1.5,
    freeSpinsPerMonth: 50,
    prioritySupport: true,
    exclusiveGames: true,
    birthdayBonus: 100,
    monthlyBonus: 200,
    vipBadge: true,
    customAvatarFrame: true,
    leaderboardMultiplier: 1.2,
    withdrawalLimit: 25000,
    depositBonus: 20,
  },
  platinum: {
    tier: 'platinum',
    minSpend: 5000,
    maxSpend: 9999,
    bonusPercentage: 20,
    cashbackPercentage: 2,
    freeSpinsPerMonth: 100,
    prioritySupport: true,
    exclusiveGames: true,
    birthdayBonus: 250,
    monthlyBonus: 500,
    vipBadge: true,
    customAvatarFrame: true,
    leaderboardMultiplier: 1.3,
    withdrawalLimit: 50000,
    depositBonus: 25,
  },
  diamond: {
    tier: 'diamond',
    minSpend: 10000,
    maxSpend: 24999,
    bonusPercentage: 25,
    cashbackPercentage: 2.5,
    freeSpinsPerMonth: 200,
    prioritySupport: true,
    exclusiveGames: true,
    birthdayBonus: 500,
    monthlyBonus: 1000,
    vipBadge: true,
    customAvatarFrame: true,
    leaderboardMultiplier: 1.5,
    withdrawalLimit: 100000,
    depositBonus: 30,
  },
  elite: {
    tier: 'elite',
    minSpend: 25000,
    maxSpend: Infinity,
    bonusPercentage: 30,
    cashbackPercentage: 3,
    freeSpinsPerMonth: 500,
    prioritySupport: true,
    exclusiveGames: true,
    birthdayBonus: 1000,
    monthlyBonus: 2500,
    vipBadge: true,
    customAvatarFrame: true,
    leaderboardMultiplier: 2,
    withdrawalLimit: 250000,
    depositBonus: 50,
  },
};

/**
 * Determine VIP tier based on spend
 */
export function getTierFromSpend(totalSpend: number): VIPTier {
  if (totalSpend >= 25000) return 'elite';
  if (totalSpend >= 10000) return 'diamond';
  if (totalSpend >= 5000) return 'platinum';
  if (totalSpend >= 1500) return 'gold';
  if (totalSpend >= 500) return 'silver';
  return 'bronze';
}

/**
 * Create VIP status for player
 */
export function createVIPStatus(userId: number, totalSpend: number = 0): PlayerVIPStatus {
  const tier = getTierFromSpend(totalSpend);
  const tierConfig = VIP_TIERS[tier];
  const nextTier = getNextTier(tier);
  const nextTierConfig = nextTier ? VIP_TIERS[nextTier] : null;

  let nextTierProgress = 0;
  if (nextTierConfig) {
    const tierRange = nextTierConfig.minSpend - tierConfig.minSpend;
    const currentProgress = totalSpend - tierConfig.minSpend;
    nextTierProgress = Math.min(100, (currentProgress / tierRange) * 100);
  }

  return {
    userId,
    currentTier: tier,
    totalSpend,
    monthlySpend: 0,
    points: Math.floor(totalSpend / 10),
    promotedAt: new Date(),
    nextTierProgress,
    perks: generatePerks(tierConfig),
    activeRewards: [],
  };
}

/**
 * Get next VIP tier
 */
export function getNextTier(currentTier: VIPTier): VIPTier | null {
  const tiers: VIPTier[] = ['bronze', 'silver', 'gold', 'platinum', 'diamond', 'elite'];
  const currentIndex = tiers.indexOf(currentTier);
  return currentIndex < tiers.length - 1 ? tiers[currentIndex + 1] : null;
}

/**
 * Generate perks for a tier
 */
export function generatePerks(tierConfig: VIPTierConfig): string[] {
  const perks: string[] = [];

  if (tierConfig.bonusPercentage > 0) {
    perks.push(`${tierConfig.bonusPercentage}% deposit bonus`);
  }
  if (tierConfig.cashbackPercentage > 0) {
    perks.push(`${tierConfig.cashbackPercentage}% cashback on losses`);
  }
  if (tierConfig.freeSpinsPerMonth > 0) {
    perks.push(`${tierConfig.freeSpinsPerMonth} free spins per month`);
  }
  if (tierConfig.prioritySupport) {
    perks.push('24/7 priority customer support');
  }
  if (tierConfig.exclusiveGames) {
    perks.push('Access to exclusive VIP games');
  }
  if (tierConfig.birthdayBonus > 0) {
    perks.push(`$${tierConfig.birthdayBonus} birthday bonus`);
  }
  if (tierConfig.monthlyBonus > 0) {
    perks.push(`$${tierConfig.monthlyBonus} monthly bonus`);
  }
  if (tierConfig.customAvatarFrame) {
    perks.push('Custom avatar frame');
  }
  if (tierConfig.leaderboardMultiplier > 1) {
    perks.push(`${tierConfig.leaderboardMultiplier}x leaderboard points`);
  }

  return perks;
}

/**
 * Update player spend and check for tier promotion
 */
export function updatePlayerSpend(
  vipStatus: PlayerVIPStatus,
  amount: number,
  isMonthly: boolean = true
): { promoted: boolean; newTier?: VIPTier; oldTier: VIPTier } {
  const oldTier = vipStatus.currentTier;

  vipStatus.totalSpend += amount;
  if (isMonthly) {
    vipStatus.monthlySpend += amount;
  }

  const newTier = getTierFromSpend(vipStatus.totalSpend);
  const promoted = newTier !== oldTier;

  if (promoted) {
    vipStatus.currentTier = newTier;
    vipStatus.promotedAt = new Date();
    vipStatus.perks = generatePerks(VIP_TIERS[newTier]);
  }

  // Update points
  vipStatus.points = Math.floor(vipStatus.totalSpend / 10);

  // Update next tier progress
  const nextTier = getNextTier(newTier);
  if (nextTier) {
    const tierConfig = VIP_TIERS[newTier];
    const nextTierConfig = VIP_TIERS[nextTier];
    const tierRange = nextTierConfig.minSpend - tierConfig.minSpend;
    const currentProgress = vipStatus.totalSpend - tierConfig.minSpend;
    vipStatus.nextTierProgress = Math.min(100, (currentProgress / tierRange) * 100);
  } else {
    vipStatus.nextTierProgress = 100;
  }

  return { promoted, newTier, oldTier };
}

/**
 * Generate monthly bonus for player
 */
export function generateMonthlyBonus(vipStatus: PlayerVIPStatus): VIPReward {
  const tierConfig = VIP_TIERS[vipStatus.currentTier];

  return {
    id: `reward_${vipStatus.userId}_${Date.now()}`,
    type: 'bonus',
    amount: tierConfig.monthlyBonus,
    expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
    claimed: false,
  };
}

/**
 * Generate birthday bonus for player
 */
export function generateBirthdayBonus(vipStatus: PlayerVIPStatus): VIPReward {
  const tierConfig = VIP_TIERS[vipStatus.currentTier];

  return {
    id: `reward_${vipStatus.userId}_birthday_${Date.now()}`,
    type: 'bonus',
    amount: tierConfig.birthdayBonus,
    expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
    claimed: false,
  };
}

/**
 * Generate free spins for player
 */
export function generateFreeSpins(vipStatus: PlayerVIPStatus): VIPReward {
  const tierConfig = VIP_TIERS[vipStatus.currentTier];
  const monthlySpins = tierConfig.freeSpinsPerMonth;

  return {
    id: `reward_${vipStatus.userId}_spins_${Date.now()}`,
    type: 'freespins',
    amount: monthlySpins,
    expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
    claimed: false,
  };
}

/**
 * Claim reward
 */
export function claimReward(vipStatus: PlayerVIPStatus, rewardId: string): boolean {
  const reward = vipStatus.activeRewards.find((r) => r.id === rewardId);

  if (!reward || reward.claimed || new Date() > reward.expiresAt) {
    return false;
  }

  reward.claimed = true;
  reward.claimedAt = new Date();
  return true;
}

/**
 * Calculate tier benefits comparison
 */
export interface TierComparison {
  tier: VIPTier;
  minSpend: number;
  bonusPercentage: number;
  cashbackPercentage: number;
  freeSpinsPerMonth: number;
  monthlyBonus: number;
}

export function getTierComparison(): TierComparison[] {
  return Object.entries(VIP_TIERS).map(([_, config]) => ({
    tier: config.tier,
    minSpend: config.minSpend,
    bonusPercentage: config.bonusPercentage,
    cashbackPercentage: config.cashbackPercentage,
    freeSpinsPerMonth: config.freeSpinsPerMonth,
    monthlyBonus: config.monthlyBonus,
  }));
}

/**
 * Get spend required for next tier
 */
export function getSpendForNextTier(currentSpend: number): number {
  const currentTier = getTierFromSpend(currentSpend);
  const nextTier = getNextTier(currentTier);

  if (!nextTier) {
    return 0; // Already at elite
  }

  return VIP_TIERS[nextTier].minSpend - currentSpend;
}