Database handling added

1 files changed, 42 insertions, 41 deletions

diff --git a/src/match_up/controller.py b/src/match_up/controller.py
index a21fced..3b4a6f9 100644
--- a/src/match_up/controller.py
+++ b/src/match_up/controller.py
@@ -5,6 +5,8 @@ from match_up.utilities import sample_list, Timer
 from match_up.model import (
     Team,
     Game,
+    Player,
+    DisplayPlayer,
     PlayerList,
     CourtList,
     MAX_LEVEL,
@@ -13,37 +15,51 @@ from match_up.model import (
 
 
 def _create_placeholders(courts: dict, name: str) -> list[Game]:
-    dummy_team = Team(player1=name, player2=name)
+    dummy_player = Player(first=name)
+    dummy_team = Team(
+        player1=DisplayPlayer(dummy_player), player2=DisplayPlayer(dummy_player)
+    )
     games = [Game(court, dummy_team, dummy_team) for court in courts]
     return games
 
 
-def _normalize_skill(players: dict, new_max: int) -> int:
-    player_levels = []
-    for _, player in players.items():
-        skill_level = player.skill
-        new_level = round((new_max - 1) * (skill_level / MAX_LEVEL)) + 1
-        player_levels.append(new_level)
-    return player_levels
+def _normalize_skill(level: int, new_max: int) -> int:
+    new_level = round((new_max - 1) * (level / MAX_LEVEL)) + 1
+    return new_level
 
 
-def _create_groups_of_four_players(players: dict, new_max: int) -> list[dict]:
-    player_levels = _normalize_skill(players, new_max)
-    identifiers = sample_list([*players], player_levels)
-    clumps = []
+def _select_players(players: list[Player], count: int) -> dict:
+    identifiers = [player.id for player in players]
+    play_count = [player.count for player in players]
+    ids = sample_list(identifiers, play_count, count)
+    selected_players = [player for player in players if player.id in ids]
+    return selected_players
+
+
+def _create_groups_of_four_players(
+    players: list[Player], new_max: int
+) -> list[list[Player]]:
+    identifiers = [player.id for player in players]
+    player_levels = [_normalize_skill(player.level, new_max) for player in players]
+    identifiers = sample_list(identifiers, player_levels)
+    court_players = []
     for i in range(0, len(players), PLAYER_PER_COURT):
-        clumps.append(identifiers[i : i + PLAYER_PER_COURT])
-    combinations = [{id: players[id] for id in clump} for clump in clumps]
-    return combinations
+        court_ids = identifiers[i : i + PLAYER_PER_COURT]
+        selected_players = [player for player in players if player.id in court_ids]
+        court_players.append(selected_players)
+    return court_players
 
 
-def _create_games(courts: dict, players: list[dict], levels: int):
-    grouped_players = _create_groups_of_four_players(players, levels)
+def _create_games(courts: dict, players: list[Player], levels: int):
+    court_players = _create_groups_of_four_players(players, levels)
     games = []
-    for court, players in zip(courts, grouped_players):
-        ids = [*players]
-        team1 = Team(player1=players[ids[0]].name, player2=players[ids[3]].name)
-        team2 = Team(player1=players[ids[1]].name, player2=players[ids[2]].name)
+    for court, players in zip(courts, court_players):
+        team1 = Team(
+            player1=DisplayPlayer(players[0]), player2=DisplayPlayer(players[3])
+        )
+        team2 = Team(
+            player1=DisplayPlayer(players[1]), player2=DisplayPlayer(players[2])
+        )
         games.append(Game(court, team1, team2))
     return games
 
@@ -57,8 +73,7 @@ class RoundGenerator:
 
     def __post_init__(self) -> None:
         self.timer = Timer()
-        self.history = {key: 0 for key, _ in self.players.get_players().items()}
-        self.games = self._generate_proposal(MAX_LEVEL)[0]
+        self.games = _create_placeholders(self.courts.get_courts(), "---")
 
     def _separate_courts(self, courts: dict) -> Tuple[dict, dict]:
         possible_games = min(len(courts), self.players.get_possible_game_count())
@@ -67,20 +82,6 @@ class RoundGenerator:
         unused_courts = dict(courts_as_list[possible_games:])
         return used_courts, unused_courts
 
-    def _select_players(self, count: int) -> dict:
-        active_players = self.players.get_potential_players()
-        identifiers = [*active_players]
-        play_count = [
-            (
-                self.history[player_id]
-                if player_id < self.players.guest_id_start
-                else self.round
-            )
-            for player_id in active_players
-        ]
-        ids = sample_list(identifiers, play_count, count)
-        return {player_id: active_players[player_id] for player_id in ids}
-
     def _create_inactive_games(self) -> list[Game]:
         active_courts, reserved_courts = self.courts.separate_courts()
         reserved_games = _create_placeholders(reserved_courts, "RESERVED")
@@ -93,7 +94,8 @@ class RoundGenerator:
         active_courts, _ = self.courts.separate_courts()
         used_courts, _ = self._separate_courts(active_courts)
         required_player_count = len(used_courts) * PLAYER_PER_COURT
-        selected_players = self._select_players(required_player_count)
+        active_players = self.players.get_players()
+        selected_players = _select_players(active_players, required_player_count)
         games = _create_games(used_courts, selected_players, total_levels)
         return games, selected_players
 
@@ -117,9 +119,8 @@ class RoundGenerator:
         if self.games == proposed_games or len(proposed_games) == 0:
             return self.games
         self.games = proposed_games
-        for player_id in proposed_players:
-            if player_id < self.players.guest_id_start:
-                self.history[player_id] = self.history[player_id] + 1
+        identifiers = [player.id for player in proposed_players]
+        self.players.increment_game_count(identifiers)
         self.proposal = tuple()
         self.round += 1
         self.timer.start()