feat: implement Analytics module with performance insights

- Add PerformanceController with team overview and trends
- Add ChampionsController for champion pool analysis
- Add KdaTrendController for KDA tracking over time
- Add LaningController for CS and gold performance
- Add TeamfightsController for damage and participation stats
- Add VisionController for vision score analysis
- Add TeamComparisonController for player comparisons

Author: Bulletdev

app/controllers/api/v1/analytics/champions_controller.rb

@@ -0,0 +1,27 @@
+class Api::V1::Analytics::ChampionsController < Api::V1::BaseController
+  def show
+    player = organization_scoped(Player).find(params[:player_id])
+    champion_pools = player.champion_pools.order(games_played: :desc)
+
+    champion_data = {
+      player: PlayerSerializer.render_as_hash(player),
+      champion_pool: ChampionPoolSerializer.render_as_hash(champion_pools),
+      top_champions: champion_pools.limit(5).map do |pool|
+        {
+          champion: pool.champion,
+          games: pool.games_played,
+          win_rate: pool.wins.to_f / pool.games_played * 100,
+          avg_kda: pool.average_kda,
+          mastery: pool.mastery_level
+        }
+      end,
+      champion_diversity: {
+        total_champions: champion_pools.count,
+        highly_played: champion_pools.where('games_played >= ?', 10).count,
+        mastery_points: champion_pools.sum(:mastery_points)
+      }
+    }
+
+    render_success(champion_data)
+  end
+end

app/controllers/api/v1/analytics/kda_trend_controller.rb

@@ -0,0 +1,49 @@
+class Api::V1::Analytics::KdaTrendController < Api::V1::BaseController
+  def show
+    player = organization_scoped(Player).find(params[:player_id])
+
+    # Get recent matches for the player
+    stats = PlayerMatchStat.joins(:match)
+                          .where(player: player, match: { organization: current_organization })
+                          .order('matches.game_start DESC')
+                          .limit(50)
+                          .includes(:match)
+
+    trend_data = {
+      player: PlayerSerializer.render_as_hash(player),
+      kda_by_match: stats.map do |stat|
+        kda = stat.deaths.zero? ? (stat.kills + stat.assists).to_f : ((stat.kills + stat.assists).to_f / stat.deaths)
+        {
+          match_id: stat.match.id,
+          date: stat.match.game_start,
+          kills: stat.kills,
+          deaths: stat.deaths,
+          assists: stat.assists,
+          kda: kda.round(2),
+          champion: stat.champion,
+          victory: stat.match.victory
+        }
+      end,
+      averages: {
+        last_10_games: calculate_kda_average(stats.limit(10)),
+        last_20_games: calculate_kda_average(stats.limit(20)),
+        overall: calculate_kda_average(stats)
+      }
+    }
+
+    render_success(trend_data)
+  end
+
+  private
+
+  def calculate_kda_average(stats)
+    return 0 if stats.empty?
+
+    total_kills = stats.sum(:kills)
+    total_deaths = stats.sum(:deaths)
+    total_assists = stats.sum(:assists)
+
+    deaths = total_deaths.zero? ? 1 : total_deaths
+    ((total_kills + total_assists).to_f / deaths).round(2)
+  end
+end

app/controllers/api/v1/analytics/laning_controller.rb

@@ -0,0 +1,61 @@
+class Api::V1::Analytics::LaningController < Api::V1::BaseController
+  def show
+    player = organization_scoped(Player).find(params[:player_id])
+
+    stats = PlayerMatchStat.joins(:match)
+                          .where(player: player, match: { organization: current_organization })
+                          .order('matches.game_start DESC')
+                          .limit(20)
+
+    laning_data = {
+      player: PlayerSerializer.render_as_hash(player),
+      cs_performance: {
+        avg_cs_total: stats.average('minions_killed + jungle_minions_killed')&.round(1),
+        avg_cs_per_min: calculate_avg_cs_per_min(stats),
+        best_cs_game: stats.maximum('minions_killed + jungle_minions_killed'),
+        worst_cs_game: stats.minimum('minions_killed + jungle_minions_killed')
+      },
+      gold_performance: {
+        avg_gold: stats.average(:gold_earned)&.round(0),
+        best_gold_game: stats.maximum(:gold_earned),
+        worst_gold_game: stats.minimum(:gold_earned)
+      },
+      cs_by_match: stats.map do |stat|
+        match_duration_mins = stat.match.game_duration ? stat.match.game_duration / 60.0 : 25
+        cs_total = (stat.minions_killed || 0) + (stat.jungle_minions_killed || 0)
+        cs_per_min = cs_total / match_duration_mins
+
+        {
+          match_id: stat.match.id,
+          date: stat.match.game_start,
+          cs_total: cs_total,
+          cs_per_min: cs_per_min.round(1),
+          gold: stat.gold_earned,
+          champion: stat.champion,
+          victory: stat.match.victory
+        }
+      end
+    }
+
+    render_success(laning_data)
+  end
+
+  private
+
+  def calculate_avg_cs_per_min(stats)
+    total_cs = 0
+    total_minutes = 0
+
+    stats.each do |stat|
+      if stat.match.game_duration
+        cs = (stat.minions_killed || 0) + (stat.jungle_minions_killed || 0)
+        minutes = stat.match.game_duration / 60.0
+        total_cs += cs
+        total_minutes += minutes
+      end
+    end
+
+    return 0 if total_minutes.zero?
+    (total_cs / total_minutes).round(1)
+  end
+end

app/controllers/api/v1/analytics/performance_controller.rb

@@ -0,0 +1,138 @@
+class Api::V1::Analytics::PerformanceController < Api::V1::BaseController
+  def index
+    # Team performance analytics
+    matches = organization_scoped(Match)
+    players = organization_scoped(Player).active
+
+    # Date range filter
+    if params[:start_date].present? && params[:end_date].present?
+      matches = matches.in_date_range(params[:start_date], params[:end_date])
+    else
+      matches = matches.recent(30) # Default to last 30 days
+    end
+
+    performance_data = {
+      overview: calculate_team_overview(matches),
+      win_rate_trend: calculate_win_rate_trend(matches),
+      performance_by_role: calculate_performance_by_role(matches),
+      best_performers: identify_best_performers(players, matches),
+      match_type_breakdown: calculate_match_type_breakdown(matches)
+    }
+
+    render_success(performance_data)
+  end
+
+  private
+
+  def calculate_team_overview(matches)
+    stats = PlayerMatchStat.where(match: matches)
+
+    {
+      total_matches: matches.count,
+      wins: matches.victories.count,
+      losses: matches.defeats.count,
+      win_rate: calculate_win_rate(matches),
+      avg_game_duration: matches.average(:game_duration)&.round(0),
+      avg_kda: calculate_avg_kda(stats),
+      avg_kills_per_game: stats.average(:kills)&.round(1),
+      avg_deaths_per_game: stats.average(:deaths)&.round(1),
+      avg_assists_per_game: stats.average(:assists)&.round(1),
+      avg_gold_per_game: stats.average(:gold_earned)&.round(0),
+      avg_damage_per_game: stats.average(:total_damage_dealt)&.round(0),
+      avg_vision_score: stats.average(:vision_score)&.round(1)
+    }
+  end
+
+  def calculate_win_rate_trend(matches)
+    # Calculate win rate for each week
+    matches.group_by { |m| m.game_start.beginning_of_week }.map do |week, week_matches|
+      wins = week_matches.count(&:victory?)
+      total = week_matches.size
+      win_rate = total.zero? ? 0 : ((wins.to_f / total) * 100).round(1)
+
+      {
+        week: week.strftime('%Y-%m-%d'),
+        matches: total,
+        wins: wins,
+        losses: total - wins,
+        win_rate: win_rate
+      }
+    end.sort_by { |d| d[:week] }
+  end
+
+  def calculate_performance_by_role(matches)
+    stats = PlayerMatchStat.joins(:player).where(match: matches)
+
+    stats.group('players.role').select(
+      'players.role',
+      'COUNT(*) as games',
+      'AVG(player_match_stats.kills) as avg_kills',
+      'AVG(player_match_stats.deaths) as avg_deaths',
+      'AVG(player_match_stats.assists) as avg_assists',
+      'AVG(player_match_stats.gold_earned) as avg_gold',
+      'AVG(player_match_stats.total_damage_dealt) as avg_damage',
+      'AVG(player_match_stats.vision_score) as avg_vision'
+    ).map do |stat|
+      {
+        role: stat.role,
+        games: stat.games,
+        avg_kda: {
+          kills: stat.avg_kills&.round(1) || 0,
+          deaths: stat.avg_deaths&.round(1) || 0,
+          assists: stat.avg_assists&.round(1) || 0
+        },
+        avg_gold: stat.avg_gold&.round(0) || 0,
+        avg_damage: stat.avg_damage&.round(0) || 0,
+        avg_vision: stat.avg_vision&.round(1) || 0
+      }
+    end
+  end
+
+  def identify_best_performers(players, matches)
+    players.map do |player|
+      stats = PlayerMatchStat.where(player: player, match: matches)
+      next if stats.empty?
+
+      {
+        player: PlayerSerializer.render_as_hash(player),
+        games: stats.count,
+        avg_kda: calculate_avg_kda(stats),
+        avg_performance_score: stats.average(:performance_score)&.round(1) || 0,
+        mvp_count: stats.joins(:match).where(matches: { victory: true }).count
+      }
+    end.compact.sort_by { |p| -p[:avg_performance_score] }.take(5)
+  end
+
+  def calculate_match_type_breakdown(matches)
+    matches.group(:match_type).select(
+      'match_type',
+      'COUNT(*) as total',
+      'SUM(CASE WHEN victory THEN 1 ELSE 0 END) as wins'
+    ).map do |stat|
+      win_rate = stat.total.zero? ? 0 : ((stat.wins.to_f / stat.total) * 100).round(1)
+      {
+        match_type: stat.match_type,
+        total: stat.total,
+        wins: stat.wins,
+        losses: stat.total - stat.wins,
+        win_rate: win_rate
+      }
+    end
+  end
+
+  def calculate_win_rate(matches)
+    return 0 if matches.empty?
+    ((matches.victories.count.to_f / matches.count) * 100).round(1)
+  end
+
+  def calculate_avg_kda(stats)
+    return 0 if stats.empty?
+
+    total_kills = stats.sum(:kills)
+    total_deaths = stats.sum(:deaths)
+    total_assists = stats.sum(:assists)
+
+    deaths = total_deaths.zero? ? 1 : total_deaths
+    ((total_kills + total_assists).to_f / deaths).round(2)
+  end
+end

app/controllers/api/v1/analytics/team_comparison_controller.rb

@@ -0,0 +1,87 @@
+class Api::V1::Analytics::TeamComparisonController < Api::V1::BaseController
+  def index
+    players = organization_scoped(Player).active.includes(:player_match_stats)
+
+    # Get matches in date range
+    matches = organization_scoped(Match)
+    if params[:start_date].present? && params[:end_date].present?
+      matches = matches.in_date_range(params[:start_date], params[:end_date])
+    else
+      matches = matches.recent(30)
+    end
+
+    comparison_data = {
+      players: players.map do |player|
+        stats = PlayerMatchStat.where(player: player, match: matches)
+        next if stats.empty?
+
+        {
+          player: PlayerSerializer.render_as_hash(player),
+          games_played: stats.count,
+          kda: calculate_kda(stats),
+          avg_damage: stats.average(:total_damage_dealt)&.round(0) || 0,
+          avg_gold: stats.average(:gold_earned)&.round(0) || 0,
+          avg_cs: stats.average('minions_killed + jungle_minions_killed')&.round(1) || 0,
+          avg_vision_score: stats.average(:vision_score)&.round(1) || 0,
+          avg_performance_score: stats.average(:performance_score)&.round(1) || 0,
+          multikills: {
+            double: stats.sum(:double_kills),
+            triple: stats.sum(:triple_kills),
+            quadra: stats.sum(:quadra_kills),
+            penta: stats.sum(:penta_kills)
+          }
+        }
+      end.compact.sort_by { |p| -p[:avg_performance_score] },
+      team_averages: calculate_team_averages(matches),
+      role_rankings: calculate_role_rankings(players, matches)
+    }
+
+    render_success(comparison_data)
+  end
+
+  private
+
+  def calculate_kda(stats)
+    total_kills = stats.sum(:kills)
+    total_deaths = stats.sum(:deaths)
+    total_assists = stats.sum(:assists)
+
+    deaths = total_deaths.zero? ? 1 : total_deaths
+    ((total_kills + total_assists).to_f / deaths).round(2)
+  end
+
+  def calculate_team_averages(matches)
+    all_stats = PlayerMatchStat.where(match: matches)
+
+    {
+      avg_kda: calculate_kda(all_stats),
+      avg_damage: all_stats.average(:total_damage_dealt)&.round(0) || 0,
+      avg_gold: all_stats.average(:gold_earned)&.round(0) || 0,
+      avg_cs: all_stats.average('minions_killed + jungle_minions_killed')&.round(1) || 0,
+      avg_vision_score: all_stats.average(:vision_score)&.round(1) || 0
+    }
+  end
+
+  def calculate_role_rankings(players, matches)
+    rankings = {}
+
+    %w[top jungle mid adc support].each do |role|
+      role_players = players.where(role: role)
+      role_data = role_players.map do |player|
+        stats = PlayerMatchStat.where(player: player, match: matches)
+        next if stats.empty?
+
+        {
+          player_id: player.id,
+          summoner_name: player.summoner_name,
+          avg_performance: stats.average(:performance_score)&.round(1) || 0,
+          games: stats.count
+        }
+      end.compact.sort_by { |p| -p[:avg_performance] }
+
+      rankings[role] = role_data
+    end
+
+    rankings
+  end
+end