feat: add matches and info from riot api

Author: Bulletdev

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

@@ -1,27 +1,54 @@
 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)
+
+    stats = PlayerMatchStat.where(player: player)
+                          .group(:champion)
+                          .select(
+                            'champion',
+                            'COUNT(*) as games_played',
+                            'SUM(CASE WHEN matches.victory THEN 1 ELSE 0 END) as wins',
+                            'AVG((kills + assists)::float / NULLIF(deaths, 0)) as avg_kda'
+                          )
+                          .joins(:match)
+                          .order('games_played DESC')
+
+    champion_stats = stats.map do |stat|
+      win_rate = stat.games_played.zero? ? 0 : (stat.wins.to_f / stat.games_played)
+      {
+        champion: stat.champion,
+        games_played: stat.games_played,
+        win_rate: win_rate,
+        avg_kda: stat.avg_kda&.round(2) || 0,
+        mastery_grade: calculate_mastery_grade(win_rate, stat.avg_kda)
+      }
+    end
 
     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_stats: champion_stats,
+      top_champions: champion_stats.take(5),
       champion_diversity: {
-        total_champions: champion_pools.count,
-        highly_played: champion_pools.where('games_played >= ?', 10).count,
-        mastery_points: champion_pools.sum(:mastery_points)
+        total_champions: champion_stats.count,
+        highly_played: champion_stats.count { |c| c[:games_played] >= 10 },
+        average_games: champion_stats.empty? ? 0 : (champion_stats.sum { |c| c[:games_played] } / champion_stats.count.to_f).round(1)
       }
     }
 
     render_success(champion_data)
   end
+
+  private
+
+  def calculate_mastery_grade(win_rate, avg_kda)
+    score = (win_rate * 100 * 0.6) + ((avg_kda || 0) * 10 * 0.4)
+
+    case score
+    when 80..Float::INFINITY then 'S'
+    when 70...80 then 'A'
+    when 60...70 then 'B'
+    when 50...60 then 'C'
+    else 'D'
+    end
+  end
 end

app/controllers/api/v1/matches_controller.rb

@@ -146,13 +146,66 @@ def stats
   end
 
   def import
-    # This will import match data from Riot API
-    # Will be implemented when Riot API service is ready
-    render_error(
-      message: 'Import functionality not yet implemented',
-      code: 'NOT_IMPLEMENTED',
-      status: :not_implemented
-    )
+    player_id = params[:player_id]
+    count = params[:count]&.to_i || 20
+
+    unless player_id.present?
+      return render_error(
+        message: 'player_id is required',
+        code: 'VALIDATION_ERROR',
+        status: :unprocessable_entity
+      )
+    end
+
+    player = organization_scoped(Player).find(player_id)
+
+    unless player.riot_puuid.present?
+      return render_error(
+        message: 'Player does not have a Riot PUUID. Please sync player from Riot first.',
+        code: 'VALIDATION_ERROR',
+        status: :unprocessable_entity
+      )
+    end
+
+    begin
+      riot_service = RiotApiService.new
+      region = player.region || 'BR'
+
+      match_ids = riot_service.get_match_history(
+        puuid: player.riot_puuid,
+        region: region,
+        count: count
+      )
+
+      imported_count = 0
+      match_ids.each do |match_id|
+        # Check if match already exists
+        next if Match.exists?(riot_match_id: match_id)
+
+        SyncMatchJob.perform_later(match_id, current_organization.id, region)
+        imported_count += 1
+      end
+
+      render_success({
+        message: "Queued #{imported_count} matches for import",
+        total_matches_found: match_ids.count,
+        already_imported: match_ids.count - imported_count,
+        player: PlayerSerializer.render_as_hash(player)
+      })
+
+    rescue RiotApiService::RiotApiError => e
+      render_error(
+        message: "Failed to fetch matches from Riot API: #{e.message}",
+        code: 'RIOT_API_ERROR',
+        status: :bad_gateway
+      )
+    rescue StandardError => e
+      render_error(
+        message: "Failed to import matches: #{e.message}",
+        code: 'IMPORT_ERROR',
+        status: :internal_server_error
+      )
+    end
   end
 
   private