Merge remote-tracking branch 'origin/development' into feature/88-neue-datenbank-struktur

analysis_options.yaml

@@ -11,4 +11,3 @@ linter:
     prefer_const_literals_to_create_immutables: true
     unnecessary_const: true
     lines_longer_than_80_chars: false
-    constant_identifier_names: false

lib/core/constants.dart

@@ -3,23 +3,5 @@ class Constants {
   Constants._(); // Private constructor to prevent instantiation
 
   /// Minimum duration of all app skeletons
-  static const Duration MINIMUM_SKELETON_DURATION = Duration(milliseconds: 250);
-
-  /// Maximum length for player names
-  static const int MAX_PLAYER_NAME_LENGTH = 32;
-
-  /// Maximum length for group names
-  static const int MAX_GROUP_NAME_LENGTH = 32;
-
-  /// Maximum length for match names
-  static const int MAX_MATCH_NAME_LENGTH = 32;
-
-  /// Maximum length for game names
-  static const int MAX_GAME_NAME_LENGTH = 32;
-
-  /// 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;
+  static Duration minimumSkeletonDuration = const Duration(milliseconds: 250);
 }

lib/core/custom_theme.dart

@@ -5,32 +5,14 @@ class CustomTheme {
   CustomTheme._(); // Private constructor to prevent instantiation
 
   // ==================== Colors ====================
-
-  /// Primary color of the app theme
   static Color primaryColor = const Color(0xFF7505E4);
-
-  /// Secondary color of the app theme
   static Color secondaryColor = const Color(0xFFAFA2FF);
-
-  /// Background color of the app theme
   static Color backgroundColor = const Color(0xFF0B0B0B);
-
-  /// Default color for boxes and containers
   static Color boxColor = const Color(0xFF101010);
-
-  /// Default border color for boxes and containers
-  static Color boxBorder = const Color(0xFF272727);
-
-  /// Color for boxes and containers displayed on boxes
   static Color onBoxColor = const Color(0xFF181818);
-
-  /// Text color used throughout the app
+  static Color boxBorder = const Color(0xFF272727);
   static const Color textColor = Colors.white;
-
-  /// Selected color for the [NavbarItem]
   static Color navBarItemSelectedColor = primaryColor.withGreen(100);
-
-  /// Unselected color for the [NavbarItem]
   static Color navBarItemUnselectedColor = Colors.grey.shade400;
 
   // ==================== Border Radius ====================

lib/data/dao/game_dao.dart

@@ -0,0 +1,179 @@
+import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/db/tables/game_table.dart';
+import 'package:game_tracker/data/dto/game.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: row.ruleset,
+            description: row.description,
+            color: row.color != null ? int.tryParse(row.color!) : null,
+            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: result.ruleset,
+      description: result.description,
+      color: result.color != null ? int.tryParse(result.color!) : null,
+      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 ?? '',
+          description: Value(game.description),
+          color: Value(game.color?.toString()),
+          icon: Value(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 ?? '',
+                description: Value(game.description),
+                color: Value(game.color?.toString()),
+                icon: Value(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 String newRuleset,
+  }) async {
+    await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
+      GameTableCompanion(ruleset: Value(newRuleset)),
+    );
+  }
+
+  /// 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 int? newColor,
+  }) async {
+    await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
+      GameTableCompanion(color: Value(newColor?.toString())),
+    );
+  }
+
+  /// 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: Value(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: Value(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: Value(p.description),
                     createdAt: p.createdAt,
                   ),
                 )

lib/data/dao/group_match_dao.dart

@@ -1,98 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/db/tables/group_match_table.dart';
-import 'package:game_tracker/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:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/db/tables/game_table.dart';
+import 'package:game_tracker/data/db/tables/group_table.dart';
 import 'package:game_tracker/data/db/tables/match_table.dart';
+import 'package:game_tracker/data/db/tables/player_match_table.dart';
+import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/data/dto/group.dart';
 import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/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,20 +22,22 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
 
     return Future.wait(
       result.map((row) async {
-        final group = await db.groupMatchDao.getGroupOfMatch(matchId: row.id);
+        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 = row.winnerId != null
-            ? await db.playerDao.getPlayerById(playerId: row.winnerId!)
-            : null;
         return Match(
           id: row.id,
-          name: row.name,
+          name: row.name ?? '',
+          game: game,
           group: group,
           players: players,
+          notes: row.notes,
           createdAt: row.createdAt,
-          winner: winner,
         );
       }),
     );
@@ -42,100 +48,110 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
     final query = select(matchTable)..where((g) => g.id.equals(matchId));
     final result = await query.getSingle();
 
+    final game = await db.gameDao.getGameById(gameId: result.gameId);
+
+    Group? group;
+    if (result.groupId != null) {
+      group = await db.groupDao.getGroupById(groupId: result.groupId!);
+    }
+
     List<Player>? players;
     if (await db.playerMatchDao.matchHasPlayers(matchId: matchId)) {
       players = await db.playerMatchDao.getPlayersOfMatch(matchId: matchId);
     }
-    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!);
-    }
 
     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,
     );
   }
 
-  /// 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 {
+    if (match.game == null) {
+      throw ArgumentError('Match must have a game associated with it');
+    }
+
     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,
         ),
         mode: InsertMode.insertOrReplace,
       );
 
       if (match.players != null) {
-        for (final p in match.players ?? []) {
+        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,
-        );
-      }
     });
   }
 
-  /// 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 matches in batch
-      await db.batch(
-        (b) => b.insertAll(
-          matchTable,
-          matches
-              .map(
-                (match) => MatchTableCompanion.insert(
-                  id: match.id,
-                  name: match.name,
-                  createdAt: match.createdAt,
-                  winnerId: Value(match.winner?.id),
-                ),
-              )
-              .toList(),
-          mode: InsertMode.insertOrReplace,
-        ),
-      );
+      // Add all games first (deduplicated)
+      final uniqueGames = <String, Game>{};
+      for (final match in matches) {
+        if (match.game != null) {
+          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 ?? '',
+                    description: Value(game.description),
+                    color: Value(game.color?.toString()),
+                    icon: Value(game.icon),
+                    createdAt: game.createdAt,
+                  ),
+                )
+                .toList(),
+            mode: InsertMode.insertOrIgnore,
+          ),
+        );
+      }
 
       // 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,
+                (match) => GroupTableCompanion.insert(
+                  id: match.group!.id,
+                  name: match.group!.name,
+                  description: Value(match.group!.description),
+                  createdAt: match.group!.createdAt,
                 ),
               )
               .toList(),
@@ -143,6 +159,27 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
         ),
       );
 
+      // Add all matches in batch
+      await db.batch(
+        (b) => b.insertAll(
+          matchTable,
+          matches
+              .where((match) => match.game != null)
+              .map(
+                (match) => MatchTableCompanion.insert(
+                  id: match.id,
+                  gameId: match.game!.id,
+                  groupId: Value(match.group?.id),
+                  name: Value(match.name),
+                  notes: Value(match.notes),
+                  createdAt: match.createdAt,
+                ),
+              )
+              .toList(),
+          mode: InsertMode.insertOrReplace,
+        ),
+      );
+
       // Add all players of the matches in batch (unique)
       final uniquePlayers = <String, Player>{};
       for (final match in matches) {
@@ -160,8 +197,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 +205,7 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
                   (p) => PlayerTableCompanion.insert(
                     id: p.id,
                     name: p.name,
+                    description: Value(p.description),
                     createdAt: p.createdAt,
                   ),
                 )
@@ -183,12 +219,13 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
       await db.batch((b) {
         for (final match in matches) {
           if (match.players != null) {
-            for (final p in match.players ?? []) {
+            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 +251,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 +287,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 +312,67 @@ 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].
+  /// 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? groupId,
+  }) async {
+    final query = update(matchTable)..where((g) => g.id.equals(matchId));
+    final rowsAffected = await query.write(
+      MatchTableCompanion(groupId: Value(groupId)),
+    );
+    return rowsAffected > 0;
+  }
+
+  // ============================================================
+  // TEMPORARY: Winner methods - these are stubs and do not persist data
+  // TODO: Implement proper winner handling
+  // ============================================================
+
+  /// TEMPORARY: Checks if a match has a winner.
+  /// Currently returns true if the match has any players.
+  Future<bool> hasWinner({required String matchId}) async {
+    final players = await db.playerMatchDao.getPlayersOfMatch(matchId: matchId);
+    return players?.isNotEmpty ?? false;
+  }
+
+  /// TEMPORARY: Gets the winner of a match.
+  /// Currently returns the first player in the match's player list.
+  Future<Player?> getWinner({required String matchId}) async {
+    final players = await db.playerMatchDao.getPlayersOfMatch(matchId: matchId);
+    return (players?.isNotEmpty ?? false) ? players!.first : null;
+  }
+
+  /// TEMPORARY: Sets the winner of a match.
+  /// Currently does nothing - winner is not persisted.
+  Future<bool> setWinner({
+    required String matchId,
+    required String winnerId,
+  }) async {
+    // TODO: Implement winner persistence
+    return true;
+  }
+
+  /// TEMPORARY: Removes the winner of a match.
+  /// Currently does nothing - winner is not persisted.
+  Future<bool> removeWinner({required String matchId}) async {
+    // TODO: Implement winner persistence
+    return true;
+  }
 }

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: Value(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: Value(player.description),
                 createdAt: player.createdAt,
               ),
             )

lib/data/dao/player_match_dao.dart

@@ -1,23 +1,31 @@
 import 'package:drift/drift.dart';
 import 'package:game_tracker/data/db/database.dart';
 import 'package:game_tracker/data/db/tables/player_match_table.dart';
+import 'package:game_tracker/data/db/tables/team_table.dart';
 import 'package:game_tracker/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,
     );
   }
@@ -38,6 +46,50 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
     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 {
@@ -114,6 +166,7 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
               (id) => PlayerMatchTableCompanion.insert(
                 playerId: id,
                 matchId: matchId,
+                score: 0,
               ),
             )
             .toList();
@@ -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:game_tracker/data/db/database.dart';
+import 'package:game_tracker/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,145 @@
+import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/db/tables/team_table.dart';
+import 'package:game_tracker/data/dto/player.dart';
+import 'package:game_tracker/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,
+          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,
+      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 from table (not in DTO currently)
+          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: '',
+                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,17 +1,21 @@
 import 'package:drift/drift.dart';
 import 'package:drift_flutter/drift_flutter.dart';
+import 'package:game_tracker/data/dao/game_dao.dart';
 import 'package:game_tracker/data/dao/group_dao.dart';
-import 'package:game_tracker/data/dao/group_match_dao.dart';
 import 'package:game_tracker/data/dao/match_dao.dart';
 import 'package:game_tracker/data/dao/player_dao.dart';
 import 'package:game_tracker/data/dao/player_group_dao.dart';
 import 'package:game_tracker/data/dao/player_match_dao.dart';
-import 'package:game_tracker/data/db/tables/group_match_table.dart';
+import 'package:game_tracker/data/dao/score_dao.dart';
+import 'package:game_tracker/data/dao/team_dao.dart';
+import 'package:game_tracker/data/db/tables/game_table.dart';
 import 'package:game_tracker/data/db/tables/group_table.dart';
 import 'package:game_tracker/data/db/tables/match_table.dart';
 import 'package:game_tracker/data/db/tables/player_group_table.dart';
 import 'package:game_tracker/data/db/tables/player_match_table.dart';
 import 'package:game_tracker/data/db/tables/player_table.dart';
+import 'package:game_tracker/data/db/tables/score_table.dart';
+import 'package:game_tracker/data/db/tables/team_table.dart';
 import 'package:path_provider/path_provider.dart';
 
 part 'database.g.dart';
@@ -20,25 +24,29 @@ part 'database.g.dart';
   tables: [
     PlayerTable,
     GroupTable,
+    GameTable,
+    TeamTable,
     MatchTable,
     PlayerGroupTable,
     PlayerMatchTable,
-    GroupMatchTable,
+    ScoreTable,
   ],
   daos: [
     PlayerDao,
     GroupDao,
+    GameDao,
+    TeamDao,
     MatchDao,
     PlayerGroupDao,
     PlayerMatchDao,
-    GroupMatchDao,
+    ScoreDao,
   ],
 )
 class AppDatabase extends _$AppDatabase {
   AppDatabase([QueryExecutor? executor]) : super(executor ?? _openConnection());
 
   @override
-  int get schemaVersion => 1;
+  int get schemaVersion => 2;
 
   @override
   MigrationStrategy get migration {

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().nullable()();
+  TextColumn get color => text().nullable()();
+  TextColumn get icon => text().nullable()();
+  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:game_tracker/data/db/tables/group_table.dart';
-import 'package:game_tracker/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().nullable()();
   DateTimeColumn get createdAt => dateTime()();
 
   @override

lib/data/db/tables/match_table.dart

@@ -1,9 +1,15 @@
 import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/tables/game_table.dart';
+import 'package:game_tracker/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)();
+  TextColumn get groupId =>
+      text().references(GroupTable, #id, onDelete: KeyAction.cascade).nullable()(); // Nullable if not part of a group
+  TextColumn get name => text().nullable()();
+  TextColumn get notes => text().nullable()();
   DateTimeColumn get createdAt => dateTime()();
 
   @override

lib/data/db/tables/player_match_table.dart

@@ -1,12 +1,16 @@
 import 'package:drift/drift.dart';
 import 'package:game_tracker/data/db/tables/match_table.dart';
 import 'package:game_tracker/data/db/tables/player_table.dart';
+import 'package:game_tracker/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().nullable()();
   DateTimeColumn get createdAt => dateTime()();
 
   @override

lib/data/db/tables/score_table.dart

@@ -0,0 +1,16 @@
+import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/tables/match_table.dart';
+import 'package:game_tracker/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

@@ -18,6 +18,33 @@ class Game {
     this.description,
     this.color,
     this.icon,
-  })  : id = id ?? const Uuid().v4(),
-        createdAt = createdAt ?? clock.now();
+  }) : id = id ?? const Uuid().v4(),
+       createdAt = createdAt ?? clock.now();
+
+  @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 = json['ruleset'],
+      description = json['description'],
+      color = 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,
+    'description': description,
+    'color': color,
+    'icon': icon,
+  };
 }
+

lib/data/dto/group.dart

@@ -4,21 +4,23 @@ 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,
+    this.description,
     required this.members,
   }) : id = id ?? const Uuid().v4(),
        createdAt = createdAt ?? clock.now();
 
   @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.
@@ -26,6 +28,7 @@ class Group {
     : id = json['id'],
       createdAt = DateTime.parse(json['createdAt']),
       name = json['name'],
+      description = json['description'],
       members = (json['members'] as List)
           .map((memberJson) => Player.fromJson(memberJson))
           .toList();
@@ -35,6 +38,7 @@ class Group {
     'id': id,
     'createdAt': createdAt.toIso8601String(),
     'name': name,
+    'description': description,
     'members': members.map((member) => member.toJson()).toList(),
   };
 }

lib/data/dto/match.dart

@@ -1,4 +1,5 @@
 import 'package:clock/clock.dart';
+import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/data/dto/group.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:uuid/uuid.dart';
@@ -7,45 +8,51 @@ class Match {
   final String id;
   final DateTime createdAt;
   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,
     required this.name,
-    this.players,
+    this.game,
     this.group,
+    this.players,
+    this.notes,
     this.winner,
   }) : id = id ?? const Uuid().v4(),
        createdAt = createdAt ?? clock.now();
 
   @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, winner: $winner}';
   }
 
   /// Creates a Match instance from a JSON object.
   Match.fromJson(Map<String, dynamic> json)
     : id = json['id'],
-      name = json['name'],
       createdAt = DateTime.parse(json['createdAt']),
+      name = json['name'],
+      game = json['game'] != null ? Game.fromJson(json['game']) : null,
+      group = json['group'] != null ? Group.fromJson(json['group']) : null,
       players = json['players'] != null
           ? (json['players'] as List)
-                .map((playerJson) => Player.fromJson(playerJson))
-                .toList()
+              .map((playerJson) => Player.fromJson(playerJson))
+              .toList()
           : null,
-      group = json['group'] != null ? Group.fromJson(json['group']) : null,
-      winner = json['winner'] != null ? Player.fromJson(json['winner']) : null;
+      notes = json['notes'];
 
   /// Converts the Match instance to a JSON object.
   Map<String, dynamic> toJson() => {
     'id': id,
     'createdAt': createdAt.toIso8601String(),
     'name': name,
-    'players': players?.map((player) => player.toJson()).toList(),
+    'game': game?.toJson(),
     'group': group?.toJson(),
-    'winner': winner?.toJson(),
+    'players': players?.map((player) => player.toJson()).toList(),
+    'notes': notes,
   };
 }

lib/data/dto/pair.dart

@@ -0,0 +1,16 @@
+import 'package:game_tracker/data/dto/team.dart';
+
+class Pair extends Team {
+  Pair({
+    super.id,
+    super.createdAt,
+    required super.members,
+  });
+
+  @override
+  String toString() {
+    return 'Pair{id: $id, members: $members}';
+  }
+
+}
+

lib/data/dto/player.dart

@@ -5,26 +5,33 @@ 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,
+    this.description,
+  }) : id = id ?? const Uuid().v4(),
+       createdAt = createdAt ?? clock.now();
 
   @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,37 @@
+import 'package:clock/clock.dart';
+import 'package:game_tracker/data/dto/player.dart';
+import 'package:uuid/uuid.dart';
+
+class Team {
+  final String id;
+  final DateTime createdAt;
+  final List<Player> members;
+
+  Team({
+    String? id,
+    DateTime? createdAt,
+    required this.members,
+  }) : id = id ?? const Uuid().v4(),
+       createdAt = createdAt ?? clock.now();
+
+  @override
+  String toString() {
+    return 'Team{id: $id, members: $members}';
+  }
+
+  /// Creates a Team instance from a JSON object.
+  Team.fromJson(Map<String, dynamic> json)
+    : id = json['id'],
+      createdAt = DateTime.parse(json['createdAt']),
+      members = (json['members'] as List)
+          .map((memberJson) => Player.fromJson(memberJson))
+          .toList();
+
+  /// Converts the Team instance to a JSON object.
+  Map<String, dynamic> toJson() => {
+    'id': id,
+    'createdAt': createdAt.toIso8601String(),
+    'members': members.map((member) => member.toJson()).toList(),
+  };
+}
+

lib/l10n/arb/app_de.arb

@@ -4,18 +4,15 @@
   "all_players_selected": "Alle Spieler:innen ausgewählt",
   "amount_of_matches": "Anzahl der Spiele",
   "app_name": "Game Tracker",
-  "best_player": "Beste:r Spieler:in",
   "cancel": "Abbrechen",
   "choose_game": "Spielvorlage wählen",
   "choose_group": "Gruppe wählen",
   "choose_ruleset": "Regelwerk 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",
   "create_new_match": "Neues Spiel erstellen",
-  "created_on": "Erstellt am",
   "data": "Daten",
   "data_successfully_deleted": "Daten erfolgreich gelöscht",
   "data_successfully_exported": "Daten erfolgreich exportiert",
@@ -23,11 +20,6 @@
   "days_ago": "vor {count} Tagen",
   "delete": "Löschen",
   "delete_all_data": "Alle Daten löschen",
-  "delete_game": "Spielvorlage löschen",
-  "delete_group": "Gruppe löschen",
-  "description": "Beschreibung",
-  "edit_game": "Spielvorlage bearbeiten",
-  "edit_group": "Gruppe bearbeiten",
   "error_creating_group": "Fehler beim Erstellen der Gruppe, bitte erneut versuchen",
   "error_reading_file": "Fehler beim Lesen der Datei",
   "export_canceled": "Export abgebrochen",
@@ -37,7 +29,6 @@
   "game_name": "Spielvorlagenname",
   "group": "Gruppe",
   "group_name": "Gruppenname",
-  "group_profile": "Gruppenprofil",
   "groups": "Gruppen",
   "home": "Startseite",
   "import_canceled": "Import abgebrochen",
@@ -51,7 +42,6 @@
   "match_in_progress": "Spiel läuft...",
   "match_name": "Spieltitel",
   "matches": "Spiele",
-  "members": "Mitglieder",
   "most_points": "Höchste Punkte",
   "no_data_available": "Keine Daten verfügbar",
   "no_groups_created_yet": "Noch keine Gruppen erstellt",
@@ -67,7 +57,6 @@
   "none": "Kein",
   "none_group": "Keine",
   "not_available": "Nicht verfügbar",
-  "played_matches": "Gespielte Spiele",
   "player_name": "Spieler:innenname",
   "players": "Spieler:innen",
   "players_count": "{count} Spieler",

lib/l10n/arb/app_en.arb

@@ -12,9 +12,6 @@
   "@app_name": {
     "description": "The name of the App"
   },
-  "@best_player": {
-    "description": "Label for best player statistic"
-  },
   "@cancel": {
     "description": "Cancel button text"
   },
@@ -30,9 +27,6 @@
   "@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"
   },
@@ -45,9 +39,6 @@
   "@create_new_match": {
     "description": "Button text to create a new match"
   },
-  "@created_on": {
-    "description": "Label for creation date"
-  },
   "@data": {
     "description": "Data label"
   },
@@ -74,21 +65,6 @@
   "@delete_all_data": {
     "description": "Confirmation dialog for deleting all data"
   },
-  "@delete_game": {
-    "description": "Button text to delete a game"
-  },
-  "@delete_group": {
-    "description": "Button text to delete a group"
-  },
-  "description": {
-    "description": "Description label"
-  },
-  "edit_game": {
-    "description": "Button text to edit a game"
-   },
-  "@edit_group": {
-    "description": "Button text to edit a group"
-  },
   "@error_creating_group": {
     "description": "Error message when group creation fails"
   },
@@ -116,9 +92,6 @@
   "@group_name": {
     "description": "Placeholder for group name input"
   },
-  "@group_profile": {
-    "description": "Title for group profile view"
-  },
   "@groups": {
     "description": "Label for groups"
   },
@@ -158,9 +131,6 @@
   "@matches": {
     "description": "Label for matches"
   },
-  "@members": {
-    "description": "Label for group members"
-  },
   "@most_points": {
     "description": "Title for most points ruleset"
   },
@@ -206,9 +176,6 @@
   "@not_available": {
     "description": "Abbreviation for not available"
   },
-  "@played_matches": {
-    "description": "Label for played matches statistic"
-  },
   "@player_name": {
     "description": "Placeholder for player name input"
   },
@@ -314,17 +281,14 @@
   "all_players_selected": "All players selected",
   "amount_of_matches": "Amount of Matches",
   "app_name": "Game Tracker",
-  "best_player": "Best Player",
   "cancel": "Cancel",
   "choose_game": "Choose Game",
   "choose_group": "Choose Group",
   "choose_ruleset": "Choose Ruleset",
   "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",
-  "created_on": "Created on",
   "create_new_match": "Create new match",
   "data": "Data",
   "data_successfully_deleted": "Data successfully deleted",
@@ -333,11 +297,6 @@
   "days_ago": "{count} days ago",
   "delete": "Delete",
   "delete_all_data": "Delete all data",
-  "delete_game": "Delete Game",
-  "delete_group": "Delete Group",
-  "description": "Description",
-  "edit_game": "Edit Game",
-  "edit_group": "Edit Group",
   "error_creating_group": "Error while creating group, please try again",
   "error_reading_file": "Error reading file",
   "export_canceled": "Export canceled",
@@ -347,7 +306,6 @@
   "game_name": "Game Name",
   "group": "Group",
   "group_name": "Group name",
-  "group_profile": "Group Profile",
   "groups": "Groups",
   "home": "Home",
   "import_canceled": "Import canceled",
@@ -361,7 +319,6 @@
   "match_in_progress": "Match in progress...",
   "match_name": "Match name",
   "matches": "Matches",
-  "members": "Members",
   "most_points": "Most Points",
   "no_data_available": "No data available",
   "no_groups_created_yet": "No groups created yet",
@@ -377,7 +334,6 @@
   "none": "None",
   "none_group": "None",
   "not_available": "Not available",
-  "played_matches": "Played Matches",
   "player_name": "Player name",
   "players": "Players",
   "players_count": "{count} Players",

lib/l10n/generated/app_localizations.dart

@@ -98,18 +98,6 @@ 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:
@@ -134,12 +122,6 @@ abstract class AppLocalizations {
   /// **'Game Tracker'**
   String get app_name;
 
-  /// Label for best player statistic
-  ///
-  /// In en, this message translates to:
-  /// **'Best Player'**
-  String get best_player;
-
   /// Cancel button text
   ///
   /// In en, this message translates to:
@@ -170,12 +152,6 @@ abstract class AppLocalizations {
   /// **'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:
@@ -194,12 +170,6 @@ abstract class AppLocalizations {
   /// **'Create new group'**
   String get create_new_group;
 
-  /// Label for creation date
-  ///
-  /// In en, this message translates to:
-  /// **'Created on'**
-  String get created_on;
-
   /// Button text to create a new match
   ///
   /// In en, this message translates to:
@@ -248,24 +218,6 @@ 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;
-
-  /// Button text to delete a group
-  ///
-  /// In en, this message translates to:
-  /// **'Delete Group'**
-  String get delete_group;
-
-  /// Button text to edit a group
-  ///
-  /// In en, this message translates to:
-  /// **'Edit Group'**
-  String get edit_group;
-
   /// Error message when group creation fails
   ///
   /// In en, this message translates to:
@@ -320,12 +272,6 @@ abstract class AppLocalizations {
   /// **'Group name'**
   String get group_name;
 
-  /// Title for group profile view
-  ///
-  /// In en, this message translates to:
-  /// **'Group Profile'**
-  String get group_profile;
-
   /// Label for groups
   ///
   /// In en, this message translates to:
@@ -404,12 +350,6 @@ abstract class AppLocalizations {
   /// **'Matches'**
   String get matches;
 
-  /// Label for group members
-  ///
-  /// In en, this message translates to:
-  /// **'Members'**
-  String get members;
-
   /// Title for most points ruleset
   ///
   /// In en, this message translates to:
@@ -500,12 +440,6 @@ abstract class AppLocalizations {
   /// **'Not available'**
   String get not_available;
 
-  /// Label for played matches statistic
-  ///
-  /// In en, this message translates to:
-  /// **'Played Matches'**
-  String get played_matches;
-
   /// Placeholder for player name input
   ///
   /// In en, this message translates to:

lib/l10n/generated/app_localizations_de.dart

@@ -8,12 +8,6 @@ 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';
 
@@ -26,9 +20,6 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get app_name => 'Game Tracker';
 
-  @override
-  String get best_player => 'Beste:r Spieler:in';
-
   @override
   String get cancel => 'Abbrechen';
 
@@ -46,9 +37,6 @@ class AppLocalizationsDe extends AppLocalizations {
     return 'Spieler:in $playerName konnte nicht hinzugefügt werden';
   }
 
-  @override
-  String get create_game => 'Spielvorlage erstellen';
-
   @override
   String get create_group => 'Gruppe erstellen';
 
@@ -58,9 +46,6 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get create_new_group => 'Neue Gruppe erstellen';
 
-  @override
-  String get created_on => 'Erstellt am';
-
   @override
   String get create_new_match => 'Neues Spiel erstellen';
 
@@ -87,15 +72,6 @@ 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';
-
-  @override
-  String get edit_group => 'Gruppe bearbeiten';
-
   @override
   String get error_creating_group =>
       'Fehler beim Erstellen der Gruppe, bitte erneut versuchen';
@@ -124,9 +100,6 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get group_name => 'Gruppenname';
 
-  @override
-  String get group_profile => 'Gruppenprofil';
-
   @override
   String get groups => 'Gruppen';
 
@@ -166,9 +139,6 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get matches => 'Spiele';
 
-  @override
-  String get members => 'Mitglieder';
-
   @override
   String get most_points => 'Höchste Punkte';
 
@@ -215,9 +185,6 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get not_available => 'Nicht verfügbar';
 
-  @override
-  String get played_matches => 'Gespielte Spiele';
-
   @override
   String get player_name => 'Spieler:innenname';
 

lib/l10n/generated/app_localizations_en.dart

@@ -8,12 +8,6 @@ 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';
 
@@ -26,9 +20,6 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get app_name => 'Game Tracker';
 
-  @override
-  String get best_player => 'Best Player';
-
   @override
   String get cancel => 'Cancel';
 
@@ -46,9 +37,6 @@ class AppLocalizationsEn extends AppLocalizations {
     return 'Could not add player';
   }
 
-  @override
-  String get create_game => 'Create Game';
-
   @override
   String get create_group => 'Create Group';
 
@@ -58,9 +46,6 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get create_new_group => 'Create new group';
 
-  @override
-  String get created_on => 'Created on';
-
   @override
   String get create_new_match => 'Create new match';
 
@@ -87,15 +72,6 @@ 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';
-
-  @override
-  String get edit_group => 'Edit Group';
-
   @override
   String get error_creating_group =>
       'Error while creating group, please try again';
@@ -124,9 +100,6 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get group_name => 'Group name';
 
-  @override
-  String get group_profile => 'Group Profile';
-
   @override
   String get groups => 'Groups';
 
@@ -166,9 +139,6 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get matches => 'Matches';
 
-  @override
-  String get members => 'Members';
-
   @override
   String get most_points => 'Most Points';
 
@@ -215,9 +185,6 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get not_available => 'Not available';
 
-  @override
-  String get played_matches => 'Played Matches';
-
   @override
   String get player_name => 'Player name';
 

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

@@ -1,5 +1,4 @@
 import 'package:flutter/material.dart';
-import 'package:game_tracker/core/constants.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 import 'package:game_tracker/core/enums.dart';
 import 'package:game_tracker/data/db/database.dart';
@@ -48,7 +47,6 @@ class _CreateGroupViewState extends State<CreateGroupView> {
     final loc = AppLocalizations.of(context);
     return ScaffoldMessenger(
       child: Scaffold(
-        resizeToAvoidBottomInset: false,
         backgroundColor: CustomTheme.backgroundColor,
         appBar: AppBar(title: Text(loc.create_new_group)),
         body: SafeArea(
@@ -60,7 +58,6 @@ class _CreateGroupViewState extends State<CreateGroupView> {
                 child: TextInputField(
                   controller: _groupNameController,
                   hintText: loc.group_name,
-                  maxLength: Constants.MAX_GROUP_NAME_LENGTH,
                 ),
               ),
               Expanded(

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

@@ -1,271 +0,0 @@
-import 'package:flutter/material.dart';
-import 'package:game_tracker/core/custom_theme.dart';
-import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/group.dart';
-import 'package:game_tracker/data/dto/match.dart';
-import 'package:game_tracker/data/dto/player.dart';
-import 'package:game_tracker/l10n/generated/app_localizations.dart';
-import 'package:game_tracker/presentation/widgets/app_skeleton.dart';
-import 'package:game_tracker/presentation/widgets/buttons/animated_dialog_button.dart';
-import 'package:game_tracker/presentation/widgets/buttons/main_menu_button.dart';
-import 'package:game_tracker/presentation/widgets/colored_icon_container.dart';
-import 'package:game_tracker/presentation/widgets/custom_alert_dialog.dart';
-import 'package:game_tracker/presentation/widgets/tiles/info_tile.dart';
-import 'package:game_tracker/presentation/widgets/tiles/text_icon_tile.dart';
-import 'package:intl/intl.dart';
-import 'package:provider/provider.dart';
-
-class GroupProfileView extends StatefulWidget {
-  /// A view that displays the profile of a group
-  /// - [group]: The group to display
-  const GroupProfileView({
-    super.key,
-    required this.group,
-    required this.callback,
-  });
-
-  /// The group to display
-  final Group group;
-
-  final VoidCallback callback;
-
-  @override
-  State<GroupProfileView> createState() => _GroupProfileViewState();
-}
-
-class _GroupProfileViewState extends State<GroupProfileView> {
-  late final AppDatabase db;
-  bool isLoading = true;
-
-  /// Total matches played in this group
-  int totalMatches = 0;
-
-  String bestPlayer = '';
-
-  @override
-  void initState() {
-    super.initState();
-    db = Provider.of<AppDatabase>(context, listen: false);
-    _loadStatistics();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    final loc = AppLocalizations.of(context);
-
-    return Scaffold(
-      backgroundColor: CustomTheme.backgroundColor,
-      appBar: AppBar(
-        title: Text(loc.group_profile),
-        actions: [
-          IconButton(
-            icon: const Icon(Icons.delete),
-            onPressed: () async {
-              showDialog<bool>(
-                context: context,
-                builder: (context) => CustomAlertDialog(
-                  title: '${loc.delete_group}?',
-                  content: loc.this_cannot_be_undone,
-                  actions: [
-                    AnimatedDialogButton(
-                      onPressed: () => Navigator.of(context).pop(false),
-                      child: Text(
-                        loc.cancel,
-                        style: const TextStyle(color: CustomTheme.textColor),
-                      ),
-                    ),
-                    AnimatedDialogButton(
-                      onPressed: () => Navigator.of(context).pop(true),
-                      child: Text(
-                        loc.delete,
-                        style: TextStyle(color: CustomTheme.secondaryColor),
-                      ),
-                    ),
-                  ],
-                ),
-              ).then((confirmed) async {
-                if (confirmed! && context.mounted) {
-                  await db.groupDao.deleteGroup(groupId: widget.group.id);
-                  if (!context.mounted) return;
-                  Navigator.pop(context);
-                  widget.callback.call();
-                }
-              });
-            },
-          ),
-        ],
-      ),
-      body: SafeArea(
-        child: Stack(
-          alignment: Alignment.center,
-          children: [
-            ListView(
-              padding: const EdgeInsets.only(
-                left: 12,
-                right: 12,
-                top: 20,
-                bottom: 100,
-              ),
-              children: [
-                const Center(
-                  child: ColoredIconContainer(
-                    icon: Icons.group,
-                    containerSize: 55,
-                    iconSize: 38,
-                  ),
-                ),
-                const SizedBox(height: 10),
-                Text(
-                  widget.group.name,
-                  style: const TextStyle(
-                    fontSize: 28,
-                    fontWeight: FontWeight.bold,
-                    color: CustomTheme.textColor,
-                  ),
-                  textAlign: TextAlign.center,
-                ),
-                const SizedBox(height: 5),
-                Text(
-                  '${loc.created_on} ${DateFormat.yMMMd(Localizations.localeOf(context).toString()).format(widget.group.createdAt)}',
-                  style: const TextStyle(
-                    fontSize: 12,
-                    color: CustomTheme.textColor,
-                  ),
-                  textAlign: TextAlign.center,
-                ),
-                const SizedBox(height: 20),
-                InfoTile(
-                  title: loc.members,
-                  icon: Icons.people,
-                  horizontalAlignment: CrossAxisAlignment.start,
-                  content: Wrap(
-                    alignment: WrapAlignment.start,
-                    crossAxisAlignment: WrapCrossAlignment.start,
-                    spacing: 12,
-                    runSpacing: 8,
-                    children: widget.group.members.map((member) {
-                      return TextIconTile(
-                        text: member.name,
-                        iconEnabled: false,
-                      );
-                    }).toList(),
-                  ),
-                ),
-                const SizedBox(height: 15),
-                InfoTile(
-                  title: loc.statistics,
-                  icon: Icons.bar_chart,
-                  content: AppSkeleton(
-                    enabled: isLoading,
-                    child: Column(
-                      children: [
-                        _buildStatRow(
-                          loc.members,
-                          widget.group.members.length.toString(),
-                        ),
-                        _buildStatRow(
-                          loc.played_matches,
-                          totalMatches.toString(),
-                        ),
-                        _buildStatRow(loc.best_player, bestPlayer),
-                      ],
-                    ),
-                  ),
-                ),
-              ],
-            ),
-            Positioned(
-              bottom: MediaQuery.paddingOf(context).bottom,
-              child: MainMenuButton(
-                text: loc.edit_group,
-                icon: Icons.edit,
-                onPressed: () {
-                  // TODO: Uncomment when GroupDetailView is implemented
-                  /*
-                  await Navigator.push(
-                    context,
-                    adaptivePageRoute(
-                      builder: (context) {
-
-                        return const GroupDetailView();
-                      },
-                    ),
-                  );*/
-                  print('Edit Group pressed');
-                },
-              ),
-            ),
-          ],
-        ),
-      ),
-    );
-  }
-
-  /// Builds a single statistic row with a label and value
-  /// - [label]: The label of the statistic
-  /// - [value]: The value of the statistic
-  Widget _buildStatRow(String label, String value) {
-    return Padding(
-      padding: const EdgeInsets.symmetric(vertical: 4, horizontal: 8),
-      child: Row(
-        mainAxisAlignment: MainAxisAlignment.spaceBetween,
-        children: [
-          Row(
-            children: [
-              Text(
-                label,
-                style: const TextStyle(
-                  fontSize: 16,
-                  color: CustomTheme.textColor,
-                ),
-              ),
-            ],
-          ),
-          Text(
-            value,
-            style: const TextStyle(fontSize: 16, fontWeight: FontWeight.bold),
-          ),
-        ],
-      ),
-    );
-  }
-
-  /// Loads statistics for this group
-  Future<void> _loadStatistics() async {
-    final matches = await db.matchDao.getAllMatches();
-    final groupMatches = matches
-        .where((match) => match.group?.id == widget.group.id)
-        .toList();
-
-    setState(() {
-      totalMatches = groupMatches.length;
-      bestPlayer = _getBestPlayer(groupMatches);
-      isLoading = false;
-    });
-  }
-
-  /// Determines the best player in the group based on match wins
-  String _getBestPlayer(List<Match> matches) {
-    final bestPlayerCounts = <Player, int>{};
-
-    // Count wins for each player
-    for (var match in matches) {
-      if (match.winner != null) {
-        bestPlayerCounts.update(
-          match.winner!,
-          (value) => value + 1,
-          ifAbsent: () => 1,
-        );
-      }
-    }
-
-    // Sort players by win count
-    final sortedPlayers = bestPlayerCounts.entries.toList()
-      ..sort((a, b) => b.value.compareTo(a.value));
-
-    // Get the best player
-    bestPlayer = sortedPlayers.isNotEmpty ? sortedPlayers.first.key.name : '-';
-
-    return bestPlayer;
-  }
-}

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

@@ -7,7 +7,6 @@ import 'package:game_tracker/data/dto/group.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:game_tracker/l10n/generated/app_localizations.dart';
 import 'package:game_tracker/presentation/views/main_menu/group_view/create_group_view.dart';
-import 'package:game_tracker/presentation/views/main_menu/group_view/group_profile_view.dart';
 import 'package:game_tracker/presentation/widgets/app_skeleton.dart';
 import 'package:game_tracker/presentation/widgets/buttons/main_menu_button.dart';
 import 'package:game_tracker/presentation/widgets/tiles/group_tile.dart';
@@ -75,22 +74,7 @@ class _GroupsViewState extends State<GroupsView> {
                       height: MediaQuery.paddingOf(context).bottom - 20,
                     );
                   }
-                  return GroupTile(
-                    group: groups[index],
-                    onTap: () async {
-                      await Navigator.push(
-                        context,
-                        adaptivePageRoute(
-                          builder: (context) {
-                            return GroupProfileView(
-                              group: groups[index],
-                              callback: loadGroups,
-                            );
-                          },
-                        ),
-                      );
-                    },
-                  );
+                  return GroupTile(group: groups[index]);
                 },
               ),
             ),
@@ -121,12 +105,9 @@ class _GroupsViewState extends State<GroupsView> {
   }
 
   void loadGroups() {
-    setState(() {
-      isLoading = true;
-    });
     Future.wait([
       db.groupDao.getAllGroups(),
-      Future.delayed(Constants.MINIMUM_SKELETON_DURATION),
+      Future.delayed(Constants.minimumSkeletonDuration),
     ]).then((results) {
       loadedGroups = results[0] as List<Group>;
       setState(() {

lib/presentation/views/main_menu/home_view.dart

@@ -195,7 +195,7 @@ class _HomeViewState extends State<HomeView> {
       db.matchDao.getMatchCount(),
       db.groupDao.getGroupCount(),
       db.matchDao.getAllMatches(),
-      Future.delayed(Constants.MINIMUM_SKELETON_DURATION),
+      Future.delayed(Constants.minimumSkeletonDuration),
     ]).then((results) {
       matchCount = results[0] as int;
       groupCount = results[1] as int;

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

@@ -1,10 +1,7 @@
 import 'package:flutter/material.dart';
-import 'package:game_tracker/core/adaptive_page_route.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 import 'package:game_tracker/core/enums.dart';
-import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/l10n/generated/app_localizations.dart';
-import 'package:game_tracker/presentation/views/main_menu/match_view/create_match/game_view/create_game_view.dart';
 import 'package:game_tracker/presentation/widgets/text_input/custom_search_bar.dart';
 import 'package:game_tracker/presentation/widgets/tiles/title_description_list_tile.dart';
 
@@ -46,7 +43,6 @@ class _ChooseGameViewState extends State<ChooseGameView> {
     final loc = AppLocalizations.of(context);
     return Scaffold(
       backgroundColor: CustomTheme.backgroundColor,
-      resizeToAvoidBottomInset: false,
       appBar: AppBar(
         leading: IconButton(
           icon: const Icon(Icons.arrow_back_ios),
@@ -54,17 +50,6 @@ class _ChooseGameViewState extends State<ChooseGameView> {
             Navigator.of(context).pop(selectedGameIndex);
           },
         ),
-        actions: [IconButton(
-          icon: const Icon(Icons.add),
-          onPressed: () async {
-            await Navigator.push(context, adaptivePageRoute(
-              builder: (context) => CreateGameView(
-                callback: () {}, //TODO: implement callback
-              ),
-            )
-            );
-          },
-        )],
         title: Text(loc.choose_game),
       ),
       body: PopScope(
@@ -99,7 +84,7 @@ class _ChooseGameViewState extends State<ChooseGameView> {
                       context,
                     ),
                     isHighlighted: selectedGameIndex == index,
-                    onTap: () async {
+                    onPressed: () async {
                       setState(() {
                         if (selectedGameIndex == index) {
                           selectedGameIndex = -1;
@@ -108,16 +93,6 @@ class _ChooseGameViewState extends State<ChooseGameView> {
                         }
                       });
                     },
-                    onLongPress: () async {
-                      await Navigator.push(context, adaptivePageRoute(
-                        builder: (context) => CreateGameView(
-                          //TODO: implement callback & giving real game to create game view
-                          gameToEdit: Game(name: 'Cabo', description: '', ruleset: 'Highest Points'),
-                          callback: () {},
-                        ),
-                      )
-                      );
-                    },
                   );
                 },
               ),

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

@@ -43,7 +43,6 @@ class _ChooseGroupViewState extends State<ChooseGroupView> {
     final loc = AppLocalizations.of(context);
     return Scaffold(
       backgroundColor: CustomTheme.backgroundColor,
-      resizeToAvoidBottomInset: false,
       appBar: AppBar(
         leading: IconButton(
           icon: const Icon(Icons.arrow_back_ios),

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

@@ -3,6 +3,7 @@ import 'package:game_tracker/core/custom_theme.dart';
 import 'package:game_tracker/core/enums.dart';
 import 'package:game_tracker/l10n/generated/app_localizations.dart';
 import 'package:game_tracker/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
@@ -12,13 +13,17 @@ class ChooseRulesetView extends StatefulWidget {
     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;
@@ -28,6 +33,7 @@ class _ChooseRulesetViewState extends State<ChooseRulesetView> {
     selectedRulesetIndex = widget.initialRulesetIndex;
     super.initState();
   }
+
   @override
   Widget build(BuildContext context) {
     final loc = AppLocalizations.of(context);
@@ -68,7 +74,7 @@ class _ChooseRulesetViewState extends State<ChooseRulesetView> {
             itemCount: widget.rulesets.length,
             itemBuilder: (BuildContext context, int index) {
               return TitleDescriptionListTile(
-                onTap: () async {
+                onPressed: () async {
                   setState(() {
                     if (selectedRulesetIndex == index) {
                       selectedRulesetIndex = -1;

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

@@ -1,15 +1,16 @@
 import 'package:flutter/material.dart';
 import 'package:game_tracker/core/adaptive_page_route.dart';
-import 'package:game_tracker/core/constants.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 import 'package:game_tracker/core/enums.dart';
 import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/data/dto/group.dart';
 import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:game_tracker/l10n/generated/app_localizations.dart';
 import 'package:game_tracker/presentation/views/main_menu/match_view/create_match/choose_game_view.dart';
 import 'package:game_tracker/presentation/views/main_menu/match_view/create_match/choose_group_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/create_match/choose_ruleset_view.dart';
 import 'package:game_tracker/presentation/views/main_menu/match_view/match_result_view.dart';
 import 'package:game_tracker/presentation/widgets/buttons/custom_width_button.dart';
 import 'package:game_tracker/presentation/widgets/player_selection.dart';
@@ -57,6 +58,13 @@ class _CreateMatchViewState extends State<CreateMatchView> {
   /// the [ChooseGroupView]
   String selectedGroupId = '';
 
+  /// The currently selected ruleset
+  Ruleset? selectedRuleset;
+
+  /// The index of the currently selected ruleset in [rulesets] to mark it in
+  /// the [ChooseRulesetView]
+  int selectedRulesetIndex = -1;
+
   /// The index of the currently selected game in [games] to mark it in
   /// the [ChooseGameView]
   int selectedGameIndex = -1;
@@ -64,6 +72,9 @@ class _CreateMatchViewState extends State<CreateMatchView> {
   /// The currently selected players
   List<Player>? selectedPlayers;
 
+  /// List of available rulesets with their localized string representations
+  late final List<(Ruleset, String)> _rulesets;
+
   @override
   void initState() {
     super.initState();
@@ -96,8 +107,15 @@ class _CreateMatchViewState extends State<CreateMatchView> {
     super.didChangeDependencies();
     final loc = AppLocalizations.of(context);
     hintText ??= loc.match_name;
+    _rulesets = [
+      (Ruleset.singleWinner, loc.ruleset_single_winner),
+      (Ruleset.singleLoser, loc.ruleset_single_loser),
+      (Ruleset.mostPoints, loc.ruleset_most_points),
+      (Ruleset.leastPoints, loc.ruleset_least_points),
+    ];
   }
 
+  // TODO: Replace when games are implemented
   List<(String, String, Ruleset)> games = [
     ('Example Game 1', 'This is a description', Ruleset.leastPoints),
     ('Example Game 2', '', Ruleset.singleWinner),
@@ -108,7 +126,6 @@ class _CreateMatchViewState extends State<CreateMatchView> {
     final loc = AppLocalizations.of(context);
     return ScaffoldMessenger(
       child: Scaffold(
-        resizeToAvoidBottomInset: false,
         backgroundColor: CustomTheme.backgroundColor,
         appBar: AppBar(title: Text(loc.create_new_match)),
         body: SafeArea(
@@ -120,7 +137,6 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                 child: TextInputField(
                   controller: _matchNameController,
                   hintText: hintText ?? '',
-                  maxLength: Constants.MAX_MATCH_NAME_LENGTH,
                 ),
               ),
               ChooseTile(
@@ -140,12 +156,39 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                   setState(() {
                     if (selectedGameIndex != -1) {
                       hintText = games[selectedGameIndex].$1;
+                      selectedRuleset = games[selectedGameIndex].$3;
+                      selectedRulesetIndex = _rulesets.indexWhere(
+                        (r) => r.$1 == selectedRuleset,
+                      );
                     } else {
                       hintText = loc.match_name;
+                      selectedRuleset = null;
                     }
                   });
                 },
               ),
+              ChooseTile(
+                title: loc.ruleset,
+                trailingText: selectedRuleset == null
+                    ? loc.none
+                    : translateRulesetToString(selectedRuleset!, context),
+                onPressed: () async {
+                  selectedRuleset = await Navigator.of(context).push(
+                    adaptivePageRoute(
+                      builder: (context) => ChooseRulesetView(
+                        rulesets: _rulesets,
+                        initialRulesetIndex: selectedRulesetIndex,
+                      ),
+                    ),
+                  );
+                  if (!mounted) return;
+                  selectedRulesetIndex = _rulesets.indexWhere(
+                    (r) => r.$1 == selectedRuleset,
+                  );
+                  selectedGameIndex = -1;
+                  setState(() {});
+                },
+              ),
               ChooseTile(
                 title: loc.group,
                 trailingText: selectedGroup == null
@@ -192,11 +235,20 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                 buttonType: ButtonType.primary,
                 onPressed: _enableCreateGameButton()
                     ? () async {
+                        final selectedGame = games[selectedGameIndex];
+                        final game = Game(
+                          name: selectedGame.$1,
+                          description: selectedGame.$2.isEmpty ? null : selectedGame.$2,
+                          ruleset: selectedGame.$3.name,
+                        );
+                        // Ensure the game exists in the database before creating the match
+                        await db.gameDao.addGame(game: game);
                         Match match = Match(
                           name: _matchNameController.text.isEmpty
                               ? (hintText ?? '')
                               : _matchNameController.text.trim(),
                           createdAt: DateTime.now(),
+                          game: game,
                           group: selectedGroup,
                           players: selectedPlayers,
                         );
@@ -226,10 +278,13 @@ class _CreateMatchViewState extends State<CreateMatchView> {
   /// Determines whether the "Create Match" button should be enabled.
   ///
   /// Returns `true` if:
+  /// - A game is selected AND
   /// - A ruleset is selected AND
   /// - Either a group is selected OR at least 2 players are selected
   bool _enableCreateGameButton() {
-    return (selectedGroup != null ||
-            (selectedPlayers != null && selectedPlayers!.length > 1));
+    return selectedGameIndex != -1 &&
+        (selectedGroup != null ||
+            (selectedPlayers != null && selectedPlayers!.length > 1)) &&
+        selectedRuleset != null;
   }
 }

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

@@ -1,140 +0,0 @@
-import 'package:flutter/material.dart';
-import 'package:game_tracker/core/adaptive_page_route.dart';
-import 'package:game_tracker/core/constants.dart';
-import 'package:game_tracker/core/custom_theme.dart';
-import 'package:game_tracker/core/enums.dart';
-import 'package:game_tracker/data/dto/game.dart';
-import 'package:game_tracker/l10n/generated/app_localizations.dart';
-import 'package:game_tracker/presentation/views/main_menu/match_view/create_match/game_view/choose_ruleset_view.dart';
-import 'package:game_tracker/presentation/widgets/buttons/custom_width_button.dart';
-import 'package:game_tracker/presentation/widgets/text_input/text_input_field.dart';
-import 'package:game_tracker/presentation/widgets/tiles/choose_tile.dart';
-
-class CreateGameView extends StatefulWidget {
-  const CreateGameView({super.key, this.gameToEdit, required this.callback});
-
-  final Game? gameToEdit;
-
-  final VoidCallback callback;
-
-  @override
-  State<CreateGameView> createState() => _CreateGameViewState();
-}
-
-class _CreateGameViewState extends State<CreateGameView> {
-  Ruleset? selectedRuleset;
-  int selectedRulesetIndex = -1;
-  late List<(Ruleset, String)> _rulesets;
-
-  final _gameNameController = TextEditingController();
-  final _descriptionController = TextEditingController();
-
-  @override
-  void initState() {
-    super.initState();
-    _gameNameController.addListener(() => setState(() {}));
-  }
-
-  @override
-  void didChangeDependencies() {
-    super.didChangeDependencies();
-    final loc = AppLocalizations.of(context);
-    _rulesets = [
-      (Ruleset.singleWinner, loc.ruleset_single_winner),
-      (Ruleset.singleLoser, loc.ruleset_single_loser),
-      (Ruleset.mostPoints, loc.ruleset_most_points),
-      (Ruleset.leastPoints, loc.ruleset_least_points),
-    ];
-
-    if (widget.gameToEdit != null) {
-      _gameNameController.text = widget.gameToEdit!.name;
-      _descriptionController.text = widget.gameToEdit!.description ?? '';
-      // TODO: Handle ruleset initialization from gameToEdit
-    }
-  }
-
-  @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),
-        ),
-        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);
-                    });
-                  }
-                },
-              ),
-              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_group : loc.create_game,
-                  sizeRelativeToWidth: 1,
-                  buttonType: ButtonType.primary,
-                  onPressed: _gameNameController.text.trim().isNotEmpty && selectedRulesetIndex != -1
-                      ? () {
-                          //TODO: Handle saving to db & updating game selection view
-                          Navigator.of(context).pop();
-                        }
-                      : null,
-                ),
-              ),
-            ],
-          ),
-        ),
-      ),
-    );
-  }
-}

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

@@ -130,7 +130,7 @@ class _MatchViewState extends State<MatchView> {
   void loadGames() {
     Future.wait([
       db.matchDao.getAllMatches(),
-      Future.delayed(Constants.MINIMUM_SKELETON_DURATION),
+      Future.delayed(Constants.minimumSkeletonDuration),
     ]).then((results) {
       if (mounted) {
         setState(() {

lib/presentation/views/main_menu/settings_view/licenses/license_detail_view.dart

@@ -2,7 +2,6 @@ import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 import 'package:game_tracker/l10n/generated/app_localizations.dart';
 import 'package:game_tracker/presentation/views/main_menu/settings_view/licenses/oss_licenses.dart';
-import 'package:game_tracker/presentation/widgets/colored_icon_container.dart';
 import 'package:url_launcher/url_launcher.dart';
 
 class LicenseDetailView extends StatelessWidget {
@@ -30,11 +29,19 @@ class LicenseDetailView extends StatelessWidget {
                   Row(
                     mainAxisAlignment: MainAxisAlignment.center,
                     children: [
-                      const ColoredIconContainer(
-                        icon: Icons.description,
-                        margin: EdgeInsetsGeometry.only(right: 15),
-                        containerSize: 60,
-                        iconSize: 30,
+                      Container(
+                        margin: const EdgeInsetsGeometry.only(right: 15),
+                        width: 60,
+                        height: 60,
+                        decoration: BoxDecoration(
+                          color: CustomTheme.primaryColor.withAlpha(40),
+                          borderRadius: BorderRadius.circular(10),
+                        ),
+                        child: Icon(
+                          Icons.description,
+                          color: CustomTheme.primaryColor,
+                          size: 30,
+                        ),
                       ),
                       Column(
                         crossAxisAlignment: CrossAxisAlignment.start,

lib/presentation/views/main_menu/statistics_view.dart

@@ -106,7 +106,7 @@ class _StatisticsViewState extends State<StatisticsView> {
     Future.wait([
       db.matchDao.getAllMatches(),
       db.playerDao.getAllPlayers(),
-      Future.delayed(Constants.MINIMUM_SKELETON_DURATION),
+      Future.delayed(Constants.minimumSkeletonDuration),
     ]).then((results) async {
       if (!mounted) return;
       final matches = results[0] as List<Match>;

lib/presentation/widgets/colored_icon_container.dart

@@ -1,57 +0,0 @@
-import 'package:flutter/cupertino.dart';
-import 'package:game_tracker/core/custom_theme.dart';
-
-class ColoredIconContainer extends StatelessWidget {
-  /// A customizable container widget that displays an icon with a colored background.
-  /// - [icon]: The icon to be displayed inside the container.
-  /// - [containerSize]: The size of the container (width and height).
-  /// - [iconSize]: The size of the icon inside the container.
-  /// - [margin]: Optional margin around the container.
-  /// - [padding]: Optional padding inside the container.
-  const ColoredIconContainer({
-    super.key,
-    required this.icon,
-    this.containerSize = 44,
-    this.iconSize = 28,
-    this.margin,
-    this.padding,
-  });
-
-  /// The icon to be displayed inside the container.
-  final IconData icon;
-
-  /// The size of the container (width and height).
-  final double containerSize;
-
-  /// The size of the icon inside the container.
-  final double iconSize;
-
-  /// Optional margin around the container.
-  final EdgeInsetsGeometry? margin;
-
-  /// Optional padding inside the container.
-  final EdgeInsetsGeometry? padding;
-
-  @override
-  Widget build(BuildContext context) {
-    return Stack(
-      children: [
-        Container(
-          width: containerSize,
-          height: containerSize,
-          margin: margin,
-          padding: padding,
-          decoration: BoxDecoration(
-            color: CustomTheme.primaryColor.withAlpha(40),
-            borderRadius: BorderRadius.circular(10),
-          ),
-          child: Icon(
-            icon,
-            size: iconSize,
-            color: CustomTheme.primaryColor.withGreen(40),
-          ),
-        ),
-      ],
-    );
-  }
-}

lib/presentation/widgets/player_selection.dart

@@ -84,7 +84,6 @@ class _PlayerSelectionState extends State<PlayerSelection> {
         crossAxisAlignment: CrossAxisAlignment.start,
         children: [
           CustomSearchBar(
-            maxLength: Constants.MAX_PLAYER_NAME_LENGTH,
             controller: _searchBarController,
             constraints: const BoxConstraints(maxHeight: 45, minHeight: 45),
             hintText: loc.search_for_players,
@@ -220,7 +219,7 @@ class _PlayerSelectionState extends State<PlayerSelection> {
   void loadPlayerList() {
     _allPlayersFuture = Future.wait([
       db.playerDao.getAllPlayers(),
-      Future.delayed(Constants.MINIMUM_SKELETON_DURATION),
+      Future.delayed(Constants.minimumSkeletonDuration),
     ]).then((results) => results[0] as List<Player>);
     if (mounted) {
       _allPlayersFuture.then((loadedPlayers) {

lib/presentation/widgets/text_input/custom_search_bar.dart

@@ -21,7 +21,6 @@ class CustomSearchBar extends StatelessWidget {
     this.onTrailingButtonPressed,
     this.onChanged,
     this.constraints,
-    this.maxLength,
   });
 
   /// The controller for the search bar's text input.
@@ -48,21 +47,8 @@ class CustomSearchBar extends StatelessWidget {
   /// The constraints for the search bar.
   final BoxConstraints? constraints;
 
-  /// Optional parameter for maximum length of the input text.
-  final int? maxLength;
-
   @override
   Widget build(BuildContext context) {
-    /// Enforce maximum length on the input text
-    if (maxLength != null) {
-      if (controller.text.length > maxLength!) {
-        controller.text = controller.text.substring(0, maxLength);
-        controller.selection = TextSelection.fromPosition(
-          TextPosition(offset: controller.text.length),
-        );
-      }
-    }
-
     return SearchBar(
       controller: controller,
       constraints:

lib/presentation/widgets/text_input/text_input_field.dart

@@ -1,63 +1,37 @@
 import 'package:flutter/material.dart';
-import 'package:flutter/services.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 
 class TextInputField extends StatelessWidget {
   /// A custom text input field widget that encapsulates a [TextField] with specific styling.
   /// - [controller]: The controller for the text input field.
-  /// - [onChanged]: Optional callback invoked when the text in the field changes.
+  /// - [onChanged]: The 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.
   final TextEditingController controller;
 
-  /// Optional callback invoked when the text in the field changes.
+  /// The callback invoked when the text in the field changes.
   final ValueChanged<String>? onChanged;
 
   /// The hint text displayed in the text input field when it is empty.
   final String hintText;
 
-  /// 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(
       controller: controller,
       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),
-        counterText: showCounterText ? null : '',
         enabledBorder: OutlineInputBorder(
           borderRadius: const BorderRadius.all(Radius.circular(12)),
           borderSide: BorderSide(color: CustomTheme.boxBorder),

lib/presentation/widgets/tiles/group_tile.dart

@@ -3,17 +3,11 @@ import 'package:game_tracker/core/custom_theme.dart';
 import 'package:game_tracker/data/dto/group.dart';
 import 'package:game_tracker/presentation/widgets/tiles/text_icon_tile.dart';
 
-class GroupTile extends StatefulWidget {
+class GroupTile extends StatelessWidget {
   /// A tile widget that displays information about a group, including its name and members.
   /// - [group]: The group data to be displayed.
   /// - [isHighlighted]: Whether the tile should be highlighted.
-  /// - [onTap]: Callback function to be executed when the tile is tapped.
-  const GroupTile({
-    super.key,
-    required this.group,
-    this.isHighlighted = false,
-    this.onTap,
-  });
+  const GroupTile({super.key, required this.group, this.isHighlighted = false});
 
   /// The group data to be displayed.
   final Group group;
@@ -21,72 +15,61 @@ class GroupTile extends StatefulWidget {
   /// Whether the tile should be highlighted.
   final bool isHighlighted;
 
-  /// Callback function to be executed when the tile is tapped.
-  final VoidCallback? onTap;
-
-  @override
-  State<GroupTile> createState() => _GroupTileState();
-}
-
-class _GroupTileState extends State<GroupTile> {
   @override
   Widget build(BuildContext context) {
-    return GestureDetector(
-      onTap: widget.onTap,
-      child: AnimatedContainer(
-        margin: CustomTheme.standardMargin,
-        padding: const EdgeInsets.symmetric(vertical: 5, horizontal: 10),
-        decoration: widget.isHighlighted
-            ? CustomTheme.highlightedBoxDecoration
-            : CustomTheme.standardBoxDecoration,
-        duration: const Duration(milliseconds: 150),
-        child: Column(
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            Row(
-              mainAxisAlignment: MainAxisAlignment.spaceBetween,
-              children: [
-                Flexible(
-                  child: Text(
-                    widget.group.name,
-                    overflow: TextOverflow.ellipsis,
+    return AnimatedContainer(
+      margin: CustomTheme.standardMargin,
+      padding: const EdgeInsets.symmetric(vertical: 5, horizontal: 10),
+      decoration: isHighlighted
+          ? CustomTheme.highlightedBoxDecoration
+          : CustomTheme.standardBoxDecoration,
+      duration: const Duration(milliseconds: 150),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Row(
+            mainAxisAlignment: MainAxisAlignment.spaceBetween,
+            children: [
+              Flexible(
+                child: Text(
+                  group.name,
+                  overflow: TextOverflow.ellipsis,
+                  style: const TextStyle(
+                    fontWeight: FontWeight.bold,
+                    fontSize: 18,
+                  ),
+                ),
+              ),
+              Row(
+                children: [
+                  Text(
+                    '${group.members.length}',
                     style: const TextStyle(
-                      fontWeight: FontWeight.bold,
+                      fontWeight: FontWeight.w900,
                       fontSize: 18,
                     ),
                   ),
-                ),
-                Row(
-                  children: [
-                    Text(
-                      '${widget.group.members.length}',
-                      style: const TextStyle(
-                        fontWeight: FontWeight.w900,
-                        fontSize: 18,
-                      ),
-                    ),
-                    const SizedBox(width: 3),
-                    const Icon(Icons.group, size: 22),
-                  ],
-                ),
-              ],
-            ),
-            const SizedBox(height: 5),
-            Wrap(
-              alignment: WrapAlignment.start,
-              crossAxisAlignment: WrapCrossAlignment.start,
-              spacing: 12.0,
-              runSpacing: 8.0,
-              children: <Widget>[
-                for (var member in [
-                  ...widget.group.members,
-                ]..sort((a, b) => a.name.compareTo(b.name)))
-                  TextIconTile(text: member.name, iconEnabled: false),
-              ],
-            ),
-            const SizedBox(height: 2.5),
-          ],
-        ),
+                  const SizedBox(width: 3),
+                  const Icon(Icons.group, size: 22),
+                ],
+              ),
+            ],
+          ),
+          const SizedBox(height: 5),
+          Wrap(
+            alignment: WrapAlignment.start,
+            crossAxisAlignment: WrapCrossAlignment.start,
+            spacing: 12.0,
+            runSpacing: 8.0,
+            children: <Widget>[
+              for (var member in [
+                ...group.members,
+              ]..sort((a, b) => a.name.compareTo(b.name)))
+                TextIconTile(text: member.name, iconEnabled: false),
+            ],
+          ),
+          const SizedBox(height: 2.5),
+        ],
       ),
     );
   }

lib/presentation/widgets/tiles/info_tile.dart

@@ -17,7 +17,6 @@ class InfoTile extends StatefulWidget {
     this.padding,
     this.height,
     this.width,
-    this.horizontalAlignment = CrossAxisAlignment.center,
   });
 
   /// The title text displayed on the tile.
@@ -38,9 +37,6 @@ class InfoTile extends StatefulWidget {
   /// Optional width for the tile.
   final double? width;
 
-  /// The main axis alignment for the content.
-  final CrossAxisAlignment horizontalAlignment;
-
   @override
   State<InfoTile> createState() => _InfoTileState();
 }
@@ -55,7 +51,7 @@ class _InfoTileState extends State<InfoTile> {
       decoration: CustomTheme.standardBoxDecoration,
       child: Column(
         mainAxisAlignment: MainAxisAlignment.start,
-        crossAxisAlignment: widget.horizontalAlignment,
+        crossAxisAlignment: CrossAxisAlignment.center,
         children: [
           Row(
             children: [

lib/presentation/widgets/tiles/license_tile.dart

@@ -2,7 +2,6 @@ import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 import 'package:game_tracker/presentation/views/main_menu/settings_view/licenses/license_detail_view.dart';
 import 'package:game_tracker/presentation/views/main_menu/settings_view/licenses/oss_licenses.dart';
-import 'package:game_tracker/presentation/widgets/colored_icon_container.dart';
 
 class LicenseTile extends StatelessWidget {
   /// A tile widget that displays information about a software package license.
@@ -30,10 +29,18 @@ class LicenseTile extends StatelessWidget {
         ),
         child: Row(
           children: [
-            const ColoredIconContainer(
-              icon: Icons.description,
-              containerSize: 50,
-              iconSize: 32,
+            Container(
+              width: 50,
+              height: 50,
+              decoration: BoxDecoration(
+                color: CustomTheme.primaryColor.withAlpha(40),
+                borderRadius: BorderRadius.circular(10),
+              ),
+              child: Icon(
+                Icons.description,
+                color: CustomTheme.primaryColor,
+                size: 32,
+              ),
             ),
             const SizedBox(width: 16),
             Expanded(

lib/presentation/widgets/tiles/match_tile.dart

@@ -230,7 +230,7 @@ class _MatchTileState extends State<MatchTile> {
     } else if (difference.inDays < 7) {
       return loc.days_ago(difference.inDays);
     } else {
-      return '${loc.created_on} ${DateFormat.yMMMd(Localizations.localeOf(context).toString()).format(dateTime)}';
+      return DateFormat('MMM d, yyyy').format(dateTime);
     }
   }
 

lib/presentation/widgets/tiles/settings_list_tile.dart

@@ -1,6 +1,5 @@
 import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
-import 'package:game_tracker/presentation/widgets/colored_icon_container.dart';
 
 class SettingsListTile extends StatelessWidget {
   /// A customizable settings list tile widget that displays an icon, title, and an optional suffix widget.
@@ -47,10 +46,18 @@ class SettingsListTile extends StatelessWidget {
                   Row(
                     mainAxisSize: MainAxisSize.min,
                     children: [
-                      ColoredIconContainer(
-                        icon: icon,
-                        containerSize: 44,
-                        iconSize: 28,
+                      Container(
+                        width: 44,
+                        height: 44,
+                        decoration: BoxDecoration(
+                          color: CustomTheme.primaryColor.withAlpha(40),
+                          borderRadius: BorderRadius.circular(10),
+                        ),
+                        child: Icon(
+                          icon,
+                          size: 28,
+                          color: CustomTheme.primaryColor.withGreen(40),
+                        ),
                       ),
                       const SizedBox(width: 16),
                       Text(title, style: const TextStyle(fontSize: 18)),

lib/presentation/widgets/tiles/title_description_list_tile.dart

@@ -6,7 +6,6 @@ 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.
@@ -14,8 +13,7 @@ class TitleDescriptionListTile extends StatelessWidget {
     super.key,
     required this.title,
     required this.description,
-    this.onTap,
-    this.onLongPress,
+    this.onPressed,
     this.isHighlighted = false,
     this.badgeText,
     this.badgeColor,
@@ -28,10 +26,7 @@ class TitleDescriptionListTile extends StatelessWidget {
   final String description;
 
   /// The callback invoked when the tile is tapped.
-  final VoidCallback? onTap;
-
-  /// The callback invoked when the tile is long-pressed.
-  final VoidCallback? onLongPress;
+  final VoidCallback? onPressed;
 
   /// A boolean to determine if the tile should be highlighted.
   final bool isHighlighted;
@@ -45,8 +40,7 @@ class TitleDescriptionListTile extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return GestureDetector(
-      onTap: onTap,
-      onLongPress: onLongPress,
+      onTap: onPressed,
       child: AnimatedContainer(
         margin: const EdgeInsets.symmetric(vertical: 10, horizontal: 10),
         padding: const EdgeInsets.symmetric(vertical: 6, horizontal: 12),
@@ -79,6 +73,7 @@ class TitleDescriptionListTile extends StatelessWidget {
                   const Spacer(),
                   Container(
                     constraints: const BoxConstraints(maxWidth: 115),
+                    margin: const EdgeInsets.only(top: 4),
                     padding: const EdgeInsets.symmetric(
                       vertical: 2,
                       horizontal: 6,

pubspec.yaml

@@ -1,7 +1,7 @@
 name: game_tracker
 description: "Game Tracking App for Card Games"
 publish_to: 'none'
-version: 0.0.10+248
+version: 0.0.7+212
 
 environment:
   sdk: ^3.8.1

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:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/group.dart';
-import 'package:game_tracker/data/dto/match.dart';
-import 'package:game_tracker/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);
-      }
-    });
-  });
-}