feat: implement inhouse integration

Author: Bulletdev

app/models/inhouse.rb

@@ -3,23 +3,28 @@
 # Represents an internal practice session where an organization's own players
 # compete against each other in a controlled environment.
 #
-# An inhouse goes through three phases:
+# An inhouse goes through four phases:
 #   waiting     — lobby open, players joining
-#   in_progress — teams balanced, games being played
+#   draft       — captain draft in progress (picks 1-2-2-2-1)
+#   in_progress — teams set, games being played
 #   done        — session closed
 #
 class Inhouse < ApplicationRecord
+  PICK_ORDER = %w[blue red red blue blue red red blue].freeze
+
   # Associations
   belongs_to :organization
   belongs_to :created_by, class_name: 'User', foreign_key: :created_by_user_id
+  belongs_to :blue_captain, class_name: 'Player', optional: true
+  belongs_to :red_captain,  class_name: 'Player', optional: true
   has_many :inhouse_participations, dependent: :destroy
   has_many :players, through: :inhouse_participations
 
   # Enum
-  enum :status, { waiting: 'waiting', in_progress: 'in_progress', done: 'done' }, prefix: false
+  enum :status, { waiting: 'waiting', draft: 'draft', in_progress: 'in_progress', done: 'done' }, prefix: false
 
   # Scopes
-  scope :active, -> { where(status: %w[waiting in_progress]) }
+  scope :active, -> { where(status: %w[waiting draft in_progress]) }
   scope :history, -> { where(status: 'done') }
   scope :recent, -> { order(created_at: :desc) }
 
@@ -28,13 +33,29 @@ class Inhouse < ApplicationRecord
 
   validate :valid_status_transition, on: :update
 
+  # Returns which team should pick next during draft ('blue' or 'red').
+  # Returns nil if draft is not active or all picks are done.
+  def current_pick_team
+    return nil unless draft?
+    return nil if draft_pick_number.nil?
+    return nil if draft_pick_number >= PICK_ORDER.size
+
+    PICK_ORDER[draft_pick_number]
+  end
+
+  # True when all 8 non-captain picks have been made.
+  def draft_complete?
+    draft_pick_number.to_i >= PICK_ORDER.size
+  end
+
   private
 
   def valid_status_transition
     return unless status_changed?
 
     allowed = {
-      'waiting' => %w[in_progress done],
+      'waiting' => %w[draft in_progress done],
+      'draft' => %w[in_progress done],
       'in_progress' => %w[done],
       'done' => []
     }

app/models/inhouse_queue.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Represents a role-based queue for an inhouse session.
+# Players join the queue by role (max 2 per role, 10 total).
+# Once full and checked-in, a coach starts the session from this queue.
+#
+# Lifecycle: open → check_in → closed
+#
+class InhouseQueue < ApplicationRecord
+  ROLES     = %w[top jungle mid adc support].freeze
+  MAX_SLOTS = 10 # 5 roles × 2 players
+
+  belongs_to :organization
+  belongs_to :created_by, class_name: 'User', foreign_key: :created_by_user_id
+  has_many   :inhouse_queue_entries, dependent: :destroy
+  has_many   :players, through: :inhouse_queue_entries
+
+  enum :status, { open: 'open', check_in: 'check_in', closed: 'closed' }, prefix: false
+
+  scope :active, -> { where(status: %w[open check_in]) }
+  scope :recent, -> { order(created_at: :desc) }
+
+  validates :status, presence: true, inclusion: { in: statuses.keys }
+
+  def full?
+    inhouse_queue_entries.size >= MAX_SLOTS
+  end
+
+  def slots_for_role(role)
+    inhouse_queue_entries.where(role: role).count
+  end
+
+  def checked_in_entries
+    inhouse_queue_entries.where(checked_in: true)
+  end
+
+  def serialize(detailed: false)
+    result = {
+      id: id,
+      status: status,
+      check_in_deadline: check_in_deadline,
+      total_entries: inhouse_queue_entries.size,
+      total_slots: MAX_SLOTS,
+      full: full?,
+      created_at: created_at
+    }
+
+    merge_detailed_fields(result) if detailed
+    result
+  end
+
+  private
+
+  def merge_detailed_fields(result)
+    loaded = inhouse_queue_entries.includes(:player)
+    by_role = loaded.group_by(&:role)
+    result[:entries_by_role] = ROLES.index_with { |role| (by_role[role] || []).map(&:serialize) }
+    result[:entries] = loaded.map(&:serialize)
+  end
+end

app/models/inhouse_queue_entry.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# A single player slot in an InhouseQueue.
+# Tracks role, tier at join time, and check-in status.
+class InhouseQueueEntry < ApplicationRecord
+  belongs_to :inhouse_queue
+  belongs_to :player
+
+  validates :role, presence: true, inclusion: { in: InhouseQueue::ROLES }
+  validates :player_id, uniqueness: { scope: :inhouse_queue_id, message: 'is already in this queue' }
+
+  def serialize
+    {
+      id: id,
+      player_id: player_id,
+      player_name: player&.summoner_name,
+      role: role,
+      tier_snapshot: tier_snapshot,
+      checked_in: checked_in,
+      checked_in_at: checked_in_at
+    }
+  end
+end

app/models/organization.rb

@@ -47,7 +47,8 @@ class Organization < ApplicationRecord
 
   # New tier-based associations
   has_many :scrims, dependent: :destroy
-  has_many :inhouses, dependent: :destroy
+  has_many :inhouses,       dependent: :destroy
+  has_many :inhouse_queues, dependent: :destroy
   has_many :competitive_matches, dependent: :destroy
   has_many :messages,     dependent: :destroy
   has_many :saved_builds, dependent: :destroy