made icon optional and default to empty string & adjust all game instances

# Conflicts:
#	lib/data/dto/game.dart
#	lib/l10n/arb/app_de.arb
#	lib/l10n/arb/app_en.arb
#	lib/l10n/generated/app_localizations.dart
#	lib/l10n/generated/app_localizations_de.dart
#	lib/presentation/views/main_menu/match_view/create_match/choose_game_view.dart
#	lib/presentation/widgets/text_input/text_input_field.dart
#	pubspec.yaml

analysis_options.yaml

@@ -1,5 +1,9 @@
 include: package:flutter_lints/flutter.yaml
 
+analyzer:
+  exclude:
+    - lib/presentation/views/main_menu/settings_view/licenses/oss_licenses.dart
+
 linter:
   rules:
     avoid_print: false

assets/schema.json

@@ -15,16 +15,91 @@
           },
           "name": {
             "type": "string"
+          },
+          "description": {
+            "type": "string"
           }
         },
         "required": [
           "id",
           "createdAt",
-          "name"
+          "name",
+          "description"
+        ]
+      }
+    },
+    "games": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "createdAt": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          },
+          "ruleset": {
+            "type": "string"
+          },
+          "description": {
+            "type": "string"
+          },
+          "color": {
+            "type": "string"
+          },
+          "icon": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "id",
+          "createdAt",
+          "name",
+          "ruleset",
+          "description",
+          "color",
+          "icon"
         ]
       }
     },
     "groups": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          },
+          "createdAt": {
+            "type": "string"
+          },
+          "description": {
+            "type": "string"
+          },
+          "memberIds": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        },
+        "required": [
+          "id",
+          "name",
+          "createdAt",
+          "description",
+          "memberIds"
+        ]
+      }
+    },
+    "teams": {
       "type": "array",
       "items": {
         "type": "object",
@@ -67,11 +142,14 @@
           "createdAt": {
             "type": "string"
           },
+          "endedAt": {
+            "type": ["string", "null"]
+          },
+          "gameId": {
+            "type": "string"
+          },
           "groupId": {
-            "anyOf": [
-              {"type": "string"},
-              {"type": "null"}
-            ]
+            "type": ["string", "null"]
           },
           "playerIds": {
             "type": "array",
@@ -79,26 +157,26 @@
               "type": "string"
             }
           },
-          "winnerId": {
-            "anyOf": [
-              {"type": "string"},
-              {"type": "null"}
-            ]
+          "notes": {
+            "type": "string"
           }
         },
         "required": [
           "id",
           "name",
           "createdAt",
-          "groupId",
-          "playerIds"
+          "gameId",
+          "playerIds",
+          "notes"
         ]
       }
     }
   },
   "required": [
     "players",
+    "games",
     "groups",
+    "teams",
     "matches"
   ]
 }

ios/Flutter/AppFrameworkInfo.plist

@@ -20,7 +20,5 @@
   <string>????</string>
   <key>CFBundleVersion</key>
   <string>1.0</string>
-  <key>MinimumOSVersion</key>
-  <string>13.0</string>
 </dict>
 </plist>

ios/Runner/AppDelegate.swift

@@ -2,12 +2,15 @@ import Flutter
 import UIKit
 
 @main
-@objc class AppDelegate: FlutterAppDelegate {
+@objc class AppDelegate: FlutterAppDelegate, FlutterImplicitEngineDelegate {
   override func application(
     _ application: UIApplication,
     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
   ) -> Bool {
-    GeneratedPluginRegistrant.register(with: self)
     return super.application(application, didFinishLaunchingWithOptions: launchOptions)
   }
+
+  func didInitializeImplicitFlutterEngine(_ engineBridge: FlutterImplicitEngineBridge) {
+    GeneratedPluginRegistrant.register(with: engineBridge.pluginRegistry)
+  }
 }

ios/Runner/Info.plist

@@ -31,6 +31,27 @@
 	</array>
 	<key>LSRequiresIPhoneOS</key>
 	<true/>
+	<key>UIApplicationSceneManifest</key>
+	<dict>
+		<key>UIApplicationSupportsMultipleScenes</key>
+		<false/>
+		<key>UISceneConfigurations</key>
+		<dict>
+			<key>UIWindowSceneSessionRoleApplication</key>
+			<array>
+				<dict>
+					<key>UISceneClassName</key>
+					<string>UIWindowScene</string>
+					<key>UISceneConfigurationName</key>
+					<string>flutter</string>
+					<key>UISceneDelegateClassName</key>
+					<string>FlutterSceneDelegate</string>
+					<key>UISceneStoryboardFile</key>
+					<string>Main</string>
+				</dict>
+			</array>
+		</dict>
+	</dict>
 	<key>UIApplicationSupportsIndirectInputEvents</key>
 	<true/>
 	<key>UILaunchStoryboardName</key>

lib/core/common.dart

@@ -0,0 +1,90 @@
+import 'package:flutter/material.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/l10n/generated/app_localizations.dart';
+
+/// Translates a [Ruleset] enum value to its corresponding localized string.
+String translateRulesetToString(Ruleset ruleset, BuildContext context) {
+  final loc = AppLocalizations.of(context);
+  switch (ruleset) {
+    case Ruleset.highestScore:
+      return loc.highest_score;
+    case Ruleset.lowestScore:
+      return loc.lowest_score;
+    case Ruleset.singleWinner:
+      return loc.single_winner;
+    case Ruleset.singleLoser:
+      return loc.single_loser;
+    case Ruleset.multipleWinners:
+      return loc.multiple_winners;
+  }
+}
+
+/// Translates a [GameColor] enum value to its corresponding localized string.
+String translateGameColorToString(GameColor color, BuildContext context) {
+  final loc = AppLocalizations.of(context);
+  switch (color) {
+    case GameColor.red:
+      return loc.color_red;
+    case GameColor.blue:
+      return loc.color_blue;
+    case GameColor.green:
+      return loc.color_green;
+    case GameColor.yellow:
+      return loc.color_yellow;
+    case GameColor.purple:
+      return loc.color_purple;
+    case GameColor.orange:
+      return loc.color_orange;
+    case GameColor.pink:
+      return loc.color_pink;
+    case GameColor.teal:
+      return loc.color_teal;
+  }
+}
+
+/// Returns the [Color] object corresponding to a [GameColor] enum value.
+Color getColorFromGameColor(GameColor color) {
+  switch (color) {
+    case GameColor.red:
+      return Colors.red;
+    case GameColor.blue:
+      return Colors.blue;
+    case GameColor.green:
+      return Colors.green;
+    case GameColor.yellow:
+      return Colors.yellow;
+    case GameColor.purple:
+      return Colors.purple;
+    case GameColor.orange:
+      return Colors.orange;
+    case GameColor.pink:
+      return Colors.pink;
+    case GameColor.teal:
+      return Colors.teal;
+  }
+}
+
+/// Counts how many players in the match are not part of the group
+/// Returns the count as a string, or an empty string if there is no group
+String getExtraPlayerCount(Match match) {
+  int count = 0;
+
+  if (match.group == null) {
+    return '';
+  }
+
+  final groupMembers = match.group!.members;
+  final players = match.players;
+
+  for (var player in players) {
+    if (!groupMembers.any((member) => member.id == player.id)) {
+      count++;
+    }
+  }
+
+  if (count == 0) {
+    return '';
+  }
+  return ' + ${count.toString()}';
+}

lib/core/constants.dart

@@ -19,4 +19,7 @@ class Constants {
 
   /// Maximum length for team names
   static const int MAX_TEAM_NAME_LENGTH = 32;
+
+  /// Maximum length for game descriptions
+  static const int MAX_GAME_DESCRIPTION_LENGTH = 256;
 }

lib/core/custom_theme.dart

@@ -27,6 +27,9 @@ class CustomTheme {
   /// Text color used throughout the app
   static const Color textColor = Color(0xFFFFFFFF);
 
+  /// Text color used throughout the app
+  static const Color hintColor = Color(0xFF888888);
+
   /// Background color for the navigation bar
   static const Color navBarBackgroundColor = Color(0xFF131313);
 
@@ -65,7 +68,7 @@ class CustomTheme {
     boxShadow: [BoxShadow(color: primaryColor.withAlpha(120), blurRadius: 12)],
   );
 
-  // ==================== App Bar Theme ====================
+  // ==================== Component Themes ====================
   static const AppBarTheme appBarTheme = AppBarTheme(
     backgroundColor: backgroundColor,
     foregroundColor: textColor,
@@ -80,4 +83,23 @@ class CustomTheme {
     ),
     iconTheme: IconThemeData(color: textColor),
   );
+
+  static const SearchBarThemeData searchBarTheme = SearchBarThemeData(
+    textStyle: WidgetStatePropertyAll(TextStyle(color: CustomTheme.textColor)),
+    hintStyle: WidgetStatePropertyAll(TextStyle(color: CustomTheme.hintColor)),
+  );
+
+  static final RadioThemeData radioTheme = RadioThemeData(
+    fillColor: WidgetStateProperty.resolveWith<Color>((states) {
+      if (states.contains(WidgetState.selected)) {
+        return CustomTheme.primaryColor;
+      }
+      return CustomTheme.textColor;
+    }),
+  );
+
+  static const InputDecorationTheme inputDecorationTheme = InputDecorationTheme(
+    labelStyle: TextStyle(color: CustomTheme.textColor),
+    hintStyle: TextStyle(color: CustomTheme.hintColor),
+  );
 }

lib/core/enums.dart

@@ -1,6 +1,3 @@
-import 'package:flutter/material.dart';
-import 'package:tallee/l10n/generated/app_localizations.dart';
-
 /// Button types used for styling the [CustomWidthButton]
 /// - [ButtonType.primary]: Primary button style.
 /// - [ButtonType.secondary]: Secondary button style.
@@ -29,24 +26,27 @@ enum ImportResult {
 /// - [ExportResult.unknownException]: An exception occurred during export.
 enum ExportResult { success, canceled, unknownException }
 
-/// Different rulesets available for matches
-/// - [Ruleset.singleWinner]: The match is won by a single player
-/// - [Ruleset.singleLoser]: The match is lost by a single player
-/// - [Ruleset.mostPoints]: The player with the most points wins.
-/// - [Ruleset.leastPoints]: The player with the fewest points wins.
-enum Ruleset { singleWinner, singleLoser, mostPoints, leastPoints }
-
-/// Translates a [Ruleset] enum value to its corresponding localized string.
-String translateRulesetToString(Ruleset ruleset, BuildContext context) {
-  final loc = AppLocalizations.of(context);
-  switch (ruleset) {
-    case Ruleset.singleWinner:
-      return loc.single_winner;
-    case Ruleset.singleLoser:
-      return loc.single_loser;
-    case Ruleset.mostPoints:
-      return loc.most_points;
-    case Ruleset.leastPoints:
-      return loc.least_points;
-  }
+/// Different rulesets available for games
+/// - [Ruleset.highestScore]: The player with the highest score wins.
+/// - [Ruleset.lowestScore]: The player with the lowest score wins.
+/// - [Ruleset.singleWinner]: The match is won by a single player.
+/// - [Ruleset.singleLoser]: The match has a single loser.
+/// - [Ruleset.multipleWinners]: Multiple players can be winners.
+enum Ruleset {
+  highestScore,
+  lowestScore,
+  singleWinner,
+  singleLoser,
+  multipleWinners,
 }
+
+/// Different colors available for games
+/// - [GameColor.red]: Red color
+/// - [GameColor.blue]: Blue color
+/// - [GameColor.green]: Green color
+/// - [GameColor.yellow]: Yellow color
+/// - [GameColor.purple]: Purple color
+/// - [GameColor.orange]: Orange color
+/// - [GameColor.pink]: Pink color
+/// - [GameColor.teal]: Teal color
+enum GameColor { red, blue, green, yellow, purple, orange, pink, teal }

lib/data/dao/game_dao.dart

@@ -0,0 +1,166 @@
+import 'package:drift/drift.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/db/tables/game_table.dart';
+import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/core/enums.dart';
+
+part 'game_dao.g.dart';
+
+@DriftAccessor(tables: [GameTable])
+class GameDao extends DatabaseAccessor<AppDatabase> with _$GameDaoMixin {
+  GameDao(super.db);
+
+  /// Retrieves all games from the database.
+  Future<List<Game>> getAllGames() async {
+    final query = select(gameTable);
+    final result = await query.get();
+    return result
+        .map(
+          (row) => Game(
+            id: row.id,
+            name: row.name,
+            ruleset: Ruleset.values.firstWhere((e) => e.name == row.ruleset),
+            description: row.description,
+            color: GameColor.values.firstWhere((e) => e.name == row.color),
+            icon: row.icon,
+            createdAt: row.createdAt,
+          ),
+        )
+        .toList();
+  }
+
+  /// Retrieves a [Game] by its [gameId].
+  Future<Game> getGameById({required String gameId}) async {
+    final query = select(gameTable)..where((g) => g.id.equals(gameId));
+    final result = await query.getSingle();
+    return Game(
+      id: result.id,
+      name: result.name,
+      ruleset: Ruleset.values.firstWhere((e) => e.name == result.ruleset),
+      description: result.description,
+      color: GameColor.values.firstWhere((e) => e.name == result.color),
+      icon: result.icon,
+      createdAt: result.createdAt,
+    );
+  }
+
+  /// Adds a new [game] to the database.
+  /// If a game with the same ID already exists, no action is taken.
+  /// Returns `true` if the game was added, `false` otherwise.
+  Future<bool> addGame({required Game game}) async {
+    if (!await gameExists(gameId: game.id)) {
+      await into(gameTable).insert(
+        GameTableCompanion.insert(
+          id: game.id,
+          name: game.name,
+          ruleset: game.ruleset.name,
+          description: game.description,
+          color: game.color.name,
+          icon: game.icon,
+          createdAt: game.createdAt,
+        ),
+        mode: InsertMode.insertOrReplace,
+      );
+      return true;
+    }
+    return false;
+  }
+
+  /// Adds multiple [games] to the database in a batch operation.
+  /// Uses insertOrIgnore to avoid overwriting existing games.
+  Future<bool> addGamesAsList({required List<Game> games}) async {
+    if (games.isEmpty) return false;
+
+    await db.batch(
+      (b) => b.insertAll(
+        gameTable,
+        games
+            .map(
+              (game) => GameTableCompanion.insert(
+                id: game.id,
+                name: game.name,
+                ruleset: game.ruleset.name,
+                description: game.description,
+                color: game.color.name,
+                icon: game.icon,
+                createdAt: game.createdAt,
+              ),
+            )
+            .toList(),
+        mode: InsertMode.insertOrIgnore,
+      ),
+    );
+
+    return true;
+  }
+
+  /// Deletes the game with the given [gameId] from the database.
+  /// Returns `true` if the game was deleted, `false` if the game did not exist.
+  Future<bool> deleteGame({required String gameId}) async {
+    final query = delete(gameTable)..where((g) => g.id.equals(gameId));
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+
+  /// Checks if a game with the given [gameId] exists in the database.
+  /// Returns `true` if the game exists, `false` otherwise.
+  Future<bool> gameExists({required String gameId}) async {
+    final query = select(gameTable)..where((g) => g.id.equals(gameId));
+    final result = await query.getSingleOrNull();
+    return result != null;
+  }
+
+  /// Updates the name of the game with the given [gameId] to [newName].
+  Future<void> updateGameName({required String gameId, required String newName}) async {
+    await (update(
+      gameTable,
+    )..where((g) => g.id.equals(gameId))).write(GameTableCompanion(name: Value(newName)));
+  }
+
+  /// Updates the ruleset of the game with the given [gameId].
+  Future<void> updateGameRuleset({required String gameId, required Ruleset newRuleset}) async {
+    await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
+      GameTableCompanion(ruleset: Value(newRuleset.name)),
+    );
+  }
+
+  /// Updates the description of the game with the given [gameId].
+  Future<void> updateGameDescription({
+    required String gameId,
+    required String newDescription,
+  }) async {
+    await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
+      GameTableCompanion(description: Value(newDescription)),
+    );
+  }
+
+  /// Updates the color of the game with the given [gameId].
+  Future<void> updateGameColor({required String gameId, required GameColor newColor}) async {
+    await (update(
+      gameTable,
+    )..where((g) => g.id.equals(gameId))).write(GameTableCompanion(color: Value(newColor.name)));
+  }
+
+  /// Updates the icon of the game with the given [gameId].
+  Future<void> updateGameIcon({required String gameId, required String newIcon}) async {
+    await (update(
+      gameTable,
+    )..where((g) => g.id.equals(gameId))).write(GameTableCompanion(icon: Value(newIcon)));
+  }
+
+  /// Retrieves the total count of games in the database.
+  Future<int> getGameCount() async {
+    final count = await (selectOnly(
+      gameTable,
+    )..addColumns([gameTable.id.count()])).map((row) => row.read(gameTable.id.count())).getSingle();
+    return count ?? 0;
+  }
+
+  /// Deletes all games from the database.
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> deleteAllGames() async {
+    final query = delete(gameTable);
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+}

lib/data/dao/game_dao.g.dart

@@ -0,0 +1,8 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'game_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$GameDaoMixin on DatabaseAccessor<AppDatabase> {
+  $GameTableTable get gameTable => attachedDatabase.gameTable;
+}

lib/data/dao/group_dao.dart

@@ -23,6 +23,7 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
         return Group(
           id: groupData.id,
           name: groupData.name,
+          description: groupData.description,
           members: members,
           createdAt: groupData.createdAt,
         );
@@ -42,6 +43,7 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
     return Group(
       id: result.id,
       name: result.name,
+      description: result.description,
       members: members,
       createdAt: result.createdAt,
     );
@@ -56,6 +58,7 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
           GroupTableCompanion.insert(
             id: group.id,
             name: group.name,
+            description: group.description,
             createdAt: group.createdAt,
           ),
           mode: InsertMode.insertOrReplace,
@@ -105,6 +108,7 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
                 (group) => GroupTableCompanion.insert(
                   id: group.id,
                   name: group.name,
+                  description: group.description,
                   createdAt: group.createdAt,
                 ),
               )
@@ -132,6 +136,7 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
                   (p) => PlayerTableCompanion.insert(
                     id: p.id,
                     name: p.name,
+                    description: p.description,
                     createdAt: p.createdAt,
                   ),
                 )
@@ -176,7 +181,7 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
 
   /// Updates the name of the group with the given [id] to [newName].
   /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> updateGroupname({
+  Future<bool> updateGroupName({
     required String groupId,
     required String newName,
   }) async {
@@ -187,6 +192,21 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
     return rowsAffected > 0;
   }
 
+  /// Updates the description of the group with the given [groupId] to [newDescription].
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> updateGroupDescription({
+    required String groupId,
+    required String newDescription,
+  }) async {
+    final rowsAffected =
+        await (update(groupTable)..where((g) => g.id.equals(groupId))).write(
+          GroupTableCompanion(description: Value(newDescription)),
+        );
+    return rowsAffected > 0;
+  }
+
+
+
   /// Retrieves the number of groups in the database.
   Future<int> getGroupCount() async {
     final count =
@@ -211,4 +231,44 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
     final rowsAffected = await query.go();
     return rowsAffected > 0;
   }
+
+  /// Replaces all players in a group with the provided list of players.
+  /// Removes all existing players from the group and adds the new players.
+  /// Also adds any new players to the player table if they don't exist.
+  Future<void> replaceGroupPlayers({
+    required String groupId,
+    required List<Player> newPlayers,
+  }) async {
+    await db.transaction(() async {
+      // Remove all existing players from the group
+      final deleteQuery = delete(db.playerGroupTable)
+        ..where((p) => p.groupId.equals(groupId));
+      await deleteQuery.go();
+
+      // Add new players to the player table if they don't exist
+      await Future.wait(
+        newPlayers.map((player) async {
+          if (!await db.playerDao.playerExists(playerId: player.id)) {
+            await db.playerDao.addPlayer(player: player);
+          }
+        }),
+      );
+
+      // Add the new players to the group
+      await db.batch(
+        (b) => b.insertAll(
+          db.playerGroupTable,
+          newPlayers
+              .map(
+                (player) => PlayerGroupTableCompanion.insert(
+                  playerId: player.id,
+                  groupId: groupId,
+                ),
+              )
+              .toList(),
+          mode: InsertMode.insertOrReplace,
+        ),
+      );
+    });
+  }
 }

lib/data/dao/group_match_dao.dart

@@ -1,98 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/db/tables/group_match_table.dart';
-import 'package:tallee/data/dto/group.dart';
-
-part 'group_match_dao.g.dart';
-
-@DriftAccessor(tables: [GroupMatchTable])
-class GroupMatchDao extends DatabaseAccessor<AppDatabase>
-    with _$GroupMatchDaoMixin {
-  GroupMatchDao(super.db);
-
-  /// Associates a group with a match by inserting a record into the
-  /// [GroupMatchTable].
-  Future<void> addGroupToMatch({
-    required String matchId,
-    required String groupId,
-  }) async {
-    if (await matchHasGroup(matchId: matchId)) {
-      throw Exception('Match already has a group');
-    }
-    await into(groupMatchTable).insert(
-      GroupMatchTableCompanion.insert(groupId: groupId, matchId: matchId),
-      mode: InsertMode.insertOrIgnore,
-    );
-  }
-
-  /// Retrieves the [Group] associated with the given [matchId].
-  /// Returns `null` if no group is found.
-  Future<Group?> getGroupOfMatch({required String matchId}) async {
-    final result = await (select(
-      groupMatchTable,
-    )..where((g) => g.matchId.equals(matchId))).getSingleOrNull();
-
-    if (result == null) {
-      return null;
-    }
-
-    final group = await db.groupDao.getGroupById(groupId: result.groupId);
-    return group;
-  }
-
-  /// Checks if there is a group associated with the given [matchId].
-  /// Returns `true` if there is a group, otherwise `false`.
-  Future<bool> matchHasGroup({required String matchId}) async {
-    final count =
-        await (selectOnly(groupMatchTable)
-              ..where(groupMatchTable.matchId.equals(matchId))
-              ..addColumns([groupMatchTable.groupId.count()]))
-            .map((row) => row.read(groupMatchTable.groupId.count()))
-            .getSingle();
-    return (count ?? 0) > 0;
-  }
-
-  /// Checks if a specific group is associated with a specific match.
-  /// Returns `true` if the group is in the match, otherwise `false`.
-  Future<bool> isGroupInMatch({
-    required String matchId,
-    required String groupId,
-  }) async {
-    final count =
-        await (selectOnly(groupMatchTable)
-              ..where(
-                groupMatchTable.matchId.equals(matchId) &
-                    groupMatchTable.groupId.equals(groupId),
-              )
-              ..addColumns([groupMatchTable.groupId.count()]))
-            .map((row) => row.read(groupMatchTable.groupId.count()))
-            .getSingle();
-    return (count ?? 0) > 0;
-  }
-
-  /// Removes the association of a group from a match based on [groupId] and
-  /// [matchId].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> removeGroupFromMatch({
-    required String matchId,
-    required String groupId,
-  }) async {
-    final query = delete(groupMatchTable)
-      ..where((g) => g.matchId.equals(matchId) & g.groupId.equals(groupId));
-    final rowsAffected = await query.go();
-    return rowsAffected > 0;
-  }
-
-  /// Updates the group associated with a match to [newGroupId] based on
-  /// [matchId].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> updateGroupOfMatch({
-    required String matchId,
-    required String newGroupId,
-  }) async {
-    final updatedRows =
-        await (update(groupMatchTable)..where((g) => g.matchId.equals(matchId)))
-            .write(GroupMatchTableCompanion(groupId: Value(newGroupId)));
-    return updatedRows > 0;
-  }
-}

lib/data/dao/group_match_dao.g.dart

@@ -1,10 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'group_match_dao.dart';
-
-// ignore_for_file: type=lint
-mixin _$GroupMatchDaoMixin on DatabaseAccessor<AppDatabase> {
-  $GroupTableTable get groupTable => attachedDatabase.groupTable;
-  $MatchTableTable get matchTable => attachedDatabase.matchTable;
-  $GroupMatchTableTable get groupMatchTable => attachedDatabase.groupMatchTable;
-}

lib/data/dao/match_dao.dart

@@ -1,13 +1,17 @@
 import 'package:drift/drift.dart';
 import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/db/tables/game_table.dart';
+import 'package:tallee/data/db/tables/group_table.dart';
 import 'package:tallee/data/db/tables/match_table.dart';
+import 'package:tallee/data/db/tables/player_match_table.dart';
+import 'package:tallee/data/dto/game.dart';
 import 'package:tallee/data/dto/group.dart';
 import 'package:tallee/data/dto/match.dart';
 import 'package:tallee/data/dto/player.dart';
 
 part 'match_dao.g.dart';
 
-@DriftAccessor(tables: [MatchTable])
+@DriftAccessor(tables: [MatchTable, GameTable, GroupTable, PlayerMatchTable])
 class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
   MatchDao(super.db);
 
@@ -18,19 +22,23 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
 
     return Future.wait(
       result.map((row) async {
-        final group = await db.groupMatchDao.getGroupOfMatch(matchId: row.id);
-        final players = await db.playerMatchDao.getPlayersOfMatch(
-          matchId: row.id,
-        );
-        final winner = row.winnerId != null
-            ? await db.playerDao.getPlayerById(playerId: row.winnerId!)
-            : null;
+        final game = await db.gameDao.getGameById(gameId: row.gameId);
+        Group? group;
+        if (row.groupId != null) {
+          group = await db.groupDao.getGroupById(groupId: row.groupId!);
+        }
+        final players =
+            await db.playerMatchDao.getPlayersOfMatch(matchId: row.id) ?? [];
+        final winner = await getWinner(matchId: row.id);
         return Match(
           id: row.id,
-          name: row.name,
+          name: row.name ?? '',
+          game: game,
           group: group,
           players: players,
+          notes: row.notes ?? '',
           createdAt: row.createdAt,
+          endedAt: row.endedAt,
           winner: winner,
         );
       }),
@@ -42,69 +50,116 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
     final query = select(matchTable)..where((g) => g.id.equals(matchId));
     final result = await query.getSingle();
 
-    List<Player>? players;
-    if (await db.playerMatchDao.matchHasPlayers(matchId: matchId)) {
-      players = await db.playerMatchDao.getPlayersOfMatch(matchId: matchId);
-    }
+    final game = await db.gameDao.getGameById(gameId: result.gameId);
+
     Group? group;
-    if (await db.groupMatchDao.matchHasGroup(matchId: matchId)) {
-      group = await db.groupMatchDao.getGroupOfMatch(matchId: matchId);
-    }
-    Player? winner;
-    if (result.winnerId != null) {
-      winner = await db.playerDao.getPlayerById(playerId: result.winnerId!);
+    if (result.groupId != null) {
+      group = await db.groupDao.getGroupById(groupId: result.groupId!);
     }
 
+    final players =
+        await db.playerMatchDao.getPlayersOfMatch(matchId: matchId) ?? [];
+
+    final winner = await getWinner(matchId: matchId);
+
     return Match(
       id: result.id,
-      name: result.name,
-      players: players,
+      name: result.name ?? '',
+      game: game,
       group: group,
-      winner: winner,
+      players: players,
+      notes: result.notes ?? '',
       createdAt: result.createdAt,
+      endedAt: result.endedAt,
+      winner: winner,
     );
   }
 
-  /// Adds a new [Match] to the database. Also adds players and group
-  /// associations. This method assumes that the players and groups added to
-  /// this match are already present in the database.
+  /// Adds a new [Match] to the database. Also adds players associations.
+  /// This method assumes that the game and group (if any) are already present
+  /// in the database.
   Future<void> addMatch({required Match match}) async {
     await db.transaction(() async {
       await into(matchTable).insert(
         MatchTableCompanion.insert(
           id: match.id,
-          name: match.name,
-          winnerId: Value(match.winner?.id),
+          gameId: match.game.id,
+          groupId: Value(match.group?.id),
+          name: Value(match.name),
+          notes: Value(match.notes),
           createdAt: match.createdAt,
+          endedAt: Value(match.endedAt),
         ),
         mode: InsertMode.insertOrReplace,
       );
 
-      if (match.players != null) {
-        for (final p in match.players ?? []) {
-          await db.playerMatchDao.addPlayerToMatch(
-            matchId: match.id,
-            playerId: p.id,
-          );
-        }
+      for (final p in match.players) {
+        await db.playerMatchDao.addPlayerToMatch(
+          matchId: match.id,
+          playerId: p.id,
+        );
       }
 
-      if (match.group != null) {
-        await db.groupMatchDao.addGroupToMatch(
-          matchId: match.id,
-          groupId: match.group!.id,
-        );
+      if (match.winner != null) {
+        await setWinner(matchId: match.id, winnerId: match.winner!.id);
       }
     });
   }
 
-  /// Adds multiple [Match]s to the database in a batch operation.
+  /// Adds multiple [Match]es to the database in a batch operation.
   /// Also adds associated players and groups if they exist.
   /// If the [matches] list is empty, the method returns immediately.
-  /// This Method should only be used to import matches from a different device.
+  /// This method should only be used to import matches from a different device.
   Future<void> addMatchAsList({required List<Match> matches}) async {
     if (matches.isEmpty) return;
     await db.transaction(() async {
+      // Add all games first (deduplicated)
+      final uniqueGames = <String, Game>{};
+      for (final match in matches) {
+        uniqueGames[match.game.id] = match.game;
+      }
+
+      if (uniqueGames.isNotEmpty) {
+        await db.batch(
+          (b) => b.insertAll(
+            db.gameTable,
+            uniqueGames.values
+                .map(
+                  (game) => GameTableCompanion.insert(
+                    id: game.id,
+                    name: game.name,
+                    ruleset: game.ruleset.name,
+                    description: game.description,
+                    color: game.color.name,
+                    icon: game.icon,
+                    createdAt: game.createdAt,
+                  ),
+                )
+                .toList(),
+            mode: InsertMode.insertOrIgnore,
+          ),
+        );
+      }
+
+      // Add all groups of the matches in batch
+      await db.batch(
+        (b) => b.insertAll(
+          db.groupTable,
+          matches
+              .where((match) => match.group != null)
+              .map(
+                (match) => GroupTableCompanion.insert(
+                  id: match.group!.id,
+                  name: match.group!.name,
+                  description: match.group!.description,
+                  createdAt: match.group!.createdAt,
+                ),
+              )
+              .toList(),
+          mode: InsertMode.insertOrIgnore,
+        ),
+      );
+
       // Add all matches in batch
       await db.batch(
         (b) => b.insertAll(
@@ -113,9 +168,12 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
               .map(
                 (match) => MatchTableCompanion.insert(
                   id: match.id,
-                  name: match.name,
+                  gameId: match.game.id,
+                  groupId: Value(match.group?.id),
+                  name: Value(match.name),
+                  notes: Value(match.notes),
                   createdAt: match.createdAt,
-                  winnerId: Value(match.winner?.id),
+                  endedAt: Value(match.endedAt),
                 ),
               )
               .toList(),
@@ -123,33 +181,11 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
         ),
       );
 
-      // Add all groups of the matches in batch
-      // Using insertOrIgnore to avoid overwriting existing groups (which would
-      // trigger cascade deletes on player_group associations)
-      await db.batch(
-        (b) => b.insertAll(
-          db.groupTable,
-          matches
-              .where((match) => match.group != null)
-              .map(
-                (matches) => GroupTableCompanion.insert(
-                  id: matches.group!.id,
-                  name: matches.group!.name,
-                  createdAt: matches.group!.createdAt,
-                ),
-              )
-              .toList(),
-          mode: InsertMode.insertOrIgnore,
-        ),
-      );
-
       // Add all players of the matches in batch (unique)
       final uniquePlayers = <String, Player>{};
       for (final match in matches) {
-        if (match.players != null) {
-          for (final p in match.players!) {
-            uniquePlayers[p.id] = p;
-          }
+        for (final p in match.players) {
+          uniquePlayers[p.id] = p;
         }
         // Also include members of groups
         if (match.group != null) {
@@ -160,8 +196,6 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
       }
 
       if (uniquePlayers.isNotEmpty) {
-        // Using insertOrIgnore to avoid triggering cascade deletes on
-        // player_group/player_match associations when players already exist
         await db.batch(
           (b) => b.insertAll(
             db.playerTable,
@@ -170,6 +204,7 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
                   (p) => PlayerTableCompanion.insert(
                     id: p.id,
                     name: p.name,
+                    description: p.description,
                     createdAt: p.createdAt,
                   ),
                 )
@@ -182,17 +217,16 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
       // Add all player-match associations in batch
       await db.batch((b) {
         for (final match in matches) {
-          if (match.players != null) {
-            for (final p in match.players ?? []) {
-              b.insert(
-                db.playerMatchTable,
-                PlayerMatchTableCompanion.insert(
-                  matchId: match.id,
-                  playerId: p.id,
-                ),
-                mode: InsertMode.insertOrIgnore,
-              );
-            }
+          for (final p in match.players) {
+            b.insert(
+              db.playerMatchTable,
+              PlayerMatchTableCompanion.insert(
+                matchId: match.id,
+                playerId: p.id,
+                score: 0,
+              ),
+              mode: InsertMode.insertOrIgnore,
+            );
           }
         }
       });
@@ -214,22 +248,6 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
           }
         }
       });
-
-      // Add all group-match associations in batch
-      await db.batch((b) {
-        for (final match in matches) {
-          if (match.group != null) {
-            b.insert(
-              db.groupMatchTable,
-              GroupMatchTableCompanion.insert(
-                matchId: match.id,
-                groupId: match.group!.id,
-              ),
-              mode: InsertMode.insertOrIgnore,
-            );
-          }
-        }
-      });
     });
   }
 
@@ -266,52 +284,20 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
     return rowsAffected > 0;
   }
 
-  /// Sets the winner of the match with the given [matchId] to the player with
-  /// the given [winnerId].
+  /// Updates the notes of the match with the given [matchId].
   /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> setWinner({
+  Future<bool> updateMatchNotes({
     required String matchId,
-    required String winnerId,
+    required String? notes,
   }) async {
     final query = update(matchTable)..where((g) => g.id.equals(matchId));
     final rowsAffected = await query.write(
-      MatchTableCompanion(winnerId: Value(winnerId)),
+      MatchTableCompanion(notes: Value(notes)),
     );
     return rowsAffected > 0;
   }
 
-  /// Retrieves the winner of the match with the given [matchId].
-  /// Returns the [Player] who won the match, or `null` if no winner is set.
-  Future<Player?> getWinner({required String matchId}) async {
-    final query = select(matchTable)..where((g) => g.id.equals(matchId));
-    final result = await query.getSingleOrNull();
-    if (result == null || result.winnerId == null) {
-      return null;
-    }
-    final winner = await db.playerDao.getPlayerById(playerId: result.winnerId!);
-    return winner;
-  }
-
-  /// Removes the winner of the match with the given [matchId].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> removeWinner({required String matchId}) async {
-    final query = update(matchTable)..where((g) => g.id.equals(matchId));
-    final rowsAffected = await query.write(
-      const MatchTableCompanion(winnerId: Value(null)),
-    );
-    return rowsAffected > 0;
-  }
-
-  /// Checks if the match with the given [matchId] has a winner set.
-  /// Returns `true` if a winner is set, otherwise `false`.
-  Future<bool> hasWinner({required String matchId}) async {
-    final query = select(matchTable)
-      ..where((g) => g.id.equals(matchId) & g.winnerId.isNotNull());
-    final result = await query.getSingleOrNull();
-    return result != null;
-  }
-
-  /// Changes the title of the match with the given [matchId] to [newName].
+  /// Changes the name of the match with the given [matchId] to [newName].
   /// Returns `true` if more than 0 rows were affected, otherwise `false`.
   Future<bool> updateMatchName({
     required String matchId,
@@ -323,4 +309,180 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
     );
     return rowsAffected > 0;
   }
+
+  /// Updates the game of the match with the given [matchId].
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> updateMatchGame({
+    required String matchId,
+    required String gameId,
+  }) async {
+    final query = update(matchTable)..where((g) => g.id.equals(matchId));
+    final rowsAffected = await query.write(
+      MatchTableCompanion(gameId: Value(gameId)),
+    );
+    return rowsAffected > 0;
+  }
+
+  /// Updates the group of the match with the given [matchId].
+  /// Replaces the existing group association with the new group specified by [newGroupId].
+  /// Pass null to remove the group association.
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> updateMatchGroup({
+    required String matchId,
+    required String? newGroupId,
+  }) async {
+    final query = update(matchTable)..where((g) => g.id.equals(matchId));
+    final rowsAffected = await query.write(
+      MatchTableCompanion(groupId: Value(newGroupId)),
+    );
+    return rowsAffected > 0;
+  }
+
+  /// Updates the createdAt timestamp of the match with the given [matchId].
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> updateMatchCreatedAt({
+    required String matchId,
+    required DateTime createdAt,
+  }) async {
+    final query = update(matchTable)..where((g) => g.id.equals(matchId));
+    final rowsAffected = await query.write(
+      MatchTableCompanion(createdAt: Value(createdAt)),
+    );
+    return rowsAffected > 0;
+  }
+
+  /// Updates the endedAt timestamp of the match with the given [matchId].
+  /// Pass null to remove the ended time (mark match as ongoing).
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> updateMatchEndedAt({
+    required String matchId,
+    required DateTime? endedAt,
+  }) async {
+    final query = update(matchTable)..where((g) => g.id.equals(matchId));
+    final rowsAffected = await query.write(
+      MatchTableCompanion(endedAt: Value(endedAt)),
+    );
+    return rowsAffected > 0;
+  }
+
+  /// Replaces all players in a match with the provided list of players.
+  /// Removes all existing players from the match and adds the new players.
+  /// Also adds any new players to the player table if they don't exist.
+  Future<void> replaceMatchPlayers({
+    required String matchId,
+    required List<Player> newPlayers,
+  }) async {
+    await db.transaction(() async {
+      // Remove all existing players from the match
+      final deleteQuery = delete(db.playerMatchTable)
+        ..where((p) => p.matchId.equals(matchId));
+      await deleteQuery.go();
+
+      // Add new players to the player table if they don't exist
+      await Future.wait(
+        newPlayers.map((player) async {
+          if (!await db.playerDao.playerExists(playerId: player.id)) {
+            await db.playerDao.addPlayer(player: player);
+          }
+        }),
+      );
+
+      // Add the new players to the match
+      await Future.wait(
+        newPlayers.map(
+          (player) => db.playerMatchDao.addPlayerToMatch(
+            matchId: matchId,
+            playerId: player.id,
+          ),
+        ),
+      );
+    });
+  }
+
+  // ============================================================
+  // Winner methods - handle winner logic via player scores
+  // ============================================================
+
+  /// Checks if a match has a winner.
+  /// Returns true if any player in the match has their score set to 1.
+  Future<bool> hasWinner({required String matchId}) async {
+    final players =
+        await db.playerMatchDao.getPlayersOfMatch(matchId: matchId) ?? [];
+
+    for (final player in players) {
+      final score = await db.playerMatchDao.getPlayerScore(
+        matchId: matchId,
+        playerId: player.id,
+      );
+      if (score == 1) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /// Gets the winner of a match.
+  /// Returns the player with score 1, or null if no winner is set.
+  Future<Player?> getWinner({required String matchId}) async {
+    final players =
+        await db.playerMatchDao.getPlayersOfMatch(matchId: matchId) ?? [];
+
+    for (final player in players) {
+      final score = await db.playerMatchDao.getPlayerScore(
+        matchId: matchId,
+        playerId: player.id,
+      );
+      if (score == 1) {
+        return player;
+      }
+    }
+    return null;
+  }
+
+  /// Sets the winner of a match.
+  /// Sets all players' scores to 0, then sets the specified player's score to 1.
+  /// Returns `true` if the operation was successful, otherwise `false`.
+  Future<bool> setWinner({
+    required String matchId,
+    required String winnerId,
+  }) async {
+    await db.transaction(() async {
+      final players =
+          await db.playerMatchDao.getPlayersOfMatch(matchId: matchId) ?? [];
+
+      // Set all players' scores to 0
+      for (final player in players) {
+        await db.playerMatchDao.updatePlayerScore(
+          matchId: matchId,
+          playerId: player.id,
+          newScore: 0,
+        );
+      }
+
+      // Set the winner's score to 1
+      await db.playerMatchDao.updatePlayerScore(
+        matchId: matchId,
+        playerId: winnerId,
+        newScore: 1,
+      );
+    });
+    return true;
+  }
+
+  /// Removes the winner of a match.
+  /// Sets the current winner's score to 0 (no winner).
+  /// Returns `true` if a winner was removed, otherwise `false`.
+  Future<bool> removeWinner({required String matchId}) async {
+    final winner = await getWinner(matchId: matchId);
+    if (winner == null) {
+      return false;
+    }
+
+    final success = await db.playerMatchDao.updatePlayerScore(
+      matchId: matchId,
+      playerId: winner.id,
+      newScore: 0,
+    );
+    return success;
+  }
 }

lib/data/dao/match_dao.g.dart

@@ -4,5 +4,11 @@ part of 'match_dao.dart';
 
 // ignore_for_file: type=lint
 mixin _$MatchDaoMixin on DatabaseAccessor<AppDatabase> {
+  $GameTableTable get gameTable => attachedDatabase.gameTable;
+  $GroupTableTable get groupTable => attachedDatabase.groupTable;
   $MatchTableTable get matchTable => attachedDatabase.matchTable;
+  $PlayerTableTable get playerTable => attachedDatabase.playerTable;
+  $TeamTableTable get teamTable => attachedDatabase.teamTable;
+  $PlayerMatchTableTable get playerMatchTable =>
+      attachedDatabase.playerMatchTable;
 }

lib/data/dao/player_dao.dart

@@ -15,7 +15,12 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
     final result = await query.get();
     return result
         .map(
-          (row) => Player(id: row.id, name: row.name, createdAt: row.createdAt),
+          (row) => Player(
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            createdAt: row.createdAt,
+          ),
         )
         .toList();
   }
@@ -27,6 +32,7 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
     return Player(
       id: result.id,
       name: result.name,
+      description: result.description,
       createdAt: result.createdAt,
     );
   }
@@ -40,6 +46,7 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
         PlayerTableCompanion.insert(
           id: player.id,
           name: player.name,
+          description: player.description,
           createdAt: player.createdAt,
         ),
         mode: InsertMode.insertOrReplace,
@@ -63,6 +70,7 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
               (player) => PlayerTableCompanion.insert(
                 id: player.id,
                 name: player.name,
+                description: player.description,
                 createdAt: player.createdAt,
               ),
             )
@@ -91,7 +99,7 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
   }
 
   /// Updates the name of the player with the given [playerId] to [newName].
-  Future<void> updatePlayername({
+  Future<void> updatePlayerName({
     required String playerId,
     required String newName,
   }) async {

lib/data/dao/player_group_dao.dart

@@ -27,7 +27,7 @@ class PlayerGroupDao extends DatabaseAccessor<AppDatabase>
     }
 
     if (!await db.playerDao.playerExists(playerId: player.id)) {
-      db.playerDao.addPlayer(player: player);
+      await db.playerDao.addPlayer(player: player);
     }
 
     await into(playerGroupTable).insert(

lib/data/dao/player_match_dao.dart

@@ -1,23 +1,31 @@
 import 'package:drift/drift.dart';
 import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/db/tables/player_match_table.dart';
+import 'package:tallee/data/db/tables/team_table.dart';
 import 'package:tallee/data/dto/player.dart';
 
 part 'player_match_dao.g.dart';
 
-@DriftAccessor(tables: [PlayerMatchTable])
+@DriftAccessor(tables: [PlayerMatchTable, TeamTable])
 class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
     with _$PlayerMatchDaoMixin {
   PlayerMatchDao(super.db);
 
   /// Associates a player with a match by inserting a record into the
-  /// [PlayerMatchTable].
+  /// [PlayerMatchTable]. Optionally associates with a team and sets initial score.
   Future<void> addPlayerToMatch({
     required String matchId,
     required String playerId,
+    String? teamId,
+    int score = 0,
   }) async {
     await into(playerMatchTable).insert(
-      PlayerMatchTableCompanion.insert(playerId: playerId, matchId: matchId),
+      PlayerMatchTableCompanion.insert(
+        playerId: playerId,
+        matchId: matchId,
+        teamId: Value(teamId),
+        score: score,
+      ),
       mode: InsertMode.insertOrIgnore,
     );
   }
@@ -32,21 +40,65 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
     if (result.isEmpty) return null;
 
     final futures = result.map(
-      (row) => db.playerDao.getPlayerById(playerId: row.playerId),
+          (row) => db.playerDao.getPlayerById(playerId: row.playerId),
     );
     final players = await Future.wait(futures);
     return players;
   }
 
+  /// Retrieves a player's score for a specific match.
+  /// Returns null if the player is not in the match.
+  Future<int?> getPlayerScore({
+    required String matchId,
+    required String playerId,
+  }) async {
+    final result = await (select(playerMatchTable)
+      ..where(
+            (p) => p.matchId.equals(matchId) & p.playerId.equals(playerId),
+      ))
+        .getSingleOrNull();
+    return result?.score;
+  }
+
+  /// Updates the score for a player in a match.
+  /// Returns `true` if the update was successful, otherwise `false`.
+  Future<bool> updatePlayerScore({
+    required String matchId,
+    required String playerId,
+    required int newScore,
+  }) async {
+    final rowsAffected = await (update(playerMatchTable)
+      ..where(
+            (p) => p.matchId.equals(matchId) & p.playerId.equals(playerId),
+      ))
+        .write(PlayerMatchTableCompanion(score: Value(newScore)));
+    return rowsAffected > 0;
+  }
+
+  /// Updates the team for a player in a match.
+  /// Returns `true` if the update was successful, otherwise `false`.
+  Future<bool> updatePlayerTeam({
+    required String matchId,
+    required String playerId,
+    required String? teamId,
+  }) async {
+    final rowsAffected = await (update(playerMatchTable)
+      ..where(
+            (p) => p.matchId.equals(matchId) & p.playerId.equals(playerId),
+      ))
+        .write(PlayerMatchTableCompanion(teamId: Value(teamId)));
+    return rowsAffected > 0;
+  }
+
   /// Checks if there are any players associated with the given [matchId].
   /// Returns `true` if there are players, otherwise `false`.
   Future<bool> matchHasPlayers({required String matchId}) async {
     final count =
-        await (selectOnly(playerMatchTable)
-              ..where(playerMatchTable.matchId.equals(matchId))
-              ..addColumns([playerMatchTable.playerId.count()]))
-            .map((row) => row.read(playerMatchTable.playerId.count()))
-            .getSingle();
+    await (selectOnly(playerMatchTable)
+      ..where(playerMatchTable.matchId.equals(matchId))
+      ..addColumns([playerMatchTable.playerId.count()]))
+        .map((row) => row.read(playerMatchTable.playerId.count()))
+        .getSingle();
     return (count ?? 0) > 0;
   }
 
@@ -57,12 +109,12 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
     required String playerId,
   }) async {
     final count =
-        await (selectOnly(playerMatchTable)
-              ..where(playerMatchTable.matchId.equals(matchId))
-              ..where(playerMatchTable.playerId.equals(playerId))
-              ..addColumns([playerMatchTable.playerId.count()]))
-            .map((row) => row.read(playerMatchTable.playerId.count()))
-            .getSingle();
+    await (selectOnly(playerMatchTable)
+      ..where(playerMatchTable.matchId.equals(matchId))
+      ..where(playerMatchTable.playerId.equals(playerId))
+      ..addColumns([playerMatchTable.playerId.count()]))
+        .map((row) => row.read(playerMatchTable.playerId.count()))
+        .getSingle();
     return (count ?? 0) > 0;
   }
 
@@ -96,14 +148,14 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
     final playersToAdd = newPlayerIdsSet.difference(currentPlayerIds);
     final playersToRemove = currentPlayerIds.difference(newPlayerIdsSet);
 
-    db.transaction(() async {
+    await db.transaction(() async {
       // Remove old players
       if (playersToRemove.isNotEmpty) {
         await (delete(playerMatchTable)..where(
               (pg) =>
-                  pg.matchId.equals(matchId) &
-                  pg.playerId.isIn(playersToRemove.toList()),
-            ))
+          pg.matchId.equals(matchId) &
+          pg.playerId.isIn(playersToRemove.toList()),
+        ))
             .go();
       }
 
@@ -112,14 +164,15 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
         final inserts = playersToAdd
             .map(
               (id) => PlayerMatchTableCompanion.insert(
-                playerId: id,
-                matchId: matchId,
-              ),
-            )
+            playerId: id,
+            matchId: matchId,
+            score: 0,
+          ),
+        )
             .toList();
         await Future.wait(
           inserts.map(
-            (c) => into(
+                (c) => into(
               playerMatchTable,
             ).insert(c, mode: InsertMode.insertOrIgnore),
           ),
@@ -127,4 +180,23 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
       }
     });
   }
+
+  /// Retrieves all players in a specific team for a match.
+  Future<List<Player>> getPlayersInTeam({
+    required String matchId,
+    required String teamId,
+  }) async {
+    final result = await (select(playerMatchTable)
+      ..where(
+            (p) => p.matchId.equals(matchId) & p.teamId.equals(teamId),
+      ))
+        .get();
+
+    if (result.isEmpty) return [];
+
+    final futures = result.map(
+          (row) => db.playerDao.getPlayerById(playerId: row.playerId),
+    );
+    return Future.wait(futures);
+  }
 }

lib/data/dao/player_match_dao.g.dart

@@ -5,7 +5,10 @@ part of 'player_match_dao.dart';
 // ignore_for_file: type=lint
 mixin _$PlayerMatchDaoMixin on DatabaseAccessor<AppDatabase> {
   $PlayerTableTable get playerTable => attachedDatabase.playerTable;
+  $GameTableTable get gameTable => attachedDatabase.gameTable;
+  $GroupTableTable get groupTable => attachedDatabase.groupTable;
   $MatchTableTable get matchTable => attachedDatabase.matchTable;
+  $TeamTableTable get teamTable => attachedDatabase.teamTable;
   $PlayerMatchTableTable get playerMatchTable =>
       attachedDatabase.playerMatchTable;
 }

lib/data/dao/score_dao.dart

@@ -0,0 +1,191 @@
+import 'package:drift/drift.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/db/tables/score_table.dart';
+
+part 'score_dao.g.dart';
+
+/// A data class representing a score entry.
+class ScoreEntry {
+  final String playerId;
+  final String matchId;
+  final int roundNumber;
+  final int score;
+  final int change;
+
+  ScoreEntry({
+    required this.playerId,
+    required this.matchId,
+    required this.roundNumber,
+    required this.score,
+    required this.change,
+  });
+}
+
+@DriftAccessor(tables: [ScoreTable])
+class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
+  ScoreDao(super.db);
+
+  /// Adds a score entry to the database.
+  Future<void> addScore({
+    required String playerId,
+    required String matchId,
+    required int roundNumber,
+    required int score,
+    required int change,
+  }) async {
+    await into(scoreTable).insert(
+      ScoreTableCompanion.insert(
+        playerId: playerId,
+        matchId: matchId,
+        roundNumber: roundNumber,
+        score: score,
+        change: change,
+      ),
+      mode: InsertMode.insertOrReplace,
+    );
+  }
+
+  /// Retrieves all scores for a specific match.
+  Future<List<ScoreEntry>> getScoresForMatch({required String matchId}) async {
+    final query = select(scoreTable)..where((s) => s.matchId.equals(matchId));
+    final result = await query.get();
+    return result
+        .map(
+          (row) => ScoreEntry(
+            playerId: row.playerId,
+            matchId: row.matchId,
+            roundNumber: row.roundNumber,
+            score: row.score,
+            change: row.change,
+          ),
+        )
+        .toList();
+  }
+
+  /// Retrieves all scores for a specific player in a match.
+  Future<List<ScoreEntry>> getPlayerScoresInMatch({
+    required String playerId,
+    required String matchId,
+  }) async {
+    final query = select(scoreTable)
+      ..where(
+        (s) => s.playerId.equals(playerId) & s.matchId.equals(matchId),
+      )
+      ..orderBy([(s) => OrderingTerm.asc(s.roundNumber)]);
+    final result = await query.get();
+    return result
+        .map(
+          (row) => ScoreEntry(
+            playerId: row.playerId,
+            matchId: row.matchId,
+            roundNumber: row.roundNumber,
+            score: row.score,
+            change: row.change,
+          ),
+        )
+        .toList();
+  }
+
+  /// Retrieves the score for a specific round.
+  Future<ScoreEntry?> getScoreForRound({
+    required String playerId,
+    required String matchId,
+    required int roundNumber,
+  }) async {
+    final query = select(scoreTable)
+      ..where(
+        (s) =>
+            s.playerId.equals(playerId) &
+            s.matchId.equals(matchId) &
+            s.roundNumber.equals(roundNumber),
+      );
+    final result = await query.getSingleOrNull();
+    if (result == null) return null;
+    return ScoreEntry(
+      playerId: result.playerId,
+      matchId: result.matchId,
+      roundNumber: result.roundNumber,
+      score: result.score,
+      change: result.change,
+    );
+  }
+
+  /// Updates a score entry.
+  Future<bool> updateScore({
+    required String playerId,
+    required String matchId,
+    required int roundNumber,
+    required int newScore,
+    required int newChange,
+  }) async {
+    final rowsAffected = await (update(scoreTable)
+          ..where(
+            (s) =>
+                s.playerId.equals(playerId) &
+                s.matchId.equals(matchId) &
+                s.roundNumber.equals(roundNumber),
+          ))
+        .write(
+          ScoreTableCompanion(
+            score: Value(newScore),
+            change: Value(newChange),
+          ),
+        );
+    return rowsAffected > 0;
+  }
+
+  /// Deletes a score entry.
+  Future<bool> deleteScore({
+    required String playerId,
+    required String matchId,
+    required int roundNumber,
+  }) async {
+    final query = delete(scoreTable)
+      ..where(
+        (s) =>
+            s.playerId.equals(playerId) &
+            s.matchId.equals(matchId) &
+            s.roundNumber.equals(roundNumber),
+      );
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+
+  /// Deletes all scores for a specific match.
+  Future<bool> deleteScoresForMatch({required String matchId}) async {
+    final query = delete(scoreTable)..where((s) => s.matchId.equals(matchId));
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+
+  /// Deletes all scores for a specific player.
+  Future<bool> deleteScoresForPlayer({required String playerId}) async {
+    final query = delete(scoreTable)..where((s) => s.playerId.equals(playerId));
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+
+  /// Gets the latest round number for a match.
+  Future<int> getLatestRoundNumber({required String matchId}) async {
+    final query = selectOnly(scoreTable)
+      ..where(scoreTable.matchId.equals(matchId))
+      ..addColumns([scoreTable.roundNumber.max()]);
+    final result = await query.getSingle();
+    return result.read(scoreTable.roundNumber.max()) ?? 0;
+  }
+
+  /// Gets the total score for a player in a match (sum of all changes).
+  Future<int> getTotalScoreForPlayer({
+    required String playerId,
+    required String matchId,
+  }) async {
+    final scores = await getPlayerScoresInMatch(
+      playerId: playerId,
+      matchId: matchId,
+    );
+    if (scores.isEmpty) return 0;
+    // Return the score from the latest round
+    return scores.last.score;
+  }
+}
+

lib/data/dao/score_dao.g.dart

@@ -0,0 +1,12 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'score_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$ScoreDaoMixin on DatabaseAccessor<AppDatabase> {
+  $PlayerTableTable get playerTable => attachedDatabase.playerTable;
+  $GameTableTable get gameTable => attachedDatabase.gameTable;
+  $GroupTableTable get groupTable => attachedDatabase.groupTable;
+  $MatchTableTable get matchTable => attachedDatabase.matchTable;
+  $ScoreTableTable get scoreTable => attachedDatabase.scoreTable;
+}

lib/data/dao/team_dao.dart

@@ -0,0 +1,147 @@
+import 'package:drift/drift.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/db/tables/team_table.dart';
+import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/dto/team.dart';
+
+part 'team_dao.g.dart';
+
+@DriftAccessor(tables: [TeamTable])
+class TeamDao extends DatabaseAccessor<AppDatabase> with _$TeamDaoMixin {
+  TeamDao(super.db);
+
+  /// Retrieves all teams from the database.
+  /// Note: This returns teams without their members. Use getTeamById for full team data.
+  Future<List<Team>> getAllTeams() async {
+    final query = select(teamTable);
+    final result = await query.get();
+    return Future.wait(
+      result.map((row) async {
+        final members = await _getTeamMembers(teamId: row.id);
+        return Team(
+          id: row.id,
+          name: row.name,
+          createdAt: row.createdAt,
+          members: members,
+        );
+      }),
+    );
+  }
+
+  /// Retrieves a [Team] by its [teamId], including its members.
+  Future<Team> getTeamById({required String teamId}) async {
+    final query = select(teamTable)..where((t) => t.id.equals(teamId));
+    final result = await query.getSingle();
+    final members = await _getTeamMembers(teamId: teamId);
+    return Team(
+      id: result.id,
+      name: result.name,
+      createdAt: result.createdAt,
+      members: members,
+    );
+  }
+
+  /// Helper method to get team members from player_match_table.
+  /// This assumes team members are tracked via the player_match_table.
+  Future<List<Player>> _getTeamMembers({required String teamId}) async {
+    // Get all player_match entries with this teamId
+    final playerMatchQuery = select(db.playerMatchTable)
+      ..where((pm) => pm.teamId.equals(teamId));
+    final playerMatches = await playerMatchQuery.get();
+
+    if (playerMatches.isEmpty) return [];
+
+    // Get unique player IDs
+    final playerIds = playerMatches.map((pm) => pm.playerId).toSet();
+
+    // Fetch all players
+    final players = await Future.wait(
+      playerIds.map((id) => db.playerDao.getPlayerById(playerId: id)),
+    );
+    return players;
+  }
+
+  /// Adds a new [team] to the database.
+  /// Returns `true` if the team was added, `false` otherwise.
+  Future<bool> addTeam({required Team team}) async {
+    if (!await teamExists(teamId: team.id)) {
+      await into(teamTable).insert(
+        TeamTableCompanion.insert(
+          id: team.id,
+          name: team.name,
+          createdAt: team.createdAt,
+        ),
+        mode: InsertMode.insertOrReplace,
+      );
+      return true;
+    }
+    return false;
+  }
+
+  /// Adds multiple [teams] to the database in a batch operation.
+  Future<bool> addTeamsAsList({required List<Team> teams}) async {
+    if (teams.isEmpty) return false;
+
+    await db.batch(
+      (b) => b.insertAll(
+        teamTable,
+        teams
+            .map(
+              (team) => TeamTableCompanion.insert(
+                id: team.id,
+                name: team.name,
+                createdAt: team.createdAt,
+              ),
+            )
+            .toList(),
+        mode: InsertMode.insertOrIgnore,
+      ),
+    );
+
+    return true;
+  }
+
+  /// Deletes the team with the given [teamId] from the database.
+  /// Returns `true` if the team was deleted, `false` otherwise.
+  Future<bool> deleteTeam({required String teamId}) async {
+    final query = delete(teamTable)..where((t) => t.id.equals(teamId));
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+
+  /// Checks if a team with the given [teamId] exists in the database.
+  /// Returns `true` if the team exists, `false` otherwise.
+  Future<bool> teamExists({required String teamId}) async {
+    final query = select(teamTable)..where((t) => t.id.equals(teamId));
+    final result = await query.getSingleOrNull();
+    return result != null;
+  }
+
+  /// Updates the name of the team with the given [teamId].
+  Future<void> updateTeamName({
+    required String teamId,
+    required String newName,
+  }) async {
+    await (update(teamTable)..where((t) => t.id.equals(teamId))).write(
+      TeamTableCompanion(name: Value(newName)),
+    );
+  }
+
+  /// Retrieves the total count of teams in the database.
+  Future<int> getTeamCount() async {
+    final count =
+        await (selectOnly(teamTable)..addColumns([teamTable.id.count()]))
+            .map((row) => row.read(teamTable.id.count()))
+            .getSingle();
+    return count ?? 0;
+  }
+
+  /// Deletes all teams from the database.
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> deleteAllTeams() async {
+    final query = delete(teamTable);
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+}
+

lib/data/dao/team_dao.g.dart

@@ -0,0 +1,8 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'team_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$TeamDaoMixin on DatabaseAccessor<AppDatabase> {
+  $TeamTableTable get teamTable => attachedDatabase.teamTable;
+}

lib/data/db/database.dart

@@ -1,18 +1,22 @@
 import 'package:drift/drift.dart';
 import 'package:drift_flutter/drift_flutter.dart';
 import 'package:path_provider/path_provider.dart';
+import 'package:tallee/data/dao/game_dao.dart';
 import 'package:tallee/data/dao/group_dao.dart';
-import 'package:tallee/data/dao/group_match_dao.dart';
 import 'package:tallee/data/dao/match_dao.dart';
 import 'package:tallee/data/dao/player_dao.dart';
 import 'package:tallee/data/dao/player_group_dao.dart';
 import 'package:tallee/data/dao/player_match_dao.dart';
-import 'package:tallee/data/db/tables/group_match_table.dart';
+import 'package:tallee/data/dao/score_dao.dart';
+import 'package:tallee/data/dao/team_dao.dart';
+import 'package:tallee/data/db/tables/game_table.dart';
 import 'package:tallee/data/db/tables/group_table.dart';
 import 'package:tallee/data/db/tables/match_table.dart';
 import 'package:tallee/data/db/tables/player_group_table.dart';
 import 'package:tallee/data/db/tables/player_match_table.dart';
 import 'package:tallee/data/db/tables/player_table.dart';
+import 'package:tallee/data/db/tables/score_table.dart';
+import 'package:tallee/data/db/tables/team_table.dart';
 
 part 'database.g.dart';
 
@@ -23,7 +27,9 @@ part 'database.g.dart';
     MatchTable,
     PlayerGroupTable,
     PlayerMatchTable,
-    GroupMatchTable,
+    GameTable,
+    TeamTable,
+    ScoreTable,
   ],
   daos: [
     PlayerDao,
@@ -31,7 +37,9 @@ part 'database.g.dart';
     MatchDao,
     PlayerGroupDao,
     PlayerMatchDao,
-    GroupMatchDao,
+    GameDao,
+    ScoreDao,
+    TeamDao
   ],
 )
 class AppDatabase extends _$AppDatabase {
@@ -52,9 +60,7 @@ class AppDatabase extends _$AppDatabase {
   static QueryExecutor _openConnection() {
     return driftDatabase(
       name: 'gametracker_db',
-      native: const DriftNativeOptions(
-        databaseDirectory: getApplicationSupportDirectory,
-      ),
+      native: const DriftNativeOptions(databaseDirectory: getApplicationSupportDirectory),
     );
   }
 }

lib/data/db/tables/game_table.dart

@@ -0,0 +1,14 @@
+import 'package:drift/drift.dart';
+
+class GameTable extends Table {
+  TextColumn get id => text()();
+  TextColumn get name => text()();
+  TextColumn get ruleset => text()();
+  TextColumn get description => text()();
+  TextColumn get color => text()();
+  TextColumn get icon => text()();
+  DateTimeColumn get createdAt => dateTime()();
+
+  @override
+  Set<Column<Object>> get primaryKey => {id};
+}

lib/data/db/tables/group_match_table.dart

@@ -1,13 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:tallee/data/db/tables/group_table.dart';
-import 'package:tallee/data/db/tables/match_table.dart';
-
-class GroupMatchTable extends Table {
-  TextColumn get groupId =>
-      text().references(GroupTable, #id, onDelete: KeyAction.cascade)();
-  TextColumn get matchId =>
-      text().references(MatchTable, #id, onDelete: KeyAction.cascade)();
-
-  @override
-  Set<Column<Object>> get primaryKey => {groupId, matchId};
-}

lib/data/db/tables/group_table.dart

@@ -3,6 +3,7 @@ import 'package:drift/drift.dart';
 class GroupTable extends Table {
   TextColumn get id => text()();
   TextColumn get name => text()();
+  TextColumn get description => text()();
   DateTimeColumn get createdAt => dateTime()();
 
   @override

lib/data/db/tables/match_table.dart

@@ -1,10 +1,18 @@
 import 'package:drift/drift.dart';
+import 'package:tallee/data/db/tables/game_table.dart';
+import 'package:tallee/data/db/tables/group_table.dart';
 
 class MatchTable extends Table {
   TextColumn get id => text()();
-  TextColumn get name => text()();
-  late final winnerId = text().nullable()();
+  TextColumn get gameId =>
+      text().references(GameTable, #id, onDelete: KeyAction.cascade)();
+  // Nullable if there is no group associated with the match
+  TextColumn get groupId =>
+      text().references(GroupTable, #id, onDelete: KeyAction.cascade).nullable()();
+  TextColumn get name => text().nullable()();
+  TextColumn get notes => text().nullable()();
   DateTimeColumn get createdAt => dateTime()();
+  DateTimeColumn get endedAt => dateTime().nullable()();
 
   @override
   Set<Column<Object>> get primaryKey => {id};

lib/data/db/tables/player_match_table.dart

@@ -1,12 +1,16 @@
 import 'package:drift/drift.dart';
 import 'package:tallee/data/db/tables/match_table.dart';
 import 'package:tallee/data/db/tables/player_table.dart';
+import 'package:tallee/data/db/tables/team_table.dart';
 
 class PlayerMatchTable extends Table {
   TextColumn get playerId =>
       text().references(PlayerTable, #id, onDelete: KeyAction.cascade)();
   TextColumn get matchId =>
       text().references(MatchTable, #id, onDelete: KeyAction.cascade)();
+  TextColumn get teamId =>
+      text().references(TeamTable, #id).nullable()();
+  IntColumn get score => integer()();
 
   @override
   Set<Column<Object>> get primaryKey => {playerId, matchId};

lib/data/db/tables/player_table.dart

@@ -3,6 +3,7 @@ import 'package:drift/drift.dart';
 class PlayerTable extends Table {
   TextColumn get id => text()();
   TextColumn get name => text()();
+  TextColumn get description => text()();
   DateTimeColumn get createdAt => dateTime()();
 
   @override

lib/data/db/tables/score_table.dart

@@ -0,0 +1,16 @@
+import 'package:drift/drift.dart';
+import 'package:tallee/data/db/tables/match_table.dart';
+import 'package:tallee/data/db/tables/player_table.dart';
+
+class ScoreTable extends Table {
+  TextColumn get playerId =>
+      text().references(PlayerTable, #id, onDelete: KeyAction.cascade)();
+  TextColumn get matchId =>
+      text().references(MatchTable, #id, onDelete: KeyAction.cascade)();
+  IntColumn get roundNumber => integer()();
+  IntColumn get score => integer()();
+  IntColumn get change => integer()();
+
+  @override
+  Set<Column<Object>> get primaryKey => {playerId, matchId, roundNumber};
+}

lib/data/db/tables/team_table.dart

@@ -0,0 +1,10 @@
+import 'package:drift/drift.dart';
+
+class TeamTable extends Table {
+  TextColumn get id => text()();
+  TextColumn get name => text()();
+  DateTimeColumn get createdAt => dateTime()();
+
+  @override
+  Set<Column<Object>> get primaryKey => {id};
+}

lib/data/dto/game.dart

@@ -0,0 +1,52 @@
+import 'package:clock/clock.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:uuid/uuid.dart';
+
+class Game {
+  final String id;
+  final DateTime createdAt;
+  final String name;
+  final Ruleset ruleset;
+  final String description;
+  final GameColor color;
+  final String icon;
+
+  Game({
+    String? id,
+    DateTime? createdAt,
+    required this.name,
+    required this.ruleset,
+    String? description,
+    required this.color,
+    String? icon,
+  }) : id = id ?? const Uuid().v4(),
+       createdAt = createdAt ?? clock.now(),
+       description = description ?? '',
+       icon = icon ?? '';
+
+  @override
+  String toString() {
+    return 'Game{id: $id, name: $name, ruleset: $ruleset, description: $description, color: $color, icon: $icon}';
+  }
+
+  /// Creates a Game instance from a JSON object.
+  Game.fromJson(Map<String, dynamic> json)
+    : id = json['id'],
+      createdAt = DateTime.parse(json['createdAt']),
+      name = json['name'],
+      ruleset = Ruleset.values.firstWhere((e) => e.name == json['ruleset']),
+      description = json['description'],
+      color = GameColor.values.firstWhere((e) => e.name == json['color']),
+      icon = json['icon'];
+
+  /// Converts the Game instance to a JSON object.
+  Map<String, dynamic> toJson() => {
+    'id': id,
+    'createdAt': createdAt.toIso8601String(),
+    'name': name,
+    'ruleset': ruleset.name,
+    'description': description,
+    'color': color.name,
+    'icon': icon,
+  };
+}

lib/data/dto/group.dart

@@ -4,37 +4,41 @@ import 'package:uuid/uuid.dart';
 
 class Group {
   final String id;
-  final DateTime createdAt;
   final String name;
+  final String description;
+  final DateTime createdAt;
   final List<Player> members;
 
   Group({
     String? id,
     DateTime? createdAt,
     required this.name,
+    String? description,
     required this.members,
   }) : id = id ?? const Uuid().v4(),
-       createdAt = createdAt ?? clock.now();
+       createdAt = createdAt ?? clock.now(),
+       description = description ?? '';
 
   @override
   String toString() {
-    return 'Group{id: $id, name: $name,members: $members}';
+    return 'Group{id: $id, name: $name, description: $description, members: $members}';
   }
 
-  /// Creates a Group instance from a JSON object.
+  /// Creates a Group instance from a JSON object (memberIds format).
+  /// Player objects are reconstructed from memberIds by the DataTransferService.
   Group.fromJson(Map<String, dynamic> json)
     : id = json['id'],
       createdAt = DateTime.parse(json['createdAt']),
       name = json['name'],
-      members = (json['members'] as List)
-          .map((memberJson) => Player.fromJson(memberJson))
-          .toList();
+      description = json['description'],
+      members = []; // Populated during import via DataTransferService
 
-  /// Converts the Group instance to a JSON object.
+  /// Converts the Group instance to a JSON object using normalized format (memberIds only).
   Map<String, dynamic> toJson() => {
     'id': id,
     'createdAt': createdAt.toIso8601String(),
     'name': name,
-    'members': members.map((member) => member.toJson()).toList(),
+    'description': description,
+    'memberIds': members.map((member) => member.id).toList(),
   };
 }

lib/data/dto/match.dart

@@ -1,4 +1,6 @@
 import 'package:clock/clock.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/dto/game.dart';
 import 'package:tallee/data/dto/group.dart';
 import 'package:tallee/data/dto/player.dart';
 import 'package:uuid/uuid.dart';
@@ -6,46 +8,61 @@ import 'package:uuid/uuid.dart';
 class Match {
   final String id;
   final DateTime createdAt;
+  final DateTime? endedAt;
   final String name;
-  final List<Player>? players;
+  final Game game;
   final Group? group;
+  final List<Player> players;
+  final String notes;
   Player? winner;
 
   Match({
     String? id,
     DateTime? createdAt,
+    this.endedAt,
     required this.name,
-    this.players,
+    required this.game,
     this.group,
+    this.players = const [],
+    String? notes,
     this.winner,
   }) : id = id ?? const Uuid().v4(),
-       createdAt = createdAt ?? clock.now();
+       createdAt = createdAt ?? clock.now(),
+       notes = notes ?? '';
 
   @override
   String toString() {
-    return 'Match{\n\tid: $id,\n\tname: $name,\n\tplayers: $players,\n\tgroup: $group,\n\twinner: $winner\n}';
+    return 'Match{id: $id, name: $name, game: $game, group: $group, players: $players, notes: $notes, endedAt: $endedAt}';
   }
 
-  /// Creates a Match instance from a JSON object.
+  /// Creates a Match instance from a JSON object (ID references format).
+  /// Related objects are reconstructed from IDs by the DataTransferService.
   Match.fromJson(Map<String, dynamic> json)
     : id = json['id'],
-      name = json['name'],
       createdAt = DateTime.parse(json['createdAt']),
-      players = json['players'] != null
-          ? (json['players'] as List)
-                .map((playerJson) => Player.fromJson(playerJson))
-                .toList()
+      endedAt = json['endedAt'] != null
+          ? DateTime.parse(json['endedAt'])
           : null,
-      group = json['group'] != null ? Group.fromJson(json['group']) : null,
-      winner = json['winner'] != null ? Player.fromJson(json['winner']) : null;
+      name = json['name'],
+      game = Game(
+        name: '',
+        ruleset: Ruleset.singleWinner,
+        description: '',
+        color: GameColor.blue,
+      ), // Populated during import via DataTransferService
+      group = null, // Populated during import via DataTransferService
+      players = [], // Populated during import via DataTransferService
+      notes = json['notes'] ?? '';
 
-  /// Converts the Match instance to a JSON object.
+  /// Converts the Match instance to a JSON object using normalized format (ID references only).
   Map<String, dynamic> toJson() => {
     'id': id,
     'createdAt': createdAt.toIso8601String(),
+    'endedAt': endedAt?.toIso8601String(),
     'name': name,
-    'players': players?.map((player) => player.toJson()).toList(),
-    'group': group?.toJson(),
-    'winner': winner?.toJson(),
+    'gameId': game.id,
+    'groupId': group?.id,
+    'playerIds': players.map((player) => player.id).toList(),
+    'notes': notes,
   };
 }

lib/data/dto/player.dart

@@ -5,26 +5,34 @@ class Player {
   final String id;
   final DateTime createdAt;
   final String name;
+  final String description;
 
-  Player({String? id, DateTime? createdAt, required this.name})
-    : id = id ?? const Uuid().v4(),
-      createdAt = createdAt ?? clock.now();
+  Player({
+    String? id,
+    DateTime? createdAt,
+    required this.name,
+    String? description,
+  }) : id = id ?? const Uuid().v4(),
+       createdAt = createdAt ?? clock.now(),
+       description = description ?? '';
 
   @override
   String toString() {
-    return 'Player{id: $id,name: $name}';
+    return 'Player{id: $id, name: $name, description: $description}';
   }
 
   /// Creates a Player instance from a JSON object.
   Player.fromJson(Map<String, dynamic> json)
     : id = json['id'],
       createdAt = DateTime.parse(json['createdAt']),
-      name = json['name'];
+      name = json['name'],
+      description = json['description'];
 
   /// Converts the Player instance to a JSON object.
   Map<String, dynamic> toJson() => {
     'id': id,
     'createdAt': createdAt.toIso8601String(),
     'name': name,
+    'description': description,
   };
 }

lib/data/dto/team.dart

@@ -0,0 +1,40 @@
+import 'package:clock/clock.dart';
+import 'package:tallee/data/dto/player.dart';
+import 'package:uuid/uuid.dart';
+
+class Team {
+  final String id;
+  final String name;
+  final DateTime createdAt;
+  final List<Player> members;
+
+  Team({
+    String? id,
+    required this.name,
+    DateTime? createdAt,
+    required this.members,
+  }) : id = id ?? const Uuid().v4(),
+       createdAt = createdAt ?? clock.now();
+
+  @override
+  String toString() {
+    return 'Team{id: $id, name: $name, members: $members}';
+  }
+
+  /// Creates a Team instance from a JSON object (memberIds format).
+  /// Player objects are reconstructed from memberIds by the DataTransferService.
+  Team.fromJson(Map<String, dynamic> json)
+    : id = json['id'],
+      name = json['name'],
+      createdAt = DateTime.parse(json['createdAt']),
+      members = []; // Populated during import via DataTransferService
+
+  /// Converts the Team instance to a JSON object using normalized format (memberIds only).
+  Map<String, dynamic> toJson() => {
+    'id': id,
+    'name': name,
+    'createdAt': createdAt.toIso8601String(),
+    'memberIds': members.map((member) => member.id).toList(),
+  };
+}
+

lib/l10n/arb/app_de.arb

@@ -9,7 +9,9 @@
   "choose_game": "Spielvorlage wählen",
   "choose_group": "Gruppe wählen",
   "choose_ruleset": "Regelwerk wählen",
+  "choose_color": "Farbe wählen",
   "could_not_add_player": "Spieler:in {playerName} konnte nicht hinzugefügt werden",
+  "create_game": "Spielvorlage erstellen",
   "create_group": "Gruppe erstellen",
   "create_match": "Spiel erstellen",
   "create_new_group": "Neue Gruppe erstellen",
@@ -23,12 +25,16 @@
   "delete": "Löschen",
   "delete_all_data": "Alle Daten löschen",
   "delete_group": "Diese Gruppe löschen",
-  "edit_group": "Gruppe bearbeiten",
-  "delete_group": "Gruppe löschen",
   "delete_match": "Spiel löschen",
+  "delete_game": "Spielvorlage löschen",
+  "delete_group": "Gruppe löschen",
+  "description": "Beschreibung",
+  "edit_game": "Spielvorlage bearbeiten",
   "edit_group": "Gruppe bearbeiten",
+  "edit_match": "Gruppe bearbeiten",
   "enter_results": "Ergebnisse eintragen",
   "error_creating_group": "Fehler beim Erstellen der Gruppe, bitte erneut versuchen",
+  "error_deleting_game": "Fehler beim Löschen der Spielvorlage, bitte erneut versuchen",
   "error_deleting_group": "Fehler beim Löschen der Gruppe, bitte erneut versuchen",
   "error_editing_group": "Fehler beim Bearbeiten der Gruppe, bitte erneut versuchen",
   "error_reading_file": "Fehler beim Lesen der Datei",
@@ -93,6 +99,9 @@
   "settings": "Einstellungen",
   "single_loser": "Ein:e Verlierer:in",
   "single_winner": "Ein:e Gewinner:in",
+  "highest_score": "Höchste Punkte",
+  "lowest_score": "Niedrigste Punkte",
+  "multiple_winners": "Mehrere Gewinner:innen",
   "statistics": "Statistiken",
   "stats": "Statistiken",
   "successfully_added_player": "Spieler:in {playerName} erfolgreich hinzugefügt",
@@ -104,5 +113,14 @@
   "winner": "Gewinner:in",
   "winrate": "Siegquote",
   "wins": "Siege",
-  "yesterday_at": "Gestern um"
+  "yesterday_at": "Gestern um",
+  "color_red": "Rot",
+  "color_blue": "Blau",
+  "color_green": "Grün",
+  "color_yellow": "Gelb",
+  "color_purple": "Lila",
+  "color_orange": "Orange",
+  "color_pink": "Rosa",
+  "color_teal": "Türkis",
+  "color": "Farbe"
 }

lib/l10n/arb/app_en.arb

@@ -27,9 +27,15 @@
   "@choose_ruleset": {
     "description": "Label for choosing a ruleset"
   },
+  "@choose_color": {
+    "description": "Label for choosing a color"
+  },
   "@could_not_add_player": {
     "description": "Error message when adding a player fails"
   },
+  "@create_game": {
+    "description": "Button text to create a game"
+  },
   "@create_group": {
     "description": "Button text to create a group"
   },
@@ -71,21 +77,36 @@
   "@delete_all_data": {
     "description": "Confirmation dialog for deleting all data"
   },
+  "@delete_game": {
+    "description": "Button text to delete a game"
+  },
   "@delete_group": {
     "description": "Confirmation dialog for deleting a group"
   },
   "@delete_match": {
     "description": "Button text to delete a match"
   },
+  "description": {
+    "description": "Description label"
+  },
+  "edit_game": {
+    "description": "Button text to edit a game"
+   },
   "@edit_group": {
       "description": "Button & Appbar label for editing a group"
   },
+  "@edit_match": {
+      "description": "Button & Appbar label for editing a match"
+  },
   "@enter_results": {
     "description": "Button text to enter match results"
   },
   "@error_creating_group": {
     "description": "Error message when group creation fails"
   },
+  "@error_deleting_game": {
+    "description": "Error message when game deletion fails"
+  },
   "@error_deleting_group": {
       "description": "Error message when group deletion fails"
   },
@@ -322,6 +343,9 @@
   "@yesterday_at": {
     "description": "Date format for yesterday"
   },
+  "@color": {
+    "description": "Color label"
+  },
   "all_players": "All players",
   "all_players_selected": "All players selected",
   "amount_of_matches": "Amount of Matches",
@@ -331,7 +355,9 @@
   "choose_game": "Choose Game",
   "choose_group": "Choose Group",
   "choose_ruleset": "Choose Ruleset",
+  "choose_color": "Choose Color",
   "could_not_add_player": "Could not add player",
+  "create_game": "Create Game",
   "create_group": "Create Group",
   "create_match": "Create match",
   "create_new_group": "Create new group",
@@ -344,11 +370,16 @@
   "days_ago": "{count} days ago",
   "delete": "Delete",
   "delete_all_data": "Delete all data",
+  "delete_game": "Delete Game",
   "delete_group": "Delete Group",
   "delete_match": "Delete Match",
+  "description": "Description",
+  "edit_game": "Edit Game",
   "edit_group": "Edit Group",
+  "edit_match": "Edit Match",
   "enter_results": "Enter Results",
   "error_creating_group": "Error while creating group, please try again",
+  "error_deleting_game": "Error while deleting game, please try again",
   "error_deleting_group": "Error while deleting group, please try again",
   "error_editing_group": "Error while editing group, please try again",
   "error_reading_file": "Error reading file",
@@ -412,6 +443,9 @@
   "settings": "Settings",
   "single_loser": "Single Loser",
   "single_winner": "Single Winner",
+  "highest_score": "Highest Score",
+  "lowest_score": "Lowest Score",
+  "multiple_winners": "Multiple Winners",
   "statistics": "Statistics",
   "stats": "Stats",
   "successfully_added_player": "Successfully added player {playerName}",
@@ -423,5 +457,14 @@
   "winner": "Winner",
   "winrate": "Winrate",
   "wins": "Wins",
-  "yesterday_at": "Yesterday at"
+  "yesterday_at": "Yesterday at",
+  "color_red": "Red",
+  "color_blue": "Blue",
+  "color_green": "Green",
+  "color_yellow": "Yellow",
+  "color_purple": "Purple",
+  "color_orange": "Orange",
+  "color_pink": "Pink",
+  "color_teal": "Teal",
+  "color": "Color"
 }

lib/l10n/generated/app_localizations.dart

@@ -98,6 +98,18 @@ abstract class AppLocalizations {
     Locale('en'),
   ];
 
+  /// No description provided for @description.
+  ///
+  /// In en, this message translates to:
+  /// **'Description'**
+  String get description;
+
+  /// No description provided for @edit_game.
+  ///
+  /// In en, this message translates to:
+  /// **'Edit Game'**
+  String get edit_game;
+
   /// Label for all players list
   ///
   /// In en, this message translates to:
@@ -152,12 +164,24 @@ abstract class AppLocalizations {
   /// **'Choose Ruleset'**
   String get choose_ruleset;
 
+  /// Label for choosing a color
+  ///
+  /// In en, this message translates to:
+  /// **'Choose Color'**
+  String get choose_color;
+
   /// Error message when adding a player fails
   ///
   /// In en, this message translates to:
   /// **'Could not add player'**
   String could_not_add_player(Object playerName);
 
+  /// Button text to create a game
+  ///
+  /// In en, this message translates to:
+  /// **'Create Game'**
+  String get create_game;
+
   /// Button text to create a group
   ///
   /// In en, this message translates to:
@@ -230,6 +254,12 @@ abstract class AppLocalizations {
   /// **'Delete all data'**
   String get delete_all_data;
 
+  /// Button text to delete a game
+  ///
+  /// In en, this message translates to:
+  /// **'Delete Game'**
+  String get delete_game;
+
   /// Confirmation dialog for deleting a group
   ///
   /// In en, this message translates to:
@@ -248,6 +278,12 @@ abstract class AppLocalizations {
   /// **'Edit Group'**
   String get edit_group;
 
+  /// Button & Appbar label for editing a match
+  ///
+  /// In en, this message translates to:
+  /// **'Edit Match'**
+  String get edit_match;
+
   /// Button text to enter match results
   ///
   /// In en, this message translates to:
@@ -260,6 +296,12 @@ abstract class AppLocalizations {
   /// **'Error while creating group, please try again'**
   String get error_creating_group;
 
+  /// Error message when game deletion fails
+  ///
+  /// In en, this message translates to:
+  /// **'Error while deleting game, please try again'**
+  String get error_deleting_game;
+
   /// Error message when group deletion fails
   ///
   /// In en, this message translates to:
@@ -638,6 +680,24 @@ abstract class AppLocalizations {
   /// **'Single Winner'**
   String get single_winner;
 
+  /// No description provided for @highest_score.
+  ///
+  /// In en, this message translates to:
+  /// **'Highest Score'**
+  String get highest_score;
+
+  /// No description provided for @lowest_score.
+  ///
+  /// In en, this message translates to:
+  /// **'Lowest Score'**
+  String get lowest_score;
+
+  /// No description provided for @multiple_winners.
+  ///
+  /// In en, this message translates to:
+  /// **'Multiple Winners'**
+  String get multiple_winners;
+
   /// Statistics tab label
   ///
   /// In en, this message translates to:
@@ -709,6 +769,60 @@ abstract class AppLocalizations {
   /// In en, this message translates to:
   /// **'Yesterday at'**
   String get yesterday_at;
+
+  /// No description provided for @color_red.
+  ///
+  /// In en, this message translates to:
+  /// **'Red'**
+  String get color_red;
+
+  /// No description provided for @color_blue.
+  ///
+  /// In en, this message translates to:
+  /// **'Blue'**
+  String get color_blue;
+
+  /// No description provided for @color_green.
+  ///
+  /// In en, this message translates to:
+  /// **'Green'**
+  String get color_green;
+
+  /// No description provided for @color_yellow.
+  ///
+  /// In en, this message translates to:
+  /// **'Yellow'**
+  String get color_yellow;
+
+  /// No description provided for @color_purple.
+  ///
+  /// In en, this message translates to:
+  /// **'Purple'**
+  String get color_purple;
+
+  /// No description provided for @color_orange.
+  ///
+  /// In en, this message translates to:
+  /// **'Orange'**
+  String get color_orange;
+
+  /// No description provided for @color_pink.
+  ///
+  /// In en, this message translates to:
+  /// **'Pink'**
+  String get color_pink;
+
+  /// No description provided for @color_teal.
+  ///
+  /// In en, this message translates to:
+  /// **'Teal'**
+  String get color_teal;
+
+  /// Color label
+  ///
+  /// In en, this message translates to:
+  /// **'Color'**
+  String get color;
 }
 
 class _AppLocalizationsDelegate

lib/l10n/generated/app_localizations_de.dart

@@ -8,6 +8,12 @@ import 'app_localizations.dart';
 class AppLocalizationsDe extends AppLocalizations {
   AppLocalizationsDe([String locale = 'de']) : super(locale);
 
+  @override
+  String get description => 'Beschreibung';
+
+  @override
+  String get edit_game => 'Spielvorlage bearbeiten';
+
   @override
   String get all_players => 'Alle Spieler:innen';
 
@@ -35,11 +41,17 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get choose_ruleset => 'Regelwerk wählen';
 
+  @override
+  String get choose_color => 'Farbe wählen';
+
   @override
   String could_not_add_player(Object playerName) {
     return 'Spieler:in $playerName konnte nicht hinzugefügt werden';
   }
 
+  @override
+  String get create_game => 'Spielvorlage erstellen';
+
   @override
   String get create_group => 'Gruppe erstellen';
 
@@ -78,6 +90,9 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get delete_all_data => 'Alle Daten löschen';
 
+  @override
+  String get delete_game => 'Spielvorlage löschen';
+
   @override
   String get delete_group => 'Gruppe löschen';
 
@@ -87,6 +102,9 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get edit_group => 'Gruppe bearbeiten';
 
+  @override
+  String get edit_match => 'Gruppe bearbeiten';
+
   @override
   String get enter_results => 'Ergebnisse eintragen';
 
@@ -94,6 +112,10 @@ class AppLocalizationsDe extends AppLocalizations {
   String get error_creating_group =>
       'Fehler beim Erstellen der Gruppe, bitte erneut versuchen';
 
+  @override
+  String get error_deleting_game =>
+      'Fehler beim Löschen der Spielvorlage, bitte erneut versuchen';
+
   @override
   String get error_deleting_group =>
       'Fehler beim Löschen der Gruppe, bitte erneut versuchen';
@@ -292,6 +314,15 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get single_winner => 'Ein:e Gewinner:in';
 
+  @override
+  String get highest_score => 'Höchste Punkte';
+
+  @override
+  String get lowest_score => 'Niedrigste Punkte';
+
+  @override
+  String get multiple_winners => 'Mehrere Gewinner:innen';
+
   @override
   String get statistics => 'Statistiken';
 
@@ -331,4 +362,31 @@ class AppLocalizationsDe extends AppLocalizations {
 
   @override
   String get yesterday_at => 'Gestern um';
+
+  @override
+  String get color_red => 'Rot';
+
+  @override
+  String get color_blue => 'Blau';
+
+  @override
+  String get color_green => 'Grün';
+
+  @override
+  String get color_yellow => 'Gelb';
+
+  @override
+  String get color_purple => 'Lila';
+
+  @override
+  String get color_orange => 'Orange';
+
+  @override
+  String get color_pink => 'Rosa';
+
+  @override
+  String get color_teal => 'Türkis';
+
+  @override
+  String get color => 'Farbe';
 }

lib/l10n/generated/app_localizations_en.dart

@@ -8,6 +8,12 @@ import 'app_localizations.dart';
 class AppLocalizationsEn extends AppLocalizations {
   AppLocalizationsEn([String locale = 'en']) : super(locale);
 
+  @override
+  String get description => 'Description';
+
+  @override
+  String get edit_game => 'Edit Game';
+
   @override
   String get all_players => 'All players';
 
@@ -35,11 +41,17 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get choose_ruleset => 'Choose Ruleset';
 
+  @override
+  String get choose_color => 'Choose Color';
+
   @override
   String could_not_add_player(Object playerName) {
     return 'Could not add player';
   }
 
+  @override
+  String get create_game => 'Create Game';
+
   @override
   String get create_group => 'Create Group';
 
@@ -78,6 +90,9 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get delete_all_data => 'Delete all data';
 
+  @override
+  String get delete_game => 'Delete Game';
+
   @override
   String get delete_group => 'Delete Group';
 
@@ -87,6 +102,9 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get edit_group => 'Edit Group';
 
+  @override
+  String get edit_match => 'Edit Match';
+
   @override
   String get enter_results => 'Enter Results';
 
@@ -94,6 +112,10 @@ class AppLocalizationsEn extends AppLocalizations {
   String get error_creating_group =>
       'Error while creating group, please try again';
 
+  @override
+  String get error_deleting_game =>
+      'Error while deleting game, please try again';
+
   @override
   String get error_deleting_group =>
       'Error while deleting group, please try again';
@@ -292,6 +314,15 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get single_winner => 'Single Winner';
 
+  @override
+  String get highest_score => 'Highest Score';
+
+  @override
+  String get lowest_score => 'Lowest Score';
+
+  @override
+  String get multiple_winners => 'Multiple Winners';
+
   @override
   String get statistics => 'Statistics';
 
@@ -330,4 +361,31 @@ class AppLocalizationsEn extends AppLocalizations {
 
   @override
   String get yesterday_at => 'Yesterday at';
+
+  @override
+  String get color_red => 'Red';
+
+  @override
+  String get color_blue => 'Blue';
+
+  @override
+  String get color_green => 'Green';
+
+  @override
+  String get color_yellow => 'Yellow';
+
+  @override
+  String get color_purple => 'Purple';
+
+  @override
+  String get color_orange => 'Orange';
+
+  @override
+  String get color_pink => 'Pink';
+
+  @override
+  String get color_teal => 'Teal';
+
+  @override
+  String get color => 'Color';
 }

lib/main.dart

@@ -35,15 +35,25 @@ class GameTracker extends StatelessWidget {
       },
       debugShowCheckedModeBanner: false,
       onGenerateTitle: (context) => AppLocalizations.of(context).app_name,
-      themeMode: ThemeMode.dark, // forces dark mode
+      themeMode: ThemeMode.dark,
       theme: ThemeData(
+        // main colors
         primaryColor: CustomTheme.primaryColor,
         scaffoldBackgroundColor: CustomTheme.backgroundColor,
+        // themes
         appBarTheme: CustomTheme.appBarTheme,
+        inputDecorationTheme: CustomTheme.inputDecorationTheme,
+        searchBarTheme: CustomTheme.searchBarTheme,
+        radioTheme: CustomTheme.radioTheme,
+        // color scheme
         colorScheme: ColorScheme.fromSeed(
-          seedColor: CustomTheme.primaryColor,
+          seedColor: CustomTheme.textColor,
           brightness: Brightness.dark,
-        ).copyWith(surface: CustomTheme.backgroundColor),
+          primary: CustomTheme.primaryColor,
+          onPrimary: CustomTheme.textColor,
+          surface: CustomTheme.backgroundColor,
+          onSurface: CustomTheme.textColor,
+        ),
         pageTransitionsTheme: const PageTransitionsTheme(
           builders: {
             TargetPlatform.iOS: CupertinoPageTransitionsBuilder(),

lib/presentation/views/main_menu/custom_navigation_bar.dart

@@ -141,7 +141,7 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
   }
 
   /// Returns the title of the current tab based on [currentIndex].
-  String _currentTabTitle(context) {
+  String _currentTabTitle(BuildContext context) {
     final loc = AppLocalizations.of(context);
     switch (currentIndex) {
       case 0:

lib/presentation/views/main_menu/group_view/create_group_view.dart

@@ -158,6 +158,7 @@ class _CreateGroupViewState extends State<CreateGroupView> {
                           updatedGroup = Group(
                             id: widget.groupToEdit!.id,
                             name: _groupNameController.text.trim(),
+                            description: '',
                             members: selectedPlayers,
                           );
                           //TODO: Implement group editing in database

lib/presentation/views/main_menu/group_view/group_view.dart

@@ -35,7 +35,8 @@ class _GroupViewState extends State<GroupView> {
     7,
     Group(
       name: 'Skeleton Group',
-      members: List.filled(6, Player(name: 'Skeleton Player')),
+      description: '',
+      members: List.filled(6, Player(name: 'Skeleton Player', description: '')),
     ),
   );
 

lib/presentation/views/main_menu/home_view.dart

@@ -2,7 +2,9 @@ import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import 'package:tallee/core/adaptive_page_route.dart';
 import 'package:tallee/core/constants.dart';
+import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/game.dart';
 import 'package:tallee/data/dto/group.dart';
 import 'package:tallee/data/dto/match.dart';
 import 'package:tallee/data/dto/player.dart';
@@ -40,13 +42,21 @@ class _HomeViewState extends State<HomeView> {
     2,
     Match(
       name: 'Skeleton Match',
+      game: Game(
+        name: '',
+        ruleset: Ruleset.singleWinner,
+        description: '',
+        color: GameColor.blue,
+      ),
       group: Group(
         name: 'Skeleton Group',
+        description: '',
         members: [
-          Player(name: 'Skeleton Player 1'),
-          Player(name: 'Skeleton Player 2'),
+          Player(name: 'Skeleton Player 1', description: ''),
+          Player(name: 'Skeleton Player 2', description: ''),
         ],
       ),
+      notes: '',
     ),
   );
 
@@ -114,7 +124,7 @@ class _HomeViewState extends State<HomeView> {
                                           MatchResultView(match: match),
                                     ),
                                   );
-                                  await updatedWinnerinRecentMatches(match.id);
+                                  await updatedWinnerInRecentMatches(match.id);
                                 },
                               ),
                             )
@@ -214,7 +224,7 @@ class _HomeViewState extends State<HomeView> {
   }
 
   /// Updates the winner information for a specific match in the recent matches list.
-  Future<void> updatedWinnerinRecentMatches(String matchId) async {
+  Future<void> updatedWinnerInRecentMatches(String matchId) async {
     final db = Provider.of<AppDatabase>(context, listen: false);
     final winner = await db.matchDao.getWinner(matchId: matchId);
     final matchIndex = recentMatches.indexWhere((match) => match.id == matchId);

lib/presentation/views/main_menu/match_view/create_match/choose_game_view.dart

@@ -1,25 +1,33 @@
 import 'package:flutter/material.dart';
+import 'package:tallee/core/adaptive_page_route.dart';
+import 'package:tallee/core/common.dart';
 import 'package:tallee/core/custom_theme.dart';
-import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/dto/game.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
+import 'package:tallee/presentation/views/main_menu/match_view/create_match/game_view/create_game_view.dart';
 import 'package:tallee/presentation/widgets/text_input/custom_search_bar.dart';
 import 'package:tallee/presentation/widgets/tiles/title_description_list_tile.dart';
 
 class ChooseGameView extends StatefulWidget {
   /// A view that allows the user to choose a game from a list of available games
-  /// - [games]: A list of tuples containing the game name, description and ruleset
-  /// - [initialGameIndex]: The index of the initially selected game
+  /// - [games]: The list of available games
+  /// - [initialSelectedGameId]: The id of the initially selected game
+  /// - [onGamesUpdated]: Optional callback invoked when the games are updated
   const ChooseGameView({
     super.key,
     required this.games,
-    required this.initialGameIndex,
+    required this.initialSelectedGameId,
+    this.onGamesUpdated,
   });
 
   /// A list of tuples containing the game name, description and ruleset
-  final List<(String, String, Ruleset)> games;
+  final List<Game> games;
 
   /// The index of the initially selected game
-  final int initialGameIndex;
+  final String initialSelectedGameId;
+
+  /// Optional callback invoked when the games are updated
+  final VoidCallback? onGamesUpdated;
 
   @override
   State<ChooseGameView> createState() => _ChooseGameViewState();
@@ -29,12 +37,18 @@ class _ChooseGameViewState extends State<ChooseGameView> {
   /// Controller for the search bar
   final TextEditingController searchBarController = TextEditingController();
 
-  /// Currently selected game index
-  late int selectedGameIndex;
+  /// Currently selected game id
+  late String selectedGameId;
+
+  /// Games filtered according to the current search query
+  late List<Game> filteredGames;
 
   @override
   void initState() {
-    selectedGameIndex = widget.initialGameIndex;
+    selectedGameId = widget.initialSelectedGameId;
+
+    // Start with all games visible
+    filteredGames = List<Game>.from(widget.games);
     super.initState();
   }
 
@@ -48,9 +62,32 @@ class _ChooseGameViewState extends State<ChooseGameView> {
         leading: IconButton(
           icon: const Icon(Icons.arrow_back_ios),
           onPressed: () {
-            Navigator.of(context).pop(selectedGameIndex);
+            Navigator.of(context).pop(selectedGameId);
           },
         ),
+        actions: [
+          IconButton(
+            icon: const Icon(Icons.add),
+            onPressed: () async {
+              final result = await Navigator.push(
+                context,
+                adaptivePageRoute(
+                  builder: (context) => CreateGameView(
+                    onGameChanged: () {
+                      widget.onGamesUpdated?.call();
+                    },
+                  ),
+                ),
+              );
+              if (result != null && result.game != null) {
+                setState(() {
+                  widget.games.insert(0, result.game);
+                });
+                _refreshFromSource();
+              }
+            },
+          ),
+        ],
         title: Text(loc.choose_game),
       ),
       body: PopScope(
@@ -61,7 +98,7 @@ class _ChooseGameViewState extends State<ChooseGameView> {
           if (didPop) {
             return;
           }
-          Navigator.of(context).pop(selectedGameIndex);
+          Navigator.of(context).pop(selectedGameId);
         },
         child: Column(
           children: [
@@ -70,30 +107,63 @@ class _ChooseGameViewState extends State<ChooseGameView> {
               child: CustomSearchBar(
                 controller: searchBarController,
                 hintText: loc.game_name,
+                onChanged: (value) {
+                  _applySearchFilter(value);
+                },
               ),
             ),
             const SizedBox(height: 5),
             Expanded(
               child: ListView.builder(
-                itemCount: widget.games.length,
+                itemCount: filteredGames.length,
                 itemBuilder: (BuildContext context, int index) {
+                  final game = filteredGames[index];
                   return TitleDescriptionListTile(
-                    title: widget.games[index].$1,
-                    description: widget.games[index].$2,
-                    badgeText: translateRulesetToString(
-                      widget.games[index].$3,
-                      context,
-                    ),
-                    isHighlighted: selectedGameIndex == index,
-                    onPressed: () async {
+                    title: game.name,
+                    description: game.description,
+                    badgeText: translateRulesetToString(game.ruleset, context),
+                    isHighlighted: selectedGameId == game.id,
+                    onTap: () async {
                       setState(() {
-                        if (selectedGameIndex == index) {
-                          selectedGameIndex = -1;
+                        if (selectedGameId == game.id) {
+                          selectedGameId = '';
                         } else {
-                          selectedGameIndex = index;
+                          selectedGameId = game.id;
                         }
                       });
                     },
+                    onLongPress: () async {
+                      final result = await Navigator.push(
+                        context,
+                        adaptivePageRoute(
+                          builder: (context) => CreateGameView(
+                            gameToEdit: game,
+                            onGameChanged: () {
+                              widget.onGamesUpdated?.call();
+                            },
+                          ),
+                        ),
+                      );
+                      if (result != null && result.game != null) {
+                        // Find the index in the original list to mutate
+                        final originalIndex = widget.games.indexWhere(
+                          (g) => g.id == game.id,
+                        );
+                        if (originalIndex == -1) {
+                          return;
+                        }
+                        if (result.delete) {
+                          setState(() {
+                            widget.games.removeAt(originalIndex);
+                          });
+                        } else {
+                          setState(() {
+                            widget.games[originalIndex] = result.game;
+                          });
+                        }
+                        _refreshFromSource();
+                      }
+                    },
                   );
                 },
               ),
@@ -103,4 +173,28 @@ class _ChooseGameViewState extends State<ChooseGameView> {
       ),
     );
   }
+
+  /// Applies the search filter to the games list based on [query].
+  void _applySearchFilter(String query) {
+    final q = query.toLowerCase().trim();
+    if (q.isEmpty) {
+      setState(() {
+        filteredGames = List<Game>.from(widget.games);
+      });
+      return;
+    }
+
+    setState(() {
+      filteredGames = widget.games.where((game) {
+        final name = game.name.toLowerCase();
+        final description = game.description.toLowerCase();
+        return name.contains(q) || description.contains(q);
+      }).toList();
+    });
+  }
+
+  /// Re-applies the current filter after the underlying games list changed.
+  void _refreshFromSource() {
+    _applySearchFilter(searchBarController.text);
+  }
 }

lib/presentation/views/main_menu/match_view/create_match/create_match_view.dart

@@ -5,6 +5,7 @@ import 'package:tallee/core/constants.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/game.dart';
 import 'package:tallee/data/dto/group.dart';
 import 'package:tallee/data/dto/match.dart';
 import 'package:tallee/data/dto/player.dart';
@@ -17,57 +18,63 @@ import 'package:tallee/presentation/widgets/player_selection.dart';
 import 'package:tallee/presentation/widgets/text_input/text_input_field.dart';
 import 'package:tallee/presentation/widgets/tiles/choose_tile.dart';
 
+/// A stateful widget for creating or editing a match.
 class CreateMatchView extends StatefulWidget {
-  /// A view that allows creating a new match
-  /// [onWinnerChanged]: Optional callback invoked when the winner is changed
-  const CreateMatchView({super.key, this.onWinnerChanged, this.match});
+  /// Constructor for `CreateMatchView`.
+  ///
+  /// [onWinnerChanged] is an optional callback invoked when the winner is changed.
+  /// [matchToEdit] is an optional match to prefill the fields.
+  /// [onMatchUpdated] is an optional callback invoked when the match is updated.
+  const CreateMatchView({
+    super.key,
+    this.onWinnerChanged,
+    this.matchToEdit,
+    this.onMatchUpdated,
+  });
 
-  /// Optional callback invoked when the winner is changed
+  /// Optional callback invoked when the winner is changed.
   final VoidCallback? onWinnerChanged;
 
-  /// An optional match to prefill the fields
-  final Match? match;
+  /// Optional callback invoked when the match is updated.
+  final void Function(Match)? onMatchUpdated;
+
+  /// An optional match to prefill the fields.
+  final Match? matchToEdit;
 
   @override
   State<CreateMatchView> createState() => _CreateMatchViewState();
 }
 
+/// The state class for `CreateMatchView`, managing the UI and logic for creating or editing a match.
 class _CreateMatchViewState extends State<CreateMatchView> {
+  /// The database instance for accessing match data.
   late final AppDatabase db;
 
-  /// Controller for the match name input field
+  /// Controller for the match name input field.
   final TextEditingController _matchNameController = TextEditingController();
 
-  /// Hint text for the match name input field
+  /// Hint text for the match name input field.
   String? hintText;
 
-  /// List of all groups from the database
+  /// List of all games from the database.
+  List<Game> gamesList = [];
+
+  /// List of all groups from the database.
   List<Group> groupsList = [];
 
-  /// List of all players from the database
+  /// List of all players from the database.
   List<Player> playerList = [];
 
-  /// List of players filtered based on the selected group
-  /// If a group is selected, this list contains all players from [playerList]
-  /// who are not members of the selected group. If no group is selected,
-  /// this list is identical to [playerList].
-  List<Player> filteredPlayerList = [];
-
-  /// The currently selected group
+  /// The currently selected group.
   Group? selectedGroup;
 
-  /// The index of the currently selected group in [groupsList] to mark it in
-  /// the [ChooseGroupView]
-  String selectedGroupId = '';
+  /// The currently selected game.
+  Game? selectedGame;
 
-  /// The index of the currently selected game in [games] to mark it in
-  /// the [ChooseGameView]
-  int selectedGameIndex = -1;
+  /// The currently selected players.
+  List<Player> selectedPlayers = [];
 
-  /// The currently selected players
-  List<Player>? selectedPlayers;
-
-  /// GlobalKey for ScaffoldMessenger to show snackbars
+  /// GlobalKey for ScaffoldMessenger to show snackbars.
   final _scaffoldMessengerKey = GlobalKey<ScaffoldMessengerState>();
 
   @override
@@ -79,30 +86,22 @@ class _CreateMatchViewState extends State<CreateMatchView> {
 
     db = Provider.of<AppDatabase>(context, listen: false);
 
+    // Load games, groups, and players from the database.
     Future.wait([
+      db.gameDao.getAllGames(),
       db.groupDao.getAllGroups(),
       db.playerDao.getAllPlayers(),
     ]).then((result) async {
-      groupsList = result[0] as List<Group>;
-      playerList = result[1] as List<Player>;
-      setState(() {
-        filteredPlayerList = List.from(playerList);
-      });
-    });
+      gamesList = result[0] as List<Game>;
+      gamesList.sort((a, b) => b.createdAt.compareTo(a.createdAt));
+      groupsList = result[1] as List<Group>;
+      playerList = result[2] as List<Player>;
 
-    // If a match is provided, prefill the fields
-    if (widget.match != null) {
-      final match = widget.match!;
-      _matchNameController.text = match.name;
-      selectedGroup = match.group;
-      selectedGroupId = match.group?.id ?? '';
-      selectedPlayers = match.players ?? [];
-      if (selectedGroup != null) {
-        filteredPlayerList = playerList
-            .where((p) => !selectedGroup!.members.any((m) => m.id == p.id))
-            .toList();
+      // If a match is provided, prefill the fields.
+      if (widget.matchToEdit != null) {
+        prefillMatchDetails();
       }
-    }
+    });
   }
 
   @override
@@ -118,28 +117,27 @@ class _CreateMatchViewState extends State<CreateMatchView> {
     hintText ??= loc.match_name;
   }
 
-  List<(String, String, Ruleset)> games = [
-    ('Example Game 1', 'This is a description', Ruleset.leastPoints),
-    ('Example Game 2', '', Ruleset.singleWinner),
-  ];
-
   @override
   Widget build(BuildContext context) {
     final loc = AppLocalizations.of(context);
-    final buttonText = widget.match != null
+    final buttonText = widget.matchToEdit != null
         ? loc.save_changes
         : loc.create_match;
+    final viewTitle = widget.matchToEdit != null
+        ? loc.edit_match
+        : loc.create_new_match;
 
     return ScaffoldMessenger(
       key: _scaffoldMessengerKey,
       child: Scaffold(
         resizeToAvoidBottomInset: false,
         backgroundColor: CustomTheme.backgroundColor,
-        appBar: AppBar(title: Text(loc.create_new_match)),
+        appBar: AppBar(title: Text(viewTitle)),
         body: SafeArea(
           child: Column(
             mainAxisAlignment: MainAxisAlignment.start,
             children: [
+              // Match name input field.
               Container(
                 margin: CustomTheme.tileMargin,
                 child: TextInputField(
@@ -148,69 +146,88 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                   maxLength: Constants.MAX_MATCH_NAME_LENGTH,
                 ),
               ),
+              // Game selection tile.
               ChooseTile(
                 title: loc.game,
-                trailingText: selectedGameIndex == -1
+                trailingText: selectedGame == null
                     ? loc.none
-                    : games[selectedGameIndex].$1,
+                    : selectedGame!.name,
                 onPressed: () async {
-                  selectedGameIndex = await Navigator.of(context).push(
-                    adaptivePageRoute(
-                      builder: (context) => ChooseGameView(
-                        games: games,
-                        initialGameIndex: selectedGameIndex,
-                      ),
-                    ),
-                  );
+                  final String? selectedGameId = await Navigator.of(context)
+                      .push(
+                        adaptivePageRoute(
+                          builder: (context) => ChooseGameView(
+                            games: gamesList,
+                            initialSelectedGameId: selectedGame?.id ?? '',
+                            onGamesUpdated: loadGames,
+                          ),
+                        ),
+                      );
+
+                  try {
+                    selectedGame = gamesList.firstWhere(
+                      (g) => g.id == selectedGameId,
+                    );
+                  } catch (_) {
+                    selectedGame = null;
+                  }
+
                   setState(() {
-                    if (selectedGameIndex != -1) {
-                      hintText = games[selectedGameIndex].$1;
+                    if (selectedGame != null) {
+                      hintText = selectedGame!.name;
                     } else {
                       hintText = loc.match_name;
                     }
                   });
                 },
               ),
+              // Group selection tile.
               ChooseTile(
                 title: loc.group,
                 trailingText: selectedGroup == null
                     ? loc.none_group
                     : selectedGroup!.name,
                 onPressed: () async {
+                  selectedPlayers.removeWhere(
+                    (player) =>
+                        selectedGroup?.members.any(
+                          (member) => member.id == player.id,
+                        ) ??
+                        false,
+                  );
+
                   selectedGroup = await Navigator.of(context).push(
                     adaptivePageRoute(
                       builder: (context) => ChooseGroupView(
                         groups: groupsList,
-                        initialGroupId: selectedGroupId,
+                        initialGroupId: selectedGroup?.id ?? '',
                       ),
                     ),
                   );
-                  selectedGroupId = selectedGroup?.id ?? '';
-                  if (selectedGroup != null) {
-                    filteredPlayerList = playerList
-                        .where(
-                          (p) =>
-                              !selectedGroup!.members.any((m) => m.id == p.id),
-                        )
-                        .toList();
-                  } else {
-                    filteredPlayerList = List.from(playerList);
-                  }
-                  setState(() {});
+
+                  setState(() {
+                    if (selectedGroup != null) {
+                      setState(() {
+                        selectedPlayers += [...selectedGroup!.members];
+                      });
+                    }
+                  });
                 },
               ),
+              // Player selection widget.
               Expanded(
                 child: PlayerSelection(
                   key: ValueKey(selectedGroup?.id ?? 'no_group'),
-                  initialSelectedPlayers: selectedPlayers ?? [],
-                  availablePlayers: filteredPlayerList,
+                  initialSelectedPlayers: selectedPlayers,
                   onChanged: (value) {
                     setState(() {
                       selectedPlayers = value;
+                      removeGroupWhenNoMemberLeft();
                     });
                   },
                 ),
               ),
+              // Create or save button.
               CustomWidthButton(
                 text: buttonText,
                 sizeRelativeToWidth: 0.95,
@@ -232,26 +249,25 @@ class _CreateMatchViewState extends State<CreateMatchView> {
   ///
   /// Returns `true` if:
   /// - A ruleset is selected AND
-  /// - Either a group is selected OR at least 2 players are selected
+  /// - Either a group is selected OR at least 2 players are selected.
   bool _enableCreateGameButton() {
     return (selectedGroup != null ||
-        (selectedPlayers != null && selectedPlayers!.length > 1));
+        (selectedPlayers.length > 1) && selectedGame != null);
   }
 
+  /// Handles navigation when the create or save button is pressed.
+  ///
+  /// If a match is being edited, updates the match in the database.
+  /// Otherwise, creates a new match and navigates to the MatchResultView.
   void buttonNavigation(BuildContext context) async {
-    if (widget.match != null) {
-      // TODO: Implement updating match logic here
-      Navigator.pop(context);
+    if (widget.matchToEdit != null) {
+      await updateMatch();
+      if (context.mounted) {
+        Navigator.pop(context);
+      }
     } else {
-      Match match = Match(
-        name: _matchNameController.text.isEmpty
-            ? (hintText ?? '')
-            : _matchNameController.text.trim(),
-        createdAt: DateTime.now(),
-        group: selectedGroup,
-        players: selectedPlayers,
-      );
-      await db.matchDao.addMatch(match: match);
+      final match = await createMatch();
+
       if (context.mounted) {
         Navigator.pushReplacement(
           context,
@@ -266,4 +282,115 @@ class _CreateMatchViewState extends State<CreateMatchView> {
       }
     }
   }
+
+  /// Updates the existing match in the database.
+  Future<void> updateMatch() async {
+    final updatedMatch = Match(
+      id: widget.matchToEdit!.id,
+      name: _matchNameController.text.isEmpty
+          ? (hintText ?? '')
+          : _matchNameController.text.trim(),
+      group: selectedGroup,
+      players: selectedPlayers,
+      game: selectedGame!,
+      winner: widget.matchToEdit!.winner,
+      createdAt: widget.matchToEdit!.createdAt,
+      endedAt: widget.matchToEdit!.endedAt,
+      notes: widget.matchToEdit!.notes,
+    );
+
+    if (widget.matchToEdit!.name != updatedMatch.name) {
+      await db.matchDao.updateMatchName(
+        matchId: widget.matchToEdit!.id,
+        newName: updatedMatch.name,
+      );
+    }
+
+    if (widget.matchToEdit!.group?.id != updatedMatch.group?.id) {
+      await db.matchDao.updateMatchGroup(
+        matchId: widget.matchToEdit!.id,
+        newGroupId: updatedMatch.group?.id,
+      );
+    }
+
+    if (widget.matchToEdit!.game.id != updatedMatch.game.id) {
+      await db.matchDao.updateMatchGame(
+        matchId: widget.matchToEdit!.id,
+        gameId: updatedMatch.game.id,
+      );
+    }
+
+    for (var player in updatedMatch.players) {
+      if (!widget.matchToEdit!.players.any((p) => p.id == player.id)) {
+        await db.playerMatchDao.addPlayerToMatch(
+          matchId: widget.matchToEdit!.id,
+          playerId: player.id,
+        );
+      }
+    }
+
+    for (var player in widget.matchToEdit!.players) {
+      if (!updatedMatch.players.any((p) => p.id == player.id)) {
+        await db.playerMatchDao.removePlayerFromMatch(
+          matchId: widget.matchToEdit!.id,
+          playerId: player.id,
+        );
+        if (widget.matchToEdit!.winner?.id == player.id) {
+          updatedMatch.winner = null;
+        }
+      }
+    }
+
+    widget.onMatchUpdated?.call(updatedMatch);
+  }
+
+  /// Creates a new match and adds it to the database.
+  Future<Match> createMatch() async {
+    Match match = Match(
+      name: _matchNameController.text.isEmpty
+          ? (hintText ?? '')
+          : _matchNameController.text.trim(),
+      createdAt: DateTime.now(),
+      group: selectedGroup,
+      players: selectedPlayers,
+      game: selectedGame!,
+    );
+    await db.matchDao.addMatch(match: match);
+    return match;
+  }
+
+  /// Prefills the input fields if a match was provided to the view.
+  void prefillMatchDetails() {
+    final match = widget.matchToEdit!;
+    _matchNameController.text = match.name;
+    selectedPlayers = match.players;
+    selectedGame = match.game;
+
+    if (match.group != null) {
+      selectedGroup = match.group;
+    }
+  }
+
+  /// Removes the group if none of its members are in the selected players list.
+  Future<void> removeGroupWhenNoMemberLeft() async {
+    if (selectedGroup == null) return;
+
+    if (!selectedPlayers.any(
+      (player) =>
+          selectedGroup!.members.any((member) => member.id == player.id),
+    )) {
+      setState(() {
+        selectedGroup = null;
+      });
+    }
+  }
+
+  /// Loads all games from the database and updates the state.
+  Future<void> loadGames() async {
+    final result = await db.gameDao.getAllGames();
+    result.sort((a, b) => b.createdAt.compareTo(a.createdAt));
+    setState(() {
+      gamesList = result;
+    });
+  }
 }

lib/presentation/views/main_menu/match_view/create_match/game_view/choose_color_view.dart

@@ -0,0 +1,78 @@
+import 'package:flutter/material.dart';
+import 'package:tallee/core/common.dart';
+import 'package:tallee/core/custom_theme.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/l10n/generated/app_localizations.dart';
+import 'package:tallee/presentation/widgets/tiles/title_description_list_tile.dart';
+
+class ChooseColorView extends StatefulWidget {
+  /// A view that allows the user to choose a color from a list of available game colors
+  /// - [initialColor]: The initially selected color
+  const ChooseColorView({super.key, this.initialColor});
+
+  /// The initially selected color
+  final GameColor? initialColor;
+
+  @override
+  State<ChooseColorView> createState() => _ChooseColorViewState();
+}
+
+class _ChooseColorViewState extends State<ChooseColorView> {
+  /// Currently selected color
+  GameColor? selectedColor;
+
+  @override
+  void initState() {
+    selectedColor = widget.initialColor;
+    super.initState();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final loc = AppLocalizations.of(context);
+    const colors = GameColor.values;
+
+    return Scaffold(
+      backgroundColor: CustomTheme.backgroundColor,
+      appBar: AppBar(
+        leading: IconButton(
+          icon: const Icon(Icons.arrow_back_ios),
+          onPressed: () {
+            Navigator.of(context).pop(selectedColor);
+          },
+        ),
+        title: Text(loc.choose_color),
+      ),
+      body: PopScope(
+        canPop: false,
+        onPopInvokedWithResult: (bool didPop, Object? result) {
+          if (didPop) return;
+          Navigator.of(context).pop(selectedColor);
+        },
+        child: ListView.builder(
+          padding: const EdgeInsets.only(bottom: 85),
+          itemCount: colors.length,
+          itemBuilder: (BuildContext context, int index) {
+            final color = colors[index];
+            return TitleDescriptionListTile(
+              onTap: () {
+                setState(() {
+                  if (selectedColor == color) {
+                    selectedColor = null;
+                  } else {
+                    selectedColor = color;
+                  }
+                });
+              },
+              title: translateGameColorToString(color, context),
+              description: '',
+              isHighlighted: selectedColor == color,
+              badgeText: '          ', //Breite für Color Badge
+              badgeColor: getColorFromGameColor(color),
+            );
+          },
+        ),
+      ),
+    );
+  }
+}

lib/presentation/views/main_menu/match_view/create_match/game_view/choose_ruleset_view.dart

@@ -0,0 +1,99 @@
+import 'package:flutter/material.dart';
+import 'package:tallee/core/common.dart';
+import 'package:tallee/core/custom_theme.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/l10n/generated/app_localizations.dart';
+import 'package:tallee/presentation/widgets/tiles/title_description_list_tile.dart';
+
+class ChooseRulesetView extends StatefulWidget {
+  /// A view that allows the user to choose a ruleset from a list of available rulesets
+  /// - [rulesets]: A list of tuples containing the ruleset and its description
+  /// - [initialRulesetIndex]: The index of the initially selected ruleset
+  const ChooseRulesetView({
+    super.key,
+    required this.rulesets,
+    required this.initialRulesetIndex,
+  });
+
+  /// A list of tuples containing the ruleset and its description
+  final List<(Ruleset, String)> rulesets;
+
+  /// The index of the initially selected ruleset
+  final int initialRulesetIndex;
+  @override
+  State<ChooseRulesetView> createState() => _ChooseRulesetViewState();
+}
+
+class _ChooseRulesetViewState extends State<ChooseRulesetView> {
+  /// Currently selected ruleset index
+  late int selectedRulesetIndex;
+
+  @override
+  void initState() {
+    selectedRulesetIndex = widget.initialRulesetIndex;
+    super.initState();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final loc = AppLocalizations.of(context);
+    return DefaultTabController(
+      length: 2,
+      initialIndex: 0,
+      child: Scaffold(
+        backgroundColor: CustomTheme.backgroundColor,
+        appBar: AppBar(
+          leading: IconButton(
+            icon: const Icon(Icons.arrow_back_ios),
+            onPressed: () {
+              Navigator.of(context).pop(
+                selectedRulesetIndex == -1
+                    ? null
+                    : widget.rulesets[selectedRulesetIndex].$1,
+              );
+            },
+          ),
+          title: Text(loc.choose_ruleset),
+        ),
+        body: PopScope(
+          // This fixes that the Android Back Gesture didn't return the
+          // selectedRulesetIndex and therefore the selected Ruleset wasn't saved
+          canPop: false,
+          onPopInvokedWithResult: (bool didPop, Object? result) {
+            if (didPop) {
+              return;
+            }
+            Navigator.of(context).pop(
+              selectedRulesetIndex == -1
+                  ? null
+                  : widget.rulesets[selectedRulesetIndex].$1,
+            );
+          },
+          child: ListView.builder(
+            padding: const EdgeInsets.only(bottom: 85),
+            itemCount: widget.rulesets.length,
+            itemBuilder: (BuildContext context, int index) {
+              return TitleDescriptionListTile(
+                onTap: () async {
+                  setState(() {
+                    if (selectedRulesetIndex == index) {
+                      selectedRulesetIndex = -1;
+                    } else {
+                      selectedRulesetIndex = index;
+                    }
+                  });
+                },
+                title: translateRulesetToString(
+                  widget.rulesets[index].$1,
+                  context,
+                ),
+                description: widget.rulesets[index].$2,
+                isHighlighted: selectedRulesetIndex == index,
+              );
+            },
+          ),
+        ),
+      ),
+    );
+  }
+}

lib/presentation/views/main_menu/match_view/create_match/game_view/create_game_view.dart

@@ -0,0 +1,351 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:tallee/core/adaptive_page_route.dart';
+import 'package:tallee/core/common.dart';
+import 'package:tallee/core/constants.dart';
+import 'package:tallee/core/custom_theme.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/l10n/generated/app_localizations.dart';
+import 'package:tallee/presentation/views/main_menu/match_view/create_match/game_view/choose_color_view.dart';
+import 'package:tallee/presentation/views/main_menu/match_view/create_match/game_view/choose_ruleset_view.dart';
+import 'package:tallee/presentation/widgets/buttons/custom_width_button.dart';
+import 'package:tallee/presentation/widgets/custom_alert_dialog.dart';
+import 'package:tallee/presentation/widgets/text_input/text_input_field.dart';
+import 'package:tallee/presentation/widgets/tiles/choose_tile.dart';
+
+/// A stateful widget for creating or editing a game.
+/// - [gameToEdit] An optional game to prefill the fields
+/// - [onGameChanged] Callback to invoke when the game is created or edited
+class CreateGameView extends StatefulWidget {
+  const CreateGameView({
+    super.key,
+    this.gameToEdit,
+    required this.onGameChanged,
+  });
+
+  /// An optional game to prefill the fields
+  final Game? gameToEdit;
+
+  /// Callback to invoke when the game is created or edited
+  final VoidCallback onGameChanged;
+
+  @override
+  State<CreateGameView> createState() => _CreateGameViewState();
+}
+
+class _CreateGameViewState extends State<CreateGameView> {
+  /// GlobalKey for ScaffoldMessenger to show snackbars
+  final _scaffoldMessengerKey = GlobalKey<ScaffoldMessengerState>();
+
+  /// The database instance for accessing game data.
+  late final AppDatabase db;
+
+  /// The currently selected ruleset for the game.
+  Ruleset? selectedRuleset;
+
+  /// The index of the currently selected ruleset.
+  int selectedRulesetIndex = -1;
+
+  /// A list of available rulesets and their localized names.
+  late List<(Ruleset, String)> _rulesets;
+
+  /// The currently selected color for the game.
+  GameColor? selectedColor;
+
+  /// Controller for the game name input field.
+  final _gameNameController = TextEditingController();
+
+  /// Controller for the game description input field.
+  final _descriptionController = TextEditingController();
+
+  /// The ID of the currently selected group.
+  late String selectedGroupId;
+
+  /// A controller for the search bar input field.
+  final TextEditingController controller = TextEditingController();
+
+  /// A list of groups filtered based on the search query.
+  late final List<Group> filteredGroups;
+
+  @override
+  void initState() {
+    super.initState();
+    db = Provider.of<AppDatabase>(context, listen: false);
+    _gameNameController.addListener(() => setState(() {}));
+  }
+
+  @override
+  void didChangeDependencies() {
+    super.didChangeDependencies();
+    _rulesets = [
+      (
+        Ruleset.singleWinner,
+        translateRulesetToString(Ruleset.singleWinner, context),
+      ),
+      (
+        Ruleset.singleLoser,
+        translateRulesetToString(Ruleset.singleLoser, context),
+      ),
+      (
+        Ruleset.highestScore,
+        translateRulesetToString(Ruleset.highestScore, context),
+      ),
+      (
+        Ruleset.lowestScore,
+        translateRulesetToString(Ruleset.lowestScore, context),
+      ),
+      (
+        Ruleset.multipleWinners,
+        translateRulesetToString(Ruleset.multipleWinners, context),
+      ),
+    ];
+
+    if (widget.gameToEdit != null) {
+      _gameNameController.text = widget.gameToEdit!.name;
+      _descriptionController.text = widget.gameToEdit!.description;
+      selectedRuleset = widget.gameToEdit!.ruleset;
+      selectedColor = widget.gameToEdit!.color;
+
+      selectedRulesetIndex = _rulesets.indexWhere(
+        (r) => r.$1 == selectedRuleset,
+      );
+    }
+  }
+
+  @override
+  void dispose() {
+    _gameNameController.dispose();
+    _descriptionController.dispose();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    var loc = AppLocalizations.of(context);
+    final isEditing = widget.gameToEdit != null;
+
+    return ScaffoldMessenger(
+      child: Scaffold(
+        backgroundColor: CustomTheme.backgroundColor,
+        appBar: AppBar(
+          title: Text(isEditing ? loc.edit_game : loc.create_game),
+          actions: widget.gameToEdit == null
+              ? []
+              : [
+                  IconButton(
+                    icon: const Icon(Icons.delete),
+                    onPressed: () async {
+                      if (widget.gameToEdit != null) {
+                        showDialog<bool>(
+                          context: context,
+                          builder: (context) => CustomAlertDialog(
+                            title: loc.delete_game,
+                            content: loc.this_cannot_be_undone,
+                            actions: [
+                              TextButton(
+                                onPressed: () =>
+                                    Navigator.of(context).pop(false),
+                                child: Text(loc.cancel),
+                              ),
+                              TextButton(
+                                onPressed: () =>
+                                    Navigator.of(context).pop(true),
+                                child: Text(loc.delete),
+                              ),
+                            ],
+                          ),
+                        ).then((confirmed) async {
+                          if (confirmed == true && context.mounted) {
+                            bool success = await db.gameDao.deleteGame(
+                              gameId: widget.gameToEdit!.id,
+                            );
+                            if (!context.mounted) return;
+                            if (success) {
+                              widget.onGameChanged.call();
+                              Navigator.of(
+                                context,
+                              ).pop((game: widget.gameToEdit, delete: true));
+                            } else {
+                              if (!mounted) return;
+                              showSnackbar(message: loc.error_deleting_game);
+                            }
+                          }
+                        });
+                      }
+                    },
+                  ),
+                ],
+        ),
+        body: SafeArea(
+          child: Column(
+            children: [
+              Container(
+                margin: CustomTheme.tileMargin,
+                child: TextInputField(
+                  controller: _gameNameController,
+                  maxLength: Constants.MAX_MATCH_NAME_LENGTH,
+                  hintText: loc.game_name,
+                ),
+              ),
+              ChooseTile(
+                title: loc.ruleset,
+                trailingText: selectedRuleset == null
+                    ? loc.none
+                    : translateRulesetToString(selectedRuleset!, context),
+                onPressed: () async {
+                  final result = await Navigator.of(context).push<Ruleset?>(
+                    adaptivePageRoute(
+                      builder: (context) => ChooseRulesetView(
+                        rulesets: _rulesets,
+                        initialRulesetIndex: selectedRulesetIndex,
+                      ),
+                    ),
+                  );
+                  if (mounted) {
+                    setState(() {
+                      selectedRuleset = result;
+                      selectedRulesetIndex = result == null
+                          ? -1
+                          : _rulesets.indexWhere((r) => r.$1 == result);
+                    });
+                  }
+                },
+              ),
+              ChooseTile(
+                title: loc.color,
+                trailingText: selectedColor == null
+                    ? loc.none
+                    : translateGameColorToString(selectedColor!, context),
+                onPressed: () async {
+                  final result = await Navigator.of(context).push<GameColor?>(
+                    adaptivePageRoute(
+                      builder: (context) =>
+                          ChooseColorView(initialColor: selectedColor),
+                    ),
+                  );
+                  if (mounted) {
+                    setState(() {
+                      selectedColor = result;
+                    });
+                  }
+                },
+              ),
+              Container(
+                margin: CustomTheme.tileMargin,
+                child: TextInputField(
+                  controller: _descriptionController,
+                  hintText: loc.description,
+                  minLines: 6,
+                  maxLines: 6,
+                  maxLength: Constants.MAX_GAME_DESCRIPTION_LENGTH,
+                  showCounterText: true,
+                ),
+              ),
+              const Spacer(),
+              Padding(
+                padding: const EdgeInsets.all(12.0),
+                child: CustomWidthButton(
+                  text: isEditing ? loc.edit_game : loc.create_game,
+                  sizeRelativeToWidth: 1,
+                  buttonType: ButtonType.primary,
+                  onPressed:
+                      _gameNameController.text.trim().isNotEmpty &&
+                          selectedRulesetIndex != -1 &&
+                          selectedColor != null
+                      ? () async {
+                          Game newGame = Game(
+                            name: _gameNameController.text.trim(),
+                            description: _descriptionController.text.trim(),
+                            ruleset: selectedRuleset!,
+                            color: selectedColor!,
+                          );
+                          if (isEditing) {
+                            await handleGameUpdate(newGame);
+                          } else {
+                            await handleGameCreation(newGame);
+                          }
+                          widget.onGameChanged.call();
+                          if (context.mounted) {
+                            Navigator.of(
+                              context,
+                            ).pop((game: newGame, delete: false));
+                          }
+                        }
+                      : null,
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+
+  /// Handles updating an existing game in the database.
+  ///
+  /// [newGame] The updated game object.
+  Future<void> handleGameUpdate(Game newGame) async {
+    final oldGame = widget.gameToEdit!;
+
+    if (oldGame.name != newGame.name) {
+      await db.gameDao.updateGameName(
+        gameId: oldGame.id,
+        newName: newGame.name,
+      );
+    }
+
+    if (oldGame.description != newGame.description) {
+      await db.gameDao.updateGameDescription(
+        gameId: oldGame.id,
+        newDescription: newGame.description,
+      );
+    }
+
+    if (oldGame.ruleset != newGame.ruleset) {
+      await db.gameDao.updateGameRuleset(
+        gameId: oldGame.id,
+        newRuleset: newGame.ruleset,
+      );
+    }
+
+    if (oldGame.color != newGame.color) {
+      await db.gameDao.updateGameColor(
+        gameId: oldGame.id,
+        newColor: newGame.color,
+      );
+    }
+
+    if (oldGame.icon != newGame.icon) {
+      await db.gameDao.updateGameIcon(
+        gameId: oldGame.id,
+        newIcon: newGame.icon,
+      );
+    }
+  }
+
+  /// Handles creating a new game in the database.
+  ///
+  /// [newGame] The game object to be created.
+  Future<void> handleGameCreation(Game newGame) async {
+    await db.gameDao.addGame(game: newGame);
+  }
+
+  /// Displays a snackbar with the given message and optional action.
+  ///
+  /// [message] The message to display in the snackbar.
+  void showSnackbar({required String message}) {
+    final messenger = _scaffoldMessengerKey.currentState;
+    if (messenger != null) {
+      messenger.hideCurrentSnackBar();
+      messenger.showSnackBar(
+        SnackBar(
+          content: Text(message, style: const TextStyle(color: Colors.white)),
+          backgroundColor: CustomTheme.boxColor,
+        ),
+      );
+    }
+  }
+}

lib/presentation/views/main_menu/match_view/match_detail_view.dart

@@ -2,10 +2,10 @@ import 'package:flutter/material.dart';
 import 'package:intl/intl.dart';
 import 'package:provider/provider.dart';
 import 'package:tallee/core/adaptive_page_route.dart';
+import 'package:tallee/core/common.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/dto/match.dart';
-import 'package:tallee/data/dto/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/views/main_menu/match_view/create_match/create_match_view.dart';
 import 'package:tallee/presentation/views/main_menu/match_view/match_result_view.dart';
@@ -19,18 +19,18 @@ import 'package:tallee/presentation/widgets/tiles/text_icon_tile.dart';
 class MatchDetailView extends StatefulWidget {
   /// A view that displays the profile of a match
   /// - [match]: The match to display
-  /// - [callback]: Callback to refresh the match list
+  /// - [onMatchUpdate]: Callback to refresh the match list
   const MatchDetailView({
     super.key,
     required this.match,
-    required this.callback,
+    required this.onMatchUpdate,
   });
 
   /// The match to display
   final Match match;
 
   /// Callback to refresh the match list
-  final VoidCallback callback;
+  final VoidCallback onMatchUpdate;
 
   @override
   State<MatchDetailView> createState() => _MatchDetailViewState();
@@ -39,17 +39,13 @@ class MatchDetailView extends StatefulWidget {
 class _MatchDetailViewState extends State<MatchDetailView> {
   late final AppDatabase db;
 
-  late Player? currentWinner;
-
-  /// All players who participated in the match
-  late final List<Player> allPlayers;
+  late Match match;
 
   @override
   void initState() {
     super.initState();
     db = Provider.of<AppDatabase>(context, listen: false);
-    allPlayers = _getAllPlayers();
-    currentWinner = widget.match.winner;
+    match = widget.match;
   }
 
   @override
@@ -90,10 +86,10 @@ class _MatchDetailViewState extends State<MatchDetailView> {
                 ),
               ).then((confirmed) async {
                 if (confirmed! && context.mounted) {
-                  await db.matchDao.deleteMatch(matchId: widget.match.id);
+                  await db.matchDao.deleteMatch(matchId: match.id);
                   if (!context.mounted) return;
                   Navigator.pop(context);
-                  widget.callback.call();
+                  widget.onMatchUpdate.call();
                 }
               });
             },
@@ -121,7 +117,7 @@ class _MatchDetailViewState extends State<MatchDetailView> {
                 ),
                 const SizedBox(height: 10),
                 Text(
-                  widget.match.name,
+                  match.name,
                   style: const TextStyle(
                     fontSize: 28,
                     fontWeight: FontWeight.bold,
@@ -131,7 +127,7 @@ class _MatchDetailViewState extends State<MatchDetailView> {
                 ),
                 const SizedBox(height: 5),
                 Text(
-                  '${loc.created_on} ${DateFormat.yMMMd(Localizations.localeOf(context).toString()).format(widget.match.createdAt)}',
+                  '${loc.created_on} ${DateFormat.yMMMd(Localizations.localeOf(context).toString()).format(match.createdAt)}',
                   style: const TextStyle(
                     fontSize: 12,
                     color: CustomTheme.textColor,
@@ -139,15 +135,14 @@ class _MatchDetailViewState extends State<MatchDetailView> {
                   textAlign: TextAlign.center,
                 ),
                 const SizedBox(height: 10),
-                if (widget.match.group != null) ...[
+                if (match.group != null) ...[
                   Row(
                     mainAxisAlignment: MainAxisAlignment.center,
                     children: [
                       const Icon(Icons.group),
                       const SizedBox(width: 8),
                       Text(
-                        // TODO: Update after DB changes
-                        '${widget.match.group!.name} ${widget.match.players != null ? '+ ${widget.match.players!.length}' : ''}',
+                        '${match.group!.name}${getExtraPlayerCount(match)}',
                         style: const TextStyle(fontWeight: FontWeight.bold),
                       ),
                     ],
@@ -163,7 +158,7 @@ class _MatchDetailViewState extends State<MatchDetailView> {
                     crossAxisAlignment: WrapCrossAlignment.start,
                     spacing: 12,
                     runSpacing: 8,
-                    children: allPlayers.map((player) {
+                    children: match.players.map((player) {
                       return TextIconTile(
                         text: player.name,
                         iconEnabled: false,
@@ -184,7 +179,7 @@ class _MatchDetailViewState extends State<MatchDetailView> {
                       mainAxisAlignment: MainAxisAlignment.spaceBetween,
                       children: [
                         /// TODO: Implement different ruleset results display
-                        if (currentWinner != null) ...[
+                        if (match.winner != null) ...[
                           Text(
                             loc.winner,
                             style: const TextStyle(
@@ -193,13 +188,11 @@ class _MatchDetailViewState extends State<MatchDetailView> {
                             ),
                           ),
                           Text(
-                            currentWinner!.name,
-                            style: TextStyle(
+                            match.winner!.name,
+                            style: const TextStyle(
                               fontSize: 16,
                               fontWeight: FontWeight.bold,
-                              color: widget.match.winner != null
-                                  ? CustomTheme.primaryColor
-                                  : CustomTheme.textColor,
+                              color: CustomTheme.primaryColor,
                             ),
                           ),
                         ] else ...[
@@ -227,8 +220,10 @@ class _MatchDetailViewState extends State<MatchDetailView> {
                       context,
                       adaptivePageRoute(
                         fullscreenDialog: true,
-                        builder: (context) =>
-                            CreateMatchView(match: widget.match),
+                        builder: (context) => CreateMatchView(
+                          matchToEdit: match,
+                          onMatchUpdated: onMatchUpdated,
+                        ),
                       ),
                     ),
                   ),
@@ -237,14 +232,14 @@ class _MatchDetailViewState extends State<MatchDetailView> {
                     text: loc.enter_results,
                     icon: Icons.emoji_events,
                     onPressed: () async {
-                      currentWinner = await Navigator.push(
+                      match.winner = await Navigator.push(
                         context,
                         adaptivePageRoute(
                           fullscreenDialog: true,
                           builder: (context) => MatchResultView(
-                            match: widget.match,
+                            match: match,
                             onWinnerChanged: () {
-                              widget.callback.call();
+                              widget.onMatchUpdate.call();
                               setState(() {});
                             },
                           ),
@@ -261,25 +256,12 @@ class _MatchDetailViewState extends State<MatchDetailView> {
     );
   }
 
-  /// Gets all players who participated in the match (from group and individual players)
-  List<Player> _getAllPlayers() {
-    final List<Player> players = [];
-
-    // Add group members if group exists
-    if (widget.match.group != null) {
-      players.addAll(widget.match.group!.members);
-    }
-
-    // Add individual players
-    if (widget.match.players != null) {
-      for (var player in widget.match.players!) {
-        // Avoid duplicates
-        if (!players.any((p) => p.id == player.id)) {
-          players.add(player);
-        }
-      }
-    }
-
-    return players;
+  /// Callback for when the match is updated in the edit view,
+  /// updates the match in this view
+  void onMatchUpdated(Match editedMatch) {
+    setState(() {
+      match = editedMatch;
+    });
+    widget.onMatchUpdate.call();
   }
 }

lib/presentation/views/main_menu/match_view/match_result_view.dart

@@ -35,7 +35,10 @@ class _MatchResultViewState extends State<MatchResultView> {
   @override
   void initState() {
     db = Provider.of<AppDatabase>(context, listen: false);
-    allPlayers = getAllPlayers(widget.match);
+
+    allPlayers = widget.match.players;
+    allPlayers.sort((a, b) => a.name.compareTo(b.name));
+
     if (widget.match.winner != null) {
       _selectedPlayer = allPlayers.firstWhere(
         (p) => p.id == widget.match.winner!.id,
@@ -145,23 +148,4 @@ class _MatchResultViewState extends State<MatchResultView> {
     }
     widget.onWinnerChanged?.call();
   }
-
-  /// Retrieves all players associated with the given [match].
-  /// This includes players directly assigned to the match
-  /// as well as members of the group (if any).
-  /// The returned list is sorted alphabetically by player name.
-  List<Player> getAllPlayers(Match match) {
-    List<Player> players = [];
-
-    if (match.group == null && match.players != null) {
-      players = [...match.players!];
-    } else if (match.group != null && match.players != null) {
-      players = [...match.players!, ...match.group!.members];
-    } else {
-      players = [...match.group!.members];
-    }
-
-    players.sort((a, b) => a.name.compareTo(b.name));
-    return players;
-  }
 }

lib/presentation/views/main_menu/match_view/match_view.dart

@@ -1,12 +1,12 @@
-import 'dart:core' hide Match;
-
 import 'package:flutter/material.dart';
 import 'package:fluttericon/rpg_awesome_icons.dart';
 import 'package:provider/provider.dart';
 import 'package:tallee/core/adaptive_page_route.dart';
 import 'package:tallee/core/constants.dart';
 import 'package:tallee/core/custom_theme.dart';
+import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/game.dart';
 import 'package:tallee/data/dto/group.dart';
 import 'package:tallee/data/dto/match.dart';
 import 'package:tallee/data/dto/player.dart';
@@ -19,7 +19,7 @@ import 'package:tallee/presentation/widgets/tiles/match_tile.dart';
 import 'package:tallee/presentation/widgets/top_centered_message.dart';
 
 class MatchView extends StatefulWidget {
-  /// A view that displays a list of matches
+  /// A view that displays a list of matches.
   const MatchView({super.key});
 
   @override
@@ -27,21 +27,32 @@ class MatchView extends StatefulWidget {
 }
 
 class _MatchViewState extends State<MatchView> {
+  /// Database instance used to access match data.
   late final AppDatabase db;
+
+  /// Indicates whether matches are currently being loaded.
   bool isLoading = true;
 
   /// Loaded matches from the database,
-  /// initially filled with skeleton matches
+  /// initially filled with skeleton matches.
   List<Match> matches = List.filled(
     4,
     Match(
       name: 'Skeleton match name',
+      game: Game(
+        name: '',
+        ruleset: Ruleset.singleWinner,
+        description: '',
+        color: GameColor.blue,
+      ),
       group: Group(
         name: 'Group name',
-        members: List.filled(5, Player(name: 'Player')),
+        description: '',
+        members: List.filled(5, Player(name: 'Player', description: '')),
       ),
-      winner: Player(name: 'Player'),
-      players: [Player(name: 'Player')],
+      winner: Player(name: 'Player', description: ''),
+      players: [Player(name: 'Player', description: '')],
+      notes: '',
     ),
   );
 
@@ -49,7 +60,7 @@ class _MatchViewState extends State<MatchView> {
   void initState() {
     super.initState();
     db = Provider.of<AppDatabase>(context, listen: false);
-    loadGames();
+    loadMatches();
   }
 
   @override
@@ -91,7 +102,7 @@ class _MatchViewState extends State<MatchView> {
                             adaptivePageRoute(
                               builder: (context) => MatchDetailView(
                                 match: matches[index],
-                                callback: loadGames,
+                                onMatchUpdate: loadMatches,
                               ),
                             ),
                           );
@@ -114,7 +125,7 @@ class _MatchViewState extends State<MatchView> {
                   context,
                   adaptivePageRoute(
                     builder: (context) =>
-                        CreateMatchView(onWinnerChanged: loadGames),
+                        CreateMatchView(onWinnerChanged: loadMatches),
                   ),
                 );
               },
@@ -125,8 +136,8 @@ class _MatchViewState extends State<MatchView> {
     );
   }
 
-  /// Loads the games from the database and sorts them by creation date.
-  void loadGames() {
+  /// Loads the matches from the database and sorts them by creation date.
+  void loadMatches() {
     isLoading = true;
     Future.wait([
       db.matchDao.getAllMatches(),
@@ -135,7 +146,7 @@ class _MatchViewState extends State<MatchView> {
       if (mounted) {
         setState(() {
           final loadedMatches = results[0] as List<Match>;
-          matches = loadedMatches
+          matches = [...loadedMatches]
             ..sort((a, b) => b.createdAt.compareTo(a.createdAt));
           isLoading = false;
         });

lib/presentation/views/main_menu/statistics_view.dart

@@ -167,7 +167,7 @@ class _StatisticsViewState extends State<StatisticsView> {
       final playerId = winCounts[i].$1;
       final player = players.firstWhere(
         (p) => p.id == playerId,
-        orElse: () => Player(id: playerId, name: loc.not_available),
+        orElse: () => Player(id: playerId, name: loc.not_available, description: ''),
       );
       winCounts[i] = (player.name, winCounts[i].$2);
     }
@@ -202,19 +202,17 @@ class _StatisticsViewState extends State<StatisticsView> {
           }
         }
       }
-      if (match.players != null) {
-        final members = match.players!.map((p) => p.id).toList();
-        for (var playerId in members) {
-          final index = matchCounts.indexWhere((entry) => entry.$1 == playerId);
-          // -1 means player not found in matchCounts
-          if (index != -1) {
-            final current = matchCounts[index].$2;
+      final members = match.players.map((p) => p.id).toList();
+      for (var playerId in members) {
+        final index = matchCounts.indexWhere((entry) => entry.$1 == playerId);
+        // -1 means player not found in matchCounts
+        if (index != -1) {
+          final current = matchCounts[index].$2;
             matchCounts[index] = (playerId, current + 1);
           } else {
             matchCounts.add((playerId, 1));
           }
         }
-      }
     }
 
     // Adding all players with zero matches
@@ -231,7 +229,7 @@ class _StatisticsViewState extends State<StatisticsView> {
       final playerId = matchCounts[i].$1;
       final player = players.firstWhere(
         (p) => p.id == playerId,
-        orElse: () => Player(id: playerId, name: loc.not_available),
+        orElse: () => Player(id: playerId, name: loc.not_available, description: ''),
       );
       matchCounts[i] = (player.name, matchCounts[i].$2);
     }

lib/presentation/widgets/app_skeleton.dart

@@ -47,10 +47,7 @@ class _AppSkeletonState extends State<AppSkeleton> {
             : (Widget? currentChild, List<Widget> previousChildren) {
                 return Stack(
                   alignment: Alignment.topCenter,
-                  children: [
-                    ...previousChildren,
-                    if (currentChild != null) currentChild,
-                  ],
+                  children: [...previousChildren, ?currentChild],
                 );
               },
       ),

lib/presentation/widgets/player_selection.dart

@@ -62,7 +62,7 @@ class _PlayerSelectionState extends State<PlayerSelection> {
   /// Skeleton data used while loading players.
   late final List<Player> skeletonData = List.filled(
     7,
-    Player(name: 'Player 0'),
+    Player(name: 'Player 0', description: ''),
   );
 
   @override
@@ -110,7 +110,9 @@ class _PlayerSelectionState extends State<PlayerSelection> {
                     final bool nameMatches = player.name.toLowerCase().contains(
                       value.toLowerCase(),
                     );
-                    final bool isNotSelected = !selectedPlayers.any((p) => p.id == player.id);
+                    final bool isNotSelected = !selectedPlayers.any(
+                      (p) => p.id == player.id,
+                    );
                     return nameMatches && isNotSelected;
                   }).toList();
                 }
@@ -224,49 +226,53 @@ class _PlayerSelectionState extends State<PlayerSelection> {
       db.playerDao.getAllPlayers(),
       Future.delayed(Constants.MINIMUM_SKELETON_DURATION),
     ]).then((results) => results[0] as List<Player>);
-    if (mounted) {
-      _allPlayersFuture.then((loadedPlayers) {
-        setState(() {
-          // If a list of available players is provided (even if empty), use that list.
-          if (widget.availablePlayers != null) {
-            widget.availablePlayers!.sort((a, b) => a.name.compareTo(b.name));
-            allPlayers = [...widget.availablePlayers!];
-            suggestedPlayers = [...allPlayers];
 
-            if (widget.initialSelectedPlayers != null) {
-              // Ensures that only players available for selection are pre-selected.
-              selectedPlayers = widget.initialSelectedPlayers!
-                  .where(
-                    (p) => widget.availablePlayers!.any(
-                      (available) => available.id == p.id,
-                    ),
-                  )
-                  .toList();
-            }
-          } else {
-            // Otherwise, use the loaded players from the database.
-            loadedPlayers.sort((a, b) => a.name.compareTo(b.name));
-            allPlayers = [...loadedPlayers];
-            if (widget.initialSelectedPlayers != null) {
-              // Excludes already selected players from the suggested players list.
-              suggestedPlayers = loadedPlayers.where((p) => !widget.initialSelectedPlayers!.any((ip) => ip.id == p.id)).toList();
-              // Ensures that only players available for selection are pre-selected.
-              selectedPlayers = widget.initialSelectedPlayers!
-                  .where(
-                    (p) => allPlayers.any(
-                      (available) => available.id == p.id,
-                ),
-              )
-                  .toList();
-            } else {
-              // If no initial selection, all loaded players are suggested.
-              suggestedPlayers = [...loadedPlayers];
-            }
+    _allPlayersFuture.then((loadedPlayers) {
+      if (!mounted) return;
+      setState(() {
+        // If a list of available players is provided (even if empty), use that list.
+        if (widget.availablePlayers != null) {
+          widget.availablePlayers!.sort((a, b) => a.name.compareTo(b.name));
+          allPlayers = [...widget.availablePlayers!];
+          suggestedPlayers = [...allPlayers];
+
+          if (widget.initialSelectedPlayers != null) {
+            // Ensures that only players available for selection are pre-selected.
+            selectedPlayers = widget.initialSelectedPlayers!
+                .where(
+                  (p) => widget.availablePlayers!.any(
+                    (available) => available.id == p.id,
+                  ),
+                )
+                .toList();
           }
-          isLoading = false;
-        });
+        } else {
+          // Otherwise, use the loaded players from the database.
+          loadedPlayers.sort((a, b) => a.name.compareTo(b.name));
+          allPlayers = [...loadedPlayers];
+          if (widget.initialSelectedPlayers != null) {
+            // Excludes already selected players from the suggested players list.
+            suggestedPlayers = loadedPlayers
+                .where(
+                  (p) => !widget.initialSelectedPlayers!.any(
+                    (ip) => ip.id == p.id,
+                  ),
+                )
+                .toList();
+            // Ensures that only players available for selection are pre-selected.
+            selectedPlayers = widget.initialSelectedPlayers!
+                .where(
+                  (p) => allPlayers.any((available) => available.id == p.id),
+                )
+                .toList();
+          } else {
+            // If no initial selection, all loaded players are suggested.
+            suggestedPlayers = [...loadedPlayers];
+          }
+        }
+        isLoading = false;
       });
-    }
+    });
   }
 
   /// Adds a new player to the database from the search bar input.
@@ -276,7 +282,7 @@ class _PlayerSelectionState extends State<PlayerSelection> {
     final loc = AppLocalizations.of(context);
     final playerName = _searchBarController.text.trim();
 
-    final createdPlayer = Player(name: playerName);
+    final createdPlayer = Player(name: playerName, description: '');
     final success = await db.playerDao.addPlayer(player: createdPlayer);
 
     if (!context.mounted) return;

lib/presentation/widgets/text_input/custom_search_bar.dart

@@ -69,7 +69,6 @@ class CustomSearchBar extends StatelessWidget {
           constraints ?? const BoxConstraints(maxHeight: 45, minHeight: 45),
       hintText: hintText,
       onChanged: onChanged,
-      hintStyle: WidgetStateProperty.all(const TextStyle(fontSize: 16)),
       leading: const Icon(Icons.search),
       trailing: [
         Visibility(

lib/presentation/widgets/text_input/text_input_field.dart

@@ -8,12 +8,18 @@ class TextInputField extends StatelessWidget {
   /// - [onChanged]: Optional callback invoked when the text in the field changes.
   /// - [hintText]: The hint text displayed in the text input field when it is empty
   /// - [maxLength]: Optional parameter for maximum length of the input text.
+  /// - [maxLines]: The maximum number of lines for the text input field. Defaults to 1.
+  /// - [minLines]: The minimum number of lines for the text input field. Defaults to 1.
+  /// - [showCounterText]: Whether to show the counter text in the text input field. Defaults to false.
   const TextInputField({
     super.key,
     required this.controller,
     required this.hintText,
     this.onChanged,
     this.maxLength,
+    this.maxLines = 1,
+    this.minLines = 1,
+    this.showCounterText = false,
   });
 
   /// The controller for the text input field.
@@ -28,6 +34,15 @@ class TextInputField extends StatelessWidget {
   /// Optional parameter for maximum length of the input text.
   final int? maxLength;
 
+  /// The maximum number of lines for the text input field.
+  final int? maxLines;
+
+  /// The minimum number of lines for the text input field.
+  final int? minLines;
+
+  /// Whether to show the counter text in the text input field.
+  final bool showCounterText;
+
   @override
   Widget build(BuildContext context) {
     return TextField(
@@ -35,13 +50,14 @@ class TextInputField extends StatelessWidget {
       onChanged: onChanged,
       maxLength: maxLength,
       maxLengthEnforcement: MaxLengthEnforcement.truncateAfterCompositionEnds,
+      maxLines: maxLines,
+      minLines: minLines,
       decoration: InputDecoration(
         filled: true,
         fillColor: CustomTheme.boxColor,
         hintText: hintText,
         hintStyle: const TextStyle(fontSize: 18),
-        // Hides the character counter
-        counterText: '',
+        counterText: showCounterText ? null : '',
         enabledBorder: const OutlineInputBorder(
           borderRadius: BorderRadius.all(Radius.circular(12)),
           borderSide: BorderSide(color: CustomTheme.boxBorderColor),

lib/presentation/widgets/tiles/custom_radio_list_tile.dart

@@ -36,11 +36,7 @@ class CustomRadioListTile<T> extends StatelessWidget {
         ),
         child: Row(
           children: [
-            Radio<T>(
-              value: value,
-              activeColor: CustomTheme.primaryColor,
-              toggleable: true,
-            ),
+            Radio<T>(value: value, toggleable: true),
             Expanded(
               child: Text(
                 text,

lib/presentation/widgets/tiles/match_tile.dart

@@ -1,8 +1,10 @@
+import 'dart:core' hide Match;
+
 import 'package:flutter/material.dart';
 import 'package:intl/intl.dart';
+import 'package:tallee/core/common.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/data/dto/match.dart';
-import 'package:tallee/data/dto/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/widgets/tiles/text_icon_tile.dart';
 
@@ -38,18 +40,13 @@ class MatchTile extends StatefulWidget {
 }
 
 class _MatchTileState extends State<MatchTile> {
-  late final List<Player> _allPlayers;
-
-  @override
-  void initState() {
-    super.initState();
-    _allPlayers = _getCombinedPlayers();
-  }
-
   @override
   Widget build(BuildContext context) {
-    final group = widget.match.group;
-    final winner = widget.match.winner;
+    final match = widget.match;
+    final group = match.group;
+    final winner = match.winner;
+    final players = [...match.players]
+      ..sort((a, b) => a.name.compareTo(b.name));
     final loc = AppLocalizations.of(context);
 
     return GestureDetector(
@@ -67,7 +64,7 @@ class _MatchTileState extends State<MatchTile> {
               children: [
                 Expanded(
                   child: Text(
-                    widget.match.name,
+                    match.name,
                     style: const TextStyle(
                       fontSize: 18,
                       fontWeight: FontWeight.bold,
@@ -76,7 +73,7 @@ class _MatchTileState extends State<MatchTile> {
                   ),
                 ),
                 Text(
-                  _formatDate(widget.match.createdAt, context),
+                  _formatDate(match.createdAt, context),
                   style: const TextStyle(fontSize: 12, color: Colors.grey),
                 ),
               ],
@@ -91,7 +88,7 @@ class _MatchTileState extends State<MatchTile> {
                   const SizedBox(width: 6),
                   Expanded(
                     child: Text(
-                      '${group.name}${widget.match.players != null ? ' + ${widget.match.players?.length}' : ''}',
+                      '${match.group!.name}${getExtraPlayerCount(match)}',
                       style: const TextStyle(fontSize: 14, color: Colors.grey),
                       overflow: TextOverflow.ellipsis,
                     ),
@@ -106,7 +103,7 @@ class _MatchTileState extends State<MatchTile> {
                   const SizedBox(width: 6),
                   Expanded(
                     child: Text(
-                      '${widget.match.players!.length} ${loc.players}',
+                      '${match.players.length} ${loc.players}',
                       style: const TextStyle(fontSize: 14, color: Colors.grey),
                       overflow: TextOverflow.ellipsis,
                     ),
@@ -192,7 +189,7 @@ class _MatchTileState extends State<MatchTile> {
               const SizedBox(height: 12),
             ],
 
-            if (_allPlayers.isNotEmpty && widget.compact == false) ...[
+            if (players.isNotEmpty && widget.compact == false) ...[
               Text(
                 loc.players,
                 style: const TextStyle(
@@ -205,7 +202,7 @@ class _MatchTileState extends State<MatchTile> {
               Wrap(
                 spacing: 6,
                 runSpacing: 6,
-                children: _allPlayers.map((player) {
+                children: players.map((player) {
                   return TextIconTile(text: player.name, iconEnabled: false);
                 }).toList(),
               ),
@@ -233,34 +230,4 @@ class _MatchTileState extends State<MatchTile> {
       return '${loc.created_on} ${DateFormat.yMMMd(Localizations.localeOf(context).toString()).format(dateTime)}';
     }
   }
-
-  /// Retrieves all unique players associated with the match,
-  /// combining players from both the match and its group.
-  List<Player> _getCombinedPlayers() {
-    final allPlayers = <Player>[];
-    final playerIds = <String>{};
-
-    // Add players from game.players
-    if (widget.match.players != null) {
-      for (var player in widget.match.players!) {
-        if (!playerIds.contains(player.id)) {
-          allPlayers.add(player);
-          playerIds.add(player.id);
-        }
-      }
-    }
-
-    // Add players from game.group.players
-    if (widget.match.group?.members != null) {
-      for (var player in widget.match.group!.members) {
-        if (!playerIds.contains(player.id)) {
-          allPlayers.add(player);
-          playerIds.add(player.id);
-        }
-      }
-    }
-
-    allPlayers.sort((a, b) => a.name.compareTo(b.name));
-    return allPlayers;
-  }
 }

lib/presentation/widgets/tiles/title_description_list_tile.dart

@@ -6,6 +6,7 @@ class TitleDescriptionListTile extends StatelessWidget {
   /// - [title]: The title text displayed on the tile.
   /// - [description]: The description text displayed below the title.
   /// - [onPressed]: The callback invoked when the tile is tapped.
+  /// - [onLongPress]: The callback invoked when the tile is tapped.
   /// - [isHighlighted]: A boolean to determine if the tile should be highlighted.
   /// - [badgeText]: Optional text to display in a badge on the right side of the title.
   /// - [badgeColor]: Optional color for the badge background.
@@ -13,7 +14,8 @@ class TitleDescriptionListTile extends StatelessWidget {
     super.key,
     required this.title,
     required this.description,
-    this.onPressed,
+    this.onTap,
+    this.onLongPress,
     this.isHighlighted = false,
     this.badgeText,
     this.badgeColor,
@@ -26,7 +28,10 @@ class TitleDescriptionListTile extends StatelessWidget {
   final String description;
 
   /// The callback invoked when the tile is tapped.
-  final VoidCallback? onPressed;
+  final VoidCallback? onTap;
+
+  /// The callback invoked when the tile is long-pressed.
+  final VoidCallback? onLongPress;
 
   /// A boolean to determine if the tile should be highlighted.
   final bool isHighlighted;
@@ -40,7 +45,8 @@ class TitleDescriptionListTile extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return GestureDetector(
-      onTap: onPressed,
+      onTap: onTap,
+      onLongPress: onLongPress,
       child: AnimatedContainer(
         margin: const EdgeInsets.symmetric(vertical: 10, horizontal: 10),
         padding: const EdgeInsets.symmetric(vertical: 6, horizontal: 12),

lib/services/data_transfer_service.dart

@@ -8,51 +8,69 @@ import 'package:json_schema/json_schema.dart';
 import 'package:provider/provider.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/game.dart';
 import 'package:tallee/data/dto/group.dart';
 import 'package:tallee/data/dto/match.dart';
 import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/dto/team.dart';
 
 class DataTransferService {
   /// Deletes all data from the database.
   static Future<void> deleteAllData(BuildContext context) async {
     final db = Provider.of<AppDatabase>(context, listen: false);
     await db.matchDao.deleteAllMatches();
+    await db.teamDao.deleteAllTeams();
     await db.groupDao.deleteAllGroups();
+    await db.gameDao.deleteAllGames();
     await db.playerDao.deleteAllPlayers();
   }
 
   /// Retrieves all application data and converts it to a JSON string.
-  /// Returns the JSON string representation of the data.
+  /// Returns the JSON string representation of the data in normalized format.
   static Future<String> getAppDataAsJson(BuildContext context) async {
     final db = Provider.of<AppDatabase>(context, listen: false);
     final matches = await db.matchDao.getAllMatches();
     final groups = await db.groupDao.getAllGroups();
     final players = await db.playerDao.getAllPlayers();
+    final games = await db.gameDao.getAllGames();
+    final teams = await db.teamDao.getAllTeams();
 
-    // Construct a JSON representation of the data
+    // Construct a JSON representation of the data in normalized format
     final Map<String, dynamic> jsonMap = {
       'players': players.map((p) => p.toJson()).toList(),
-
+      'games': games.map((g) => g.toJson()).toList(),
       'groups': groups
           .map(
             (g) => {
               'id': g.id,
               'name': g.name,
+              'description': g.description,
               'createdAt': g.createdAt.toIso8601String(),
               'memberIds': (g.members).map((m) => m.id).toList(),
             },
           )
           .toList(),
-
+      'teams': teams
+          .map(
+            (t) => {
+              'id': t.id,
+              'name': t.name,
+              'createdAt': t.createdAt.toIso8601String(),
+              'memberIds': (t.members).map((m) => m.id).toList(),
+            },
+          )
+          .toList(),
       'matches': matches
           .map(
             (m) => {
               'id': m.id,
               'name': m.name,
               'createdAt': m.createdAt.toIso8601String(),
+              'endedAt': m.endedAt?.toIso8601String(),
+              'gameId': m.game.id,
               'groupId': m.group?.id,
-              'playerIds': (m.players ?? []).map((p) => p.id).toList(),
-              'winnerId': m.winner?.id,
+              'playerIds': m.players.map((p) => p.id).toList(),
+              'notes': m.notes,
             },
           )
           .toList(),
@@ -114,12 +132,16 @@ class DataTransferService {
 
       final List<dynamic> playersJson =
           (decoded['players'] as List<dynamic>?) ?? [];
+      final List<dynamic> gamesJson =
+          (decoded['games'] as List<dynamic>?) ?? [];
       final List<dynamic> groupsJson =
           (decoded['groups'] as List<dynamic>?) ?? [];
+      final List<dynamic> teamsJson =
+          (decoded['teams'] as List<dynamic>?) ?? [];
       final List<dynamic> matchesJson =
           (decoded['matches'] as List<dynamic>?) ?? [];
 
-      // Players
+      // Import Players
       final List<Player> importedPlayers = playersJson
           .map((p) => Player.fromJson(p as Map<String, dynamic>))
           .toList();
@@ -128,7 +150,16 @@ class DataTransferService {
         for (final p in importedPlayers) p.id: p,
       };
 
-      // Groups
+      // Import Games
+      final List<Game> importedGames = gamesJson
+          .map((g) => Game.fromJson(g as Map<String, dynamic>))
+          .toList();
+
+      final Map<String, Game> gameById = {
+        for (final g in importedGames) g.id: g,
+      };
+
+      // Import Groups
       final List<Group> importedGroups = groupsJson.map((g) {
         final map = g as Map<String, dynamic>;
         final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
@@ -142,6 +173,7 @@ class DataTransferService {
         return Group(
           id: map['id'] as String,
           name: map['name'] as String,
+          description: map['description'] as String,
           members: members,
           createdAt: DateTime.parse(map['createdAt'] as String),
         );
@@ -151,34 +183,68 @@ class DataTransferService {
         for (final g in importedGroups) g.id: g,
       };
 
-      // Matches
+      // Import Teams
+      final List<Team> importedTeams = teamsJson.map((t) {
+        final map = t as Map<String, dynamic>;
+        final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
+            .cast<String>();
+
+        final members = memberIds
+            .map((id) => playerById[id])
+            .whereType<Player>()
+            .toList();
+
+        return Team(
+          id: map['id'] as String,
+          name: map['name'] as String,
+          members: members,
+          createdAt: DateTime.parse(map['createdAt'] as String),
+        );
+      }).toList();
+
+      // Import Matches
       final List<Match> importedMatches = matchesJson.map((m) {
         final map = m as Map<String, dynamic>;
 
+        final String gameId = map['gameId'] as String;
         final String? groupId = map['groupId'] as String?;
         final List<String> playerIds =
             (map['playerIds'] as List<dynamic>? ?? []).cast<String>();
-        final String? winnerId = map['winnerId'] as String?;
+        final DateTime? endedAt = map['endedAt'] != null
+            ? DateTime.parse(map['endedAt'] as String)
+            : null;
 
+        final game = gameById[gameId];
         final group = (groupId == null) ? null : groupById[groupId];
         final players = playerIds
             .map((id) => playerById[id])
             .whereType<Player>()
             .toList();
-        final winner = (winnerId == null) ? null : playerById[winnerId];
 
         return Match(
           id: map['id'] as String,
           name: map['name'] as String,
+          game:
+              game ??
+              Game(
+                name: 'Unknown',
+                ruleset: Ruleset.singleWinner,
+                description: '',
+                color: GameColor.blue,
+              ),
           group: group,
           players: players,
           createdAt: DateTime.parse(map['createdAt'] as String),
-          winner: winner,
+          endedAt: endedAt,
+          notes: map['notes'] as String? ?? '',
         );
       }).toList();
 
+      // Import all data into the database
       await db.playerDao.addPlayersAsList(players: importedPlayers);
+      await db.gameDao.addGamesAsList(games: importedGames);
       await db.groupDao.addGroupsAsList(groups: importedGroups);
+      await db.teamDao.addTeamsAsList(teams: importedTeams);
       await db.matchDao.addMatchAsList(matches: importedMatches);
 
       return ImportResult.success;

pubspec.yaml

@@ -1,7 +1,7 @@
 name: tallee
 description: "Tracking App for Card Games"
 publish_to: 'none'
-version: 0.0.16+250
+version: 0.0.18+252
 
 environment:
   sdk: ^3.8.1
@@ -34,7 +34,7 @@ dev_dependencies:
   build_runner: ^2.5.4
   dart_pubspec_licenses: ^3.0.14
   drift_dev: ^2.27.0
-  flutter_lints: ^5.0.0
+  flutter_lints: ^6.0.0
 
 flutter:
   uses-material-design: true

test/db_tests/aggregates/group_test.dart

@@ -0,0 +1,374 @@
+import 'package:clock/clock.dart';
+import 'package:drift/drift.dart' hide isNull;
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/dto/player.dart';
+
+void main() {
+  late AppDatabase database;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Player testPlayer4;
+  late Group testGroup1;
+  late Group testGroup2;
+  late Group testGroup3;
+  late Group testGroup4;
+  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
+
+  setUp(() {
+    database = AppDatabase(
+      DatabaseConnection(
+        NativeDatabase.memory(),
+        // Recommended for widget tests to avoid test errors.
+        closeStreamsSynchronously: true,
+      ),
+    );
+
+    withClock(fakeClock, () {
+      testPlayer1 = Player(name: 'Alice', description: '');
+      testPlayer2 = Player(name: 'Bob', description: '');
+      testPlayer3 = Player(name: 'Charlie', description: '');
+      testPlayer4 = Player(name: 'Diana', description: '');
+      testGroup1 = Group(
+        name: 'Test Group',
+        description: '',
+        members: [testPlayer1, testPlayer2, testPlayer3],
+      );
+      testGroup2 = Group(
+        id: 'gr2',
+        name: 'Second Group',
+        description: '',
+        members: [testPlayer2, testPlayer3, testPlayer4],
+      );
+      testGroup3 = Group(
+        id: 'gr2',
+        name: 'Second Group',
+        description: '',
+        members: [testPlayer2, testPlayer4],
+      );
+      testGroup4 = Group(
+        id: 'gr2',
+        name: 'Second Group',
+        description: '',
+        members: [testPlayer1, testPlayer2, testPlayer3, testPlayer4],
+      );
+    });
+  });
+  tearDown(() async {
+    await database.close();
+  });
+  group('Group Tests', () {
+
+    // Verifies that a single group can be added and retrieved with all fields and members intact.
+    test('Adding and fetching a single group works correctly', () async {
+      await database.groupDao.addGroup(group: testGroup1);
+
+      final fetchedGroup = await database.groupDao.getGroupById(
+        groupId: testGroup1.id,
+      );
+
+      expect(fetchedGroup.id, testGroup1.id);
+      expect(fetchedGroup.name, testGroup1.name);
+      expect(fetchedGroup.createdAt, testGroup1.createdAt);
+
+      expect(fetchedGroup.members.length, testGroup1.members.length);
+      for (int i = 0; i < testGroup1.members.length; i++) {
+        expect(fetchedGroup.members[i].id, testGroup1.members[i].id);
+        expect(fetchedGroup.members[i].name, testGroup1.members[i].name);
+        expect(
+          fetchedGroup.members[i].createdAt,
+          testGroup1.members[i].createdAt,
+        );
+      }
+    });
+
+    // Verifies that multiple groups can be added and retrieved with correct members.
+    test('Adding and fetching multiple groups works correctly', () async {
+      await database.groupDao.addGroupsAsList(
+        groups: [testGroup1, testGroup2, testGroup3, testGroup4],
+      );
+
+      final allGroups = await database.groupDao.getAllGroups();
+      expect(allGroups.length, 2);
+
+      final testGroups = {testGroup1.id: testGroup1, testGroup2.id: testGroup2};
+
+      for (final group in allGroups) {
+        final testGroup = testGroups[group.id]!;
+
+        expect(group.id, testGroup.id);
+        expect(group.name, testGroup.name);
+        expect(group.createdAt, testGroup.createdAt);
+
+        expect(group.members.length, testGroup.members.length);
+        for (int i = 0; i < testGroup.members.length; i++) {
+          expect(group.members[i].id, testGroup.members[i].id);
+          expect(group.members[i].name, testGroup.members[i].name);
+          expect(group.members[i].createdAt, testGroup.members[i].createdAt);
+        }
+      }
+    });
+
+    // Verifies that adding the same group twice does not create duplicates.
+    test('Adding the same group twice does not create duplicates', () async {
+      await database.groupDao.addGroup(group: testGroup1);
+      await database.groupDao.addGroup(group: testGroup1);
+
+      final allGroups = await database.groupDao.getAllGroups();
+      expect(allGroups.length, 1);
+    });
+
+    // Verifies that groupExists returns correct boolean based on group presence.
+    test('Group existence check works correctly', () async {
+      var groupExists = await database.groupDao.groupExists(
+        groupId: testGroup1.id,
+      );
+      expect(groupExists, false);
+
+      await database.groupDao.addGroup(group: testGroup1);
+
+      groupExists = await database.groupDao.groupExists(groupId: testGroup1.id);
+      expect(groupExists, true);
+    });
+
+    // Verifies that deleteGroup removes the group and returns true.
+    test('Deleting a group works correctly', () async {
+      await database.groupDao.addGroup(group: testGroup1);
+
+      final groupDeleted = await database.groupDao.deleteGroup(
+        groupId: testGroup1.id,
+      );
+      expect(groupDeleted, true);
+
+      final groupExists = await database.groupDao.groupExists(
+        groupId: testGroup1.id,
+      );
+      expect(groupExists, false);
+    });
+
+    // Verifies that updateGroupName correctly updates only the name field.
+    test('Updating a group name works correctly', () async {
+      await database.groupDao.addGroup(group: testGroup1);
+
+      const newGroupName = 'new group name';
+
+      await database.groupDao.updateGroupName(
+        groupId: testGroup1.id,
+        newName: newGroupName,
+      );
+
+      final result = await database.groupDao.getGroupById(
+        groupId: testGroup1.id,
+      );
+      expect(result.name, newGroupName);
+    });
+
+    // Verifies that getGroupCount returns correct count through add/delete operations.
+    test('Getting the group count works correctly', () async {
+      final initialCount = await database.groupDao.getGroupCount();
+      expect(initialCount, 0);
+
+      await database.groupDao.addGroup(group: testGroup1);
+
+      final groupAdded = await database.groupDao.getGroupCount();
+      expect(groupAdded, 1);
+
+      final groupRemoved = await database.groupDao.deleteGroup(
+        groupId: testGroup1.id,
+      );
+      expect(groupRemoved, true);
+
+      final finalCount = await database.groupDao.getGroupCount();
+      expect(finalCount, 0);
+    });
+
+    // Verifies that getAllGroups returns an empty list when no groups exist.
+    test('getAllGroups returns empty list when no groups exist', () async {
+      final allGroups = await database.groupDao.getAllGroups();
+      expect(allGroups, isEmpty);
+    });
+
+    // Verifies that getGroupById throws StateError for non-existent group ID.
+    test('getGroupById throws exception for non-existent group', () async {
+      expect(
+        () => database.groupDao.getGroupById(groupId: 'non-existent-id'),
+        throwsA(isA<StateError>()),
+      );
+    });
+
+    // Verifies that addGroup returns false when trying to add a duplicate group.
+    test('addGroup returns false when group already exists', () async {
+      final firstAdd = await database.groupDao.addGroup(group: testGroup1);
+      expect(firstAdd, true);
+
+      final secondAdd = await database.groupDao.addGroup(group: testGroup1);
+      expect(secondAdd, false);
+
+      final allGroups = await database.groupDao.getAllGroups();
+      expect(allGroups.length, 1);
+    });
+
+    // Verifies that addGroupsAsList handles an empty list without errors.
+    test('addGroupsAsList handles empty list correctly', () async {
+      await database.groupDao.addGroupsAsList(groups: []);
+
+      final allGroups = await database.groupDao.getAllGroups();
+      expect(allGroups.length, 0);
+    });
+
+    // Verifies that deleteGroup returns false for a non-existent group ID.
+    test('deleteGroup returns false for non-existent group', () async {
+      final deleted = await database.groupDao.deleteGroup(
+        groupId: 'non-existent-id',
+      );
+      expect(deleted, false);
+    });
+
+    // Verifies that updateGroupName returns false for a non-existent group ID.
+    test('updateGroupName returns false for non-existent group', () async {
+      final updated = await database.groupDao.updateGroupName(
+        groupId: 'non-existent-id',
+        newName: 'New Name',
+      );
+      expect(updated, false);
+    });
+
+    // Verifies that updateGroupDescription correctly updates the description field.
+    test('Updating a group description works correctly', () async {
+      await database.groupDao.addGroup(group: testGroup1);
+
+      const newDescription = 'This is a new description';
+
+      final updated = await database.groupDao.updateGroupDescription(
+        groupId: testGroup1.id,
+        newDescription: newDescription,
+      );
+      expect(updated, true);
+
+      final result = await database.groupDao.getGroupById(
+        groupId: testGroup1.id,
+      );
+      expect(result.description, newDescription);
+    });
+
+    // Verifies that updateGroupDescription can set the description to null.
+    test('updateGroupDescription can set description to null', () async {
+      final groupWithDescription = Group(
+        name: 'Group with description',
+        description: 'Initial description',
+        members: [testPlayer1],
+      );
+      await database.groupDao.addGroup(group: groupWithDescription);
+
+      final updated = await database.groupDao.updateGroupDescription(
+        groupId: groupWithDescription.id,
+        newDescription: 'Updated description',
+      );
+      expect(updated, true);
+
+      final result = await database.groupDao.getGroupById(
+        groupId: groupWithDescription.id,
+      );
+      expect(result.description, 'Updated description');
+    });
+
+    // Verifies that updateGroupDescription returns false for a non-existent group.
+    test('updateGroupDescription returns false for non-existent group',
+        () async {
+      final updated = await database.groupDao.updateGroupDescription(
+        groupId: 'non-existent-id',
+        newDescription: 'New Description',
+      );
+      expect(updated, false);
+    });
+
+    // Verifies that deleteAllGroups removes all groups from the database.
+    test('deleteAllGroups removes all groups', () async {
+      await database.groupDao.addGroupsAsList(
+        groups: [testGroup1, testGroup2],
+      );
+
+      final countBefore = await database.groupDao.getGroupCount();
+      expect(countBefore, 2);
+
+      final deleted = await database.groupDao.deleteAllGroups();
+      expect(deleted, true);
+
+      final countAfter = await database.groupDao.getGroupCount();
+      expect(countAfter, 0);
+    });
+
+    // Verifies that deleteAllGroups returns false when no groups exist.
+    test('deleteAllGroups returns false when no groups exist', () async {
+      final deleted = await database.groupDao.deleteAllGroups();
+      expect(deleted, false);
+    });
+
+    // Verifies that groups with special characters (quotes, emojis) are stored correctly.
+    test('Group with special characters in name is stored correctly', () async {
+      final specialGroup = Group(
+        name: 'Group\'s & "Special" <Name>',
+        description: 'Description with émojis 🎮🎲',
+        members: [testPlayer1],
+      );
+      await database.groupDao.addGroup(group: specialGroup);
+
+      final fetchedGroup = await database.groupDao.getGroupById(
+        groupId: specialGroup.id,
+      );
+      expect(fetchedGroup.name, 'Group\'s & "Special" <Name>');
+      expect(fetchedGroup.description, 'Description with émojis 🎮🎲');
+    });
+
+    // Verifies that a group with an empty members list can be stored and retrieved.
+    test('Group with empty members list is stored correctly', () async {
+      final emptyGroup = Group(
+        name: 'Empty Group',
+        description: '',
+        members: [],
+      );
+      await database.groupDao.addGroup(group: emptyGroup);
+
+      final fetchedGroup = await database.groupDao.getGroupById(
+        groupId: emptyGroup.id,
+      );
+      expect(fetchedGroup.name, 'Empty Group');
+      expect(fetchedGroup.members, isEmpty);
+    });
+
+    // Verifies that multiple sequential updates to the same group work correctly.
+    test('Multiple updates to the same group work correctly', () async {
+      await database.groupDao.addGroup(group: testGroup1);
+
+      await database.groupDao.updateGroupName(
+        groupId: testGroup1.id,
+        newName: 'Updated Name',
+      );
+      await database.groupDao.updateGroupDescription(
+        groupId: testGroup1.id,
+        newDescription: 'Updated Description',
+      );
+
+      final updatedGroup = await database.groupDao.getGroupById(
+        groupId: testGroup1.id,
+      );
+      expect(updatedGroup.name, 'Updated Name');
+      expect(updatedGroup.description, 'Updated Description');
+      expect(updatedGroup.members.length, testGroup1.members.length);
+    });
+
+    // Verifies that addGroupsAsList with duplicate groups only adds unique ones.
+    test('addGroupsAsList with duplicate groups only adds once', () async {
+      await database.groupDao.addGroupsAsList(
+        groups: [testGroup1, testGroup1, testGroup1],
+      );
+
+      final allGroups = await database.groupDao.getAllGroups();
+      expect(allGroups.length, 1);
+    });
+  });
+}

test/db_tests/aggregates/match_test.dart

@@ -1,8 +1,10 @@
 import 'package:clock/clock.dart';
-import 'package:drift/drift.dart';
+import 'package:drift/drift.dart' hide isNotNull;
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/game.dart';
 import 'package:tallee/data/dto/group.dart';
 import 'package:tallee/data/dto/match.dart';
 import 'package:tallee/data/dto/player.dart';
@@ -16,6 +18,7 @@ void main() {
   late Player testPlayer5;
   late Group testGroup1;
   late Group testGroup2;
+  late Game testGame;
   late Match testMatch1;
   late Match testMatch2;
   late Match testMatchOnlyPlayers;
@@ -33,39 +36,55 @@ void main() {
     );
 
     withClock(fakeClock, () {
-      testPlayer1 = Player(name: 'Alice');
-      testPlayer2 = Player(name: 'Bob');
-      testPlayer3 = Player(name: 'Charlie');
-      testPlayer4 = Player(name: 'Diana');
-      testPlayer5 = Player(name: 'Eve');
+      testPlayer1 = Player(name: 'Alice', description: '');
+      testPlayer2 = Player(name: 'Bob', description: '');
+      testPlayer3 = Player(name: 'Charlie', description: '');
+      testPlayer4 = Player(name: 'Diana', description: '');
+      testPlayer5 = Player(name: 'Eve', description: '');
       testGroup1 = Group(
         name: 'Test Group 2',
+        description: '',
         members: [testPlayer1, testPlayer2, testPlayer3],
       );
       testGroup2 = Group(
         name: 'Test Group 2',
+        description: '',
         members: [testPlayer4, testPlayer5],
       );
+      testGame = Game(
+        name: 'Test Game',
+        ruleset: Ruleset.singleWinner,
+        description: 'A test game',
+        color: GameColor.blue,
+      );
       testMatch1 = Match(
         name: 'First Test Match',
+        game: testGame,
         group: testGroup1,
         players: [testPlayer4, testPlayer5],
         winner: testPlayer4,
+        notes: '',
       );
       testMatch2 = Match(
         name: 'Second Test Match',
+        game: testGame,
         group: testGroup2,
         players: [testPlayer1, testPlayer2, testPlayer3],
         winner: testPlayer2,
+        notes: '',
       );
       testMatchOnlyPlayers = Match(
         name: 'Test Match with Players',
+        game: testGame,
         players: [testPlayer1, testPlayer2, testPlayer3],
         winner: testPlayer3,
+        notes: '',
       );
       testMatchOnlyGroup = Match(
         name: 'Test Match with Group',
+        game: testGame,
         group: testGroup2,
+        notes: '',
       );
     });
     await database.playerDao.addPlayersAsList(
@@ -78,12 +97,14 @@ void main() {
       ],
     );
     await database.groupDao.addGroupsAsList(groups: [testGroup1, testGroup2]);
+    await database.gameDao.addGame(game: testGame);
   });
   tearDown(() async {
     await database.close();
   });
 
   group('Match Tests', () {
+    // Verifies that a single match can be added and retrieved with all fields, group, and players intact.
     test('Adding and fetching single match works correctly', () async {
       await database.matchDao.addMatch(match: testMatch1);
 
@@ -95,14 +116,6 @@ void main() {
       expect(result.name, testMatch1.name);
       expect(result.createdAt, testMatch1.createdAt);
 
-      if (result.winner != null && testMatch1.winner != null) {
-        expect(result.winner!.id, testMatch1.winner!.id);
-        expect(result.winner!.name, testMatch1.winner!.name);
-        expect(result.winner!.createdAt, testMatch1.winner!.createdAt);
-      } else {
-        expect(result.winner, testMatch1.winner);
-      }
-
       if (result.group != null) {
         expect(result.group!.members.length, testGroup1.members.length);
 
@@ -113,22 +126,16 @@ void main() {
       } else {
         fail('Group is null');
       }
-      if (result.players != null) {
-        expect(result.players!.length, testMatch1.players!.length);
+      expect(result.players.length, testMatch1.players.length);
 
-        for (int i = 0; i < testMatch1.players!.length; i++) {
-          expect(result.players![i].id, testMatch1.players![i].id);
-          expect(result.players![i].name, testMatch1.players![i].name);
-          expect(
-            result.players![i].createdAt,
-            testMatch1.players![i].createdAt,
-          );
-        }
-      } else {
-        fail('Players is null');
+      for (int i = 0; i < testMatch1.players.length; i++) {
+        expect(result.players[i].id, testMatch1.players[i].id);
+        expect(result.players[i].name, testMatch1.players[i].name);
+        expect(result.players[i].createdAt, testMatch1.players[i].createdAt);
       }
     });
 
+    // Verifies that multiple matches can be added and retrieved with correct groups and players.
     test('Adding and fetching multiple matches works correctly', () async {
       await database.matchDao.addMatchAsList(
         matches: [
@@ -156,13 +163,6 @@ void main() {
         expect(match.id, testMatch.id);
         expect(match.name, testMatch.name);
         expect(match.createdAt, testMatch.createdAt);
-        if (match.winner != null && testMatch.winner != null) {
-          expect(match.winner!.id, testMatch.winner!.id);
-          expect(match.winner!.name, testMatch.winner!.name);
-          expect(match.winner!.createdAt, testMatch.winner!.createdAt);
-        } else {
-          expect(match.winner, testMatch.winner);
-        }
 
         // Group-Checks
         if (testMatch.group != null) {
@@ -188,22 +188,16 @@ void main() {
         }
 
         // Players-Checks
-        if (testMatch.players != null) {
-          expect(match.players!.length, testMatch.players!.length);
-          for (int i = 0; i < testMatch.players!.length; i++) {
-            expect(match.players![i].id, testMatch.players![i].id);
-            expect(match.players![i].name, testMatch.players![i].name);
-            expect(
-              match.players![i].createdAt,
-              testMatch.players![i].createdAt,
-            );
-          }
-        } else {
-          expect(match.players, null);
+        expect(match.players.length, testMatch.players.length);
+        for (int i = 0; i < testMatch.players.length; i++) {
+          expect(match.players[i].id, testMatch.players[i].id);
+          expect(match.players[i].name, testMatch.players[i].name);
+          expect(match.players[i].createdAt, testMatch.players[i].createdAt);
         }
       }
     });
 
+    // Verifies that adding the same match twice does not create duplicates.
     test('Adding the same match twice does not create duplicates', () async {
       await database.matchDao.addMatch(match: testMatch1);
       await database.matchDao.addMatch(match: testMatch1);
@@ -212,6 +206,7 @@ void main() {
       expect(matchCount, 1);
     });
 
+    // Verifies that matchExists returns correct boolean based on match presence.
     test('Match existence check works correctly', () async {
       var matchExists = await database.matchDao.matchExists(
         matchId: testMatch1.id,
@@ -224,6 +219,7 @@ void main() {
       expect(matchExists, true);
     });
 
+    // Verifies that deleteMatch removes the match and returns true.
     test('Deleting a match works correctly', () async {
       await database.matchDao.addMatch(match: testMatch1);
 
@@ -238,6 +234,7 @@ void main() {
       expect(matchExists, false);
     });
 
+    // Verifies that getMatchCount returns correct count through add/delete operations.
     test('Getting the match count works correctly', () async {
       var matchCount = await database.matchDao.getMatchCount();
       expect(matchCount, 0);
@@ -263,82 +260,7 @@ void main() {
       expect(matchCount, 0);
     });
 
-    test('Checking if match has winner works correctly', () async {
-      await database.matchDao.addMatch(match: testMatch1);
-      await database.matchDao.addMatch(match: testMatchOnlyGroup);
-
-      var hasWinner = await database.matchDao.hasWinner(matchId: testMatch1.id);
-      expect(hasWinner, true);
-
-      hasWinner = await database.matchDao.hasWinner(
-        matchId: testMatchOnlyGroup.id,
-      );
-      expect(hasWinner, false);
-    });
-
-    test('Fetching the winner of a match works correctly', () async {
-      await database.matchDao.addMatch(match: testMatch1);
-
-      final winner = await database.matchDao.getWinner(matchId: testMatch1.id);
-      if (winner == null) {
-        fail('Winner is null');
-      } else {
-        expect(winner.id, testMatch1.winner!.id);
-        expect(winner.name, testMatch1.winner!.name);
-        expect(winner.createdAt, testMatch1.winner!.createdAt);
-      }
-    });
-
-    test('Updating the winner of a match works correctly', () async {
-      await database.matchDao.addMatch(match: testMatch1);
-
-      final winner = await database.matchDao.getWinner(matchId: testMatch1.id);
-      if (winner == null) {
-        fail('Winner is null');
-      } else {
-        expect(winner.id, testMatch1.winner!.id);
-        expect(winner.name, testMatch1.winner!.name);
-        expect(winner.createdAt, testMatch1.winner!.createdAt);
-        expect(winner.id, testPlayer4.id);
-        expect(winner.id != testPlayer5.id, true);
-      }
-
-      await database.matchDao.setWinner(
-        matchId: testMatch1.id,
-        winnerId: testPlayer5.id,
-      );
-
-      final newWinner = await database.matchDao.getWinner(
-        matchId: testMatch1.id,
-      );
-
-      if (newWinner == null) {
-        fail('New winner is null');
-      } else {
-        expect(newWinner.id, testPlayer5.id);
-        expect(newWinner.name, testPlayer5.name);
-        expect(newWinner.createdAt, testPlayer5.createdAt);
-      }
-    });
-
-    test('Removing a winner works correctly', () async {
-      await database.matchDao.addMatch(match: testMatch2);
-
-      var hasWinner = await database.matchDao.hasWinner(matchId: testMatch2.id);
-      expect(hasWinner, true);
-
-      await database.matchDao.removeWinner(matchId: testMatch2.id);
-
-      hasWinner = await database.matchDao.hasWinner(matchId: testMatch2.id);
-      expect(hasWinner, false);
-
-      final removedWinner = await database.matchDao.getWinner(
-        matchId: testMatch2.id,
-      );
-
-      expect(removedWinner, null);
-    });
-
+    // Verifies that updateMatchName correctly updates only the name field.
     test('Renaming a match works correctly', () async {
       await database.matchDao.addMatch(match: testMatch1);
 
@@ -358,5 +280,31 @@ void main() {
       );
       expect(fetchedMatch.name, newName);
     });
+
+    test('Fetching a winner works correctly', () async {
+      await database.matchDao.addMatch(match: testMatch1);
+
+      var fetchedMatch = await database.matchDao.getMatchById(
+        matchId: testMatch1.id,
+      );
+
+      expect(fetchedMatch.winner, isNotNull);
+      expect(fetchedMatch.winner!.id, testPlayer4.id);
+    });
+
+    test('Setting a winner works correctly', () async {
+      await database.matchDao.addMatch(match: testMatch1);
+
+      await database.matchDao.setWinner(
+        matchId: testMatch1.id,
+        winnerId: testPlayer5.id,
+      );
+
+      final fetchedMatch = await database.matchDao.getMatchById(
+        matchId: testMatch1.id,
+      );
+      expect(fetchedMatch.winner, isNotNull);
+      expect(fetchedMatch.winner!.id, testPlayer5.id);
+    });
   });
 }

test/db_tests/aggregates/team_test.dart

@@ -0,0 +1,521 @@
+import 'package:clock/clock.dart';
+import 'package:drift/drift.dart';
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/dto/team.dart';
+
+void main() {
+  late AppDatabase database;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Player testPlayer4;
+  late Team testTeam1;
+  late Team testTeam2;
+  late Team testTeam3;
+  late Game testGame1;
+  late Game testGame2;
+  final fixedDate = DateTime(2025, 11, 19, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
+
+  setUp(() async {
+    database = AppDatabase(
+      DatabaseConnection(
+        NativeDatabase.memory(),
+        // Recommended for widget tests to avoid test errors.
+        closeStreamsSynchronously: true,
+      ),
+    );
+
+    withClock(fakeClock, () {
+      testPlayer1 = Player(name: 'Alice', description: '');
+      testPlayer2 = Player(name: 'Bob', description: '');
+      testPlayer3 = Player(name: 'Charlie', description: '');
+      testPlayer4 = Player(name: 'Diana', description: '');
+      testTeam1 = Team(name: 'Team Alpha', members: [testPlayer1, testPlayer2]);
+      testTeam2 = Team(name: 'Team Beta', members: [testPlayer3, testPlayer4]);
+      testTeam3 = Team(name: 'Team Gamma', members: [testPlayer1, testPlayer3]);
+      testGame1 = Game(
+        name: 'Game 1',
+        ruleset: Ruleset.singleWinner,
+        description: 'Test game 1',
+        color: GameColor.blue,
+      );
+      testGame2 = Game(
+        name: 'Game 2',
+        ruleset: Ruleset.highestScore,
+        description: 'Test game 2',
+        color: GameColor.red,
+      );
+    });
+
+    await database.playerDao.addPlayersAsList(
+      players: [testPlayer1, testPlayer2, testPlayer3, testPlayer4],
+    );
+    await database.gameDao.addGame(game: testGame1);
+    await database.gameDao.addGame(game: testGame2);
+  });
+
+  tearDown(() async {
+    await database.close();
+  });
+
+  group('Team Tests', () {
+    // Verifies that a single team can be added and retrieved with all fields intact.
+    test('Adding and fetching a single team works correctly', () async {
+      final added = await database.teamDao.addTeam(team: testTeam1);
+      expect(added, true);
+
+      final fetchedTeam = await database.teamDao.getTeamById(
+        teamId: testTeam1.id,
+      );
+
+      expect(fetchedTeam.id, testTeam1.id);
+      expect(fetchedTeam.name, testTeam1.name);
+      expect(fetchedTeam.createdAt, testTeam1.createdAt);
+    });
+
+    // Verifies that multiple teams can be added at once and retrieved correctly.
+    test('Adding and fetching multiple teams works correctly', () async {
+      await database.teamDao.addTeamsAsList(
+        teams: [testTeam1, testTeam2, testTeam3],
+      );
+
+      final allTeams = await database.teamDao.getAllTeams();
+      expect(allTeams.length, 3);
+
+      final testTeams = {
+        testTeam1.id: testTeam1,
+        testTeam2.id: testTeam2,
+        testTeam3.id: testTeam3,
+      };
+
+      for (final team in allTeams) {
+        final testTeam = testTeams[team.id]!;
+
+        expect(team.id, testTeam.id);
+        expect(team.name, testTeam.name);
+        expect(team.createdAt, testTeam.createdAt);
+      }
+    });
+
+    // Verifies that adding the same team twice does not create duplicates and returns false.
+    test('Adding the same team twice does not create duplicates', () async {
+      await database.teamDao.addTeam(team: testTeam1);
+      final addedAgain = await database.teamDao.addTeam(team: testTeam1);
+
+      expect(addedAgain, false);
+
+      final teamCount = await database.teamDao.getTeamCount();
+      expect(teamCount, 1);
+    });
+
+    // Verifies that teamExists returns correct boolean based on team presence.
+    test('Team existence check works correctly', () async {
+      var teamExists = await database.teamDao.teamExists(teamId: testTeam1.id);
+      expect(teamExists, false);
+
+      await database.teamDao.addTeam(team: testTeam1);
+
+      teamExists = await database.teamDao.teamExists(teamId: testTeam1.id);
+      expect(teamExists, true);
+    });
+
+    // Verifies that deleteTeam removes the team and returns true.
+    test('Deleting a team works correctly', () async {
+      await database.teamDao.addTeam(team: testTeam1);
+
+      final teamDeleted = await database.teamDao.deleteTeam(
+        teamId: testTeam1.id,
+      );
+      expect(teamDeleted, true);
+
+      final teamExists = await database.teamDao.teamExists(
+        teamId: testTeam1.id,
+      );
+      expect(teamExists, false);
+    });
+
+    // Verifies that deleteTeam returns false for a non-existent team ID.
+    test('Deleting a non-existent team returns false', () async {
+      final teamDeleted = await database.teamDao.deleteTeam(
+        teamId: 'non-existent-id',
+      );
+      expect(teamDeleted, false);
+    });
+
+    // Verifies that getTeamCount returns correct count through add/delete operations.
+    test('Getting the team count works correctly', () async {
+      var teamCount = await database.teamDao.getTeamCount();
+      expect(teamCount, 0);
+
+      await database.teamDao.addTeam(team: testTeam1);
+
+      teamCount = await database.teamDao.getTeamCount();
+      expect(teamCount, 1);
+
+      await database.teamDao.addTeam(team: testTeam2);
+
+      teamCount = await database.teamDao.getTeamCount();
+      expect(teamCount, 2);
+
+      await database.teamDao.deleteTeam(teamId: testTeam1.id);
+
+      teamCount = await database.teamDao.getTeamCount();
+      expect(teamCount, 1);
+
+      await database.teamDao.deleteTeam(teamId: testTeam2.id);
+
+      teamCount = await database.teamDao.getTeamCount();
+      expect(teamCount, 0);
+    });
+
+    // Verifies that updateTeamName correctly updates only the name field.
+    test('Updating team name works correctly', () async {
+      await database.teamDao.addTeam(team: testTeam1);
+
+      var fetchedTeam = await database.teamDao.getTeamById(
+        teamId: testTeam1.id,
+      );
+      expect(fetchedTeam.name, testTeam1.name);
+
+      const newName = 'Updated Team Name';
+      await database.teamDao.updateTeamName(
+        teamId: testTeam1.id,
+        newName: newName,
+      );
+
+      fetchedTeam = await database.teamDao.getTeamById(teamId: testTeam1.id);
+      expect(fetchedTeam.name, newName);
+    });
+
+    // Verifies that deleteAllTeams removes all teams from the database.
+    test('Deleting all teams works correctly', () async {
+      await database.teamDao.addTeamsAsList(
+        teams: [testTeam1, testTeam2, testTeam3],
+      );
+
+      var teamCount = await database.teamDao.getTeamCount();
+      expect(teamCount, 3);
+
+      final deleted = await database.teamDao.deleteAllTeams();
+      expect(deleted, true);
+
+      teamCount = await database.teamDao.getTeamCount();
+      expect(teamCount, 0);
+    });
+
+    // Verifies that deleteAllTeams returns false when no teams exist.
+    test('Deleting all teams when empty returns false', () async {
+      final deleted = await database.teamDao.deleteAllTeams();
+      expect(deleted, false);
+    });
+
+    // Verifies that addTeamsAsList returns false when given an empty list.
+    test('Adding teams as list with empty list returns false', () async {
+      final added = await database.teamDao.addTeamsAsList(teams: []);
+      expect(added, false);
+    });
+
+    // Verifies that addTeamsAsList with duplicate IDs ignores duplicates and keeps the first.
+    test('Adding teams with duplicate IDs ignores duplicates', () async {
+      final duplicateTeam = Team(
+        id: testTeam1.id,
+        name: 'Duplicate Team',
+        members: [testPlayer4],
+      );
+
+      await database.teamDao.addTeamsAsList(
+        teams: [testTeam1, duplicateTeam, testTeam2],
+      );
+
+      final teamCount = await database.teamDao.getTeamCount();
+      expect(teamCount, 2);
+
+      // The first one should be kept (insertOrIgnore)
+      final fetchedTeam = await database.teamDao.getTeamById(
+        teamId: testTeam1.id,
+      );
+      expect(fetchedTeam.name, testTeam1.name);
+    });
+
+    // Verifies that getAllTeams returns empty list when no teams exist.
+    test('Getting all teams when empty returns empty list', () async {
+      final allTeams = await database.teamDao.getAllTeams();
+      expect(allTeams.isEmpty, true);
+    });
+
+    // Verifies that getTeamById throws exception for non-existent team.
+    test('Getting non-existent team throws exception', () async {
+      expect(
+        () => database.teamDao.getTeamById(teamId: 'non-existent-id'),
+        throwsA(isA<StateError>()),
+      );
+    });
+
+    // Verifies that updating team name preserves other fields.
+    test('Updating team name preserves other team fields', () async {
+      await database.teamDao.addTeam(team: testTeam1);
+      final originalTeam = await database.teamDao.getTeamById(
+        teamId: testTeam1.id,
+      );
+      final originalCreatedAt = originalTeam.createdAt;
+
+      const newName = 'Brand New Team Name';
+      await database.teamDao.updateTeamName(
+        teamId: testTeam1.id,
+        newName: newName,
+      );
+
+      final updatedTeam = await database.teamDao.getTeamById(
+        teamId: testTeam1.id,
+      );
+
+      expect(updatedTeam.name, newName);
+      expect(updatedTeam.id, testTeam1.id);
+      expect(updatedTeam.createdAt, originalCreatedAt);
+    });
+
+    // Verifies that team name can be updated to an empty string.
+    test('Updating team name to empty string works', () async {
+      await database.teamDao.addTeam(team: testTeam1);
+
+      await database.teamDao.updateTeamName(teamId: testTeam1.id, newName: '');
+
+      final updatedTeam = await database.teamDao.getTeamById(
+        teamId: testTeam1.id,
+      );
+
+      expect(updatedTeam.name, '');
+    });
+
+    // Verifies that team name can be updated to a very long string.
+    test('Updating team name to long string works', () async {
+      await database.teamDao.addTeam(team: testTeam1);
+      final longName = 'A' * 500; // 500 character name
+
+      await database.teamDao.updateTeamName(
+        teamId: testTeam1.id,
+        newName: longName,
+      );
+
+      final updatedTeam = await database.teamDao.getTeamById(
+        teamId: testTeam1.id,
+      );
+
+      expect(updatedTeam.name, longName);
+      expect(updatedTeam.name.length, 500);
+    });
+
+    // Verifies that updating non-existent team name doesn't throw error.
+    test('Updating non-existent team name completes without error', () async {
+      expect(
+        () => database.teamDao.updateTeamName(
+          teamId: 'non-existent-id',
+          newName: 'New Name',
+        ),
+        returnsNormally,
+      );
+    });
+
+    // Verifies that deleteTeam only affects the specified team.
+    test('Deleting one team does not affect other teams', () async {
+      await database.teamDao.addTeamsAsList(
+        teams: [testTeam1, testTeam2, testTeam3],
+      );
+
+      await database.teamDao.deleteTeam(teamId: testTeam2.id);
+
+      final allTeams = await database.teamDao.getAllTeams();
+      expect(allTeams.length, 2);
+      expect(allTeams.any((t) => t.id == testTeam1.id), true);
+      expect(allTeams.any((t) => t.id == testTeam2.id), false);
+      expect(allTeams.any((t) => t.id == testTeam3.id), true);
+    });
+
+    // Verifies that teams with overlapping members are independent.
+    test('Teams with overlapping members are independent', () async {
+      // Create two matches since player_match has primary key {playerId, matchId}
+      final match1 = Match(name: 'Match 1', game: testGame1, notes: '');
+      final match2 = Match(name: 'Match 2', game: testGame2, notes: '');
+      await database.matchDao.addMatch(match: match1);
+      await database.matchDao.addMatch(match: match2);
+
+      // Add teams to database
+      await database.teamDao.addTeamsAsList(teams: [testTeam1, testTeam3]);
+
+      // Associate players with teams through match1
+      // testTeam1: player1, player2
+      await database.playerMatchDao.addPlayerToMatch(
+        playerId: testPlayer1.id,
+        matchId: match1.id,
+        teamId: testTeam1.id,
+        score: 0,
+      );
+      await database.playerMatchDao.addPlayerToMatch(
+        playerId: testPlayer2.id,
+        matchId: match1.id,
+        teamId: testTeam1.id,
+        score: 0,
+      );
+
+      // Associate players with teams through match2
+      // testTeam3: player1, player3 (overlapping player1)
+      await database.playerMatchDao.addPlayerToMatch(
+        playerId: testPlayer1.id,
+        matchId: match2.id,
+        teamId: testTeam3.id,
+        score: 0,
+      );
+      await database.playerMatchDao.addPlayerToMatch(
+        playerId: testPlayer3.id,
+        matchId: match2.id,
+        teamId: testTeam3.id,
+        score: 0,
+      );
+
+      final team1 = await database.teamDao.getTeamById(teamId: testTeam1.id);
+      final team3 = await database.teamDao.getTeamById(teamId: testTeam3.id);
+
+      expect(team1.members.length, 2);
+      expect(team3.members.length, 2);
+      expect(team1.members.any((p) => p.id == testPlayer1.id), true);
+      expect(team3.members.any((p) => p.id == testPlayer1.id), true);
+    });
+
+    // Verifies that adding teams sequentially works correctly.
+    test('Adding teams sequentially maintains correct count', () async {
+      var count = await database.teamDao.getTeamCount();
+      expect(count, 0);
+
+      await database.teamDao.addTeam(team: testTeam1);
+      count = await database.teamDao.getTeamCount();
+      expect(count, 1);
+
+      await database.teamDao.addTeam(team: testTeam2);
+      count = await database.teamDao.getTeamCount();
+      expect(count, 2);
+
+      await database.teamDao.addTeam(team: testTeam3);
+      count = await database.teamDao.getTeamCount();
+      expect(count, 3);
+    });
+
+    // Verifies that getAllTeams returns all teams with correct data.
+    test('Getting all teams returns all teams with correct data', () async {
+      await database.teamDao.addTeamsAsList(
+        teams: [testTeam1, testTeam2, testTeam3],
+      );
+
+      final allTeams = await database.teamDao.getAllTeams();
+
+      expect(allTeams.length, 3);
+      expect(allTeams.map((t) => t.id).toSet(), {
+        testTeam1.id,
+        testTeam2.id,
+        testTeam3.id,
+      });
+    });
+
+    // Verifies that teamExists returns false for deleted teams.
+    test('Team existence returns false after deletion', () async {
+      await database.teamDao.addTeam(team: testTeam1);
+      expect(await database.teamDao.teamExists(teamId: testTeam1.id), true);
+
+      await database.teamDao.deleteTeam(teamId: testTeam1.id);
+      expect(await database.teamDao.teamExists(teamId: testTeam1.id), false);
+    });
+
+    // Verifies that adding multiple teams in batch then deleting returns correct count.
+    test('Batch add then partial delete maintains correct count', () async {
+      await database.teamDao.addTeamsAsList(
+        teams: [testTeam1, testTeam2, testTeam3],
+      );
+
+      expect(await database.teamDao.getTeamCount(), 3);
+
+      await database.teamDao.deleteTeam(teamId: testTeam1.id);
+      expect(await database.teamDao.getTeamCount(), 2);
+
+      await database.teamDao.deleteTeam(teamId: testTeam3.id);
+      expect(await database.teamDao.getTeamCount(), 1);
+    });
+
+    // Verifies that deleteAllTeams with single team works.
+    test('Deleting all teams with single team returns true', () async {
+      await database.teamDao.addTeam(team: testTeam1);
+      expect(await database.teamDao.getTeamCount(), 1);
+
+      final deleted = await database.teamDao.deleteAllTeams();
+      expect(deleted, true);
+      expect(await database.teamDao.getTeamCount(), 0);
+    });
+
+    // Verifies that addTeam after deleteAllTeams works correctly.
+    test('Adding team after deleteAllTeams works correctly', () async {
+      await database.teamDao.addTeamsAsList(teams: [testTeam1, testTeam2]);
+      expect(await database.teamDao.getTeamCount(), 2);
+
+      await database.teamDao.deleteAllTeams();
+      expect(await database.teamDao.getTeamCount(), 0);
+
+      final added = await database.teamDao.addTeam(team: testTeam3);
+      expect(added, true);
+      expect(await database.teamDao.getTeamCount(), 1);
+
+      final fetchedTeam = await database.teamDao.getTeamById(
+        teamId: testTeam3.id,
+      );
+      expect(fetchedTeam.name, testTeam3.name);
+    });
+
+    // Verifies that addTeamsAsList with partial duplicates ignores duplicates.
+    test('Adding teams with some duplicates ignores only duplicates', () async {
+      await database.teamDao.addTeam(team: testTeam1);
+
+      final duplicateTeam1 = Team(
+        id: testTeam1.id,
+        name: 'Different Name',
+        members: [testPlayer3],
+      );
+
+      await database.teamDao.addTeamsAsList(
+        teams: [duplicateTeam1, testTeam2, testTeam3],
+      );
+
+      final allTeams = await database.teamDao.getAllTeams();
+      expect(allTeams.length, 3);
+
+      // Verify testTeam1 retained original name (was inserted first)
+      final team1 = await database.teamDao.getTeamById(teamId: testTeam1.id);
+      expect(team1.name, testTeam1.name);
+    });
+
+    // Verifies that team IDs are preserved correctly.
+    test('Team IDs are preserved through add and retrieve', () async {
+      await database.teamDao.addTeam(team: testTeam1);
+
+      final fetchedTeam = await database.teamDao.getTeamById(
+        teamId: testTeam1.id,
+      );
+
+      expect(fetchedTeam.id, testTeam1.id);
+    });
+
+    // Verifies that createdAt timestamps are preserved.
+    test('Team createdAt timestamps are preserved', () async {
+      await database.teamDao.addTeam(team: testTeam1);
+
+      final fetchedTeam = await database.teamDao.getTeamById(
+        teamId: testTeam1.id,
+      );
+
+      expect(fetchedTeam.createdAt, testTeam1.createdAt);
+    });
+  });
+}

test/db_tests/entities/game_test.dart

@@ -0,0 +1,540 @@
+import 'package:clock/clock.dart';
+import 'package:drift/drift.dart' hide isNull;
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/game.dart';
+
+void main() {
+  late AppDatabase database;
+  late Game testGame1;
+  late Game testGame2;
+  late Game testGame3;
+  final fixedDate = DateTime(2025, 11, 19, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
+
+  setUp(() {
+    database = AppDatabase(
+      DatabaseConnection(
+        NativeDatabase.memory(),
+        closeStreamsSynchronously: true,
+      ),
+    );
+
+    withClock(fakeClock, () {
+      testGame1 = Game(
+        name: 'Chess',
+        ruleset: Ruleset.singleWinner,
+        description: 'A classic strategy game',
+        color: GameColor.blue,
+        icon: 'chess_icon',
+      );
+      testGame2 = Game(
+        id: 'game2',
+        name: 'Poker',
+        ruleset: Ruleset.multipleWinners,
+        description: 'Card game with multiple winners',
+        color: GameColor.red,
+        icon: 'poker_icon',
+      );
+      testGame3 = Game(
+        id: 'game3',
+        name: 'Monopoly',
+        ruleset: Ruleset.highestScore,
+        description: 'A board game about real estate',
+        color: GameColor.orange,
+      );
+    });
+  });
+
+  tearDown(() async {
+    await database.close();
+  });
+
+  group('Game Tests', () {
+    // Verifies that getAllGames returns an empty list when the database has no games.
+    test('getAllGames returns empty list when no games exist', () async {
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames, isEmpty);
+    });
+
+    // Verifies that a single game can be added and retrieved with all fields intact.
+    test('Adding and fetching a single game works correctly', () async {
+      await database.gameDao.addGame(game: testGame1);
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames.length, 1);
+      expect(allGames.first.id, testGame1.id);
+      expect(allGames.first.name, testGame1.name);
+      expect(allGames.first.ruleset, testGame1.ruleset);
+      expect(allGames.first.description, testGame1.description);
+      expect(allGames.first.color, testGame1.color);
+      expect(allGames.first.icon, testGame1.icon);
+      expect(allGames.first.createdAt, testGame1.createdAt);
+    });
+
+    // Verifies that multiple games can be added and retrieved correctly.
+    test('Adding and fetching multiple games works correctly', () async {
+      await database.gameDao.addGame(game: testGame1);
+      await database.gameDao.addGame(game: testGame2);
+      await database.gameDao.addGame(game: testGame3);
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames.length, 3);
+
+      final names = allGames.map((g) => g.name).toList();
+      expect(names, containsAll(['Chess', 'Poker', 'Monopoly']));
+    });
+
+    // Verifies that getGameById returns the correct game with all properties.
+    test('getGameById returns correct game', () async {
+      await database.gameDao.addGame(game: testGame1);
+      await database.gameDao.addGame(game: testGame2);
+
+      final game = await database.gameDao.getGameById(gameId: testGame2.id);
+      expect(game.id, testGame2.id);
+      expect(game.name, testGame2.name);
+      expect(game.ruleset, testGame2.ruleset);
+      expect(game.description, testGame2.description);
+      expect(game.color, testGame2.color);
+      expect(game.icon, testGame2.icon);
+    });
+
+    // Verifies that getGameById throws a StateError when the game doesn't exist.
+    test('getGameById throws exception for non-existent game', () async {
+      expect(
+        () => database.gameDao.getGameById(gameId: 'non-existent-id'),
+        throwsA(isA<StateError>()),
+      );
+    });
+
+    // Verifies that addGame returns true when a game is successfully added.
+    test('addGame returns true when game is added successfully', () async {
+      final result = await database.gameDao.addGame(game: testGame1);
+      expect(result, true);
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames.length, 1);
+    });
+
+    // Verifies that addGame returns false when trying to add a duplicate game.
+    test('addGame returns false when game already exists', () async {
+      final firstAdd = await database.gameDao.addGame(game: testGame1);
+      expect(firstAdd, true);
+
+      final secondAdd = await database.gameDao.addGame(game: testGame1);
+      expect(secondAdd, false);
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames.length, 1);
+    });
+
+    // Verifies that a game with empty optional fields can be added and retrieved.
+    test('addGame handles game with null optional fields', () async {
+      final gameWithNulls = Game(
+        name: 'Simple Game',
+        ruleset: Ruleset.lowestScore,
+        description: 'A simple game',
+        color: GameColor.green,
+      );
+      final result = await database.gameDao.addGame(game: gameWithNulls);
+      expect(result, true);
+
+      final fetchedGame = await database.gameDao.getGameById(
+        gameId: gameWithNulls.id,
+      );
+      expect(fetchedGame.name, 'Simple Game');
+      expect(fetchedGame.description, 'A simple game');
+      expect(fetchedGame.color, GameColor.green);
+      expect(fetchedGame.icon, '');
+    });
+
+    // Verifies that multiple games can be added at once using addGamesAsList.
+    test('addGamesAsList adds multiple games correctly', () async {
+      final result = await database.gameDao.addGamesAsList(
+        games: [testGame1, testGame2, testGame3],
+      );
+      expect(result, true);
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames.length, 3);
+    });
+
+    // Verifies that addGamesAsList returns false when given an empty list.
+    test('addGamesAsList returns false for empty list', () async {
+      final result = await database.gameDao.addGamesAsList(games: []);
+      expect(result, false);
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames.length, 0);
+    });
+
+    // Verifies that addGamesAsList ignores duplicate games when adding.
+    test('addGamesAsList ignores duplicate games', () async {
+      await database.gameDao.addGame(game: testGame1);
+
+      final result = await database.gameDao.addGamesAsList(
+        games: [testGame1, testGame2],
+      );
+      expect(result, true);
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames.length, 2);
+    });
+
+    // Verifies that deleteGame returns true and removes the game from database.
+    test('deleteGame returns true when game is deleted', () async {
+      await database.gameDao.addGame(game: testGame1);
+
+      final result = await database.gameDao.deleteGame(gameId: testGame1.id);
+      expect(result, true);
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames, isEmpty);
+    });
+
+    // Verifies that deleteGame returns false for a non-existent game ID.
+    test('deleteGame returns false for non-existent game', () async {
+      final result = await database.gameDao.deleteGame(
+        gameId: 'non-existent-id',
+      );
+      expect(result, false);
+    });
+
+    // Verifies that deleteGame only removes the specified game, leaving others intact.
+    test('deleteGame only deletes the specified game', () async {
+      await database.gameDao.addGamesAsList(
+        games: [testGame1, testGame2, testGame3],
+      );
+
+      await database.gameDao.deleteGame(gameId: testGame2.id);
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames.length, 2);
+      expect(allGames.any((g) => g.id == testGame2.id), false);
+      expect(allGames.any((g) => g.id == testGame1.id), true);
+      expect(allGames.any((g) => g.id == testGame3.id), true);
+    });
+
+    // Verifies that gameExists returns true when the game exists in database.
+    test('gameExists returns true for existing game', () async {
+      await database.gameDao.addGame(game: testGame1);
+
+      final exists = await database.gameDao.gameExists(gameId: testGame1.id);
+      expect(exists, true);
+    });
+
+    // Verifies that gameExists returns false for a non-existent game ID.
+    test('gameExists returns false for non-existent game', () async {
+      final exists = await database.gameDao.gameExists(
+        gameId: 'non-existent-id',
+      );
+      expect(exists, false);
+    });
+
+    // Verifies that gameExists returns false after a game has been deleted.
+    test('gameExists returns false after game is deleted', () async {
+      await database.gameDao.addGame(game: testGame1);
+      await database.gameDao.deleteGame(gameId: testGame1.id);
+
+      final exists = await database.gameDao.gameExists(gameId: testGame1.id);
+      expect(exists, false);
+    });
+
+    // Verifies that updateGameName correctly updates only the name field.
+    test('updateGameName updates the name correctly', () async {
+      await database.gameDao.addGame(game: testGame1);
+
+      await database.gameDao.updateGameName(
+        gameId: testGame1.id,
+        newName: 'Updated Chess',
+      );
+
+      final updatedGame = await database.gameDao.getGameById(
+        gameId: testGame1.id,
+      );
+      expect(updatedGame.name, 'Updated Chess');
+      expect(updatedGame.ruleset, testGame1.ruleset);
+    });
+
+    // Verifies that updateGameName does nothing when game doesn't exist.
+    test('updateGameName does nothing for non-existent game', () async {
+      await database.gameDao.updateGameName(
+        gameId: 'non-existent-id',
+        newName: 'New Name',
+      );
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames, isEmpty);
+    });
+
+    // Verifies that updateGameRuleset correctly updates only the ruleset field.
+    test('updateGameRuleset updates the ruleset correctly', () async {
+      await database.gameDao.addGame(game: testGame1);
+
+      await database.gameDao.updateGameRuleset(
+        gameId: testGame1.id,
+        newRuleset: Ruleset.highestScore,
+      );
+
+      final updatedGame = await database.gameDao.getGameById(
+        gameId: testGame1.id,
+      );
+      expect(updatedGame.ruleset, Ruleset.highestScore);
+      expect(updatedGame.name, testGame1.name);
+    });
+
+    // Verifies that updateGameRuleset does nothing when game doesn't exist.
+    test('updateGameRuleset does nothing for non-existent game', () async {
+      await database.gameDao.updateGameRuleset(
+        gameId: 'non-existent-id',
+        newRuleset: Ruleset.lowestScore,
+      );
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames, isEmpty);
+    });
+
+    // Verifies that updateGameDescription correctly updates the description.
+    test('updateGameDescription updates the description correctly', () async {
+      await database.gameDao.addGame(game: testGame1);
+
+      await database.gameDao.updateGameDescription(
+        gameId: testGame1.id,
+        newDescription: 'An updated description',
+      );
+
+      final updatedGame = await database.gameDao.getGameById(
+        gameId: testGame1.id,
+      );
+      expect(updatedGame.description, 'An updated description');
+    });
+
+    // Verifies that updateGameDescription can set the description to an empty string.
+    test('updateGameDescription can set description to empty string', () async {
+      await database.gameDao.addGame(game: testGame1);
+
+      await database.gameDao.updateGameDescription(
+        gameId: testGame1.id,
+        newDescription: '',
+      );
+
+      final updatedGame = await database.gameDao.getGameById(
+        gameId: testGame1.id,
+      );
+      expect(updatedGame.description, '');
+    });
+
+    // Verifies that updateGameDescription does nothing when game doesn't exist.
+    test('updateGameDescription does nothing for non-existent game', () async {
+      await database.gameDao.updateGameDescription(
+        gameId: 'non-existent-id',
+        newDescription: 'New Description',
+      );
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames, isEmpty);
+    });
+
+    // Verifies that updateGameColor correctly updates the color value.
+    test('updateGameColor updates the color correctly', () async {
+      await database.gameDao.addGame(game: testGame1);
+
+      await database.gameDao.updateGameColor(
+        gameId: testGame1.id,
+        newColor: GameColor.green,
+      );
+
+      final updatedGame = await database.gameDao.getGameById(
+        gameId: testGame1.id,
+      );
+      expect(updatedGame.color, GameColor.green);
+    });
+
+    // Verifies that updateGameColor does nothing when game doesn't exist.
+    test('updateGameColor does nothing for non-existent game', () async {
+      await database.gameDao.updateGameColor(
+        gameId: 'non-existent-id',
+        newColor: GameColor.green,
+      );
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames, isEmpty);
+    });
+
+    // Verifies that updateGameIcon correctly updates the icon value.
+    test('updateGameIcon updates the icon correctly', () async {
+      await database.gameDao.addGame(game: testGame1);
+
+      await database.gameDao.updateGameIcon(
+        gameId: testGame1.id,
+        newIcon: 'new_chess_icon',
+      );
+
+      final updatedGame = await database.gameDao.getGameById(
+        gameId: testGame1.id,
+      );
+      expect(updatedGame.icon, 'new_chess_icon');
+    });
+
+    // Verifies that updateGameIcon can update the icon.
+    test('updateGameIcon updates icon correctly', () async {
+      await database.gameDao.addGame(game: testGame1);
+
+      await database.gameDao.updateGameIcon(
+        gameId: testGame1.id,
+        newIcon: 'new_icon',
+      );
+
+      final updatedGame = await database.gameDao.getGameById(
+        gameId: testGame1.id,
+      );
+      expect(updatedGame.icon, 'new_icon');
+    });
+
+    // Verifies that updateGameIcon does nothing when game doesn't exist.
+    test('updateGameIcon does nothing for non-existent game', () async {
+      await database.gameDao.updateGameIcon(
+        gameId: 'non-existent-id',
+        newIcon: 'some_icon',
+      );
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames, isEmpty);
+    });
+
+    // Verifies that getGameCount returns 0 when no games exist.
+    test('getGameCount returns 0 when no games exist', () async {
+      final count = await database.gameDao.getGameCount();
+      expect(count, 0);
+    });
+
+    // Verifies that getGameCount returns the correct count after adding games.
+    test('getGameCount returns correct count after adding games', () async {
+      await database.gameDao.addGamesAsList(
+        games: [testGame1, testGame2, testGame3],
+      );
+
+      final count = await database.gameDao.getGameCount();
+      expect(count, 3);
+    });
+
+    // Verifies that getGameCount updates correctly after deleting a game.
+    test('getGameCount updates correctly after deletion', () async {
+      await database.gameDao.addGamesAsList(games: [testGame1, testGame2]);
+
+      final countBefore = await database.gameDao.getGameCount();
+      expect(countBefore, 2);
+
+      await database.gameDao.deleteGame(gameId: testGame1.id);
+
+      final countAfter = await database.gameDao.getGameCount();
+      expect(countAfter, 1);
+    });
+
+    // Verifies that deleteAllGames removes all games from the database.
+    test('deleteAllGames removes all games', () async {
+      await database.gameDao.addGamesAsList(
+        games: [testGame1, testGame2, testGame3],
+      );
+
+      final countBefore = await database.gameDao.getGameCount();
+      expect(countBefore, 3);
+
+      final result = await database.gameDao.deleteAllGames();
+      expect(result, true);
+
+      final countAfter = await database.gameDao.getGameCount();
+      expect(countAfter, 0);
+    });
+
+    // Verifies that deleteAllGames returns false when no games exist.
+    test('deleteAllGames returns false when no games exist', () async {
+      final result = await database.gameDao.deleteAllGames();
+      expect(result, false);
+    });
+
+    // Verifies that games with special characters (quotes, emojis) are stored correctly.
+    test('Game with special characters in name is stored correctly', () async {
+      final specialGame = Game(
+        name: 'Game\'s & "Special" <Name>',
+        ruleset: Ruleset.multipleWinners,
+        description: 'Description with émojis 🎮🎲',
+        color: GameColor.purple,
+      );
+      await database.gameDao.addGame(game: specialGame);
+
+      final fetchedGame = await database.gameDao.getGameById(
+        gameId: specialGame.id,
+      );
+      expect(fetchedGame.name, 'Game\'s & "Special" <Name>');
+      expect(fetchedGame.description, 'Description with émojis 🎮🎲');
+    });
+
+    // Verifies that games with empty string fields are stored and retrieved correctly.
+    test('Game with empty string fields is stored correctly', () async {
+      final emptyGame = Game(
+        name: '',
+        ruleset: Ruleset.singleWinner,
+        description: '',
+        color: GameColor.red,
+      );
+      await database.gameDao.addGame(game: emptyGame);
+
+      final fetchedGame = await database.gameDao.getGameById(
+        gameId: emptyGame.id,
+      );
+      expect(fetchedGame.name, '');
+      expect(fetchedGame.ruleset, Ruleset.singleWinner);
+      expect(fetchedGame.description, '');
+      expect(fetchedGame.icon, '');
+    });
+
+    // Verifies that games with very long strings (10000 chars) are handled correctly.
+    test('Game with very long strings is stored correctly', () async {
+      final longString = 'A' * 10000;
+      final longGame = Game(
+        name: longString,
+        description: longString,
+        ruleset: Ruleset.multipleWinners,
+        color: GameColor.yellow,
+      );
+      await database.gameDao.addGame(game: longGame);
+
+      final fetchedGame = await database.gameDao.getGameById(
+        gameId: longGame.id,
+      );
+      expect(fetchedGame.name.length, 10000);
+      expect(fetchedGame.description.length, 10000);
+      expect(fetchedGame.ruleset, Ruleset.multipleWinners);
+    });
+
+    // Verifies that multiple sequential updates to the same game work correctly.
+    test('Multiple updates to the same game work correctly', () async {
+      await database.gameDao.addGame(game: testGame1);
+
+      await database.gameDao.updateGameName(
+        gameId: testGame1.id,
+        newName: 'Updated Name',
+      );
+      await database.gameDao.updateGameColor(
+        gameId: testGame1.id,
+        newColor: GameColor.teal,
+      );
+      await database.gameDao.updateGameDescription(
+        gameId: testGame1.id,
+        newDescription: 'Updated Description',
+      );
+
+      final updatedGame = await database.gameDao.getGameById(
+        gameId: testGame1.id,
+      );
+      expect(updatedGame.name, 'Updated Name');
+      expect(updatedGame.color, GameColor.teal);
+      expect(updatedGame.description, 'Updated Description');
+      expect(updatedGame.ruleset, testGame1.ruleset);
+      expect(updatedGame.icon, testGame1.icon);
+    });
+  });
+}

test/db_tests/entities/player_test.dart

@@ -0,0 +1,377 @@
+import 'package:clock/clock.dart';
+import 'package:drift/drift.dart' hide isNull;
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/player.dart';
+
+void main() {
+  late AppDatabase database;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Player testPlayer4;
+  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
+
+  setUp(() {
+    database = AppDatabase(
+      DatabaseConnection(
+        NativeDatabase.memory(),
+        // Recommended for widget tests to avoid test errors.
+        closeStreamsSynchronously: true,
+      ),
+    );
+
+    withClock(fakeClock, () {
+      testPlayer1 = Player(name: 'Test Player', description: '');
+      testPlayer2 = Player(name: 'Second Player', description: '');
+      testPlayer3 = Player(name: 'Charlie', description: '');
+      testPlayer4 = Player(name: 'Diana', description: '');
+    });
+  });
+  tearDown(() async {
+    await database.close();
+  });
+
+  group('Player Tests', () {
+
+    // Verifies that players can be added and retrieved with all fields intact.
+    test('Adding and fetching single player works correctly', () async {
+      await database.playerDao.addPlayer(player: testPlayer1);
+      await database.playerDao.addPlayer(player: testPlayer2);
+
+      final allPlayers = await database.playerDao.getAllPlayers();
+      expect(allPlayers.length, 2);
+
+      final fetchedPlayer1 = allPlayers.firstWhere(
+        (g) => g.id == testPlayer1.id,
+      );
+      expect(fetchedPlayer1.name, testPlayer1.name);
+      expect(fetchedPlayer1.createdAt, testPlayer1.createdAt);
+
+      final fetchedPlayer2 = allPlayers.firstWhere(
+        (g) => g.id == testPlayer2.id,
+      );
+      expect(fetchedPlayer2.name, testPlayer2.name);
+      expect(fetchedPlayer2.createdAt, testPlayer2.createdAt);
+    });
+
+    // Verifies that multiple players can be added at once and retrieved correctly.
+    test('Adding and fetching multiple players works correctly', () async {
+      await database.playerDao.addPlayersAsList(
+        players: [testPlayer1, testPlayer2, testPlayer3, testPlayer4],
+      );
+
+      final allPlayers = await database.playerDao.getAllPlayers();
+      expect(allPlayers.length, 4);
+
+      // Map for connecting fetched players with expected players
+      final testPlayers = {
+        testPlayer1.id: testPlayer1,
+        testPlayer2.id: testPlayer2,
+        testPlayer3.id: testPlayer3,
+        testPlayer4.id: testPlayer4,
+      };
+
+      for (final player in allPlayers) {
+        final testPlayer = testPlayers[player.id]!;
+
+        expect(player.id, testPlayer.id);
+        expect(player.name, testPlayer.name);
+        expect(player.createdAt, testPlayer.createdAt);
+      }
+    });
+
+    // Verifies that adding the same player twice does not create duplicates.
+    test('Adding the same player twice does not create duplicates', () async {
+      await database.playerDao.addPlayer(player: testPlayer1);
+      await database.playerDao.addPlayer(player: testPlayer1);
+
+      final allPlayers = await database.playerDao.getAllPlayers();
+      expect(allPlayers.length, 1);
+    });
+
+    // Verifies that playerExists returns correct boolean based on player presence.
+    test('Player existence check works correctly', () async {
+      var playerExists = await database.playerDao.playerExists(
+        playerId: testPlayer1.id,
+      );
+      expect(playerExists, false);
+
+      await database.playerDao.addPlayer(player: testPlayer1);
+
+      playerExists = await database.playerDao.playerExists(
+        playerId: testPlayer1.id,
+      );
+      expect(playerExists, true);
+    });
+
+    // Verifies that deletePlayer removes the player and returns true.
+    test('Deleting a player works correctly', () async {
+      await database.playerDao.addPlayer(player: testPlayer1);
+      final playerDeleted = await database.playerDao.deletePlayer(
+        playerId: testPlayer1.id,
+      );
+      expect(playerDeleted, true);
+
+      final playerExists = await database.playerDao.playerExists(
+        playerId: testPlayer1.id,
+      );
+      expect(playerExists, false);
+    });
+
+    // Verifies that updatePlayerName correctly updates only the name field.
+    test('Updating a player name works correctly', () async {
+      await database.playerDao.addPlayer(player: testPlayer1);
+
+      const newPlayerName = 'new player name';
+
+      await database.playerDao.updatePlayerName(
+        playerId: testPlayer1.id,
+        newName: newPlayerName,
+      );
+
+      final result = await database.playerDao.getPlayerById(
+        playerId: testPlayer1.id,
+      );
+      expect(result.name, newPlayerName);
+    });
+
+    // Verifies that getPlayerCount returns correct count through add/delete operations.
+    test('Getting the player count works correctly', () async {
+      var playerCount = await database.playerDao.getPlayerCount();
+      expect(playerCount, 0);
+
+      await database.playerDao.addPlayer(player: testPlayer1);
+
+      playerCount = await database.playerDao.getPlayerCount();
+      expect(playerCount, 1);
+
+      await database.playerDao.addPlayer(player: testPlayer2);
+
+      playerCount = await database.playerDao.getPlayerCount();
+      expect(playerCount, 2);
+
+      await database.playerDao.deletePlayer(playerId: testPlayer1.id);
+
+      playerCount = await database.playerDao.getPlayerCount();
+      expect(playerCount, 1);
+
+      await database.playerDao.deletePlayer(playerId: testPlayer2.id);
+
+      playerCount = await database.playerDao.getPlayerCount();
+      expect(playerCount, 0);
+    });
+
+    // Verifies that getAllPlayers returns an empty list when no players exist.
+    test('getAllPlayers returns empty list when no players exist', () async {
+      final allPlayers = await database.playerDao.getAllPlayers();
+      expect(allPlayers, isEmpty);
+    });
+
+    // Verifies that getPlayerById returns the correct player.
+    test('getPlayerById returns correct player', () async {
+      await database.playerDao.addPlayer(player: testPlayer1);
+      await database.playerDao.addPlayer(player: testPlayer2);
+
+      final fetchedPlayer = await database.playerDao.getPlayerById(
+        playerId: testPlayer1.id,
+      );
+
+      expect(fetchedPlayer.id, testPlayer1.id);
+      expect(fetchedPlayer.name, testPlayer1.name);
+      expect(fetchedPlayer.createdAt, testPlayer1.createdAt);
+      expect(fetchedPlayer.description, testPlayer1.description);
+    });
+
+    // Verifies that getPlayerById throws StateError for non-existent player ID.
+    test('getPlayerById throws exception for non-existent player', () async {
+      expect(
+        () => database.playerDao.getPlayerById(playerId: 'non-existent-id'),
+        throwsA(isA<StateError>()),
+      );
+    });
+
+    // Verifies that addPlayer returns false when trying to add a duplicate player.
+    test('addPlayer returns false when player already exists', () async {
+      final firstAdd = await database.playerDao.addPlayer(player: testPlayer1);
+      expect(firstAdd, true);
+
+      final secondAdd = await database.playerDao.addPlayer(player: testPlayer1);
+      expect(secondAdd, false);
+    });
+
+    // Verifies that addPlayersAsList handles empty list correctly.
+    test('addPlayersAsList handles empty list correctly', () async {
+      final result = await database.playerDao.addPlayersAsList(players: []);
+      expect(result, false);
+
+      final allPlayers = await database.playerDao.getAllPlayers();
+      expect(allPlayers, isEmpty);
+    });
+
+    // Verifies that addPlayersAsList ignores duplicate player IDs.
+    test('addPlayersAsList with duplicate IDs ignores duplicates', () async {
+      await database.playerDao.addPlayersAsList(
+        players: [testPlayer1, testPlayer1, testPlayer2],
+      );
+
+      final allPlayers = await database.playerDao.getAllPlayers();
+      expect(allPlayers.length, 2);
+    });
+
+    // Verifies that deletePlayer returns false for non-existent player.
+    test('deletePlayer returns false for non-existent player', () async {
+      final result = await database.playerDao.deletePlayer(
+        playerId: 'non-existent-id',
+      );
+      expect(result, false);
+    });
+
+    // Verifies that updatePlayerName does nothing for non-existent player (no exception).
+    test('updatePlayerName does nothing for non-existent player', () async {
+      // Should not throw, just do nothing
+      await database.playerDao.updatePlayerName(
+        playerId: 'non-existent-id',
+        newName: 'New Name',
+      );
+
+      final allPlayers = await database.playerDao.getAllPlayers();
+      expect(allPlayers, isEmpty);
+    });
+
+    // Verifies that deleteAllPlayers removes all players.
+    test('deleteAllPlayers removes all players', () async {
+      await database.playerDao.addPlayersAsList(
+        players: [testPlayer1, testPlayer2, testPlayer3],
+      );
+
+      var playerCount = await database.playerDao.getPlayerCount();
+      expect(playerCount, 3);
+
+      final result = await database.playerDao.deleteAllPlayers();
+      expect(result, true);
+
+      playerCount = await database.playerDao.getPlayerCount();
+      expect(playerCount, 0);
+    });
+
+    // Verifies that deleteAllPlayers returns false when no players exist.
+    test('deleteAllPlayers returns false when no players exist', () async {
+      final result = await database.playerDao.deleteAllPlayers();
+      expect(result, false);
+    });
+
+    // Verifies that a player with special characters in name is stored correctly.
+    test('Player with special characters in name is stored correctly', () async {
+      final specialPlayer = Player(name: 'Test!@#\$%^&*()_+-=[]{}|;\':",.<>?/`~', description: '');
+
+      await database.playerDao.addPlayer(player: specialPlayer);
+
+      final fetchedPlayer = await database.playerDao.getPlayerById(
+        playerId: specialPlayer.id,
+      );
+      expect(fetchedPlayer.name, specialPlayer.name);
+    });
+
+    // Verifies that a player with description is stored correctly.
+    test('Player with description is stored correctly', () async {
+      final playerWithDescription = Player(
+        name: 'Described Player',
+        description: 'This is a test description',
+      );
+
+      await database.playerDao.addPlayer(player: playerWithDescription);
+
+      final fetchedPlayer = await database.playerDao.getPlayerById(
+        playerId: playerWithDescription.id,
+      );
+      expect(fetchedPlayer.name, playerWithDescription.name);
+      expect(fetchedPlayer.description, playerWithDescription.description);
+    });
+
+    // Verifies that a player with null description is stored correctly.
+    test('Player with null description is stored correctly', () async {
+      final playerWithoutDescription = Player(name: 'No Description Player', description: '');
+
+      await database.playerDao.addPlayer(player: playerWithoutDescription);
+
+      final fetchedPlayer = await database.playerDao.getPlayerById(
+        playerId: playerWithoutDescription.id,
+      );
+      expect(fetchedPlayer.description, '');
+    });
+
+    // Verifies that multiple updates to the same player work correctly.
+    test('Multiple updates to the same player work correctly', () async {
+      await database.playerDao.addPlayer(player: testPlayer1);
+
+      await database.playerDao.updatePlayerName(
+        playerId: testPlayer1.id,
+        newName: 'First Update',
+      );
+
+      var fetchedPlayer = await database.playerDao.getPlayerById(
+        playerId: testPlayer1.id,
+      );
+      expect(fetchedPlayer.name, 'First Update');
+
+      await database.playerDao.updatePlayerName(
+        playerId: testPlayer1.id,
+        newName: 'Second Update',
+      );
+
+      fetchedPlayer = await database.playerDao.getPlayerById(
+        playerId: testPlayer1.id,
+      );
+      expect(fetchedPlayer.name, 'Second Update');
+
+      await database.playerDao.updatePlayerName(
+        playerId: testPlayer1.id,
+        newName: 'Third Update',
+      );
+
+      fetchedPlayer = await database.playerDao.getPlayerById(
+        playerId: testPlayer1.id,
+      );
+      expect(fetchedPlayer.name, 'Third Update');
+    });
+
+    // Verifies that a player with empty string name is stored correctly.
+    test('Player with empty string name is stored correctly', () async {
+      final emptyNamePlayer = Player(name: '', description: '');
+
+      await database.playerDao.addPlayer(player: emptyNamePlayer);
+
+      final fetchedPlayer = await database.playerDao.getPlayerById(
+        playerId: emptyNamePlayer.id,
+      );
+      expect(fetchedPlayer.name, '');
+    });
+
+    // Verifies that a player with very long name is stored correctly.
+    test('Player with very long name is stored correctly', () async {
+      final longName = 'A' * 1000;
+      final longNamePlayer = Player(name: longName, description: '');
+
+      await database.playerDao.addPlayer(player: longNamePlayer);
+
+      final fetchedPlayer = await database.playerDao.getPlayerById(
+        playerId: longNamePlayer.id,
+      );
+      expect(fetchedPlayer.name, longName);
+    });
+
+    // Verifies that addPlayer returns true on first add.
+    test('addPlayer returns true when player is added successfully', () async {
+      final result = await database.playerDao.addPlayer(player: testPlayer1);
+      expect(result, true);
+
+      final playerExists = await database.playerDao.playerExists(
+        playerId: testPlayer1.id,
+      );
+      expect(playerExists, true);
+    });
+  });
+}

test/db_tests/group_match_test.dart

@@ -1,221 +0,0 @@
-import 'package:clock/clock.dart';
-import 'package:drift/drift.dart' hide isNotNull;
-import 'package:drift/native.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/group.dart';
-import 'package:tallee/data/dto/match.dart';
-import 'package:tallee/data/dto/player.dart';
-
-void main() {
-  late AppDatabase database;
-  late Player testPlayer1;
-  late Player testPlayer2;
-  late Player testPlayer3;
-  late Player testPlayer4;
-  late Player testPlayer5;
-  late Group testGroup1;
-  late Group testGroup2;
-  late Match testMatchWithGroup;
-  late Match testMatchWithPlayers;
-  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
-  final fakeClock = Clock(() => fixedDate);
-
-  setUp(() async {
-    database = AppDatabase(
-      DatabaseConnection(
-        NativeDatabase.memory(),
-        // Recommended for widget tests to avoid test errors.
-        closeStreamsSynchronously: true,
-      ),
-    );
-
-    withClock(fakeClock, () {
-      testPlayer1 = Player(name: 'Alice');
-      testPlayer2 = Player(name: 'Bob');
-      testPlayer3 = Player(name: 'Charlie');
-      testPlayer4 = Player(name: 'Diana');
-      testPlayer5 = Player(name: 'Eve');
-      testGroup1 = Group(
-        name: 'Test Group',
-        members: [testPlayer1, testPlayer2, testPlayer3],
-      );
-      testGroup2 = Group(
-        name: 'Test Group',
-        members: [testPlayer3, testPlayer2],
-      );
-      testMatchWithPlayers = Match(
-        name: 'Test Match with Players',
-        players: [testPlayer4, testPlayer5],
-      );
-      testMatchWithGroup = Match(
-        name: 'Test Match with Group',
-        group: testGroup1,
-      );
-    });
-    await database.playerDao.addPlayersAsList(
-      players: [
-        testPlayer1,
-        testPlayer2,
-        testPlayer3,
-        testPlayer4,
-        testPlayer5,
-      ],
-    );
-    await database.groupDao.addGroupsAsList(groups: [testGroup1, testGroup2]);
-  });
-  tearDown(() async {
-    await database.close();
-  });
-  group('Group-Match Tests', () {
-    test('matchHasGroup() has group works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchWithPlayers);
-      await database.groupDao.addGroup(group: testGroup1);
-
-      var matchHasGroup = await database.groupMatchDao.matchHasGroup(
-        matchId: testMatchWithPlayers.id,
-      );
-
-      expect(matchHasGroup, false);
-
-      await database.groupMatchDao.addGroupToMatch(
-        matchId: testMatchWithPlayers.id,
-        groupId: testGroup1.id,
-      );
-
-      matchHasGroup = await database.groupMatchDao.matchHasGroup(
-        matchId: testMatchWithPlayers.id,
-      );
-
-      expect(matchHasGroup, true);
-    });
-
-    test('Adding a group to a match works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchWithPlayers);
-      await database.groupDao.addGroup(group: testGroup1);
-      await database.groupMatchDao.addGroupToMatch(
-        matchId: testMatchWithPlayers.id,
-        groupId: testGroup1.id,
-      );
-
-      var groupAdded = await database.groupMatchDao.isGroupInMatch(
-        matchId: testMatchWithPlayers.id,
-        groupId: testGroup1.id,
-      );
-      expect(groupAdded, true);
-
-      groupAdded = await database.groupMatchDao.isGroupInMatch(
-        matchId: testMatchWithPlayers.id,
-        groupId: '',
-      );
-      expect(groupAdded, false);
-    });
-
-    test('Removing group from match works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchWithGroup);
-
-      final groupToRemove = testMatchWithGroup.group!;
-
-      final removed = await database.groupMatchDao.removeGroupFromMatch(
-        groupId: groupToRemove.id,
-        matchId: testMatchWithGroup.id,
-      );
-      expect(removed, true);
-
-      final result = await database.matchDao.getMatchById(
-        matchId: testMatchWithGroup.id,
-      );
-      expect(result.group, null);
-    });
-
-    test('Retrieving group of a match works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchWithGroup);
-      final group = await database.groupMatchDao.getGroupOfMatch(
-        matchId: testMatchWithGroup.id,
-      );
-
-      if (group == null) {
-        fail('Group should not be null');
-      }
-
-      expect(group.id, testGroup1.id);
-      expect(group.name, testGroup1.name);
-      expect(group.createdAt, testGroup1.createdAt);
-      expect(group.members.length, testGroup1.members.length);
-      for (int i = 0; i < group.members.length; i++) {
-        expect(group.members[i].id, testGroup1.members[i].id);
-        expect(group.members[i].name, testGroup1.members[i].name);
-        expect(group.members[i].createdAt, testGroup1.members[i].createdAt);
-      }
-    });
-
-    test('Updating the group of a match works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchWithGroup);
-
-      var group = await database.groupMatchDao.getGroupOfMatch(
-        matchId: testMatchWithGroup.id,
-      );
-
-      if (group == null) {
-        fail('Initial group should not be null');
-      } else {
-        expect(group.id, testGroup1.id);
-        expect(group.name, testGroup1.name);
-        expect(group.createdAt, testGroup1.createdAt);
-        expect(group.members.length, testGroup1.members.length);
-      }
-
-      await database.groupDao.addGroup(group: testGroup2);
-      await database.groupMatchDao.updateGroupOfMatch(
-        matchId: testMatchWithGroup.id,
-        newGroupId: testGroup2.id,
-      );
-
-      group = await database.groupMatchDao.getGroupOfMatch(
-        matchId: testMatchWithGroup.id,
-      );
-
-      if (group == null) {
-        fail('Updated group should not be null');
-      } else {
-        expect(group.id, testGroup2.id);
-        expect(group.name, testGroup2.name);
-        expect(group.createdAt, testGroup2.createdAt);
-        expect(group.members.length, testGroup2.members.length);
-        for (int i = 0; i < group.members.length; i++) {
-          expect(group.members[i].id, testGroup2.members[i].id);
-          expect(group.members[i].name, testGroup2.members[i].name);
-          expect(group.members[i].createdAt, testGroup2.members[i].createdAt);
-        }
-      }
-    });
-
-    test('Adding the same group to seperate matches works correctly', () async {
-      final match1 = Match(name: 'Match 1', group: testGroup1);
-      final match2 = Match(name: 'Match 2', group: testGroup1);
-
-      await Future.wait([
-        database.matchDao.addMatch(match: match1),
-        database.matchDao.addMatch(match: match2),
-      ]);
-
-      final group1 = await database.groupMatchDao.getGroupOfMatch(
-        matchId: match1.id,
-      );
-      final group2 = await database.groupMatchDao.getGroupOfMatch(
-        matchId: match2.id,
-      );
-
-      expect(group1, isNotNull);
-      expect(group2, isNotNull);
-
-      final groups = [group1!, group2!];
-      for (final group in groups) {
-        expect(group.members.length, testGroup1.members.length);
-        expect(group.id, testGroup1.id);
-        expect(group.name, testGroup1.name);
-        expect(group.createdAt, testGroup1.createdAt);
-      }
-    });
-  });
-}

test/db_tests/group_test.dart

@@ -1,177 +0,0 @@
-import 'package:clock/clock.dart';
-import 'package:drift/drift.dart';
-import 'package:drift/native.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/group.dart';
-import 'package:tallee/data/dto/player.dart';
-
-void main() {
-  late AppDatabase database;
-  late Player testPlayer1;
-  late Player testPlayer2;
-  late Player testPlayer3;
-  late Player testPlayer4;
-  late Group testGroup1;
-  late Group testGroup2;
-  late Group testGroup3;
-  late Group testGroup4;
-  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
-  final fakeClock = Clock(() => fixedDate);
-
-  setUp(() {
-    database = AppDatabase(
-      DatabaseConnection(
-        NativeDatabase.memory(),
-        // Recommended for widget tests to avoid test errors.
-        closeStreamsSynchronously: true,
-      ),
-    );
-
-    withClock(fakeClock, () {
-      testPlayer1 = Player(name: 'Alice');
-      testPlayer2 = Player(name: 'Bob');
-      testPlayer3 = Player(name: 'Charlie');
-      testPlayer4 = Player(name: 'Diana');
-      testGroup1 = Group(
-        name: 'Test Group',
-        members: [testPlayer1, testPlayer2, testPlayer3],
-      );
-      testGroup2 = Group(
-        id: 'gr2',
-        name: 'Second Group',
-        members: [testPlayer2, testPlayer3, testPlayer4],
-      );
-      testGroup3 = Group(
-        id: 'gr2',
-        name: 'Second Group',
-        members: [testPlayer2, testPlayer4],
-      );
-      testGroup4 = Group(
-        id: 'gr2',
-        name: 'Second Group',
-        members: [testPlayer1, testPlayer2, testPlayer3, testPlayer4],
-      );
-    });
-  });
-  tearDown(() async {
-    await database.close();
-  });
-  group('Group Tests', () {
-    test('Adding and fetching a single group works correctly', () async {
-      await database.groupDao.addGroup(group: testGroup1);
-
-      final fetchedGroup = await database.groupDao.getGroupById(
-        groupId: testGroup1.id,
-      );
-
-      expect(fetchedGroup.id, testGroup1.id);
-      expect(fetchedGroup.name, testGroup1.name);
-      expect(fetchedGroup.createdAt, testGroup1.createdAt);
-
-      expect(fetchedGroup.members.length, testGroup1.members.length);
-      for (int i = 0; i < testGroup1.members.length; i++) {
-        expect(fetchedGroup.members[i].id, testGroup1.members[i].id);
-        expect(fetchedGroup.members[i].name, testGroup1.members[i].name);
-        expect(
-          fetchedGroup.members[i].createdAt,
-          testGroup1.members[i].createdAt,
-        );
-      }
-    });
-
-    test('Adding and fetching multiple groups works correctly', () async {
-      await database.groupDao.addGroupsAsList(
-        groups: [testGroup1, testGroup2, testGroup3, testGroup4],
-      );
-
-      final allGroups = await database.groupDao.getAllGroups();
-      expect(allGroups.length, 2);
-
-      final testGroups = {testGroup1.id: testGroup1, testGroup2.id: testGroup2};
-
-      for (final group in allGroups) {
-        final testGroup = testGroups[group.id]!;
-
-        expect(group.id, testGroup.id);
-        expect(group.name, testGroup.name);
-        expect(group.createdAt, testGroup.createdAt);
-
-        expect(group.members.length, testGroup.members.length);
-        for (int i = 0; i < testGroup.members.length; i++) {
-          expect(group.members[i].id, testGroup.members[i].id);
-          expect(group.members[i].name, testGroup.members[i].name);
-          expect(group.members[i].createdAt, testGroup.members[i].createdAt);
-        }
-      }
-    });
-
-    test('Adding the same group twice does not create duplicates', () async {
-      await database.groupDao.addGroup(group: testGroup1);
-      await database.groupDao.addGroup(group: testGroup1);
-
-      final allGroups = await database.groupDao.getAllGroups();
-      expect(allGroups.length, 1);
-    });
-
-    test('Group existence check works correctly', () async {
-      var groupExists = await database.groupDao.groupExists(
-        groupId: testGroup1.id,
-      );
-      expect(groupExists, false);
-
-      await database.groupDao.addGroup(group: testGroup1);
-
-      groupExists = await database.groupDao.groupExists(groupId: testGroup1.id);
-      expect(groupExists, true);
-    });
-
-    test('Deleting a group works correctly', () async {
-      await database.groupDao.addGroup(group: testGroup1);
-
-      final groupDeleted = await database.groupDao.deleteGroup(
-        groupId: testGroup1.id,
-      );
-      expect(groupDeleted, true);
-
-      final groupExists = await database.groupDao.groupExists(
-        groupId: testGroup1.id,
-      );
-      expect(groupExists, false);
-    });
-
-    test('Updating a group name works correcly', () async {
-      await database.groupDao.addGroup(group: testGroup1);
-
-      const newGroupName = 'new group name';
-
-      await database.groupDao.updateGroupname(
-        groupId: testGroup1.id,
-        newName: newGroupName,
-      );
-
-      final result = await database.groupDao.getGroupById(
-        groupId: testGroup1.id,
-      );
-      expect(result.name, newGroupName);
-    });
-
-    test('Getting the group count works correctly', () async {
-      final initialCount = await database.groupDao.getGroupCount();
-      expect(initialCount, 0);
-
-      await database.groupDao.addGroup(group: testGroup1);
-
-      final groupAdded = await database.groupDao.getGroupCount();
-      expect(groupAdded, 1);
-
-      final groupRemoved = await database.groupDao.deleteGroup(
-        groupId: testGroup1.id,
-      );
-      expect(groupRemoved, true);
-
-      final finalCount = await database.groupDao.getGroupCount();
-      expect(finalCount, 0);
-    });
-  });
-}

test/db_tests/player_group_test.dart

@@ -1,103 +0,0 @@
-import 'package:clock/clock.dart';
-import 'package:drift/drift.dart';
-import 'package:drift/native.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/group.dart';
-import 'package:tallee/data/dto/player.dart';
-
-void main() {
-  late AppDatabase database;
-  late Player testPlayer1;
-  late Player testPlayer2;
-  late Player testPlayer3;
-  late Player testPlayer4;
-  late Group testgroup;
-  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
-  final fakeClock = Clock(() => fixedDate);
-
-  setUp(() {
-    database = AppDatabase(
-      DatabaseConnection(
-        NativeDatabase.memory(),
-        // Recommended for widget tests to avoid test errors.
-        closeStreamsSynchronously: true,
-      ),
-    );
-
-    withClock(fakeClock, () {
-      testPlayer1 = Player(name: 'Alice');
-      testPlayer2 = Player(name: 'Bob');
-      testPlayer3 = Player(name: 'Charlie');
-      testPlayer4 = Player(name: 'Diana');
-      testgroup = Group(
-        name: 'Test Group',
-        members: [testPlayer1, testPlayer2, testPlayer3],
-      );
-    });
-  });
-  tearDown(() async {
-    await database.close();
-  });
-
-  group('Player-Group Tests', () {
-    /// No need to test if group has players since the members attribute is
-    /// not nullable
-
-    test('Adding a player to a group works correctly', () async {
-      await database.groupDao.addGroup(group: testgroup);
-      await database.playerDao.addPlayer(player: testPlayer4);
-      await database.playerGroupDao.addPlayerToGroup(
-        groupId: testgroup.id,
-        player: testPlayer4,
-      );
-
-      var playerAdded = await database.playerGroupDao.isPlayerInGroup(
-        groupId: testgroup.id,
-        playerId: testPlayer4.id,
-      );
-
-      expect(playerAdded, true);
-
-      playerAdded = await database.playerGroupDao.isPlayerInGroup(
-        groupId: testgroup.id,
-        playerId: '',
-      );
-
-      expect(playerAdded, false);
-    });
-
-    test('Removing player from group works correctly', () async {
-      await database.groupDao.addGroup(group: testgroup);
-
-      final playerToRemove = testgroup.members[0];
-
-      final removed = await database.playerGroupDao.removePlayerFromGroup(
-        playerId: playerToRemove.id,
-        groupId: testgroup.id,
-      );
-      expect(removed, true);
-
-      final result = await database.groupDao.getGroupById(
-        groupId: testgroup.id,
-      );
-      expect(result.members.length, testgroup.members.length - 1);
-
-      final playerExists = result.members.any((p) => p.id == playerToRemove.id);
-      expect(playerExists, false);
-    });
-
-    test('Retrieving players of a group works correctly', () async {
-      await database.groupDao.addGroup(group: testgroup);
-      final players = await database.playerGroupDao.getPlayersOfGroup(
-        groupId: testgroup.id,
-      );
-
-      for (int i = 0; i < players.length; i++) {
-        expect(players[i].id, testgroup.members[i].id);
-        expect(players[i].name, testgroup.members[i].name);
-        expect(players[i].createdAt, testgroup.members[i].createdAt);
-      }
-    });
-  });
-}

test/db_tests/player_match_test.dart

@@ -1,237 +0,0 @@
-import 'package:clock/clock.dart';
-import 'package:drift/drift.dart' hide isNotNull;
-import 'package:drift/native.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/group.dart';
-import 'package:tallee/data/dto/match.dart';
-import 'package:tallee/data/dto/player.dart';
-
-void main() {
-  late AppDatabase database;
-  late Player testPlayer1;
-  late Player testPlayer2;
-  late Player testPlayer3;
-  late Player testPlayer4;
-  late Player testPlayer5;
-  late Player testPlayer6;
-  late Group testgroup;
-  late Match testMatchOnlyGroup;
-  late Match testMatchOnlyPlayers;
-  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
-  final fakeClock = Clock(() => fixedDate);
-
-  setUp(() async {
-    database = AppDatabase(
-      DatabaseConnection(
-        NativeDatabase.memory(),
-        // Recommended for widget tests to avoid test errors.
-        closeStreamsSynchronously: true,
-      ),
-    );
-
-    withClock(fakeClock, () {
-      testPlayer1 = Player(name: 'Alice');
-      testPlayer2 = Player(name: 'Bob');
-      testPlayer3 = Player(name: 'Charlie');
-      testPlayer4 = Player(name: 'Diana');
-      testPlayer5 = Player(name: 'Eve');
-      testPlayer6 = Player(name: 'Frank');
-      testgroup = Group(
-        name: 'Test Group',
-        members: [testPlayer1, testPlayer2, testPlayer3],
-      );
-      testMatchOnlyGroup = Match(
-        name: 'Test Match with Group',
-        group: testgroup,
-      );
-      testMatchOnlyPlayers = Match(
-        name: 'Test Match with Players',
-        players: [testPlayer4, testPlayer5, testPlayer6],
-      );
-    });
-    await database.playerDao.addPlayersAsList(
-      players: [
-        testPlayer1,
-        testPlayer2,
-        testPlayer3,
-        testPlayer4,
-        testPlayer5,
-        testPlayer6,
-      ],
-    );
-    await database.groupDao.addGroup(group: testgroup);
-  });
-  tearDown(() async {
-    await database.close();
-  });
-
-  group('Player-Match Tests', () {
-    test('Match has player works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyGroup);
-      await database.playerDao.addPlayer(player: testPlayer1);
-
-      var matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
-        matchId: testMatchOnlyGroup.id,
-      );
-
-      expect(matchHasPlayers, false);
-
-      await database.playerMatchDao.addPlayerToMatch(
-        matchId: testMatchOnlyGroup.id,
-        playerId: testPlayer1.id,
-      );
-
-      matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
-        matchId: testMatchOnlyGroup.id,
-      );
-
-      expect(matchHasPlayers, true);
-    });
-
-    test('Adding a player to a match works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyGroup);
-      await database.playerDao.addPlayer(player: testPlayer5);
-      await database.playerMatchDao.addPlayerToMatch(
-        matchId: testMatchOnlyGroup.id,
-        playerId: testPlayer5.id,
-      );
-
-      var playerAdded = await database.playerMatchDao.isPlayerInMatch(
-        matchId: testMatchOnlyGroup.id,
-        playerId: testPlayer5.id,
-      );
-
-      expect(playerAdded, true);
-
-      playerAdded = await database.playerMatchDao.isPlayerInMatch(
-        matchId: testMatchOnlyGroup.id,
-        playerId: '',
-      );
-
-      expect(playerAdded, false);
-    });
-
-    test('Removing player from match works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
-
-      final playerToRemove = testMatchOnlyPlayers.players![0];
-
-      final removed = await database.playerMatchDao.removePlayerFromMatch(
-        playerId: playerToRemove.id,
-        matchId: testMatchOnlyPlayers.id,
-      );
-      expect(removed, true);
-
-      final result = await database.matchDao.getMatchById(
-        matchId: testMatchOnlyPlayers.id,
-      );
-      expect(result.players!.length, testMatchOnlyPlayers.players!.length - 1);
-
-      final playerExists = result.players!.any(
-        (p) => p.id == playerToRemove.id,
-      );
-      expect(playerExists, false);
-    });
-
-    test('Retrieving players of a match works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
-      final players = await database.playerMatchDao.getPlayersOfMatch(
-        matchId: testMatchOnlyPlayers.id,
-      );
-
-      if (players == null) {
-        fail('Players should not be null');
-      }
-
-      for (int i = 0; i < players.length; i++) {
-        expect(players[i].id, testMatchOnlyPlayers.players![i].id);
-        expect(players[i].name, testMatchOnlyPlayers.players![i].name);
-        expect(
-          players[i].createdAt,
-          testMatchOnlyPlayers.players![i].createdAt,
-        );
-      }
-    });
-
-    test('Updating the match players works coreclty', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
-
-      final newPlayers = [testPlayer1, testPlayer2, testPlayer4];
-      await database.playerDao.addPlayersAsList(players: newPlayers);
-
-      // First, remove all existing players
-      final existingPlayers = await database.playerMatchDao.getPlayersOfMatch(
-        matchId: testMatchOnlyPlayers.id,
-      );
-
-      if (existingPlayers == null || existingPlayers.isEmpty) {
-        fail('Existing players should not be null or empty');
-      }
-
-      await database.playerMatchDao.updatePlayersFromMatch(
-        matchId: testMatchOnlyPlayers.id,
-        newPlayer: newPlayers,
-      );
-
-      final updatedPlayers = await database.playerMatchDao.getPlayersOfMatch(
-        matchId: testMatchOnlyPlayers.id,
-      );
-
-      if (updatedPlayers == null) {
-        fail('Updated players should not be null');
-      }
-
-      expect(updatedPlayers.length, newPlayers.length);
-
-      /// Create a map of new players for easy lookup
-      final testPlayers = {for (var p in newPlayers) p.id: p};
-
-      /// Verify each updated player matches the new players
-      for (final player in updatedPlayers) {
-        final testPlayer = testPlayers[player.id]!;
-
-        expect(player.id, testPlayer.id);
-        expect(player.name, testPlayer.name);
-        expect(player.createdAt, testPlayer.createdAt);
-      }
-    });
-
-    test(
-      'Adding the same player to seperate matches works correctly',
-      () async {
-        final playersList = [testPlayer1, testPlayer2, testPlayer3];
-        final match1 = Match(name: 'Match 1', players: playersList);
-        final match2 = Match(name: 'Match 2', players: playersList);
-
-        await Future.wait([
-          database.matchDao.addMatch(match: match1),
-          database.matchDao.addMatch(match: match2),
-        ]);
-
-        final players1 = await database.playerMatchDao.getPlayersOfMatch(
-          matchId: match1.id,
-        );
-        final players2 = await database.playerMatchDao.getPlayersOfMatch(
-          matchId: match2.id,
-        );
-
-        expect(players1, isNotNull);
-        expect(players2, isNotNull);
-
-        expect(
-          players1!.map((p) => p.id).toList(),
-          equals(players2!.map((p) => p.id).toList()),
-        );
-        expect(
-          players1.map((p) => p.name).toList(),
-          equals(players2.map((p) => p.name).toList()),
-        );
-        expect(
-          players1.map((p) => p.createdAt).toList(),
-          equals(players2.map((p) => p.createdAt).toList()),
-        );
-      },
-    );
-  });
-}

test/db_tests/player_test.dart

@@ -1,159 +0,0 @@
-import 'package:clock/clock.dart';
-import 'package:drift/drift.dart';
-import 'package:drift/native.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/player.dart';
-
-void main() {
-  late AppDatabase database;
-  late Player testPlayer1;
-  late Player testPlayer2;
-  late Player testPlayer3;
-  late Player testPlayer4;
-  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
-  final fakeClock = Clock(() => fixedDate);
-
-  setUp(() {
-    database = AppDatabase(
-      DatabaseConnection(
-        NativeDatabase.memory(),
-        // Recommended for widget tests to avoid test errors.
-        closeStreamsSynchronously: true,
-      ),
-    );
-
-    withClock(fakeClock, () {
-      testPlayer1 = Player(name: 'Test Player');
-      testPlayer2 = Player(name: 'Second Player');
-      testPlayer3 = Player(name: 'Charlie');
-      testPlayer4 = Player(name: 'Diana');
-    });
-  });
-  tearDown(() async {
-    await database.close();
-  });
-
-  group('Player Tests', () {
-    test('Adding and fetching single player works correctly', () async {
-      await database.playerDao.addPlayer(player: testPlayer1);
-      await database.playerDao.addPlayer(player: testPlayer2);
-
-      final allPlayers = await database.playerDao.getAllPlayers();
-      expect(allPlayers.length, 2);
-
-      final fetchedPlayer1 = allPlayers.firstWhere(
-        (g) => g.id == testPlayer1.id,
-      );
-      expect(fetchedPlayer1.name, testPlayer1.name);
-      expect(fetchedPlayer1.createdAt, testPlayer1.createdAt);
-
-      final fetchedPlayer2 = allPlayers.firstWhere(
-        (g) => g.id == testPlayer2.id,
-      );
-      expect(fetchedPlayer2.name, testPlayer2.name);
-      expect(fetchedPlayer2.createdAt, testPlayer2.createdAt);
-    });
-
-    test('Adding and fetching multiple players works correctly', () async {
-      await database.playerDao.addPlayersAsList(
-        players: [testPlayer1, testPlayer2, testPlayer3, testPlayer4],
-      );
-
-      final allPlayers = await database.playerDao.getAllPlayers();
-      expect(allPlayers.length, 4);
-
-      // Map for connencting fetched players with expected players
-      final testPlayers = {
-        testPlayer1.id: testPlayer1,
-        testPlayer2.id: testPlayer2,
-        testPlayer3.id: testPlayer3,
-        testPlayer4.id: testPlayer4,
-      };
-
-      for (final player in allPlayers) {
-        final testPlayer = testPlayers[player.id]!;
-
-        expect(player.id, testPlayer.id);
-        expect(player.name, testPlayer.name);
-        expect(player.createdAt, testPlayer.createdAt);
-      }
-    });
-
-    test('Adding the same player twice does not create duplicates', () async {
-      await database.playerDao.addPlayer(player: testPlayer1);
-      await database.playerDao.addPlayer(player: testPlayer1);
-
-      final allPlayers = await database.playerDao.getAllPlayers();
-      expect(allPlayers.length, 1);
-    });
-
-    test('Player existence check works correctly', () async {
-      var playerExists = await database.playerDao.playerExists(
-        playerId: testPlayer1.id,
-      );
-      expect(playerExists, false);
-
-      await database.playerDao.addPlayer(player: testPlayer1);
-
-      playerExists = await database.playerDao.playerExists(
-        playerId: testPlayer1.id,
-      );
-      expect(playerExists, true);
-    });
-
-    test('Deleting a player works correctly', () async {
-      await database.playerDao.addPlayer(player: testPlayer1);
-      final playerDeleted = await database.playerDao.deletePlayer(
-        playerId: testPlayer1.id,
-      );
-      expect(playerDeleted, true);
-
-      final playerExists = await database.playerDao.playerExists(
-        playerId: testPlayer1.id,
-      );
-      expect(playerExists, false);
-    });
-
-    test('Updating a player name works correcly', () async {
-      await database.playerDao.addPlayer(player: testPlayer1);
-
-      const newPlayerName = 'new player name';
-
-      await database.playerDao.updatePlayername(
-        playerId: testPlayer1.id,
-        newName: newPlayerName,
-      );
-
-      final result = await database.playerDao.getPlayerById(
-        playerId: testPlayer1.id,
-      );
-      expect(result.name, newPlayerName);
-    });
-
-    test('Getting the player count works correctly', () async {
-      var playerCount = await database.playerDao.getPlayerCount();
-      expect(playerCount, 0);
-
-      await database.playerDao.addPlayer(player: testPlayer1);
-
-      playerCount = await database.playerDao.getPlayerCount();
-      expect(playerCount, 1);
-
-      await database.playerDao.addPlayer(player: testPlayer2);
-
-      playerCount = await database.playerDao.getPlayerCount();
-      expect(playerCount, 2);
-
-      await database.playerDao.deletePlayer(playerId: testPlayer1.id);
-
-      playerCount = await database.playerDao.getPlayerCount();
-      expect(playerCount, 1);
-
-      await database.playerDao.deletePlayer(playerId: testPlayer2.id);
-
-      playerCount = await database.playerDao.getPlayerCount();
-      expect(playerCount, 0);
-    });
-  });
-}

test/db_tests/relationships/player_group_test.dart

@@ -0,0 +1,342 @@
+import 'package:clock/clock.dart';
+import 'package:drift/drift.dart';
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/dto/player.dart';
+
+void main() {
+  late AppDatabase database;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Player testPlayer4;
+  late Group testGroup;
+  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
+
+  setUp(() {
+    database = AppDatabase(
+      DatabaseConnection(
+        NativeDatabase.memory(),
+        // Recommended for widget tests to avoid test errors.
+        closeStreamsSynchronously: true,
+      ),
+    );
+
+    withClock(fakeClock, () {
+      testPlayer1 = Player(name: 'Alice', description: '');
+      testPlayer2 = Player(name: 'Bob', description: '');
+      testPlayer3 = Player(name: 'Charlie', description: '');
+      testPlayer4 = Player(name: 'Diana', description: '');
+      testGroup = Group(
+        name: 'Test Group',
+        description: '',
+        members: [testPlayer1, testPlayer2, testPlayer3],
+      );
+    });
+  });
+  tearDown(() async {
+    await database.close();
+  });
+
+  group('Player-Group Tests', () {
+
+    // Verifies that a player can be added to an existing group and isPlayerInGroup returns true.
+    test('Adding a player to a group works correctly', () async {
+      await database.groupDao.addGroup(group: testGroup);
+      await database.playerDao.addPlayer(player: testPlayer4);
+      await database.playerGroupDao.addPlayerToGroup(
+        groupId: testGroup.id,
+        player: testPlayer4,
+      );
+
+      var playerAdded = await database.playerGroupDao.isPlayerInGroup(
+        groupId: testGroup.id,
+        playerId: testPlayer4.id,
+      );
+
+      expect(playerAdded, true);
+
+      playerAdded = await database.playerGroupDao.isPlayerInGroup(
+        groupId: testGroup.id,
+        playerId: '',
+      );
+
+      expect(playerAdded, false);
+    });
+
+    // Verifies that a player can be removed from a group and the group's member count decreases.
+    test('Removing player from group works correctly', () async {
+      await database.groupDao.addGroup(group: testGroup);
+
+      final playerToRemove = testGroup.members[0];
+
+      final removed = await database.playerGroupDao.removePlayerFromGroup(
+        playerId: playerToRemove.id,
+        groupId: testGroup.id,
+      );
+      expect(removed, true);
+
+      final result = await database.groupDao.getGroupById(
+        groupId: testGroup.id,
+      );
+      expect(result.members.length, testGroup.members.length - 1);
+
+      final playerExists = result.members.any((p) => p.id == playerToRemove.id);
+      expect(playerExists, false);
+    });
+
+    // Verifies that getPlayersOfGroup returns all members of a group with correct data.
+    test('Retrieving players of a group works correctly', () async {
+      await database.groupDao.addGroup(group: testGroup);
+      final players = await database.playerGroupDao.getPlayersOfGroup(
+        groupId: testGroup.id,
+      );
+
+      for (int i = 0; i < players.length; i++) {
+        expect(players[i].id, testGroup.members[i].id);
+        expect(players[i].name, testGroup.members[i].name);
+        expect(players[i].createdAt, testGroup.members[i].createdAt);
+      }
+    });
+
+    // Verifies that isPlayerInGroup returns false for non-existent player.
+    test('isPlayerInGroup returns false for non-existent player', () async {
+      await database.groupDao.addGroup(group: testGroup);
+
+      final result = await database.playerGroupDao.isPlayerInGroup(
+        playerId: 'non-existent-player-id',
+        groupId: testGroup.id,
+      );
+
+      expect(result, false);
+    });
+
+    // Verifies that isPlayerInGroup returns false for non-existent group.
+    test('isPlayerInGroup returns false for non-existent group', () async {
+      await database.playerDao.addPlayer(player: testPlayer1);
+
+      final result = await database.playerGroupDao.isPlayerInGroup(
+        playerId: testPlayer1.id,
+        groupId: 'non-existent-group-id',
+      );
+
+      expect(result, false);
+    });
+
+    // Verifies that addPlayerToGroup returns false when player already in group.
+    test('addPlayerToGroup returns false when player already in group', () async {
+      await database.groupDao.addGroup(group: testGroup);
+
+      // testPlayer1 is already in testGroup via group creation
+      final result = await database.playerGroupDao.addPlayerToGroup(
+        player: testPlayer1,
+        groupId: testGroup.id,
+      );
+
+      expect(result, false);
+    });
+
+    // Verifies that addPlayerToGroup adds player to player table if not exists.
+    test('addPlayerToGroup adds player to player table if not exists', () async {
+      await database.groupDao.addGroup(group: testGroup);
+
+      // testPlayer4 is not in the database yet
+      var playerExists = await database.playerDao.playerExists(
+        playerId: testPlayer4.id,
+      );
+      expect(playerExists, false);
+
+      await database.playerGroupDao.addPlayerToGroup(
+        player: testPlayer4,
+        groupId: testGroup.id,
+      );
+
+      // Now player should exist in player table
+      playerExists = await database.playerDao.playerExists(
+        playerId: testPlayer4.id,
+      );
+      expect(playerExists, true);
+    });
+
+    // Verifies that removePlayerFromGroup returns false for non-existent player.
+    test('removePlayerFromGroup returns false for non-existent player', () async {
+      await database.groupDao.addGroup(group: testGroup);
+
+      final result = await database.playerGroupDao.removePlayerFromGroup(
+        playerId: 'non-existent-player-id',
+        groupId: testGroup.id,
+      );
+
+      expect(result, false);
+    });
+
+    // Verifies that removePlayerFromGroup returns false for non-existent group.
+    test('removePlayerFromGroup returns false for non-existent group', () async {
+      await database.playerDao.addPlayer(player: testPlayer1);
+
+      final result = await database.playerGroupDao.removePlayerFromGroup(
+        playerId: testPlayer1.id,
+        groupId: 'non-existent-group-id',
+      );
+
+      expect(result, false);
+    });
+
+    // Verifies that getPlayersOfGroup returns empty list for group with no members.
+    test('getPlayersOfGroup returns empty list for empty group', () async {
+      final emptyGroup = Group(name: 'Empty Group', description: '', members: []);
+      await database.groupDao.addGroup(group: emptyGroup);
+
+      final players = await database.playerGroupDao.getPlayersOfGroup(
+        groupId: emptyGroup.id,
+      );
+
+      expect(players, isEmpty);
+    });
+
+    // Verifies that getPlayersOfGroup returns empty list for non-existent group.
+    test('getPlayersOfGroup returns empty list for non-existent group', () async {
+      final players = await database.playerGroupDao.getPlayersOfGroup(
+        groupId: 'non-existent-group-id',
+      );
+
+      expect(players, isEmpty);
+    });
+
+    // Verifies that removing all players from a group leaves the group empty.
+    test('Removing all players from a group leaves group empty', () async {
+      await database.groupDao.addGroup(group: testGroup);
+
+      for (final player in testGroup.members) {
+        await database.playerGroupDao.removePlayerFromGroup(
+          playerId: player.id,
+          groupId: testGroup.id,
+        );
+      }
+
+      final players = await database.playerGroupDao.getPlayersOfGroup(
+        groupId: testGroup.id,
+      );
+      expect(players, isEmpty);
+
+      // Group should still exist
+      final groupExists = await database.groupDao.groupExists(
+        groupId: testGroup.id,
+      );
+      expect(groupExists, true);
+    });
+
+    // Verifies that a player can be in multiple groups.
+    test('Player can be in multiple groups', () async {
+      final secondGroup = Group(name: 'Second Group', description: '', members: []);
+      await database.groupDao.addGroup(group: testGroup);
+      await database.groupDao.addGroup(group: secondGroup);
+
+      // Add testPlayer1 to second group (already in testGroup)
+      await database.playerGroupDao.addPlayerToGroup(
+        player: testPlayer1,
+        groupId: secondGroup.id,
+      );
+
+      final inFirstGroup = await database.playerGroupDao.isPlayerInGroup(
+        playerId: testPlayer1.id,
+        groupId: testGroup.id,
+      );
+      final inSecondGroup = await database.playerGroupDao.isPlayerInGroup(
+        playerId: testPlayer1.id,
+        groupId: secondGroup.id,
+      );
+
+      expect(inFirstGroup, true);
+      expect(inSecondGroup, true);
+    });
+
+    // Verifies that removing player from one group doesn't affect other groups.
+    test('Removing player from one group does not affect other groups', () async {
+      final secondGroup = Group(name: 'Second Group', description: '', members: [testPlayer1]);
+      await database.groupDao.addGroup(group: testGroup);
+      await database.groupDao.addGroup(group: secondGroup);
+
+      // Remove testPlayer1 from testGroup
+      await database.playerGroupDao.removePlayerFromGroup(
+        playerId: testPlayer1.id,
+        groupId: testGroup.id,
+      );
+
+      final inFirstGroup = await database.playerGroupDao.isPlayerInGroup(
+        playerId: testPlayer1.id,
+        groupId: testGroup.id,
+      );
+      final inSecondGroup = await database.playerGroupDao.isPlayerInGroup(
+        playerId: testPlayer1.id,
+        groupId: secondGroup.id,
+      );
+
+      expect(inFirstGroup, false);
+      expect(inSecondGroup, true);
+    });
+
+    // Verifies that addPlayerToGroup returns true on successful addition.
+    test('addPlayerToGroup returns true on successful addition', () async {
+      await database.groupDao.addGroup(group: testGroup);
+      await database.playerDao.addPlayer(player: testPlayer4);
+
+      final result = await database.playerGroupDao.addPlayerToGroup(
+        player: testPlayer4,
+        groupId: testGroup.id,
+      );
+
+      expect(result, true);
+    });
+
+    // Verifies that removing the same player twice returns false on second attempt.
+    test('Removing same player twice returns false on second attempt', () async {
+      await database.groupDao.addGroup(group: testGroup);
+
+      final firstRemoval = await database.playerGroupDao.removePlayerFromGroup(
+        playerId: testPlayer1.id,
+        groupId: testGroup.id,
+      );
+      expect(firstRemoval, true);
+
+      final secondRemoval = await database.playerGroupDao.removePlayerFromGroup(
+        playerId: testPlayer1.id,
+        groupId: testGroup.id,
+      );
+      expect(secondRemoval, false);
+    });
+
+    // Verifies that replaceGroupPlayers removes all existing players and replaces with new list.
+    test('replaceGroupPlayers replaces all group members correctly', () async {
+      // Create initial group with 3 players
+      await database.groupDao.addGroup(group: testGroup);
+
+      // Verify initial members
+      var groupMembers = await database.groupDao.getGroupById(
+        groupId: testGroup.id,
+      );
+      expect(groupMembers.members.length, 3);
+
+      // Replace with new list containing 2 different players
+      final newPlayersList = [testPlayer3, testPlayer4];
+      await database.groupDao.replaceGroupPlayers(
+        groupId: testGroup.id,
+        newPlayers: newPlayersList,
+      );
+
+      // Get updated group and verify members
+      groupMembers = await database.groupDao.getGroupById(
+        groupId: testGroup.id,
+      );
+
+      expect(groupMembers.members.length, 2);
+      expect(groupMembers.members.any((p) => p.id == testPlayer3.id), true);
+      expect(groupMembers.members.any((p) => p.id == testPlayer4.id), true);
+      expect(groupMembers.members.any((p) => p.id == testPlayer1.id), false);
+      expect(groupMembers.members.any((p) => p.id == testPlayer2.id), false);
+    });
+  });
+}

test/db_tests/relationships/player_match_test.dart

@@ -0,0 +1,961 @@
+import 'package:clock/clock.dart';
+import 'package:drift/drift.dart' hide isNotNull, isNull;
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/dto/team.dart';
+
+void main() {
+  late AppDatabase database;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Player testPlayer4;
+  late Player testPlayer5;
+  late Player testPlayer6;
+  late Group testGroup;
+  late Game testGame;
+  late Match testMatchOnlyGroup;
+  late Match testMatchOnlyPlayers;
+  late Team testTeam1;
+  late Team testTeam2;
+  final fixedDate = DateTime(2025, 11, 19, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
+
+  setUp(() async {
+    database = AppDatabase(
+      DatabaseConnection(
+        NativeDatabase.memory(),
+        // Recommended for widget tests to avoid test errors.
+        closeStreamsSynchronously: true,
+      ),
+    );
+
+    withClock(fakeClock, () {
+      testPlayer1 = Player(name: 'Alice', description: '');
+      testPlayer2 = Player(name: 'Bob', description: '');
+      testPlayer3 = Player(name: 'Charlie', description: '');
+      testPlayer4 = Player(name: 'Diana', description: '');
+      testPlayer5 = Player(name: 'Eve', description: '');
+      testPlayer6 = Player(name: 'Frank', description: '');
+      testGroup = Group(
+        name: 'Test Group',
+        description: '',
+        members: [testPlayer1, testPlayer2, testPlayer3],
+      );
+      testGame = Game(
+        name: 'Test Game',
+        ruleset: Ruleset.singleWinner,
+        description: 'A test game',
+        color: GameColor.blue,
+      );
+      testMatchOnlyGroup = Match(
+        name: 'Test Match with Group',
+        game: testGame,
+        group: testGroup,
+        notes: '',
+      );
+      testMatchOnlyPlayers = Match(
+        name: 'Test Match with Players',
+        game: testGame,
+        players: [testPlayer4, testPlayer5, testPlayer6],
+        notes: '',
+      );
+      testTeam1 = Team(name: 'Team Alpha', members: [testPlayer1, testPlayer2]);
+      testTeam2 = Team(name: 'Team Beta', members: [testPlayer3, testPlayer4]);
+    });
+    await database.playerDao.addPlayersAsList(
+      players: [
+        testPlayer1,
+        testPlayer2,
+        testPlayer3,
+        testPlayer4,
+        testPlayer5,
+        testPlayer6,
+      ],
+    );
+    await database.groupDao.addGroup(group: testGroup);
+    await database.gameDao.addGame(game: testGame);
+  });
+  tearDown(() async {
+    await database.close();
+  });
+
+  group('Player-Match Tests', () {
+    // Verifies that matchHasPlayers returns false initially and true after adding a player.
+    test('Match has player works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+      await database.playerDao.addPlayer(player: testPlayer1);
+
+      var matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
+        matchId: testMatchOnlyGroup.id,
+      );
+
+      expect(matchHasPlayers, false);
+
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+      );
+
+      matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
+        matchId: testMatchOnlyGroup.id,
+      );
+
+      expect(matchHasPlayers, true);
+    });
+
+    // Verifies that a player can be added to a match and isPlayerInMatch returns true.
+    test('Adding a player to a match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+      await database.playerDao.addPlayer(player: testPlayer5);
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer5.id,
+      );
+
+      var playerAdded = await database.playerMatchDao.isPlayerInMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer5.id,
+      );
+
+      expect(playerAdded, true);
+
+      playerAdded = await database.playerMatchDao.isPlayerInMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: '',
+      );
+
+      expect(playerAdded, false);
+    });
+
+    // Verifies that a player can be removed from a match and the player count decreases.
+    test('Removing player from match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+      final playerToRemove = testMatchOnlyPlayers.players[0];
+
+      final removed = await database.playerMatchDao.removePlayerFromMatch(
+        playerId: playerToRemove.id,
+        matchId: testMatchOnlyPlayers.id,
+      );
+      expect(removed, true);
+
+      final result = await database.matchDao.getMatchById(
+        matchId: testMatchOnlyPlayers.id,
+      );
+      expect(result.players.length, testMatchOnlyPlayers.players.length - 1);
+
+      final playerExists = result.players.any((p) => p.id == playerToRemove.id);
+      expect(playerExists, false);
+    });
+
+    // Verifies that getPlayersOfMatch returns all players of a match with correct data.
+    test('Retrieving players of a match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+      final players =
+          await database.playerMatchDao.getPlayersOfMatch(
+            matchId: testMatchOnlyPlayers.id,
+          ) ??
+          [];
+
+      for (int i = 0; i < players.length; i++) {
+        expect(players[i].id, testMatchOnlyPlayers.players[i].id);
+        expect(players[i].name, testMatchOnlyPlayers.players[i].name);
+        expect(players[i].createdAt, testMatchOnlyPlayers.players[i].createdAt);
+      }
+    });
+
+    // Verifies that updatePlayersFromMatch replaces all existing players with new ones.
+    test('Updating the match players works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+      final newPlayers = [testPlayer1, testPlayer2, testPlayer4];
+      await database.playerDao.addPlayersAsList(players: newPlayers);
+
+      // First, remove all existing players
+      final existingPlayers = await database.playerMatchDao.getPlayersOfMatch(
+        matchId: testMatchOnlyPlayers.id,
+      );
+
+      if (existingPlayers == null || existingPlayers.isEmpty) {
+        fail('Existing players should not be null or empty');
+      }
+
+      await database.playerMatchDao.updatePlayersFromMatch(
+        matchId: testMatchOnlyPlayers.id,
+        newPlayer: newPlayers,
+      );
+
+      final updatedPlayers = await database.playerMatchDao.getPlayersOfMatch(
+        matchId: testMatchOnlyPlayers.id,
+      );
+
+      if (updatedPlayers == null) {
+        fail('Updated players should not be null');
+      }
+
+      expect(updatedPlayers.length, newPlayers.length);
+
+      /// Create a map of new players for easy lookup
+      final testPlayers = {for (var p in newPlayers) p.id: p};
+
+      /// Verify each updated player matches the new players
+      for (final player in updatedPlayers) {
+        final testPlayer = testPlayers[player.id]!;
+
+        expect(player.id, testPlayer.id);
+        expect(player.name, testPlayer.name);
+        expect(player.createdAt, testPlayer.createdAt);
+      }
+    });
+
+    // Verifies that the same player can be added to multiple different matches.
+    test(
+      'Adding the same player to separate matches works correctly',
+      () async {
+        final playersList = [testPlayer1, testPlayer2, testPlayer3];
+        final match1 = Match(
+          name: 'Match 1',
+          game: testGame,
+          players: playersList,
+          notes: '',
+        );
+        final match2 = Match(
+          name: 'Match 2',
+          game: testGame,
+          players: playersList,
+          notes: '',
+        );
+
+        await Future.wait([
+          database.matchDao.addMatch(match: match1),
+          database.matchDao.addMatch(match: match2),
+        ]);
+
+        final players1 = await database.playerMatchDao.getPlayersOfMatch(
+          matchId: match1.id,
+        );
+        final players2 = await database.playerMatchDao.getPlayersOfMatch(
+          matchId: match2.id,
+        );
+
+        expect(players1, isNotNull);
+        expect(players2, isNotNull);
+
+        expect(
+          players1!.map((p) => p.id).toList(),
+          equals(players2!.map((p) => p.id).toList()),
+        );
+        expect(
+          players1.map((p) => p.name).toList(),
+          equals(players2.map((p) => p.name).toList()),
+        );
+        expect(
+          players1.map((p) => p.createdAt).toList(),
+          equals(players2.map((p) => p.createdAt).toList()),
+        );
+      },
+    );
+
+    // Verifies that getPlayersOfMatch returns null for a non-existent match.
+    test('getPlayersOfMatch returns null for non-existent match', () async {
+      final players = await database.playerMatchDao.getPlayersOfMatch(
+        matchId: 'non-existent-match-id',
+      );
+
+      expect(players, isNull);
+    });
+
+    // Verifies that adding a player with initial score works correctly.
+    test('Adding player with initial score works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+        score: 100,
+      );
+
+      final score = await database.playerMatchDao.getPlayerScore(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+      );
+
+      expect(score, 100);
+    });
+
+    // Verifies that getPlayerScore returns the correct score.
+    test('getPlayerScore returns correct score', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+      // Default score should be 0 when added through match
+      final score = await database.playerMatchDao.getPlayerScore(
+        matchId: testMatchOnlyPlayers.id,
+        playerId: testPlayer4.id,
+      );
+
+      expect(score, 0);
+    });
+
+    // Verifies that getPlayerScore returns null for non-existent player-match combination.
+    test(
+      'getPlayerScore returns null for non-existent player in match',
+      () async {
+        await database.matchDao.addMatch(match: testMatchOnlyGroup);
+
+        final score = await database.playerMatchDao.getPlayerScore(
+          matchId: testMatchOnlyGroup.id,
+          playerId: 'non-existent-player-id',
+        );
+
+        expect(score, isNull);
+      },
+    );
+
+    // Verifies that updatePlayerScore updates the score correctly.
+    test('updatePlayerScore updates score correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+      final updated = await database.playerMatchDao.updatePlayerScore(
+        matchId: testMatchOnlyPlayers.id,
+        playerId: testPlayer4.id,
+        newScore: 50,
+      );
+
+      expect(updated, true);
+
+      final score = await database.playerMatchDao.getPlayerScore(
+        matchId: testMatchOnlyPlayers.id,
+        playerId: testPlayer4.id,
+      );
+
+      expect(score, 50);
+    });
+
+    // Verifies that updatePlayerScore returns false for non-existent player-match.
+    test(
+      'updatePlayerScore returns false for non-existent player-match',
+      () async {
+        await database.matchDao.addMatch(match: testMatchOnlyGroup);
+
+        final updated = await database.playerMatchDao.updatePlayerScore(
+          matchId: testMatchOnlyGroup.id,
+          playerId: 'non-existent-player-id',
+          newScore: 50,
+        );
+
+        expect(updated, false);
+      },
+    );
+
+    // Verifies that adding a player with teamId works correctly.
+    test('Adding player with teamId works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+      await database.teamDao.addTeam(team: testTeam1);
+
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+        teamId: testTeam1.id,
+      );
+
+      final playersInTeam = await database.playerMatchDao.getPlayersInTeam(
+        matchId: testMatchOnlyGroup.id,
+        teamId: testTeam1.id,
+      );
+
+      expect(playersInTeam.length, 1);
+      expect(playersInTeam[0].id, testPlayer1.id);
+    });
+
+    // Verifies that updatePlayerTeam updates the team correctly.
+    test('updatePlayerTeam updates team correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+      await database.teamDao.addTeam(team: testTeam1);
+      await database.teamDao.addTeam(team: testTeam2);
+
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+        teamId: testTeam1.id,
+      );
+
+      // Update player's team
+      final updated = await database.playerMatchDao.updatePlayerTeam(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+        teamId: testTeam2.id,
+      );
+
+      expect(updated, true);
+
+      // Verify player is now in testTeam2
+      final playersInTeam2 = await database.playerMatchDao.getPlayersInTeam(
+        matchId: testMatchOnlyGroup.id,
+        teamId: testTeam2.id,
+      );
+
+      expect(playersInTeam2.length, 1);
+      expect(playersInTeam2[0].id, testPlayer1.id);
+
+      // Verify player is no longer in testTeam1
+      final playersInTeam1 = await database.playerMatchDao.getPlayersInTeam(
+        matchId: testMatchOnlyGroup.id,
+        teamId: testTeam1.id,
+      );
+
+      expect(playersInTeam1.isEmpty, true);
+    });
+
+    // Verifies that updatePlayerTeam can set team to null.
+    test('updatePlayerTeam can remove player from team', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+      await database.teamDao.addTeam(team: testTeam1);
+
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+        teamId: testTeam1.id,
+      );
+
+      // Remove player from team by setting teamId to null
+      final updated = await database.playerMatchDao.updatePlayerTeam(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+        teamId: null,
+      );
+
+      expect(updated, true);
+
+      final playersInTeam = await database.playerMatchDao.getPlayersInTeam(
+        matchId: testMatchOnlyGroup.id,
+        teamId: testTeam1.id,
+      );
+
+      expect(playersInTeam.isEmpty, true);
+    });
+
+    // Verifies that updatePlayerTeam returns false for non-existent player-match.
+    test(
+      'updatePlayerTeam returns false for non-existent player-match',
+      () async {
+        await database.matchDao.addMatch(match: testMatchOnlyGroup);
+
+        final updated = await database.playerMatchDao.updatePlayerTeam(
+          matchId: testMatchOnlyGroup.id,
+          playerId: 'non-existent-player-id',
+          teamId: testTeam1.id,
+        );
+
+        expect(updated, false);
+      },
+    );
+
+    // Verifies that getPlayersInTeam returns empty list for non-existent team.
+    test('getPlayersInTeam returns empty list for non-existent team', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+      final players = await database.playerMatchDao.getPlayersInTeam(
+        matchId: testMatchOnlyPlayers.id,
+        teamId: 'non-existent-team-id',
+      );
+
+      expect(players.isEmpty, true);
+    });
+
+    // Verifies that getPlayersInTeam returns all players of a team.
+    test('getPlayersInTeam returns all players of a team', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+      await database.teamDao.addTeam(team: testTeam1);
+
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+        teamId: testTeam1.id,
+      );
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer2.id,
+        teamId: testTeam1.id,
+      );
+
+      final playersInTeam = await database.playerMatchDao.getPlayersInTeam(
+        matchId: testMatchOnlyGroup.id,
+        teamId: testTeam1.id,
+      );
+
+      expect(playersInTeam.length, 2);
+      final playerIds = playersInTeam.map((p) => p.id).toSet();
+      expect(playerIds.contains(testPlayer1.id), true);
+      expect(playerIds.contains(testPlayer2.id), true);
+    });
+
+    // Verifies that removePlayerFromMatch returns false for non-existent player.
+    test(
+      'removePlayerFromMatch returns false for non-existent player',
+      () async {
+        await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+        final removed = await database.playerMatchDao.removePlayerFromMatch(
+          playerId: 'non-existent-player-id',
+          matchId: testMatchOnlyPlayers.id,
+        );
+
+        expect(removed, false);
+      },
+    );
+
+    // Verifies that adding the same player twice to the same match is ignored.
+    test('Adding same player twice to same match is ignored', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+        score: 10,
+      );
+
+      // Try to add the same player again with different score
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+        score: 100,
+      );
+
+      // Score should still be 10 because insert was ignored
+      final score = await database.playerMatchDao.getPlayerScore(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+      );
+
+      expect(score, 10);
+
+      // Verify player count is still 1
+      final players = await database.playerMatchDao.getPlayersOfMatch(
+        matchId: testMatchOnlyGroup.id,
+      );
+
+      expect(players?.length, 1);
+    });
+
+    // Verifies that updatePlayersFromMatch with empty list removes all players.
+    test(
+      'updatePlayersFromMatch with empty list removes all players',
+      () async {
+        await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+        // Verify players exist initially
+        var players = await database.playerMatchDao.getPlayersOfMatch(
+          matchId: testMatchOnlyPlayers.id,
+        );
+        expect(players?.length, 3);
+
+        // Update with empty list
+        await database.playerMatchDao.updatePlayersFromMatch(
+          matchId: testMatchOnlyPlayers.id,
+          newPlayer: [],
+        );
+
+        // Verify all players are removed
+        players = await database.playerMatchDao.getPlayersOfMatch(
+          matchId: testMatchOnlyPlayers.id,
+        );
+        expect(players, isNull);
+      },
+    );
+
+    // Verifies that updatePlayersFromMatch with same players makes no changes.
+    test('updatePlayersFromMatch with same players makes no changes', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+      final originalPlayers = [testPlayer4, testPlayer5, testPlayer6];
+
+      await database.playerMatchDao.updatePlayersFromMatch(
+        matchId: testMatchOnlyPlayers.id,
+        newPlayer: originalPlayers,
+      );
+
+      final players = await database.playerMatchDao.getPlayersOfMatch(
+        matchId: testMatchOnlyPlayers.id,
+      );
+
+      expect(players?.length, originalPlayers.length);
+      final playerIds = players!.map((p) => p.id).toSet();
+      for (final originalPlayer in originalPlayers) {
+        expect(playerIds.contains(originalPlayer.id), true);
+      }
+    });
+
+    // Verifies that matchHasPlayers returns false for non-existent match.
+    test('matchHasPlayers returns false for non-existent match', () async {
+      final hasPlayers = await database.playerMatchDao.matchHasPlayers(
+        matchId: 'non-existent-match-id',
+      );
+
+      expect(hasPlayers, false);
+    });
+
+    // Verifies that isPlayerInMatch returns false for non-existent match.
+    test('isPlayerInMatch returns false for non-existent match', () async {
+      final isInMatch = await database.playerMatchDao.isPlayerInMatch(
+        matchId: 'non-existent-match-id',
+        playerId: testPlayer1.id,
+      );
+
+      expect(isInMatch, false);
+    });
+
+    // Verifies that updatePlayersFromMatch preserves scores for existing players.
+    test('updatePlayersFromMatch only modifies player associations', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+      // Update score for existing player
+      await database.playerMatchDao.updatePlayerScore(
+        matchId: testMatchOnlyPlayers.id,
+        playerId: testPlayer4.id,
+        newScore: 75,
+      );
+
+      // Update players, keeping testPlayer4 and adding testPlayer1
+      await database.playerMatchDao.updatePlayersFromMatch(
+        matchId: testMatchOnlyPlayers.id,
+        newPlayer: [testPlayer4, testPlayer1],
+      );
+
+      // Verify testPlayer4's score is preserved
+      final score = await database.playerMatchDao.getPlayerScore(
+        matchId: testMatchOnlyPlayers.id,
+        playerId: testPlayer4.id,
+      );
+
+      expect(score, 75);
+
+      // Verify testPlayer1 was added with default score
+      final newPlayerScore = await database.playerMatchDao.getPlayerScore(
+        matchId: testMatchOnlyPlayers.id,
+        playerId: testPlayer1.id,
+      );
+
+      expect(newPlayerScore, 0);
+    });
+
+    // Verifies that adding a player with both score and teamId works correctly.
+    test('Adding player with score and teamId works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+      await database.teamDao.addTeam(team: testTeam1);
+
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+        teamId: testTeam1.id,
+        score: 150,
+      );
+
+      // Verify score
+      final score = await database.playerMatchDao.getPlayerScore(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+      );
+      expect(score, 150);
+
+      // Verify team assignment
+      final playersInTeam = await database.playerMatchDao.getPlayersInTeam(
+        matchId: testMatchOnlyGroup.id,
+        teamId: testTeam1.id,
+      );
+      expect(playersInTeam.length, 1);
+      expect(playersInTeam[0].id, testPlayer1.id);
+    });
+
+    // Verifies that updating score with negative value works.
+    test('updatePlayerScore with negative score works', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+      final updated = await database.playerMatchDao.updatePlayerScore(
+        matchId: testMatchOnlyPlayers.id,
+        playerId: testPlayer4.id,
+        newScore: -10,
+      );
+
+      expect(updated, true);
+
+      final score = await database.playerMatchDao.getPlayerScore(
+        matchId: testMatchOnlyPlayers.id,
+        playerId: testPlayer4.id,
+      );
+
+      expect(score, -10);
+    });
+
+    // Verifies that updating score with zero value works.
+    test('updatePlayerScore with zero score works', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+      // First set a non-zero score
+      await database.playerMatchDao.updatePlayerScore(
+        matchId: testMatchOnlyPlayers.id,
+        playerId: testPlayer4.id,
+        newScore: 100,
+      );
+
+      // Then update to zero
+      final updated = await database.playerMatchDao.updatePlayerScore(
+        matchId: testMatchOnlyPlayers.id,
+        playerId: testPlayer4.id,
+        newScore: 0,
+      );
+
+      expect(updated, true);
+
+      final score = await database.playerMatchDao.getPlayerScore(
+        matchId: testMatchOnlyPlayers.id,
+        playerId: testPlayer4.id,
+      );
+
+      expect(score, 0);
+    });
+
+    // Verifies that getPlayersInTeam returns empty list for non-existent match.
+    test(
+      'getPlayersInTeam returns empty list for non-existent match',
+      () async {
+        await database.teamDao.addTeam(team: testTeam1);
+
+        final players = await database.playerMatchDao.getPlayersInTeam(
+          matchId: 'non-existent-match-id',
+          teamId: testTeam1.id,
+        );
+
+        expect(players.isEmpty, true);
+      },
+    );
+
+    // Verifies that players in different teams within the same match are returned correctly.
+    test('Players in different teams within same match are separate', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+      await database.teamDao.addTeam(team: testTeam1);
+      await database.teamDao.addTeam(team: testTeam2);
+
+      // Add players to different teams
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+        teamId: testTeam1.id,
+      );
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer2.id,
+        teamId: testTeam1.id,
+      );
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer3.id,
+        teamId: testTeam2.id,
+      );
+
+      // Verify team 1 players
+      final playersInTeam1 = await database.playerMatchDao.getPlayersInTeam(
+        matchId: testMatchOnlyGroup.id,
+        teamId: testTeam1.id,
+      );
+      expect(playersInTeam1.length, 2);
+      final team1Ids = playersInTeam1.map((p) => p.id).toSet();
+      expect(team1Ids.contains(testPlayer1.id), true);
+      expect(team1Ids.contains(testPlayer2.id), true);
+      expect(team1Ids.contains(testPlayer3.id), false);
+
+      // Verify team 2 players
+      final playersInTeam2 = await database.playerMatchDao.getPlayersInTeam(
+        matchId: testMatchOnlyGroup.id,
+        teamId: testTeam2.id,
+      );
+      expect(playersInTeam2.length, 1);
+      expect(playersInTeam2[0].id, testPlayer3.id);
+    });
+
+    // Verifies that removePlayerFromMatch does not affect other matches.
+    test('removePlayerFromMatch does not affect other matches', () async {
+      final playersList = [testPlayer1, testPlayer2];
+      final match1 = Match(
+        name: 'Match 1',
+        game: testGame,
+        players: playersList,
+        notes: '',
+      );
+      final match2 = Match(
+        name: 'Match 2',
+        game: testGame,
+        players: playersList,
+        notes: '',
+      );
+
+      await Future.wait([
+        database.matchDao.addMatch(match: match1),
+        database.matchDao.addMatch(match: match2),
+      ]);
+
+      // Remove player from match1
+      final removed = await database.playerMatchDao.removePlayerFromMatch(
+        playerId: testPlayer1.id,
+        matchId: match1.id,
+      );
+      expect(removed, true);
+
+      // Verify player is removed from match1
+      final isInMatch1 = await database.playerMatchDao.isPlayerInMatch(
+        matchId: match1.id,
+        playerId: testPlayer1.id,
+      );
+      expect(isInMatch1, false);
+
+      // Verify player still exists in match2
+      final isInMatch2 = await database.playerMatchDao.isPlayerInMatch(
+        matchId: match2.id,
+        playerId: testPlayer1.id,
+      );
+      expect(isInMatch2, true);
+    });
+
+    // Verifies that updating scores for players in different matches are independent.
+    test('Player scores are independent across matches', () async {
+      final playersList = [testPlayer1];
+      final match1 = Match(
+        name: 'Match 1',
+        game: testGame,
+        players: playersList,
+        notes: '',
+      );
+      final match2 = Match(
+        name: 'Match 2',
+        game: testGame,
+        players: playersList,
+        notes: '',
+      );
+
+      await Future.wait([
+        database.matchDao.addMatch(match: match1),
+        database.matchDao.addMatch(match: match2),
+      ]);
+
+      // Update score in match1
+      await database.playerMatchDao.updatePlayerScore(
+        matchId: match1.id,
+        playerId: testPlayer1.id,
+        newScore: 100,
+      );
+
+      // Update score in match2
+      await database.playerMatchDao.updatePlayerScore(
+        matchId: match2.id,
+        playerId: testPlayer1.id,
+        newScore: 50,
+      );
+
+      // Verify scores are independent
+      final scoreInMatch1 = await database.playerMatchDao.getPlayerScore(
+        matchId: match1.id,
+        playerId: testPlayer1.id,
+      );
+      final scoreInMatch2 = await database.playerMatchDao.getPlayerScore(
+        matchId: match2.id,
+        playerId: testPlayer1.id,
+      );
+
+      expect(scoreInMatch1, 100);
+      expect(scoreInMatch2, 50);
+    });
+
+    // Verifies that updatePlayersFromMatch on non-existent match fails with constraint error.
+    test(
+      'updatePlayersFromMatch on non-existent match fails with foreign key constraint',
+      () async {
+        // Should throw due to foreign key constraint - match doesn't exist
+        await expectLater(
+          database.playerMatchDao.updatePlayersFromMatch(
+            matchId: 'non-existent-match-id',
+            newPlayer: [testPlayer1, testPlayer2],
+          ),
+          throwsA(anything),
+        );
+      },
+    );
+
+    // Verifies that a player can be in a match without being assigned to a team.
+    test('Player can exist in match without team assignment', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+      await database.teamDao.addTeam(team: testTeam1);
+
+      // Add player to match without team
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+      );
+
+      // Add another player to match with team
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer2.id,
+        teamId: testTeam1.id,
+      );
+
+      // Verify both players are in the match
+      final isPlayer1InMatch = await database.playerMatchDao.isPlayerInMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer1.id,
+      );
+      final isPlayer2InMatch = await database.playerMatchDao.isPlayerInMatch(
+        matchId: testMatchOnlyGroup.id,
+        playerId: testPlayer2.id,
+      );
+
+      expect(isPlayer1InMatch, true);
+      expect(isPlayer2InMatch, true);
+
+      // Verify only player2 is in the team
+      final playersInTeam = await database.playerMatchDao.getPlayersInTeam(
+        matchId: testMatchOnlyGroup.id,
+        teamId: testTeam1.id,
+      );
+
+      expect(playersInTeam.length, 1);
+      expect(playersInTeam[0].id, testPlayer2.id);
+    });
+
+    // Verifies that replaceMatchPlayers removes all existing players and replaces with new list.
+    test('replaceMatchPlayers replaces all match players correctly', () async {
+      // Create initial match with 3 players
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+      // Verify initial players
+      var matchPlayers = await database.matchDao.getMatchById(
+        matchId: testMatchOnlyPlayers.id,
+      );
+      expect(matchPlayers.players.length, 3);
+
+      // Replace with new list containing 2 different players
+      final newPlayersList = [testPlayer1, testPlayer2];
+      await database.matchDao.replaceMatchPlayers(
+        matchId: testMatchOnlyPlayers.id,
+        newPlayers: newPlayersList,
+      );
+
+      // Get updated match and verify players
+      matchPlayers = await database.matchDao.getMatchById(
+        matchId: testMatchOnlyPlayers.id,
+      );
+
+      expect(matchPlayers.players.length, 2);
+      expect(matchPlayers.players.any((p) => p.id == testPlayer1.id), true);
+      expect(matchPlayers.players.any((p) => p.id == testPlayer2.id), true);
+      expect(matchPlayers.players.any((p) => p.id == testPlayer4.id), false);
+      expect(matchPlayers.players.any((p) => p.id == testPlayer5.id), false);
+      expect(matchPlayers.players.any((p) => p.id == testPlayer6.id), false);
+    });
+  });
+}

test/db_tests/values/score_test.dart

@@ -0,0 +1,756 @@
+import 'package:clock/clock.dart';
+import 'package:drift/drift.dart' hide isNull, isNotNull;
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/dto/player.dart';
+
+void main() {
+  late AppDatabase database;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Game testGame;
+  late Match testMatch1;
+  late Match testMatch2;
+  final fixedDate = DateTime(2025, 11, 19, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
+
+  setUp(() async {
+    database = AppDatabase(
+      DatabaseConnection(
+        NativeDatabase.memory(),
+        // Recommended for widget tests to avoid test errors.
+        closeStreamsSynchronously: true,
+      ),
+    );
+
+    withClock(fakeClock, () {
+      testPlayer1 = Player(name: 'Alice', description: '');
+      testPlayer2 = Player(name: 'Bob', description: '');
+      testPlayer3 = Player(name: 'Charlie', description: '');
+      testGame = Game(
+        name: 'Test Game',
+        ruleset: Ruleset.singleWinner,
+        description: 'A test game',
+        color: GameColor.blue,
+      );
+      testMatch1 = Match(
+        name: 'Test Match 1',
+        game: testGame,
+        players: [testPlayer1, testPlayer2],
+        notes: '',
+      );
+      testMatch2 = Match(
+        name: 'Test Match 2',
+        game: testGame,
+        players: [testPlayer2, testPlayer3],
+        notes: '',
+      );
+    });
+
+    await database.playerDao.addPlayersAsList(
+      players: [testPlayer1, testPlayer2, testPlayer3],
+    );
+    await database.gameDao.addGame(game: testGame);
+    await database.matchDao.addMatch(match: testMatch1);
+    await database.matchDao.addMatch(match: testMatch2);
+  });
+
+  tearDown(() async {
+    await database.close();
+  });
+
+  group('Score Tests', () {
+    // Verifies that a score can be added and retrieved with all fields intact.
+    test('Adding and fetching a score works correctly', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+
+      final score = await database.scoreDao.getScoreForRound(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+      );
+
+      expect(score, isNotNull);
+      expect(score!.playerId, testPlayer1.id);
+      expect(score.matchId, testMatch1.id);
+      expect(score.roundNumber, 1);
+      expect(score.score, 10);
+      expect(score.change, 10);
+    });
+
+    // Verifies that getScoresForMatch returns all scores for a given match.
+    test('Getting scores for a match works correctly', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer2.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 20,
+        change: 20,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 2,
+        score: 25,
+        change: 15,
+      );
+
+      final scores = await database.scoreDao.getScoresForMatch(
+        matchId: testMatch1.id,
+      );
+
+      expect(scores.length, 3);
+    });
+
+    // Verifies that getPlayerScoresInMatch returns all scores for a player in a match, ordered by round.
+    test('Getting player scores in a match works correctly', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 2,
+        score: 25,
+        change: 15,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 3,
+        score: 30,
+        change: 5,
+      );
+
+      final playerScores = await database.scoreDao.getPlayerScoresInMatch(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+      );
+
+      expect(playerScores.length, 3);
+      expect(playerScores[0].roundNumber, 1);
+      expect(playerScores[1].roundNumber, 2);
+      expect(playerScores[2].roundNumber, 3);
+      expect(playerScores[0].score, 10);
+      expect(playerScores[1].score, 25);
+      expect(playerScores[2].score, 30);
+    });
+
+    // Verifies that getScoreForRound returns null for a non-existent round number.
+    test('Getting score for a non-existent round returns null', () async {
+      final score = await database.scoreDao.getScoreForRound(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 999,
+      );
+
+      expect(score, isNull);
+    });
+
+    // Verifies that updateScore correctly updates the score and change values.
+    test('Updating a score works correctly', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+
+      final updated = await database.scoreDao.updateScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        newScore: 50,
+        newChange: 40,
+      );
+
+      expect(updated, true);
+
+      final score = await database.scoreDao.getScoreForRound(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+      );
+
+      expect(score, isNotNull);
+      expect(score!.score, 50);
+      expect(score.change, 40);
+    });
+
+    // Verifies that updateScore returns false for a non-existent score entry.
+    test('Updating a non-existent score returns false', () async {
+      final updated = await database.scoreDao.updateScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 999,
+        newScore: 50,
+        newChange: 40,
+      );
+
+      expect(updated, false);
+    });
+
+    // Verifies that deleteScore removes the score entry and returns true.
+    test('Deleting a score works correctly', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+
+      final deleted = await database.scoreDao.deleteScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+      );
+
+      expect(deleted, true);
+
+      final score = await database.scoreDao.getScoreForRound(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+      );
+
+      expect(score, isNull);
+    });
+
+    // Verifies that deleteScore returns false for a non-existent score entry.
+    test('Deleting a non-existent score returns false', () async {
+      final deleted = await database.scoreDao.deleteScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 999,
+      );
+
+      expect(deleted, false);
+    });
+
+    // Verifies that deleteScoresForMatch removes all scores for a match but keeps other match scores.
+    test('Deleting scores for a match works correctly', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer2.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 20,
+        change: 20,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch2.id,
+        roundNumber: 1,
+        score: 15,
+        change: 15,
+      );
+
+      final deleted = await database.scoreDao.deleteScoresForMatch(
+        matchId: testMatch1.id,
+      );
+
+      expect(deleted, true);
+
+      final match1Scores = await database.scoreDao.getScoresForMatch(
+        matchId: testMatch1.id,
+      );
+      expect(match1Scores.length, 0);
+
+      final match2Scores = await database.scoreDao.getScoresForMatch(
+        matchId: testMatch2.id,
+      );
+      expect(match2Scores.length, 1);
+    });
+
+    // Verifies that deleteScoresForPlayer removes all scores for a player across all matches.
+    test('Deleting scores for a player works correctly', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch2.id,
+        roundNumber: 1,
+        score: 15,
+        change: 15,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer2.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 20,
+        change: 20,
+      );
+
+      final deleted = await database.scoreDao.deleteScoresForPlayer(
+        playerId: testPlayer1.id,
+      );
+
+      expect(deleted, true);
+
+      final player1Scores = await database.scoreDao.getPlayerScoresInMatch(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+      );
+      expect(player1Scores.length, 0);
+
+      final player2Scores = await database.scoreDao.getPlayerScoresInMatch(
+        playerId: testPlayer2.id,
+        matchId: testMatch1.id,
+      );
+      expect(player2Scores.length, 1);
+    });
+
+    // Verifies that getLatestRoundNumber returns the highest round number for a match.
+    test('Getting latest round number works correctly', () async {
+      var latestRound = await database.scoreDao.getLatestRoundNumber(
+        matchId: testMatch1.id,
+      );
+      expect(latestRound, 0);
+
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+
+      latestRound = await database.scoreDao.getLatestRoundNumber(
+        matchId: testMatch1.id,
+      );
+      expect(latestRound, 1);
+
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 5,
+        score: 50,
+        change: 40,
+      );
+
+      latestRound = await database.scoreDao.getLatestRoundNumber(
+        matchId: testMatch1.id,
+      );
+      expect(latestRound, 5);
+    });
+
+    // Verifies that getTotalScoreForPlayer returns the latest score (cumulative) for a player.
+    test('Getting total score for a player works correctly', () async {
+      var totalScore = await database.scoreDao.getTotalScoreForPlayer(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+      );
+      expect(totalScore, 0);
+
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 2,
+        score: 25,
+        change: 15,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 3,
+        score: 40,
+        change: 15,
+      );
+
+      totalScore = await database.scoreDao.getTotalScoreForPlayer(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+      );
+      expect(totalScore, 40);
+    });
+
+    // Verifies that adding a score with the same player/match/round replaces the existing one.
+    test('Adding the same score twice replaces the existing one', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 99,
+        change: 99,
+      );
+
+      final score = await database.scoreDao.getScoreForRound(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+      );
+
+      expect(score, isNotNull);
+      expect(score!.score, 99);
+      expect(score.change, 99);
+    });
+
+    // Verifies that getScoresForMatch returns empty list for match with no scores.
+    test(
+      'Getting scores for match with no scores returns empty list',
+      () async {
+        final scores = await database.scoreDao.getScoresForMatch(
+          matchId: testMatch1.id,
+        );
+
+        expect(scores.isEmpty, true);
+      },
+    );
+
+    // Verifies that getPlayerScoresInMatch returns empty list when player has no scores.
+    test('Getting player scores with no scores returns empty list', () async {
+      final playerScores = await database.scoreDao.getPlayerScoresInMatch(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+      );
+
+      expect(playerScores.isEmpty, true);
+    });
+
+    // Verifies that scores can have negative values.
+    test('Score can have negative values', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: -10,
+        change: -10,
+      );
+
+      final score = await database.scoreDao.getScoreForRound(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+      );
+
+      expect(score, isNotNull);
+      expect(score!.score, -10);
+      expect(score.change, -10);
+    });
+
+    // Verifies that scores can have zero values.
+    test('Score can have zero values', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 0,
+        change: 0,
+      );
+
+      final score = await database.scoreDao.getScoreForRound(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+      );
+
+      expect(score, isNotNull);
+      expect(score!.score, 0);
+      expect(score.change, 0);
+    });
+
+    // Verifies that very large round numbers are supported.
+    test('Score supports very large round numbers', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 999999,
+        score: 100,
+        change: 100,
+      );
+
+      final score = await database.scoreDao.getScoreForRound(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 999999,
+      );
+
+      expect(score, isNotNull);
+      expect(score!.roundNumber, 999999);
+    });
+
+    // Verifies that getLatestRoundNumber returns max correctly for non-consecutive rounds.
+    test('Getting latest round number with non-consecutive rounds', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 5,
+        score: 50,
+        change: 40,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 3,
+        score: 30,
+        change: 20,
+      );
+
+      final latestRound = await database.scoreDao.getLatestRoundNumber(
+        matchId: testMatch1.id,
+      );
+
+      expect(latestRound, 5);
+    });
+
+    // Verifies that deleteScoresForMatch returns false when no scores exist.
+    test('Deleting scores for empty match returns false', () async {
+      final deleted = await database.scoreDao.deleteScoresForMatch(
+        matchId: testMatch1.id,
+      );
+
+      expect(deleted, false);
+    });
+
+    // Verifies that deleteScoresForPlayer returns false when player has no scores.
+    test('Deleting scores for player with no scores returns false', () async {
+      final deleted = await database.scoreDao.deleteScoresForPlayer(
+        playerId: testPlayer1.id,
+      );
+
+      expect(deleted, false);
+    });
+
+    // Verifies that multiple players in same match can have independent score updates.
+    test('Multiple players in same match have independent scores', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer2.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 20,
+        change: 20,
+      );
+
+      await database.scoreDao.updateScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        newScore: 100,
+        newChange: 90,
+      );
+
+      final player1Score = await database.scoreDao.getScoreForRound(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+      );
+      final player2Score = await database.scoreDao.getScoreForRound(
+        playerId: testPlayer2.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+      );
+
+      expect(player1Score!.score, 100);
+      expect(player2Score!.score, 20);
+    });
+
+    // Verifies that scores are isolated across different matches.
+    test('Scores are isolated across different matches', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch2.id,
+        roundNumber: 1,
+        score: 50,
+        change: 50,
+      );
+
+      final match1Scores = await database.scoreDao.getPlayerScoresInMatch(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+      );
+      final match2Scores = await database.scoreDao.getPlayerScoresInMatch(
+        playerId: testPlayer1.id,
+        matchId: testMatch2.id,
+      );
+
+      expect(match1Scores.length, 1);
+      expect(match2Scores.length, 1);
+      expect(match1Scores[0].score, 10);
+      expect(match2Scores[0].score, 50);
+    });
+
+    // Verifies that getTotalScoreForPlayer returns latest score across multiple rounds.
+    test('Total score for player returns latest cumulative score', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 2,
+        score: 25,
+        change: 25,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 3,
+        score: 50,
+        change: 25,
+      );
+
+      final totalScore = await database.scoreDao.getTotalScoreForPlayer(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+      );
+
+      // Should return the highest round's score
+      expect(totalScore, 50);
+    });
+
+    // Verifies that updating one player's score doesn't affect another player's score in same round.
+    test(
+      'Updating one player score does not affect other players in same round',
+      () async {
+        await database.scoreDao.addScore(
+          playerId: testPlayer1.id,
+          matchId: testMatch1.id,
+          roundNumber: 1,
+          score: 10,
+          change: 10,
+        );
+        await database.scoreDao.addScore(
+          playerId: testPlayer2.id,
+          matchId: testMatch1.id,
+          roundNumber: 1,
+          score: 20,
+          change: 20,
+        );
+        await database.scoreDao.addScore(
+          playerId: testPlayer3.id,
+          matchId: testMatch1.id,
+          roundNumber: 1,
+          score: 30,
+          change: 30,
+        );
+
+        await database.scoreDao.updateScore(
+          playerId: testPlayer2.id,
+          matchId: testMatch1.id,
+          roundNumber: 1,
+          newScore: 99,
+          newChange: 89,
+        );
+
+        final scores = await database.scoreDao.getScoresForMatch(
+          matchId: testMatch1.id,
+        );
+
+        expect(scores.length, 3);
+        expect(
+          scores.where((s) => s.playerId == testPlayer1.id).first.score,
+          10,
+        );
+        expect(
+          scores.where((s) => s.playerId == testPlayer2.id).first.score,
+          99,
+        );
+        expect(
+          scores.where((s) => s.playerId == testPlayer3.id).first.score,
+          30,
+        );
+      },
+    );
+
+    // Verifies that deleting a player's scores only affects that specific player.
+    test('Deleting player scores only affects target player', () async {
+      await database.scoreDao.addScore(
+        playerId: testPlayer1.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 10,
+        change: 10,
+      );
+      await database.scoreDao.addScore(
+        playerId: testPlayer2.id,
+        matchId: testMatch1.id,
+        roundNumber: 1,
+        score: 20,
+        change: 20,
+      );
+
+      await database.scoreDao.deleteScoresForPlayer(playerId: testPlayer1.id);
+
+      final match1Scores = await database.scoreDao.getScoresForMatch(
+        matchId: testMatch1.id,
+      );
+
+      expect(match1Scores.length, 1);
+      expect(match1Scores[0].playerId, testPlayer2.id);
+    });
+  });
+}