/**
 * Referral Affiliate Program System
 * Tiered commission structure for partners promoting CoinKrazy
 */

export interface AffiliateAccount {
  id: number;
  userId: number;
  affiliateCode: string;
  tier: 'bronze' | 'silver' | 'gold' | 'platinum' | 'diamond';
  commissionRate: number; // 5-20%
  totalReferrals: number;
  totalEarnings: number;
  monthlyEarnings: number;
  status: 'active' | 'inactive' | 'suspended';
  createdAt: Date;
  updatedAt: Date;
}

export interface AffiliateCommission {
  id: number;
  affiliateId: number;
  referralId: number;
  referrerEarnings: number; // 1 SC
  affiliateCommission: number; // 5-20% of referrer earnings
  status: 'pending' | 'completed' | 'paid';
  createdAt: Date;
  paidAt?: Date;
}

/**
 * Affiliate Tier Configuration
 */
export const AFFILIATE_TIERS = {
  bronze: {
    name: 'Bronze',
    minReferrals: 0,
    commissionRate: 0.05, // 5%
    monthlyBonus: 0,
    features: ['Basic reporting', 'Monthly payouts'],
  },
  silver: {
    name: 'Silver',
    minReferrals: 50,
    commissionRate: 0.10, // 10%
    monthlyBonus: 50, // 50 SC
    features: ['Advanced reporting', 'Weekly payouts', '50 SC monthly bonus'],
  },
  gold: {
    name: 'Gold',
    minReferrals: 200,
    commissionRate: 0.15, // 15%
    monthlyBonus: 200, // 200 SC
    features: ['Real-time analytics', 'Bi-weekly payouts', '200 SC monthly bonus', 'Dedicated support'],
  },
  platinum: {
    name: 'Platinum',
    minReferrals: 500,
    commissionRate: 0.175, // 17.5%
    monthlyBonus: 500, // 500 SC
    features: ['Premium analytics', 'Weekly payouts', '500 SC monthly bonus', 'Priority support', 'Custom campaigns'],
  },
  diamond: {
    name: 'Diamond',
    minReferrals: 1000,
    commissionRate: 0.20, // 20%
    monthlyBonus: 1000, // 1000 SC
    features: ['VIP analytics', 'Daily payouts', '1000 SC monthly bonus', 'VIP support', 'Co-marketing opportunities'],
  },
};

/**
 * Calculate affiliate tier based on referrals
 */
export function calculateAffiliateTier(
  totalReferrals: number
): keyof typeof AFFILIATE_TIERS {
  if (totalReferrals >= 1000) return 'diamond';
  if (totalReferrals >= 500) return 'platinum';
  if (totalReferrals >= 200) return 'gold';
  if (totalReferrals >= 50) return 'silver';
  return 'bronze';
}

/**
 * Calculate commission for affiliate
 */
export function calculateAffiliateCommission(
  referrerEarnings: number,
  commissionRate: number
): number {
  return Math.round(referrerEarnings * commissionRate * 100) / 100;
}

/**
 * Get affiliate tier details
 */
export function getAffiliateTierDetails(tier: keyof typeof AFFILIATE_TIERS) {
  return AFFILIATE_TIERS[tier];
}

/**
 * Generate affiliate code
 */
export function generateAffiliateCode(userId: number): string {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
  let code = `AFF${userId}`;
  for (let i = 0; i < 8; i++) {
    code += chars.charAt(Math.floor(Math.random() * chars.length));
  }
  return code;
}

/**
 * Calculate monthly affiliate earnings
 */
export function calculateMonthlyEarnings(
  referrals: number,
  commissionRate: number,
  monthlyBonus: number
): number {
  const commissionEarnings = referrals * 1 * commissionRate; // 1 SC per referral
  return Math.round((commissionEarnings + monthlyBonus) * 100) / 100;
}

/**
 * Validate affiliate eligibility
 */
export function validateAffiliateEligibility(
  userId: number,
  existingAffiliates: number[]
): { valid: boolean; reason?: string } {
  if (existingAffiliates.includes(userId)) {
    return { valid: false, reason: 'User is already an affiliate' };
  }

  return { valid: true };
}

/**
 * Get affiliate payout schedule
 */
export function getAffiliatePayoutSchedule(tier: keyof typeof AFFILIATE_TIERS): string {
  const schedules: Record<keyof typeof AFFILIATE_TIERS, string> = {
    bronze: 'Monthly',
    silver: 'Weekly',
    gold: 'Bi-weekly',
    platinum: 'Weekly',
    diamond: 'Daily',
  };
  return schedules[tier];
}

/**
 * Calculate tier upgrade progress
 */
export function calculateTierUpgradeProgress(currentReferrals: number, currentTier: keyof typeof AFFILIATE_TIERS) {
  const tierProgression = ['bronze', 'silver', 'gold', 'platinum', 'diamond'] as const;
  const currentIndex = tierProgression.indexOf(currentTier);
  
  if (currentIndex === tierProgression.length - 1) {
    return { nextTier: null, referralsNeeded: 0, progress: 100 };
  }

  const nextTier = tierProgression[currentIndex + 1];
  const nextTierMinReferrals = AFFILIATE_TIERS[nextTier].minReferrals;
  const currentTierMinReferrals = AFFILIATE_TIERS[currentTier].minReferrals;
  
  const referralsNeeded = nextTierMinReferrals - currentReferrals;
  const progress = Math.round(
    ((currentReferrals - currentTierMinReferrals) / (nextTierMinReferrals - currentTierMinReferrals)) * 100
  );

  return {
    nextTier,
    referralsNeeded: Math.max(0, referralsNeeded),
    progress: Math.min(100, progress),
  };
}