Using eager loading in GenerateTournamentMatches and AdvanceWrestler, generating/manipulating in-memory, and doing a single bulk insert or update at the end.

app/services/tournament_services/pool_to_bracket_match_generation.rb

@@ -1,44 +1,92 @@
 class PoolToBracketMatchGeneration
-   def initialize( tournament )
+   def initialize(tournament, weights: nil, wrestlers_by_weight_id: nil)
       @tournament = tournament
+      @weights = weights
+      @wrestlers_by_weight_id = wrestlers_by_weight_id
     end
 	
 	def generatePoolToBracketMatches
-        @tournament.weights.order(:max).each do |weight|
-          PoolGeneration.new(weight).generatePools()
-          last_match = @tournament.matches.where(weight: weight).order(round: :desc).limit(1).first
-          highest_round = last_match.round
-          PoolBracketGeneration.new(weight, highest_round).generateBracketMatches()
+        rows = []
+        generation_weights.each do |weight|
+          wrestlers = wrestlers_for_weight(weight)
+          pool_rows = PoolGeneration.new(weight, wrestlers: wrestlers).generatePools
+          rows.concat(pool_rows)
+
+          highest_round = pool_rows.map { |row| row[:round] }.max || 0
+          bracket_rows = PoolBracketGeneration.new(weight, highest_round).generateBracketMatches
+          rows.concat(bracket_rows)
         end
-        movePoolSeedsToFinalPoolRound
+
+        movePoolSeedsToFinalPoolRound(rows)
+        rows
     end
     
-    def movePoolSeedsToFinalPoolRound
-	    @tournament.weights.each do |w|
-	      setOriginalSeedsToWrestleLastPoolRound(w)
+    def movePoolSeedsToFinalPoolRound(match_rows)
+	    generation_weights.each do |w|
+	      setOriginalSeedsToWrestleLastPoolRound(w, match_rows)
 	    end
   	end
     
-    def setOriginalSeedsToWrestleLastPoolRound(weight)
+    def setOriginalSeedsToWrestleLastPoolRound(weight, match_rows)
 		pool = 1
-		until pool > weight.pools
-			wrestler1 = weight.pool_wrestlers_sorted_by_bracket_line(pool).first
-			wrestler2 = weight.pool_wrestlers_sorted_by_bracket_line(pool).second
-			match = wrestler1.pool_matches.sort_by{|m| m.round}.last
-			if match.w1 != wrestler2.id or match.w2 != wrestler2.id
-				if match.w1 == wrestler1.id
-					SwapWrestlers.new.swap_wrestlers_bracket_lines(match.w2,wrestler2.id)
-				elsif match.w2 == wrestler1.id
-					SwapWrestlers.new.swap_wrestlers_bracket_lines(match.w1,wrestler2.id)
-				end
+    wrestlers = wrestlers_for_weight(weight)
+    weight_pools = weight.pools
+		until pool > weight_pools
+			pool_wrestlers = wrestlers.select { |w| w.pool == pool }.sort_by(&:bracket_line)
+      wrestler1 = pool_wrestlers.first
+      wrestler2 = pool_wrestlers.second
+      if wrestler1 && wrestler2
+        pool_matches = match_rows.select { |row| row[:weight_id] == weight.id && row[:bracket_position] == "Pool" && (row[:w1] == wrestler1.id || row[:w2] == wrestler1.id) }
+        match = pool_matches.max_by { |row| row[:round] }
+        if match && (match[:w1] != wrestler2.id || match[:w2] != wrestler2.id)
+          if match[:w1] == wrestler1.id
+            swap_wrestlers_in_memory(match_rows, wrestlers, match[:w2], wrestler2.id)
+          elsif match[:w2] == wrestler1.id
+            swap_wrestlers_in_memory(match_rows, wrestlers, match[:w1], wrestler2.id)
+          end
+        end
 			end
 		    pool += 1
 		end
 	end 
-	
-	
+
+  def swap_wrestlers_in_memory(match_rows, wrestlers, wrestler1_id, wrestler2_id)
+    w1 = wrestlers.find { |w| w.id == wrestler1_id }
+    w2 = wrestlers.find { |w| w.id == wrestler2_id }
+    return unless w1 && w2
+
+    w1_bracket_line, w1_pool = w1.bracket_line, w1.pool
+    w1.bracket_line, w1.pool = w2.bracket_line, w2.pool
+    w2.bracket_line, w2.pool = w1_bracket_line, w1_pool
+
+    swap_match_rows(match_rows, wrestler1_id, wrestler2_id)
+  end
+
+  def swap_match_rows(match_rows, wrestler1_id, wrestler2_id)
+    match_rows.each do |row|
+      row[:w1] = swap_id(row[:w1], wrestler1_id, wrestler2_id)
+      row[:w2] = swap_id(row[:w2], wrestler1_id, wrestler2_id)
+      row[:winner_id] = swap_id(row[:winner_id], wrestler1_id, wrestler2_id)
+    end
+  end 
+
+  def swap_id(value, wrestler1_id, wrestler2_id)
+    return wrestler2_id if value == wrestler1_id
+    return wrestler1_id if value == wrestler2_id
+
+    value
+  end
+
+  def generation_weights
+    @weights || @tournament.weights.order(:max).to_a
+  end
+
+  def wrestlers_for_weight(weight)
+    @wrestlers_by_weight_id&.fetch(weight.id, nil) || weight.wrestlers.to_a
+  end
+
 	def assignLoserNames
 		PoolToBracketGenerateLoserNames.new(@tournament).assignLoserNames	
 	end
 	
-end
+end