/**
 * Social Sharing Rewards Service
 * Manages referral rewards and social sharing bonuses
 */

export interface ReferralReward {
  id: string;
  name: string;
  description: string;
  reward: number;
  rewardType: 'SC' | 'GC' | 'cosmetic';
  requirement: number;
  icon: string;
}

export interface ReferralTier {
  tier: number;
  minReferrals: number;
  maxReferrals: number;
  bonusMultiplier: number;
  exclusiveReward?: string;
}

export interface SocialShareReward {
  platform: 'twitter' | 'facebook' | 'tiktok' | 'instagram' | 'discord';
  name: string;
  reward: number;
  icon: string;
}

export interface PlayerReferralStats {
  userId: number;
  referralCode: string;
  totalReferrals: number;
  activeReferrals: number;
  totalRewardsEarned: number;
  currentTier: number;
  socialSharesClaimed: string[];
}

// Referral rewards tiers
const REFERRAL_REWARDS: ReferralReward[] = [
  {
    id: 'ref_1',
    name: 'First Friend',
    description: 'Refer 1 friend',
    reward: 500,
    rewardType: 'SC',
    requirement: 1,
    icon: '👤',
  },
  {
    id: 'ref_5',
    name: 'Friend Group',
    description: 'Refer 5 friends',
    reward: 3000,
    rewardType: 'SC',
    requirement: 5,
    icon: '👥',
  },
  {
    id: 'ref_10',
    name: 'Social Butterfly',
    description: 'Refer 10 friends',
    reward: 10000,
    rewardType: 'SC',
    requirement: 10,
    icon: '🦋',
  },
  {
    id: 'ref_25',
    name: 'Influencer',
    description: 'Refer 25 friends',
    reward: 25000,
    rewardType: 'cosmetic',
    requirement: 25,
    icon: '⭐',
  },
  {
    id: 'ref_50',
    name: 'Legend',
    description: 'Refer 50 friends',
    reward: 50000,
    rewardType: 'cosmetic',
    requirement: 50,
    icon: '👑',
  },
];

// Referral tiers with bonus multipliers
const REFERRAL_TIERS: ReferralTier[] = [
  { tier: 1, minReferrals: 0, maxReferrals: 4, bonusMultiplier: 1, exclusiveReward: undefined },
  { tier: 2, minReferrals: 5, maxReferrals: 9, bonusMultiplier: 1.25, exclusiveReward: undefined },
  { tier: 3, minReferrals: 10, maxReferrals: 24, bonusMultiplier: 1.5, exclusiveReward: 'Bronze Badge' },
  { tier: 4, minReferrals: 25, maxReferrals: 49, bonusMultiplier: 2, exclusiveReward: 'Silver Badge' },
  { tier: 5, minReferrals: 50, maxReferrals: Infinity, bonusMultiplier: 2.5, exclusiveReward: 'Gold Badge' },
];

// Social sharing rewards
const SOCIAL_SHARE_REWARDS: SocialShareReward[] = [
  {
    platform: 'twitter',
    name: 'Twitter/X',
    reward: 250,
    icon: '𝕏',
  },
  {
    platform: 'facebook',
    name: 'Facebook',
    reward: 300,
    icon: 'f',
  },
  {
    platform: 'tiktok',
    name: 'TikTok',
    reward: 500,
    icon: '♪',
  },
  {
    platform: 'instagram',
    name: 'Instagram',
    reward: 400,
    icon: '📷',
  },
  {
    platform: 'discord',
    name: 'Discord',
    reward: 350,
    icon: '💬',
  },
];

/**
 * Get all referral rewards
 */
export function getAllReferralRewards(): ReferralReward[] {
  return REFERRAL_REWARDS;
}

/**
 * Get referral reward by requirement
 */
export function getReferralReward(requirement: number): ReferralReward | undefined {
  return REFERRAL_REWARDS.find((r) => r.requirement === requirement);
}

/**
 * Get referral tier by number of referrals
 */
export function getReferralTier(referralCount: number): ReferralTier | undefined {
  return REFERRAL_TIERS.find((t) => referralCount >= t.minReferrals && referralCount <= t.maxReferrals);
}

/**
 * Get all referral tiers
 */
export function getAllReferralTiers(): ReferralTier[] {
  return REFERRAL_TIERS;
}

/**
 * Calculate bonus multiplier for referrals
 */
export function getBonusMultiplier(referralCount: number): number {
  const tier = getReferralTier(referralCount);
  return tier?.bonusMultiplier || 1;
}

/**
 * Get social share rewards
 */
export function getSocialShareRewards(): SocialShareReward[] {
  return SOCIAL_SHARE_REWARDS;
}

/**
 * Get social share reward by platform
 */
export function getSocialShareReward(platform: string): SocialShareReward | undefined {
  return SOCIAL_SHARE_REWARDS.find((r) => r.platform === platform);
}

/**
 * Calculate total referral rewards
 */
export function calculateTotalReferralRewards(referralCount: number): number {
  let total = 0;

  for (const reward of REFERRAL_REWARDS) {
    if (referralCount >= reward.requirement && reward.rewardType === 'SC') {
      total += reward.reward as number;
    }
  }

  return total;
}

/**
 * Get unclaimed referral rewards
 */
export function getUnclaimedReferralRewards(referralCount: number, claimedRewards: string[]): ReferralReward[] {
  return REFERRAL_REWARDS.filter(
    (r) => referralCount >= r.requirement && !claimedRewards.includes(r.id) && r.rewardType === 'SC'
  );
}

/**
 * Get unclaimed social share rewards
 */
export function getUnclaimedSocialRewards(claimedPlatforms: string[]): SocialShareReward[] {
  return SOCIAL_SHARE_REWARDS.filter((r) => !claimedPlatforms.includes(r.platform));
}

/**
 * Calculate total social share rewards
 */
export function calculateTotalSocialRewards(claimedPlatforms: string[]): number {
  return SOCIAL_SHARE_REWARDS.filter((r) => claimedPlatforms.includes(r.platform)).reduce(
    (total, reward) => total + reward.reward,
    0
  );
}

/**
 * Generate referral code
 */
export function generateReferralCode(userId: number): string {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
  let code = '';

  for (let i = 0; i < 8; i++) {
    code += chars.charAt(Math.floor(Math.random() * chars.length));
  }

  return `${code}${userId.toString().slice(-2)}`;
}

/**
 * Validate referral code format
 */
export function isValidReferralCode(code: string): boolean {
  return /^[A-Z0-9]{8}[0-9]{2}$/.test(code);
}

/**
 * Get referral tier name
 */
export function getReferralTierName(tier: number): string {
  const names: Record<number, string> = {
    1: 'Newcomer',
    2: 'Friend Maker',
    3: 'Social Star',
    4: 'Influencer',
    5: 'Legend',
  };

  return names[tier] || 'Unknown';
}

/**
 * Get next referral milestone
 */
export function getNextReferralMilestone(currentReferrals: number): ReferralReward | undefined {
  return REFERRAL_REWARDS.find((r) => r.requirement > currentReferrals);
}

/**
 * Calculate referrals needed for next tier
 */
export function getReferralsNeededForNextTier(currentReferrals: number): number {
  const currentTier = getReferralTier(currentReferrals);
  if (!currentTier || currentTier.tier === 5) return 0;

  const nextTier = REFERRAL_TIERS.find((t) => t.tier === currentTier.tier + 1);
  if (!nextTier) return 0;

  return Math.max(0, nextTier.minReferrals - currentReferrals);
}

/**
 * Get referral bonus for tier
 */
export function getReferralBonusPercentage(tier: number): number {
  const tierData = REFERRAL_TIERS.find((t) => t.tier === tier);
  return tierData ? (tierData.bonusMultiplier - 1) * 100 : 0;
}