fix: analytics performance formatting

  -  Added time_period parameter support (week/month/season)
  -  Fixed win_rate format (decimal 0-1 instead of percentage)
  -  Ensured all numeric values are floats

Author: Bulletdev

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

@@ -7,6 +7,15 @@ def index
     # Date range filter
     if params[:start_date].present? && params[:end_date].present?
       matches = matches.in_date_range(params[:start_date], params[:end_date])
+    elsif params[:time_period].present?
+      # Handle time_period parameter from frontend
+      days = case params[:time_period]
+             when 'week' then 7
+             when 'month' then 30
+             when 'season' then 90
+             else 30
+             end
+      matches = matches.where('game_start >= ?', days.days.ago)
     else
       matches = matches.recent(30) # Default to last 30 days
     end
@@ -19,6 +28,14 @@ def index
       match_type_breakdown: calculate_match_type_breakdown(matches)
     }
 
+    # Add individual player stats if player_id is provided
+    if params[:player_id].present?
+      player = organization_scoped(Player).find_by(id: params[:player_id])
+      if player
+        performance_data[:player_stats] = calculate_player_stats(player, matches)
+      end
+    end
+
     render_success(performance_data)
   end
 
@@ -135,4 +152,50 @@ def calculate_avg_kda(stats)
     deaths = total_deaths.zero? ? 1 : total_deaths
     ((total_kills + total_assists).to_f / deaths).round(2)
   end
+
+  def calculate_player_stats(player, matches)
+    stats = PlayerMatchStat.where(player: player, match: matches)
+
+    return nil if stats.empty?
+
+    total_kills = stats.sum(:kills)
+    total_deaths = stats.sum(:deaths)
+    total_assists = stats.sum(:assists)
+    games_played = stats.count
+
+    # Calculate win rate as decimal (0-1) for frontend
+    wins = stats.joins(:match).where(matches: { victory: true }).count
+    win_rate = games_played.zero? ? 0.0 : (wins.to_f / games_played)
+
+    # Calculate KDA
+    deaths = total_deaths.zero? ? 1 : total_deaths
+    kda = ((total_kills + total_assists).to_f / deaths).round(2)
+
+    # Calculate CS per min
+    total_cs = stats.sum(:cs)
+    total_duration = matches.where(id: stats.pluck(:match_id)).sum(:game_duration)
+    cs_per_min = total_duration.zero? ? 0.0 : (total_cs.to_f / (total_duration / 60.0)).round(1)
+
+    # Calculate gold per min
+    total_gold = stats.sum(:gold_earned)
+    gold_per_min = total_duration.zero? ? 0.0 : (total_gold.to_f / (total_duration / 60.0)).round(0)
+
+    # Calculate vision score
+    vision_score = stats.average(:vision_score)&.round(1) || 0.0
+
+    {
+      player_id: player.id,
+      summoner_name: player.summoner_name,
+      games_played: games_played,
+      win_rate: win_rate,
+      kda: kda,
+      cs_per_min: cs_per_min,
+      gold_per_min: gold_per_min,
+      vision_score: vision_score,
+      damage_share: 0.0, # Would need total team damage to calculate
+      avg_kills: (total_kills.to_f / games_played).round(1),
+      avg_deaths: (total_deaths.to_f / games_played).round(1),
+      avg_assists: (total_assists.to_f / games_played).round(1)
+    }
+  end
 end

app/jobs/sync_match_job.rb

@@ -45,16 +45,25 @@ def create_match_record(match_data, organization)
       game_start: match_data[:game_creation],
       game_end: match_data[:game_creation] + match_data[:game_duration].seconds,
       game_duration: match_data[:game_duration],
-      patch_version: match_data[:game_version],
+      game_version: match_data[:game_version],
       victory: determine_team_victory(match_data[:participants], organization)
     )
   end
 
   def create_player_match_stats(match, participants, organization)
+    Rails.logger.info "Creating stats for #{participants.count} participants"
+    created_count = 0
+
     participants.each do |participant_data|
       # Find player by PUUID
       player = organization.players.find_by(riot_puuid: participant_data[:puuid])
-      next unless player
+
+      if player.nil?
+        Rails.logger.debug "Participant PUUID #{participant_data[:puuid][0..20]}... not found in organization"
+        next
+      end
+
+      Rails.logger.info "Creating stat for player: #{player.summoner_name}"
 
       PlayerMatchStat.create!(
         match: match,
@@ -65,22 +74,25 @@ def create_player_match_stats(match, participants, organization)
         deaths: participant_data[:deaths],
         assists: participant_data[:assists],
         gold_earned: participant_data[:gold_earned],
-        total_damage_dealt: participant_data[:total_damage_dealt],
-        total_damage_taken: participant_data[:total_damage_taken],
-        minions_killed: participant_data[:minions_killed],
-        jungle_minions_killed: participant_data[:neutral_minions_killed],
+        damage_dealt_champions: participant_data[:total_damage_dealt],
+        damage_dealt_total: participant_data[:total_damage_dealt],
+        damage_taken: participant_data[:total_damage_taken],
+        cs: participant_data[:minions_killed].to_i + participant_data[:neutral_minions_killed].to_i,
         vision_score: participant_data[:vision_score],
         wards_placed: participant_data[:wards_placed],
-        wards_killed: participant_data[:wards_killed],
-        champion_level: participant_data[:champion_level],
-        first_blood_kill: participant_data[:first_blood_kill],
+        wards_destroyed: participant_data[:wards_killed],
+        first_blood: participant_data[:first_blood_kill],
         double_kills: participant_data[:double_kills],
         triple_kills: participant_data[:triple_kills],
         quadra_kills: participant_data[:quadra_kills],
         penta_kills: participant_data[:penta_kills],
         performance_score: calculate_performance_score(participant_data)
       )
+      created_count += 1
+      Rails.logger.info "Stat created successfully for #{player.summoner_name}"
     end
+
+    Rails.logger.info "Created #{created_count} player match stats"
   end
 
   def determine_match_type(game_mode)

app/services/riot_api_service.rb

@@ -141,11 +141,15 @@ def check_rate_limit!
   end
 
   def platform_for_region(region)
-    REGIONS.dig(region.upcase, :platform) || raise(RiotApiError, "Unknown region: #{region}")
+    # Handle both 'BR' and 'br1' formats
+    clean_region = region.to_s.upcase.gsub(/\d+/, '')
+    REGIONS.dig(clean_region, :platform) || raise(RiotApiError, "Unknown region: #{region}")
   end
 
   def regional_route_for_region(region)
-    REGIONS.dig(region.upcase, :region) || raise(RiotApiError, "Unknown region: #{region}")
+    # Handle both 'BR' and 'br1' formats
+    clean_region = region.to_s.upcase.gsub(/\d+/, '')
+    REGIONS.dig(clean_region, :region) || raise(RiotApiError, "Unknown region: #{region}")
   end
 
   def parse_summoner_response(response)