feat: implement tier thresholds

Bulletdev · Bulletdev · commit ac72fa2b5466 · 2026-04-15T08:28:20.000-03:00
diff --git a/app/modules/players/models/player.rb b/app/modules/players/models/player.rb
@@ -40,6 +40,7 @@ class Player < ApplicationRecord
   # Associations
   # optional: true — self-registered free agents (ArenaBR) can exist without an org
   belongs_to :organization, optional: true
+  belongs_to :scouted_from, class_name: 'ScoutingTarget', optional: true
   has_many :player_match_stats, dependent: :destroy
   has_many :matches, through: :player_match_stats
   has_many :champion_pools, dependent: :destroy
diff --git a/app/modules/players/services/roster_management_service.rb b/app/modules/players/services/roster_management_service.rb
@@ -84,8 +84,15 @@ def self.hire_from_scouting(scouting_target:, organization:, contract_start:, co
       watchlist = scouting_target.scouting_watchlists.find_by(organization: organization)
       watchlist&.destroy
 
-      # Clean up the global target if no other org is watching it
-      scouting_target.destroy if scouting_target.scouting_watchlists.none?
+      # Mark the global target as signed (never destroy — it is permanent scouting history)
+      scouting_target.update_columns(status: 'signed') if scouting_target.scouting_watchlists.none?
+
+      # Link the player back to the scouting record and store a snapshot of the data
+      # that informed the hiring decision, so coaches can audit it later.
+      player.update_columns(
+        scouted_from_id: scouting_target.id,
+        scouting_data_snapshot: RosterManagementService.build_scouting_snapshot(scouting_target)
+      )
 
       # Log the action
       log_roster_addition(player, scouting_target, current_user)
@@ -197,19 +204,23 @@ def find_or_build_scouting_target
   def assign_scouting_target_attributes(target)
     recent_perf = calculate_recent_performance(player)
     recent_perf[:champion_pool_stats] = calculate_champion_stats(player)
+    pool = calculate_champion_pool_from_stats(player)
+    tier = player.solo_queue_tier
 
     target.assign_attributes(
       summoner_name: player.summoner_name,
       region: normalize_region(player.region),
       riot_puuid: player.riot_puuid,
       role: player.role,
-      current_tier: player.solo_queue_tier,
+      current_tier: tier,
       current_rank: player.solo_queue_rank,
       current_lp: player.solo_queue_lp,
-      champion_pool: calculate_champion_pool_from_stats(player),
+      champion_pool: pool,
       recent_performance: recent_perf,
       performance_trend: calculate_performance_trend(player),
       playstyle: extract_playstyle_from_notes(player.notes),
+      strengths: derive_strengths(recent_perf, pool, player.role, tier),
+      weaknesses: derive_weaknesses(recent_perf, pool, player.role, tier),
       twitter_handle: player.twitter_handle,
       status: 'free_agent',
       real_name: player.real_name,
@@ -396,6 +407,63 @@ def last_game_date_for(stats)
     match.game_start&.to_date
   end
 
+  # Returns stat thresholds adjusted to the player's ranked tier.
+  # High elo players are held to a stricter standard — what is average
+  # at Platinum is a weakness at Challenger.
+  #
+  # @param tier [String, nil] e.g. "CHALLENGER", "DIAMOND", "GOLD"
+  # @return [Hash] threshold values for strengths and weaknesses
+  def tier_thresholds(tier)
+    case tier&.upcase
+    when 'CHALLENGER', 'GRANDMASTER', 'MASTER'
+      { wr_strength: 53, wr_weakness: 49, kda_strength: 4.5, kda_weakness: 3.0,
+        cs_strength: 9.0, cs_weakness: 7.5, vision_strength: 45, vision_weakness: 28 }
+    when 'DIAMOND', 'EMERALD'
+      { wr_strength: 54, wr_weakness: 47, kda_strength: 4.0, kda_weakness: 2.5,
+        cs_strength: 8.5, cs_weakness: 7.0, vision_strength: 42, vision_weakness: 24 }
+    else
+      { wr_strength: 55, wr_weakness: 45, kda_strength: 3.5, kda_weakness: 2.0,
+        cs_strength: 8.0, cs_weakness: 6.0, vision_strength: 40, vision_weakness: 20 }
+    end
+  end
+
+  # Derive positive traits from performance stats, calibrated to the player's tier.
+  def derive_strengths(perf, pool, role, tier = nil)
+    return [] if perf.blank?
+
+    t = tier_thresholds(tier)
+    strengths = []
+    strengths << 'Consistency'         if perf[:win_rate].to_f >= t[:wr_strength]
+    strengths << 'Mechanical skill'    if perf[:avg_kda].to_f >= t[:kda_strength]
+    strengths << 'CS discipline'       if non_support?(role) && perf[:avg_cs_per_min].to_f >= t[:cs_strength]
+    strengths << 'Map awareness'       if vision_role?(role) && perf[:avg_vision_score].to_f >= t[:vision_strength]
+    strengths << 'Team fighting'       if perf[:avg_kill_participation].to_f >= 65.0
+    strengths << 'Champion pool depth' if pool.size >= 6
+    strengths
+  end
+
+  # Derive areas for improvement, calibrated to the player's tier.
+  def derive_weaknesses(perf, pool, role, tier = nil)
+    return [] if perf.blank?
+
+    t = tier_thresholds(tier)
+    weaknesses = []
+    weaknesses << 'Inconsistent performance' if perf[:games_played].to_i >= 10 && perf[:win_rate].to_f < t[:wr_weakness]
+    weaknesses << 'Death management'         if perf[:avg_kda].to_f.positive? && perf[:avg_kda].to_f < t[:kda_weakness]
+    weaknesses << 'CS discipline'            if non_support?(role) && perf[:avg_cs_per_min].to_f.positive? && perf[:avg_cs_per_min].to_f < t[:cs_weakness]
+    weaknesses << 'Vision control'           if vision_role?(role) && perf[:avg_vision_score].to_f.positive? && perf[:avg_vision_score].to_f < t[:vision_weakness]
+    weaknesses << 'Limited champion pool'    if pool.size < 3
+    weaknesses
+  end
+
+  def non_support?(role)
+    role.to_s != 'support'
+  end
+
+  def vision_role?(role)
+    %w[support jungle].include?(role.to_s)
+  end
+
   # Extract playstyle from player notes
   def extract_playstyle_from_notes(notes)
     return nil if notes.blank?
@@ -501,5 +569,28 @@ def self.addition_new_values(player, scouting_target)
     }
   end
 
-  private_class_method :find_or_restore_player, :log_roster_addition, :addition_old_values, :addition_new_values
+  # Snapshot of the scouting target at the moment of hiring.
+  # Stored in players.scouting_data_snapshot so the record is immutable even if
+  # the ScoutingTarget is later re-synced or its status changes.
+  def self.build_scouting_snapshot(target)
+    {
+      summoner_name: target.summoner_name,
+      role: target.role,
+      region: target.region,
+      current_tier: target.current_tier,
+      current_rank: target.current_rank,
+      current_lp: target.current_lp,
+      champion_pool: target.champion_pool,
+      recent_performance: target.recent_performance,
+      performance_trend: target.performance_trend,
+      strengths: target.strengths,
+      weaknesses: target.weaknesses,
+      playstyle: target.playstyle,
+      scouting_score: target.scouting_score,
+      snapshotted_at: Time.current.iso8601
+    }
+  end
+
+  private_class_method :find_or_restore_player, :log_roster_addition, :addition_old_values,
+                       :addition_new_values, :build_scouting_snapshot
 end
diff --git a/app/modules/riot_integration/services/data_dragon_service.rb b/app/modules/riot_integration/services/data_dragon_service.rb
@@ -94,8 +94,7 @@ def fetch_champion_data
     champion_map = {}
     data['data'].each_value do |champion|
       champion_id = champion['key'].to_i
-      champion_name = champion['id'] # This is the champion name like "Aatrox"
-      champion_map[champion_id] = champion_name
+      champion_map[champion_id] = champion['name'] # display name: "Wukong", "Lee Sin", etc.
     end
 
     champion_map
diff --git a/app/modules/scouting/controllers/players_controller.rb b/app/modules/scouting/controllers/players_controller.rb
@@ -201,14 +201,22 @@ def perform_sync_from_riot
         league_data = riot_service.get_league_entries_by_puuid(puuid: @target.riot_puuid, region: region)
         mastery_data = riot_service.get_champion_mastery(puuid: @target.riot_puuid, region: region)
 
+        pool = extract_champion_pool(mastery_data)
+        perf = @target.recent_performance || {}
+        tier = league_data[:solo_queue]&.dig(:tier) || @target.current_tier
+        strengths = derive_strengths(perf, pool, @target.role, tier)
+        weaknesses = derive_weaknesses(perf, pool, @target.role, tier)
+
         @target.update!(
           # riot_summoner_id is no longer returned by Riot API
           summoner_name: "#{account_data[:game_name]}##{account_data[:tag_line]}",
           current_tier: league_data[:solo_queue]&.dig(:tier),
           current_rank: league_data[:solo_queue]&.dig(:rank),
           current_lp: league_data[:solo_queue]&.dig(:lp),
-          champion_pool: extract_champion_pool(mastery_data),
-          performance_trend: calculate_performance_trend(league_data)
+          champion_pool: pool,
+          performance_trend: calculate_performance_trend(league_data),
+          strengths: strengths,
+          weaknesses: weaknesses
         )
 
         watchlist = @target.scouting_watchlists.find_by(organization: current_organization)
@@ -240,7 +248,11 @@ def apply_filters(targets)
       end
 
       def apply_basic_filters(targets)
-        targets = targets.by_role(params[:role]) if params[:role].present?
+        # role param is comma-separated lowercase: "mid,top" → ["mid", "top"]
+        if params[:role].present?
+          roles = params[:role].split(',').map(&:strip).reject(&:blank?)
+          targets = targets.by_role(roles) if roles.any?
+        end
         targets = targets.by_status(params[:status]) if params[:status].present?
         targets = targets.by_region(params[:region]) if params[:region].present?
 
@@ -256,18 +268,19 @@ def apply_basic_filters(targets)
       end
 
       def apply_age_range_filter(targets)
-        return targets unless params[:age_range].present? && params[:age_range].is_a?(Array)
+        min_age = params[:age_min].presence&.to_i
+        max_age = params[:age_max].presence&.to_i
+        return targets unless min_age && max_age
 
-        min_age, max_age = params[:age_range]
-        min_age && max_age ? targets.where(age: min_age..max_age) : targets
+        targets.where(age: min_age..max_age)
       end
 
       def apply_rank_range_filter(targets)
-        return targets unless params[:rank_range].present?
+        min_lp = params[:lp_min].presence&.to_i
+        max_lp = params[:lp_max].presence&.to_i
+        return targets unless min_lp && max_lp
 
-        # Rank range filtering by LP
-        min_lp, max_lp = params[:rank_range]
-        min_lp && max_lp ? targets.where(current_lp: min_lp..max_lp) : targets
+        targets.where(current_lp: min_lp..max_lp)
       end
 
       def apply_search_filter(targets)
@@ -367,33 +380,69 @@ def target_params
         )
       end
 
-      # Extract top champions from mastery data
+      # Thresholds calibrated by tier. Mirrors RosterManagementService#tier_thresholds.
+      # JSONB from DB returns string keys, so we use with_indifferent_access throughout.
+      def tier_thresholds(tier)
+        case tier&.upcase
+        when 'CHALLENGER', 'GRANDMASTER', 'MASTER'
+          { wr_strength: 53, wr_weakness: 49, kda_strength: 4.5, kda_weakness: 3.0,
+            cs_strength: 9.0, cs_weakness: 7.5, vision_strength: 45, vision_weakness: 28 }
+        when 'DIAMOND', 'EMERALD'
+          { wr_strength: 54, wr_weakness: 47, kda_strength: 4.0, kda_weakness: 2.5,
+            cs_strength: 8.5, cs_weakness: 7.0, vision_strength: 42, vision_weakness: 24 }
+        else
+          { wr_strength: 55, wr_weakness: 45, kda_strength: 3.5, kda_weakness: 2.0,
+            cs_strength: 8.0, cs_weakness: 6.0, vision_strength: 40, vision_weakness: 20 }
+        end
+      end
+
+      def derive_strengths(perf, pool, role, tier = nil)
+        return [] if perf.blank?
+
+        p = perf.with_indifferent_access
+        t = tier_thresholds(tier)
+        strengths = []
+        strengths << 'Consistency'         if p[:win_rate].to_f >= t[:wr_strength]
+        strengths << 'Mechanical skill'    if p[:avg_kda].to_f >= t[:kda_strength]
+        strengths << 'CS discipline'       if non_support?(role) && p[:avg_cs_per_min].to_f >= t[:cs_strength]
+        strengths << 'Map awareness'       if vision_role?(role) && p[:avg_vision_score].to_f >= t[:vision_strength]
+        strengths << 'Team fighting'       if p[:avg_kill_participation].to_f >= 65.0
+        strengths << 'Champion pool depth' if pool.size >= 6
+        strengths
+      end
+
+      def derive_weaknesses(perf, pool, role, tier = nil)
+        return [] if perf.blank?
+
+        p = perf.with_indifferent_access
+        t = tier_thresholds(tier)
+        weaknesses = []
+        weaknesses << 'Inconsistent performance' if p[:games_played].to_i >= 10 && p[:win_rate].to_f < t[:wr_weakness]
+        weaknesses << 'Death management'         if p[:avg_kda].to_f.positive? && p[:avg_kda].to_f < t[:kda_weakness]
+        weaknesses << 'CS discipline'            if non_support?(role) && p[:avg_cs_per_min].to_f.positive? && p[:avg_cs_per_min].to_f < t[:cs_weakness]
+        weaknesses << 'Vision control'           if vision_role?(role) && p[:avg_vision_score].to_f.positive? && p[:avg_vision_score].to_f < t[:vision_weakness]
+        weaknesses << 'Limited champion pool'    if pool.size < 3
+        weaknesses
+      end
+
+      def non_support?(role)
+        role.to_s != 'support'
+      end
+
+      def vision_role?(role)
+        %w[support jungle].include?(role.to_s)
+      end
+
+      # Extract top champions from mastery data using DataDragonService for full champion coverage.
+      # Falls back to "Champion_<id>" only when Data Dragon is unreachable.
       def extract_champion_pool(mastery_data)
         return [] if mastery_data.blank?
 
-        # Get top 10 champions by mastery points
-        mastery_data.first(10).map do |mastery|
-          champion_id_to_name(mastery[:champion_id])
-        end.compact
-      end
-
-      # Simple champion ID to name mapping (top champions)
-      def champion_id_to_name(champion_id)
-        # This is a simplified mapping - in production you'd want a complete mapping
-        # or fetch from Data Dragon API
-        champion_map = {
-          1 => 'Annie', 2 => 'Olaf', 3 => 'Galio', 4 => 'Twisted Fate',
-          5 => 'Xin Zhao', 6 => 'Urgot', 7 => 'LeBlanc', 8 => 'Vladimir',
-          9 => 'Fiddlesticks', 10 => 'Kayle', 11 => 'Master Yi', 12 => 'Alistar',
-          13 => 'Ryze', 14 => 'Sion', 15 => 'Sivir', 16 => 'Soraka',
-          17 => 'Teemo', 18 => 'Tristana', 19 => 'Warwick', 20 => 'Nunu',
-          21 => 'Miss Fortune', 22 => 'Ashe', 23 => 'Tryndamere', 24 => 'Jax',
-          25 => 'Morgana', 26 => 'Zilean', 27 => 'Singed', 28 => 'Evelynn',
-          29 => 'Twitch', 30 => 'Karthus', 31 => 'Cho\'Gath', 32 => 'Amumu',
-          33 => 'Rammus', 34 => 'Anivia', 35 => 'Shaco', 36 => 'Dr. Mundo'
-          # Add more as needed or fetch from Data Dragon
-        }
-        champion_map[champion_id] || "Champion_#{champion_id}"
+        id_map = DataDragonService.new.champion_id_map
+
+        mastery_data.first(10).filter_map do |mastery|
+          id_map[mastery[:champion_id].to_i]
+        end
       end
 
       # Calculate performance trend based on win/loss ratio
diff --git a/db/migrate/20260414145951_add_scouting_origin_to_players.rb b/db/migrate/20260414145951_add_scouting_origin_to_players.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Preserves the link between a hired player and the ScoutingTarget they came from.
+# Also stores a snapshot of the scouting data at the time of hiring so that even if
+# the ScoutingTarget is later updated or the status changes, the coach can always see
+# what data drove the hiring decision.
+class AddScoutingOriginToPlayers < ActiveRecord::Migration[7.1]
+  def change
+    add_column :players, :scouted_from_id, :uuid, null: true
+    add_column :players, :scouting_data_snapshot, :jsonb, null: false, default: {}
+
+    add_index :players, :scouted_from_id
+    add_foreign_key :players, :scouting_targets, column: :scouted_from_id, on_delete: :nullify
+  end
+end
