import { EventEmitter } from 'events';

interface ShareableAchievement {
  achievementId: string;
  playerId: string;
  playerName: string;
  tournamentId: string;
  tournamentName: string;
  rank: number;
  score: number;
  prize?: number;
  timestamp: Date;
  imageUrl?: string;
}

interface SocialShareData {
  platform: 'twitter' | 'facebook' | 'discord' | 'telegram';
  achievement: ShareableAchievement;
  shareUrl: string;
  shareText: string;
  imageUrl?: string;
  timestamp: Date;
}

interface ShareAnalytics {
  achievementId: string;
  totalShares: number;
  sharesByPlatform: Record<string, number>;
  clicks: number;
  engagementRate: number;
  topPerformers: Array<{ platform: string; shares: number }>;
}

export class TournamentSocialSharingService extends EventEmitter {
  private achievements: Map<string, ShareableAchievement> = new Map();
  private shareHistory: SocialShareData[] = [];
  private analytics: Map<string, ShareAnalytics> = new Map();
  private shareLinks: Map<string, string> = new Map(); // achievementId -> shareUrl

  constructor() {
    super();
  }

  /**
   * Create shareable achievement
   */
  createShareableAchievement(
    playerId: string,
    playerName: string,
    tournamentId: string,
    tournamentName: string,
    rank: number,
    score: number,
    prize?: number
  ): ShareableAchievement {
    const achievementId = `achievement-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;

    const achievement: ShareableAchievement = {
      achievementId,
      playerId,
      playerName,
      tournamentId,
      tournamentName,
      rank,
      score,
      prize,
      timestamp: new Date(),
    };

    this.achievements.set(achievementId, achievement);
    this.analytics.set(achievementId, {
      achievementId,
      totalShares: 0,
      sharesByPlatform: {},
      clicks: 0,
      engagementRate: 0,
      topPerformers: [],
    });

    this.emit('achievement_created', achievement);

    return achievement;
  }

  /**
   * Generate share URL for achievement
   */
  generateShareUrl(achievementId: string, baseUrl: string = 'https://coinkrazy.com'): string {
    const shareUrl = `${baseUrl}/achievement/${achievementId}`;
    this.shareLinks.set(achievementId, shareUrl);
    return shareUrl;
  }

  /**
   * Generate Twitter share content
   */
  generateTwitterShare(achievement: ShareableAchievement): SocialShareData {
    const shareText = `🏆 I just ranked #${achievement.rank} in the ${achievement.tournamentName} tournament on CoinKrazy! 
Score: ${achievement.score.toLocaleString()} points
${achievement.prize ? `Prize: $${achievement.prize}` : ''}
Join me and compete for amazing rewards! 🎮💰
#CoinKrazy #Sweepstakes #Gaming`;

    const shareUrl = this.generateShareUrl(achievement.achievementId);

    return {
      platform: 'twitter',
      achievement,
      shareUrl,
      shareText,
      timestamp: new Date(),
    };
  }

  /**
   * Generate Facebook share content
   */
  generateFacebookShare(achievement: ShareableAchievement): SocialShareData {
    const shareText = `I just achieved an amazing rank in the ${achievement.tournamentName} tournament! 🏆

Rank: #${achievement.rank}
Score: ${achievement.score.toLocaleString()} points
${achievement.prize ? `Prize: $${achievement.prize}` : ''}

Join CoinKrazy and compete for prizes! 🎮💰`;

    const shareUrl = this.generateShareUrl(achievement.achievementId);

    return {
      platform: 'facebook',
      achievement,
      shareUrl,
      shareText,
      timestamp: new Date(),
    };
  }

  /**
   * Generate Discord share content
   */
  generateDiscordShare(achievement: ShareableAchievement): SocialShareData {
    const shareText = `🏆 **Tournament Achievement!**
**Player:** ${achievement.playerName}
**Tournament:** ${achievement.tournamentName}
**Rank:** #${achievement.rank}
**Score:** ${achievement.score.toLocaleString()} points
${achievement.prize ? `**Prize:** $${achievement.prize}` : ''}

Join CoinKrazy and compete for amazing rewards!`;

    const shareUrl = this.generateShareUrl(achievement.achievementId);

    return {
      platform: 'discord',
      achievement,
      shareUrl,
      shareText,
      timestamp: new Date(),
    };
  }

  /**
   * Generate Telegram share content
   */
  generateTelegramShare(achievement: ShareableAchievement): SocialShareData {
    const shareText = `🏆 I just ranked #${achievement.rank} in the ${achievement.tournamentName} tournament!

Score: ${achievement.score.toLocaleString()} points
${achievement.prize ? `Prize: $${achievement.prize}` : ''}

Join CoinKrazy: https://coinkrazy.com`;

    const shareUrl = this.generateShareUrl(achievement.achievementId);

    return {
      platform: 'telegram',
      achievement,
      shareUrl,
      shareText,
      timestamp: new Date(),
    };
  }

  /**
   * Record share action
   */
  recordShare(
    achievementId: string,
    platform: 'twitter' | 'facebook' | 'discord' | 'telegram'
  ): boolean {
    const achievement = this.achievements.get(achievementId);
    if (!achievement) return false;

    const analytics = this.analytics.get(achievementId)!;
    analytics.totalShares += 1;
    analytics.sharesByPlatform[platform] = (analytics.sharesByPlatform[platform] || 0) + 1;

    const shareData: SocialShareData = {
      platform,
      achievement,
      shareUrl: this.shareLinks.get(achievementId) || '',
      shareText: '',
      timestamp: new Date(),
    };

    this.shareHistory.push(shareData);

    this.emit('share_recorded', { achievementId, platform, totalShares: analytics.totalShares });

    return true;
  }

  /**
   * Record click on shared link
   */
  recordClick(achievementId: string): boolean {
    const analytics = this.analytics.get(achievementId);
    if (!analytics) return false;

    analytics.clicks += 1;
    analytics.engagementRate = (analytics.clicks / Math.max(1, analytics.totalShares)) * 100;

    this.emit('click_recorded', { achievementId, clicks: analytics.clicks });

    return true;
  }

  /**
   * Get share analytics
   */
  getAnalytics(achievementId: string): ShareAnalytics | undefined {
    return this.analytics.get(achievementId);
  }

  /**
   * Get top shared achievements
   */
  getTopSharedAchievements(limit: number = 10): ShareableAchievement[] {
    return Array.from(this.achievements.values())
      .sort((a, b) => {
        const analyticsA = this.analytics.get(a.achievementId)?.totalShares || 0;
        const analyticsB = this.analytics.get(b.achievementId)?.totalShares || 0;
        return analyticsB - analyticsA;
      })
      .slice(0, limit);
  }

  /**
   * Get share statistics by platform
   */
  getPlatformStats() {
    const stats: Record<string, number> = {
      twitter: 0,
      facebook: 0,
      discord: 0,
      telegram: 0,
    };

    this.shareHistory.forEach((share) => {
      stats[share.platform]++;
    });

    return stats;
  }

  /**
   * Get player's shared achievements
   */
  getPlayerSharedAchievements(playerId: string): ShareableAchievement[] {
    return Array.from(this.achievements.values()).filter((a) => a.playerId === playerId);
  }

  /**
   * Get tournament share statistics
   */
  getTournamentShareStats(tournamentId: string) {
    const achievements = Array.from(this.achievements.values()).filter(
      (a) => a.tournamentId === tournamentId
    );

    let totalShares = 0;
    let totalClicks = 0;

    achievements.forEach((achievement) => {
      const analytics = this.analytics.get(achievement.achievementId);
      if (analytics) {
        totalShares += analytics.totalShares;
        totalClicks += analytics.clicks;
      }
    });

    return {
      tournamentId,
      totalAchievements: achievements.length,
      totalShares,
      totalClicks,
      engagementRate: totalShares > 0 ? (totalClicks / totalShares) * 100 : 0,
    };
  }

  /**
   * Generate achievement badge
   */
  generateBadge(achievement: ShareableAchievement): string {
    const badgeUrl = `https://api.coinkrazy.com/badge/${achievement.achievementId}.png`;
    return badgeUrl;
  }

  /**
   * Create shareable card image
   */
  async generateShareCard(achievement: ShareableAchievement): Promise<string> {
    // This would integrate with image generation service
    const cardData = {
      title: `${achievement.playerName} - Tournament Champion`,
      subtitle: achievement.tournamentName,
      rank: `#${achievement.rank}`,
      score: achievement.score.toLocaleString(),
      prize: achievement.prize ? `$${achievement.prize}` : 'No Prize',
      timestamp: achievement.timestamp.toLocaleDateString(),
    };

    // Return placeholder URL
    return `https://api.coinkrazy.com/card/${achievement.achievementId}.png`;
  }
}

export default TournamentSocialSharingService;