Added nameCount to statistic tiles

Reviewed-on: #196
Reviewed-by: gelbeinhalb <spam@yannick-weigert.de>

assets/schema.json

@@ -20,6 +20,7 @@
             "type": "string"
           }
         },
+        "additionalProperties": false,
         "required": [
           "id",
           "createdAt",
@@ -55,6 +56,7 @@
             "type": "string"
           }
         },
+        "additionalProperties": false,
         "required": [
           "id",
           "createdAt",
@@ -90,6 +92,7 @@
             }
           }
         },
+        "additionalProperties": false,
         "required": [
           "id",
           "name",
@@ -120,6 +123,7 @@
             }
           }
         },
+        "additionalProperties": false,
         "required": [
           "id",
           "name",
@@ -157,10 +161,31 @@
               "type": "string"
             }
           },
+          "scores": {
+            "type": "object",
+            "items": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "properties": {
+                  "roundNumber": {
+                    "type": "number"
+                  },
+                  "score": {
+                    "type": "number"
+                  },
+                  "change": {
+                    "type": "number"
+                  }
+                }
+              }
+            }
+          },
           "notes": {
             "type": "string"
           }
         },
+        "additionalProperties": false,
         "required": [
           "id",
           "name",
@@ -172,6 +197,7 @@
       }
     }
   },
+  "additionalProperties": false,
   "required": [
     "players",
     "games",

lib/core/common.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/cupertino.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/models/match.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 
 /// Translates a [Ruleset] enum value to its corresponding localized string.
@@ -43,3 +44,10 @@ String getExtraPlayerCount(Match match) {
   }
   return ' + ${count.toString()}';
 }
+
+String getNameCountText(Player player) {
+  if (player.nameCount >= 1) {
+    return ' #${player.nameCount}';
+  }
+  return '';
+}

lib/data/dao/match_dao.dart

@@ -30,9 +30,11 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
         final players =
             await db.playerMatchDao.getPlayersOfMatch(matchId: row.id) ?? [];
 
-        final scores = await db.scoreDao.getAllMatchScores(matchId: row.id);
+        final scores = await db.scoreEntryDao.getAllMatchScores(
+          matchId: row.id,
+        );
 
-        final winner = await db.scoreDao.getWinner(matchId: row.id);
+        final winner = await db.scoreEntryDao.getWinner(matchId: row.id);
         return Match(
           id: row.id,
           name: row.name,
@@ -64,9 +66,9 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
     final players =
         await db.playerMatchDao.getPlayersOfMatch(matchId: matchId) ?? [];
 
-    final scores = await db.scoreDao.getAllMatchScores(matchId: matchId);
+    final scores = await db.scoreEntryDao.getAllMatchScores(matchId: matchId);
 
-    final winner = await db.scoreDao.getWinner(matchId: matchId);
+    final winner = await db.scoreEntryDao.getWinner(matchId: matchId);
 
     return Match(
       id: result.id,
@@ -109,15 +111,15 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
 
       for (final pid in match.scores.keys) {
         final playerScores = match.scores[pid]!;
-        await db.scoreDao.addScoresAsList(
-          scores: playerScores,
+        await db.scoreEntryDao.addScoresAsList(
+          entrys: playerScores,
           playerId: pid,
           matchId: match.id,
         );
       }
 
       if (match.winner != null) {
-        await db.scoreDao.setWinner(
+        await db.scoreEntryDao.setWinner(
           matchId: match.id,
           playerId: match.winner!.id,
         );
@@ -298,7 +300,7 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
         final group = await db.groupDao.getGroupById(groupId: groupId);
         final players =
             await db.playerMatchDao.getPlayersOfMatch(matchId: row.id) ?? [];
-        final winner = await db.scoreDao.getWinner(matchId: row.id);
+        final winner = await db.scoreEntryDao.getWinner(matchId: row.id);
         return Match(
           id: row.id,
           name: row.name,

lib/data/dao/player_dao.dart

@@ -1,4 +1,5 @@
 import 'package:drift/drift.dart';
+import 'package:flutter/cupertino.dart';
 import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/db/tables/player_table.dart';
 import 'package:tallee/data/models/player.dart';
@@ -20,6 +21,7 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
             name: row.name,
             description: row.description,
             createdAt: row.createdAt,
+            nameCount: row.nameCount,
           ),
         )
         .toList();
@@ -34,6 +36,7 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
       name: result.name,
       description: result.description,
       createdAt: result.createdAt,
+      nameCount: result.nameCount,
     );
   }
 
@@ -42,12 +45,15 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
   /// the new one.
   Future<bool> addPlayer({required Player player}) async {
     if (!await playerExists(playerId: player.id)) {
+      final int nameCount = await calculateNameCount(name: player.name);
+
       await into(playerTable).insert(
         PlayerTableCompanion.insert(
           id: player.id,
           name: player.name,
           description: player.description,
           createdAt: player.createdAt,
+          nameCount: Value(nameCount),
         ),
         mode: InsertMode.insertOrReplace,
       );
@@ -62,20 +68,67 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
   Future<bool> addPlayersAsList({required List<Player> players}) async {
     if (players.isEmpty) return false;
 
+    // Filter out players that already exist
+    final newPlayers = <Player>[];
+    for (final player in players) {
+      if (!await playerExists(playerId: player.id)) {
+        newPlayers.add(player);
+      }
+    }
+
+    if (newPlayers.isEmpty) return false;
+
+    // Group players by name
+    final nameGroups = <String, List<Player>>{};
+    for (final player in newPlayers) {
+      nameGroups.putIfAbsent(player.name, () => []).add(player);
+    }
+
+    final playersToInsert = <PlayerTableCompanion>[];
+
+    // Process each group of players with the same name
+    for (final entry in nameGroups.entries) {
+      final name = entry.key;
+      final playersWithName = entry.value;
+
+      // Get the current nameCount
+      var nameCount = await calculateNameCount(name: name);
+
+      // One player with the same name
+      if (playersWithName.length == 1) {
+        final player = playersWithName[0];
+        playersToInsert.add(
+          PlayerTableCompanion.insert(
+            id: player.id,
+            name: player.name,
+            description: player.description,
+            createdAt: player.createdAt,
+            nameCount: Value(nameCount),
+          ),
+        );
+      } else {
+        if (nameCount == 0) nameCount++;
+        // Multiple players with the same name
+        for (var i = 0; i < playersWithName.length; i++) {
+          final player = playersWithName[i];
+          playersToInsert.add(
+            PlayerTableCompanion.insert(
+              id: player.id,
+              name: player.name,
+              description: player.description,
+              createdAt: player.createdAt,
+              nameCount: Value(nameCount + i),
+            ),
+          );
+        }
+      }
+    }
+
     await db.batch(
       (b) => b.insertAll(
         playerTable,
-        players
-            .map(
-              (player) => PlayerTableCompanion.insert(
-                id: player.id,
-                name: player.name,
-                description: player.description,
-                createdAt: player.createdAt,
-              ),
-            )
-            .toList(),
-        mode: InsertMode.insertOrIgnore,
+        playersToInsert,
+        mode: InsertMode.insertOrReplace,
       ),
     );
 
@@ -90,7 +143,7 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
     return rowsAffected > 0;
   }
 
-  /// Checks if a player with the given [id] exists in the database.
+  /// Checks if a player with the given [playerId] exists in the database.
   /// Returns `true` if the player exists, `false` otherwise.
   Future<bool> playerExists({required String playerId}) async {
     final query = select(playerTable)..where((p) => p.id.equals(playerId));
@@ -103,9 +156,38 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
     required String playerId,
     required String newName,
   }) async {
+    // Get previous name and name count for the player before updating
+    final previousPlayerName =
+        await (select(playerTable)..where((p) => p.id.equals(playerId)))
+            .map((row) => row.name)
+            .getSingleOrNull() ??
+        '';
+    final previousNameCount = await getNameCount(name: previousPlayerName);
+
     await (update(playerTable)..where((p) => p.id.equals(playerId))).write(
       PlayerTableCompanion(name: Value(newName)),
     );
+
+    // Update name count for the new name
+    final count = await calculateNameCount(name: newName);
+    if (count > 0) {
+      await (update(playerTable)..where((p) => p.name.equals(newName))).write(
+        PlayerTableCompanion(nameCount: Value(count)),
+      );
+    }
+
+    if (previousNameCount > 0) {
+      // Get the player with that name and the hightest nameCount, and update their nameCount to previousNameCount
+      final player = await getPlayerWithHighestNameCount(
+        name: previousPlayerName,
+      );
+      if (player != null) {
+        await updateNameCount(
+          playerId: player.id,
+          nameCount: previousNameCount,
+        );
+      }
+    }
   }
 
   /// Retrieves the total count of players in the database.
@@ -117,6 +199,76 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
     return count ?? 0;
   }
 
+  /// Retrieves the count of players with the given [name].
+  Future<int> getNameCount({required String name}) async {
+    final query = select(playerTable)..where((p) => p.name.equals(name));
+    final result = await query.get();
+    return result.length;
+  }
+
+  /// Updates the nameCount for the player with the given [playerId] to [nameCount].
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> updateNameCount({
+    required String playerId,
+    required int nameCount,
+  }) async {
+    final query = update(playerTable)..where((p) => p.id.equals(playerId));
+    final rowsAffected = await query.write(
+      PlayerTableCompanion(nameCount: Value(nameCount)),
+    );
+    return rowsAffected > 0;
+  }
+
+  @visibleForTesting
+  Future<Player?> getPlayerWithHighestNameCount({required String name}) async {
+    final query = select(playerTable)
+      ..where((p) => p.name.equals(name))
+      ..orderBy([(p) => OrderingTerm.desc(p.nameCount)])
+      ..limit(1);
+    final result = await query.getSingleOrNull();
+    if (result != null) {
+      return Player(
+        id: result.id,
+        name: result.name,
+        description: result.description,
+        createdAt: result.createdAt,
+        nameCount: result.nameCount,
+      );
+    }
+    return null;
+  }
+
+  @visibleForTesting
+  Future<int> calculateNameCount({required String name}) async {
+    final count = await getNameCount(name: name);
+    final int nameCount;
+
+    if (count == 1) {
+      // If one other player exists with the same name, initialize the nameCount
+      await initializeNameCount(name: name);
+      // And for the new player, set nameCount to 2
+      nameCount = 2;
+    } else if (count > 1) {
+      // If more than one player exists with the same name, just increment
+      // the nameCount for the new player
+      nameCount = count + 1;
+    } else {
+      // If no other players exist with the same name, set nameCount to 0
+      nameCount = 0;
+    }
+
+    return nameCount;
+  }
+
+  @visibleForTesting
+  Future<bool> initializeNameCount({required String name}) async {
+    final rowsAffected =
+        await (update(playerTable)..where((p) => p.name.equals(name))).write(
+          const PlayerTableCompanion(nameCount: Value(1)),
+        );
+    return rowsAffected > 0;
+  }
+
   /// Deletes all players from the database.
   /// Returns `true` if more than 0 rows were affected, otherwise `false`.
   Future<bool> deleteAllPlayers() async {

lib/data/dao/score_entry_dao.dart

@@ -2,45 +2,44 @@ import 'dart:async';
 
 import 'package:drift/drift.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/db/tables/score_table.dart';
+import 'package:tallee/data/db/tables/score_entry_table.dart';
 import 'package:tallee/data/models/player.dart';
-import 'package:tallee/data/models/score.dart';
+import 'package:tallee/data/models/score_entry.dart';
 
-part 'score_dao.g.dart';
+part 'score_entry_dao.g.dart';
 
-@DriftAccessor(tables: [ScoreTable])
-class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
-  ScoreDao(super.db);
+@DriftAccessor(tables: [ScoreEntryTable])
+class ScoreEntryDao extends DatabaseAccessor<AppDatabase>
+    with _$ScoreEntryDaoMixin {
+  ScoreEntryDao(super.db);
 
   /// Adds a score entry to the database.
   Future<void> addScore({
     required String playerId,
     required String matchId,
-    required int score,
-    int change = 0,
-    int roundNumber = 0,
+    required ScoreEntry entry,
   }) async {
-    await into(scoreTable).insert(
-      ScoreTableCompanion.insert(
+    await into(scoreEntryTable).insert(
+      ScoreEntryTableCompanion.insert(
         playerId: playerId,
         matchId: matchId,
-        roundNumber: roundNumber,
-        score: score,
-        change: change,
+        roundNumber: entry.roundNumber,
+        score: entry.score,
+        change: entry.change,
       ),
       mode: InsertMode.insertOrReplace,
     );
   }
 
   Future<void> addScoresAsList({
-    required List<Score> scores,
+    required List<ScoreEntry> entrys,
     required String playerId,
     required String matchId,
   }) async {
-    if (scores.isEmpty) return;
-    final entries = scores
+    if (entrys.isEmpty) return;
+    final entries = entrys
         .map(
-          (score) => ScoreTableCompanion.insert(
+          (score) => ScoreEntryTableCompanion.insert(
             playerId: playerId,
             matchId: matchId,
             roundNumber: score.roundNumber,
@@ -51,17 +50,21 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
         .toList();
 
     await batch((batch) {
-      batch.insertAll(scoreTable, entries, mode: InsertMode.insertOrReplace);
+      batch.insertAll(
+        scoreEntryTable,
+        entries,
+        mode: InsertMode.insertOrReplace,
+      );
     });
   }
 
   /// Retrieves the score for a specific round.
-  Future<Score?> getScore({
+  Future<ScoreEntry?> getScore({
     required String playerId,
     required String matchId,
     int roundNumber = 0,
   }) async {
-    final query = select(scoreTable)
+    final query = select(scoreEntryTable)
       ..where(
         (s) =>
             s.playerId.equals(playerId) &
@@ -72,7 +75,7 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
     final result = await query.getSingleOrNull();
     if (result == null) return null;
 
-    return Score(
+    return ScoreEntry(
       roundNumber: result.roundNumber,
       score: result.score,
       change: result.change,
@@ -80,15 +83,16 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
   }
 
   /// Retrieves all scores for a specific match.
-  Future<Map<String, List<Score>>> getAllMatchScores({
+  Future<Map<String, List<ScoreEntry>>> getAllMatchScores({
     required String matchId,
   }) async {
-    final query = select(scoreTable)..where((s) => s.matchId.equals(matchId));
+    final query = select(scoreEntryTable)
+      ..where((s) => s.matchId.equals(matchId));
     final result = await query.get();
 
-    final Map<String, List<Score>> scoresByPlayer = {};
+    final Map<String, List<ScoreEntry>> scoresByPlayer = {};
     for (final row in result) {
-      final score = Score(
+      final score = ScoreEntry(
         roundNumber: row.roundNumber,
         score: row.score,
         change: row.change,
@@ -100,17 +104,17 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
   }
 
   /// Retrieves all scores for a specific player in a match.
-  Future<List<Score>> getAllPlayerScoresInMatch({
+  Future<List<ScoreEntry>> getAllPlayerScoresInMatch({
     required String playerId,
     required String matchId,
   }) async {
-    final query = select(scoreTable)
+    final query = select(scoreEntryTable)
       ..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) => Score(
+          (row) => ScoreEntry(
             roundNumber: row.roundNumber,
             score: row.score,
             change: row.change,
@@ -126,21 +130,19 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
   Future<bool> updateScore({
     required String playerId,
     required String matchId,
-    required int newScore,
-    int newChange = 0,
-    int roundNumber = 0,
+    required ScoreEntry newEntry,
   }) async {
     final rowsAffected =
-        await (update(scoreTable)..where(
+        await (update(scoreEntryTable)..where(
               (s) =>
                   s.playerId.equals(playerId) &
                   s.matchId.equals(matchId) &
-                  s.roundNumber.equals(roundNumber),
+                  s.roundNumber.equals(newEntry.roundNumber),
             ))
             .write(
-              ScoreTableCompanion(
-                score: Value(newScore),
-                change: Value(newChange),
+              ScoreEntryTableCompanion(
+                score: Value(newEntry.score),
+                change: Value(newEntry.change),
               ),
             );
     return rowsAffected > 0;
@@ -152,7 +154,7 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
     required String matchId,
     int roundNumber = 0,
   }) async {
-    final query = delete(scoreTable)
+    final query = delete(scoreEntryTable)
       ..where(
         (s) =>
             s.playerId.equals(playerId) &
@@ -164,7 +166,8 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
   }
 
   Future<bool> deleteAllScoresForMatch({required String matchId}) async {
-    final query = delete(scoreTable)..where((s) => s.matchId.equals(matchId));
+    final query = delete(scoreEntryTable)
+      ..where((s) => s.matchId.equals(matchId));
     final rowsAffected = await query.go();
     return rowsAffected > 0;
   }
@@ -173,7 +176,7 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
     required String matchId,
     required String playerId,
   }) async {
-    final query = delete(scoreTable)
+    final query = delete(scoreEntryTable)
       ..where((s) => s.playerId.equals(playerId) & s.matchId.equals(matchId));
     final rowsAffected = await query.go();
     return rowsAffected > 0;
@@ -182,11 +185,11 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
   /// Gets the highest (latest) round number for a match.
   /// Returns `null` if there are no scores for the match.
   Future<int?> getLatestRoundNumber({required String matchId}) async {
-    final query = selectOnly(scoreTable)
-      ..where(scoreTable.matchId.equals(matchId))
-      ..addColumns([scoreTable.roundNumber.max()]);
+    final query = selectOnly(scoreEntryTable)
+      ..where(scoreEntryTable.matchId.equals(matchId))
+      ..addColumns([scoreEntryTable.roundNumber.max()]);
     final result = await query.getSingle();
-    return result.read(scoreTable.roundNumber.max());
+    return result.read(scoreEntryTable.roundNumber.max());
   }
 
   /// Aggregates the total score for a player in a match by summing all their
@@ -218,8 +221,8 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
     deleteAllScoresForMatch(matchId: matchId);
 
     // Set the winner's score to 1
-    final rowsAffected = await into(scoreTable).insert(
-      ScoreTableCompanion.insert(
+    final rowsAffected = await into(scoreEntryTable).insert(
+      ScoreEntryTableCompanion.insert(
         playerId: playerId,
         matchId: matchId,
         roundNumber: 0,
@@ -234,7 +237,7 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
 
   // Retrieves the winner of a match based on the highest score.
   Future<Player?> getWinner({required String matchId}) async {
-    final query = select(scoreTable)
+    final query = select(scoreEntryTable)
       ..where((s) => s.matchId.equals(matchId))
       ..orderBy([(s) => OrderingTerm.desc(s.score)])
       ..limit(1);
@@ -278,8 +281,8 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
     deleteAllScoresForMatch(matchId: matchId);
 
     // Set the loosers score to 0
-    final rowsAffected = await into(scoreTable).insert(
-      ScoreTableCompanion.insert(
+    final rowsAffected = await into(scoreEntryTable).insert(
+      ScoreEntryTableCompanion.insert(
         playerId: playerId,
         matchId: matchId,
         roundNumber: 0,
@@ -294,7 +297,7 @@ class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
 
   /// Retrieves the looser of a match based on the score 0.
   Future<Player?> getLooser({required String matchId}) async {
-    final query = select(scoreTable)
+    final query = select(scoreEntryTable)
       ..where((s) => s.matchId.equals(matchId) & s.score.equals(0));
     final result = await query.getSingleOrNull();
 

lib/data/dao/score_entry_dao.g.dart

@@ -1,20 +1,20 @@
 // GENERATED CODE - DO NOT MODIFY BY HAND
 
-part of 'score_dao.dart';
+part of 'score_entry_dao.dart';
 
 // ignore_for_file: type=lint
-mixin _$ScoreDaoMixin on DatabaseAccessor<AppDatabase> {
+mixin _$ScoreEntryDaoMixin 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;
-  ScoreDaoManager get managers => ScoreDaoManager(this);
+  $ScoreEntryTableTable get scoreEntryTable => attachedDatabase.scoreEntryTable;
+  ScoreEntryDaoManager get managers => ScoreEntryDaoManager(this);
 }
 
-class ScoreDaoManager {
-  final _$ScoreDaoMixin _db;
-  ScoreDaoManager(this._db);
+class ScoreEntryDaoManager {
+  final _$ScoreEntryDaoMixin _db;
+  ScoreEntryDaoManager(this._db);
   $$PlayerTableTableTableManager get playerTable =>
       $$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
   $$GameTableTableTableManager get gameTable =>
@@ -23,6 +23,9 @@ class ScoreDaoManager {
       $$GroupTableTableTableManager(_db.attachedDatabase, _db.groupTable);
   $$MatchTableTableTableManager get matchTable =>
       $$MatchTableTableTableManager(_db.attachedDatabase, _db.matchTable);
-  $$ScoreTableTableTableManager get scoreTable =>
-      $$ScoreTableTableTableManager(_db.attachedDatabase, _db.scoreTable);
+  $$ScoreEntryTableTableTableManager get scoreEntryTable =>
+      $$ScoreEntryTableTableTableManager(
+        _db.attachedDatabase,
+        _db.scoreEntryTable,
+      );
 }

lib/data/db/database.dart

@@ -7,7 +7,7 @@ import 'package:tallee/data/dao/match_dao.dart';
 import 'package:tallee/data/dao/player_dao.dart';
 import 'package:tallee/data/dao/player_group_dao.dart';
 import 'package:tallee/data/dao/player_match_dao.dart';
-import 'package:tallee/data/dao/score_dao.dart';
+import 'package:tallee/data/dao/score_entry_dao.dart';
 import 'package:tallee/data/dao/team_dao.dart';
 import 'package:tallee/data/db/tables/game_table.dart';
 import 'package:tallee/data/db/tables/group_table.dart';
@@ -15,7 +15,7 @@ import 'package:tallee/data/db/tables/match_table.dart';
 import 'package:tallee/data/db/tables/player_group_table.dart';
 import 'package:tallee/data/db/tables/player_match_table.dart';
 import 'package:tallee/data/db/tables/player_table.dart';
-import 'package:tallee/data/db/tables/score_table.dart';
+import 'package:tallee/data/db/tables/score_entry_table.dart';
 import 'package:tallee/data/db/tables/team_table.dart';
 
 part 'database.g.dart';
@@ -29,7 +29,7 @@ part 'database.g.dart';
     PlayerMatchTable,
     GameTable,
     TeamTable,
-    ScoreTable,
+    ScoreEntryTable,
   ],
   daos: [
     PlayerDao,
@@ -38,8 +38,8 @@ part 'database.g.dart';
     PlayerGroupDao,
     PlayerMatchDao,
     GameDao,
-    ScoreDao,
-    TeamDao
+    ScoreEntryDao,
+    TeamDao,
   ],
 )
 class AppDatabase extends _$AppDatabase {
@@ -60,7 +60,9 @@ class AppDatabase extends _$AppDatabase {
   static QueryExecutor _openConnection() {
     return driftDatabase(
       name: 'gametracker_db',
-      native: const DriftNativeOptions(databaseDirectory: getApplicationSupportDirectory),
+      native: const DriftNativeOptions(
+        databaseDirectory: getApplicationSupportDirectory,
+      ),
     );
   }
 }

lib/data/db/tables/player_table.dart

@@ -2,9 +2,10 @@ import 'package:drift/drift.dart';
 
 class PlayerTable extends Table {
   TextColumn get id => text()();
-  TextColumn get name => text()();
-  TextColumn get description => text()();
   DateTimeColumn get createdAt => dateTime()();
+  TextColumn get name => text()();
+  IntColumn get nameCount => integer().withDefault(const Constant(0))();
+  TextColumn get description => text()();
 
   @override
   Set<Column<Object>> get primaryKey => {id};

lib/data/db/tables/score_entry_table.dart

@@ -2,7 +2,7 @@ import 'package:drift/drift.dart';
 import 'package:tallee/data/db/tables/match_table.dart';
 import 'package:tallee/data/db/tables/player_table.dart';
 
-class ScoreTable extends Table {
+class ScoreEntryTable extends Table {
   TextColumn get playerId =>
       text().references(PlayerTable, #id, onDelete: KeyAction.cascade)();
   TextColumn get matchId =>

lib/data/models/group.dart

@@ -24,16 +24,17 @@ class Group {
     return 'Group{id: $id, name: $name, description: $description, members: $members}';
   }
 
-  /// Creates a Group instance from a JSON object (memberIds format).
-  /// Player objects are reconstructed from memberIds by the DataTransferService.
+  /// Creates a Group instance from a JSON object where the related [Player]
+  /// objects are represented by their IDs.
   Group.fromJson(Map<String, dynamic> json)
     : id = json['id'],
       createdAt = DateTime.parse(json['createdAt']),
       name = json['name'],
       description = json['description'],
-      members = []; // Populated during import via DataTransferService
+      members = [];
 
-  /// Converts the Group instance to a JSON object using normalized format (memberIds only).
+  /// Converts the Group instance to a JSON object. Related [Player] objects are
+  /// represented by their IDs.
   Map<String, dynamic> toJson() => {
     'id': id,
     'createdAt': createdAt.toIso8601String(),

lib/data/models/match.dart

@@ -3,7 +3,7 @@ import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/models/game.dart';
 import 'package:tallee/data/models/group.dart';
 import 'package:tallee/data/models/player.dart';
-import 'package:tallee/data/models/score.dart';
+import 'package:tallee/data/models/score_entry.dart';
 import 'package:uuid/uuid.dart';
 
 class Match {
@@ -15,7 +15,7 @@ class Match {
   final Group? group;
   final List<Player> players;
   final String notes;
-  Map<String, List<Score>> scores;
+  Map<String, List<ScoreEntry>> scores;
   Player? winner;
 
   Match({
@@ -27,7 +27,7 @@ class Match {
     this.group,
     this.players = const [],
     this.notes = '',
-    Map<String, List<Score>>? scores,
+    Map<String, List<ScoreEntry>>? scores,
     this.winner,
   }) : id = id ?? const Uuid().v4(),
        createdAt = createdAt ?? clock.now(),
@@ -38,8 +38,9 @@ class Match {
     return 'Match{id: $id, createdAt: $createdAt, endedAt: $endedAt, name: $name, game: $game, group: $group, players: $players, notes: $notes, scores: $scores, winner: $winner}';
   }
 
-  /// Creates a Match instance from a JSON object (ID references format).
-  /// Related objects are reconstructed from IDs by the DataTransferService.
+  /// Creates a Match instance from a JSON object where related objects are
+  /// represented by their IDs. Therefore, the game, group, and players are not
+  /// fully constructed here.
   Match.fromJson(Map<String, dynamic> json)
     : id = json['id'],
       createdAt = DateTime.parse(json['createdAt']),
@@ -53,13 +54,15 @@ class Match {
         description: '',
         color: GameColor.blue,
         icon: '',
-      ), // Populated during import via DataTransferService
-      group = null, // Populated during import via DataTransferService
-      players = [], // Populated during import via DataTransferService
+      ),
+      group = null,
+      players = [],
       scores = json['scores'],
       notes = json['notes'] ?? '';
 
-  /// Converts the Match instance to a JSON object using normalized format (ID references only).
+  /// Converts the Match instance to a JSON object. Related objects are
+  /// represented by their IDs, so the game, group, and players are not fully
+  /// serialized here.
   Map<String, dynamic> toJson() => {
     'id': id,
     'createdAt': createdAt.toIso8601String(),
@@ -68,7 +71,10 @@ class Match {
     'gameId': game.id,
     'groupId': group?.id,
     'playerIds': players.map((player) => player.id).toList(),
-    'scores': scores,
+    'scores': scores.map(
+      (playerId, scoreList) =>
+          MapEntry(playerId, scoreList.map((score) => score.toJson()).toList()),
+    ),
     'notes': notes,
   };
 }

lib/data/models/player.dart

@@ -5,12 +5,14 @@ class Player {
   final String id;
   final DateTime createdAt;
   final String name;
+  int nameCount;
   final String description;
 
   Player({
     String? id,
     DateTime? createdAt,
     required this.name,
+    this.nameCount = 0,
     String? description,
   }) : id = id ?? const Uuid().v4(),
        createdAt = createdAt ?? clock.now(),
@@ -18,7 +20,7 @@ class Player {
 
   @override
   String toString() {
-    return 'Player{id: $id, name: $name, description: $description}';
+    return 'Player{id: $id, createdAt: $createdAt, name: $name, nameCount: $nameCount, description: $description}';
   }
 
   /// Creates a Player instance from a JSON object.
@@ -26,6 +28,7 @@ class Player {
     : id = json['id'],
       createdAt = DateTime.parse(json['createdAt']),
       name = json['name'],
+      nameCount = 0,
       description = json['description'];
 
   /// Converts the Player instance to a JSON object.

lib/data/models/score.dart

@@ -1,18 +0,0 @@
-class Score {
-  final int roundNumber;
-  int score = 0;
-  int change = 0;
-
-  Score({required this.roundNumber, required this.score, required this.change});
-
-  Score.fromJson(Map<String, dynamic> json)
-    : roundNumber = json['roundNumber'],
-      score = json['score'],
-      change = json['change'];
-
-  Map<String, dynamic> toJson() => {
-    'roundNumber': roundNumber,
-    'score': score,
-    'change': change,
-  };
-}

lib/data/models/score_entry.dart

@@ -0,0 +1,22 @@
+class ScoreEntry {
+  int roundNumber = 0;
+  final int score;
+  final int change;
+
+  ScoreEntry({
+    required this.roundNumber,
+    required this.score,
+    required this.change,
+  });
+
+  ScoreEntry.fromJson(Map<String, dynamic> json)
+    : roundNumber = json['roundNumber'],
+      score = json['score'],
+      change = json['change'];
+
+  Map<String, dynamic> toJson() => {
+    'roundNumber': roundNumber,
+    'score': score,
+    'change': change,
+  };
+}

lib/data/models/team.dart

@@ -29,7 +29,8 @@ class Team {
       createdAt = DateTime.parse(json['createdAt']),
       members = []; // Populated during import via DataTransferService
 
-  /// Converts the Team instance to a JSON object using normalized format (memberIds only).
+  /// Converts the Team instance to a JSON object. Related objects are
+  /// represented by their IDs.
   Map<String, dynamic> toJson() => {
     'id': id,
     'name': name,

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

@@ -2,6 +2,7 @@ import 'package:flutter/material.dart';
 import 'package:intl/intl.dart';
 import 'package:provider/provider.dart';
 import 'package:tallee/core/adaptive_page_route.dart';
+import 'package:tallee/core/common.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/models/group.dart';
@@ -153,6 +154,7 @@ class _GroupDetailViewState extends State<GroupDetailView> {
                     children: _group.members.map((member) {
                       return TextIconTile(
                         text: member.name,
+                        suffixText: getNameCountText(member),
                         iconEnabled: false,
                       );
                     }).toList(),

lib/presentation/views/main_menu/home_view.dart

@@ -227,7 +227,7 @@ class _HomeViewState extends State<HomeView> {
   /// Updates the winner information for a specific match in the recent matches list.
   Future<void> updatedWinnerInRecentMatches(String matchId) async {
     final db = Provider.of<AppDatabase>(context, listen: false);
-    final winner = await db.scoreDao.getWinner(matchId: matchId);
+    final winner = await db.scoreEntryDao.getWinner(matchId: matchId);
     final matchIndex = recentMatches.indexWhere((match) => match.id == matchId);
     if (matchIndex != -1) {
       setState(() {

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

@@ -161,6 +161,7 @@ class _MatchDetailViewState extends State<MatchDetailView> {
                     children: match.players.map((player) {
                       return TextIconTile(
                         text: player.name,
+                        suffixText: getNameCountText(player),
                         iconEnabled: false,
                       );
                     }).toList(),

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

@@ -139,9 +139,9 @@ class _MatchResultViewState extends State<MatchResultView> {
   /// based on the current selection.
   Future<void> _handleWinnerSaving() async {
     if (_selectedPlayer == null) {
-      await db.scoreDao.removeWinner(matchId: widget.match.id);
+      await db.scoreEntryDao.removeWinner(matchId: widget.match.id);
     } else {
-      await db.scoreDao.setWinner(
+      await db.scoreEntryDao.setWinner(
         matchId: widget.match.id,
         playerId: _selectedPlayer!.id,
       );

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

@@ -70,6 +70,8 @@ const allDependencies = <Package>[
   _http_parser,
   _intl,
   _io,
+  _jni,
+  _jni_flutter,
   _js,
   _json_annotation,
   _json_schema,
@@ -360,13 +362,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// async 2.13.0
+/// async 2.13.1
 const _async = Package(
     name: 'async',
     description: "Utility functions and classes related to the 'dart:async' library.",
     repository: 'https://github.com/dart-lang/core/tree/main/pkgs/async',
     authors: [],
-    version: '2.13.0',
+    version: '2.13.1',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -442,13 +444,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// build 4.0.4
+/// build 4.0.5
 const _build = Package(
     name: 'build',
     description: 'A package for authoring build_runner compatible code generators.',
     repository: 'https://github.com/dart-lang/build/tree/master/build',
     authors: [],
-    version: '4.0.4',
+    version: '4.0.5',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -565,13 +567,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// build_runner 2.12.2
+/// build_runner 2.13.1
 const _build_runner = Package(
     name: 'build_runner',
     description: 'A build system for Dart code generation and modular compilation.',
     repository: 'https://github.com/dart-lang/build/tree/master/build_runner',
     authors: [],
-    version: '2.12.2',
+    version: '2.13.1',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -649,14 +651,14 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// built_value 8.12.4
+/// built_value 8.12.5
 const _built_value = Package(
     name: 'built_value',
     description: '''Value types with builders, Dart classes as enums, and serialization. This library is the runtime dependency.
 ''',
     repository: 'https://github.com/google/built_value.dart/tree/master/built_value',
     authors: [],
-    version: '8.12.4',
+    version: '8.12.5',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -1436,18 +1438,18 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// cupertino_icons 1.0.8
+/// cupertino_icons 1.0.9
 const _cupertino_icons = Package(
     name: 'cupertino_icons',
     description: 'Default icons asset for Cupertino widgets based on Apple styled icons',
     repository: 'https://github.com/flutter/packages/tree/main/third_party/packages/cupertino_icons',
     authors: [],
-    version: '1.0.8',
+    version: '1.0.9',
     spdxIdentifiers: ['MIT'],
     isMarkdown: false,
     isSdk: false,
     dependencies: [],
-    devDependencies: [PackageRef('flutter'), PackageRef('flutter_test')],
+    devDependencies: [PackageRef('collection'), PackageRef('flutter'), PackageRef('flutter_test'), PackageRef('path')],
     license: '''The MIT License (MIT)
 
 Copyright (c) 2016 Vladimir Kharlampidi
@@ -2627,13 +2629,13 @@ const _flutter_localizations = Package(
     devDependencies: [PackageRef('flutter_test')],
   );
 
-/// flutter_plugin_android_lifecycle 2.0.33
+/// flutter_plugin_android_lifecycle 2.0.34
 const _flutter_plugin_android_lifecycle = Package(
     name: 'flutter_plugin_android_lifecycle',
     description: 'Flutter plugin for accessing an Android Lifecycle within other plugins.',
     repository: 'https://github.com/flutter/packages/tree/main/packages/flutter_plugin_android_lifecycle',
     authors: [],
-    version: '2.0.33',
+    version: '2.0.34',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -3173,6 +3175,88 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
+/// jni 1.0.0
+const _jni = Package(
+    name: 'jni',
+    description: 'A library to access JNI from Dart and Flutter that acts as a support library for package:jnigen.',
+    repository: 'https://github.com/dart-lang/native/tree/main/pkgs/jni',
+    authors: [],
+    version: '1.0.0',
+    spdxIdentifiers: ['BSD-3-Clause'],
+    isMarkdown: false,
+    isSdk: false,
+    dependencies: [PackageRef('args'), PackageRef('collection'), PackageRef('ffi'), PackageRef('meta'), PackageRef('package_config'), PackageRef('path'), PackageRef('plugin_platform_interface')],
+    devDependencies: [PackageRef('dart_style'), PackageRef('logging'), PackageRef('test')],
+    license: '''Copyright 2022, the Dart project authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of Google LLC nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
+  );
+
+/// jni_flutter 1.0.1
+const _jni_flutter = Package(
+    name: 'jni_flutter',
+    description: 'A library to access Flutter Android specific APIs from Dart.',
+    repository: 'https://github.com/dart-lang/native/tree/main/pkgs/jni_flutter',
+    authors: [],
+    version: '1.0.1',
+    spdxIdentifiers: ['BSD-3-Clause'],
+    isMarkdown: false,
+    isSdk: false,
+    dependencies: [PackageRef('flutter'), PackageRef('jni')],
+    devDependencies: [PackageRef('flutter_test')],
+    license: '''Copyright 2026, the Dart project authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of Google LLC nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
+  );
+
 /// js 0.7.2
 const _js = Package(
     name: 'js',
@@ -3511,13 +3595,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// markdown 7.3.0
+/// markdown 7.3.1
 const _markdown = Package(
     name: 'markdown',
     description: 'A portable Markdown library written in Dart that can parse Markdown into HTML.',
     repository: 'https://github.com/dart-lang/tools/tree/main/pkgs/markdown',
     authors: [],
-    version: '7.3.0',
+    version: '7.3.1',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -3890,13 +3974,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// native_toolchain_c 0.17.5
+/// native_toolchain_c 0.17.6
 const _native_toolchain_c = Package(
     name: 'native_toolchain_c',
     description: 'A library to invoke the native C compiler installed on the host machine.',
     repository: 'https://github.com/dart-lang/native/tree/main/pkgs/native_toolchain_c',
     authors: [],
-    version: '0.17.5',
+    version: '0.17.6',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -4110,14 +4194,14 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// package_info_plus 9.0.0
+/// package_info_plus 9.0.1
 const _package_info_plus = Package(
     name: 'package_info_plus',
     description: 'Flutter plugin for querying information about the application package, such as CFBundleVersion on iOS or versionCode on Android.',
     homepage: 'https://github.com/fluttercommunity/plus_plugins',
     repository: 'https://github.com/fluttercommunity/plus_plugins/tree/main/packages/package_info_plus/package_info_plus',
     authors: [],
-    version: '9.0.0',
+    version: '9.0.1',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -4194,13 +4278,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// pana 0.23.10
+/// pana 0.23.11
 const _pana = Package(
     name: 'pana',
     description: 'PAckage aNAlyzer - produce a report summarizing the health and quality of a Dart package.',
     repository: 'https://github.com/dart-lang/pana',
     authors: [],
-    version: '0.23.10',
+    version: '0.23.11',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -4315,17 +4399,17 @@ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// path_provider_android 2.2.22
+/// path_provider_android 2.3.1
 const _path_provider_android = Package(
     name: 'path_provider_android',
     description: 'Android implementation of the path_provider plugin.',
     repository: 'https://github.com/flutter/packages/tree/main/packages/path_provider/path_provider_android',
     authors: [],
-    version: '2.2.22',
+    version: '2.3.1',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
-    dependencies: [PackageRef('flutter'), PackageRef('path_provider_platform_interface')],
+    dependencies: [PackageRef('flutter'), PackageRef('jni'), PackageRef('jni_flutter'), PackageRef('path_provider_platform_interface')],
     devDependencies: [PackageRef('flutter_test'), PackageRef('test')],
     license: '''Copyright 2013 The Flutter Authors
 
@@ -36119,13 +36203,13 @@ Copyright (C) 2009-2017, International Business Machines Corporation,
 Google, and others. All Rights Reserved.''',
   );
 
-/// source_gen 4.2.0
+/// source_gen 4.2.2
 const _source_gen = Package(
     name: 'source_gen',
     description: 'Source code generation builders and utilities for the Dart build system',
     repository: 'https://github.com/dart-lang/source_gen/tree/master/source_gen',
     authors: [],
-    version: '4.2.0',
+    version: '4.2.2',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -36835,13 +36919,13 @@ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// url_launcher_android 6.3.28
+/// url_launcher_android 6.3.29
 const _url_launcher_android = Package(
     name: 'url_launcher_android',
     description: 'Android implementation of the url_launcher plugin.',
     repository: 'https://github.com/flutter/packages/tree/main/packages/url_launcher/url_launcher_android',
     authors: [],
-    version: '6.3.28',
+    version: '6.3.29',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -37796,12 +37880,12 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.''',
   );
 
-/// tallee 0.0.19+253
+/// tallee 0.0.20+254
 const _tallee = Package(
     name: 'tallee',
     description: 'Tracking App for Card Games',
     authors: [],
-    version: '0.0.19+253',
+    version: '0.0.20+254',
     spdxIdentifiers: ['LGPL-3.0'],
     isMarkdown: false,
     isSdk: false,

lib/presentation/views/main_menu/statistics_view.dart

@@ -18,9 +18,18 @@ class StatisticsView extends StatefulWidget {
 }
 
 class _StatisticsViewState extends State<StatisticsView> {
-  List<(String, int)> winCounts = List.filled(6, ('Skeleton Player', 1));
-  List<(String, int)> matchCounts = List.filled(6, ('Skeleton Player', 1));
-  List<(String, double)> winRates = List.filled(6, ('Skeleton Player', 1));
+  List<(Player, int)> winCounts = List.filled(6, (
+    Player(name: 'Skeleton Player'),
+    1,
+  ));
+  List<(Player, int)> matchCounts = List.filled(6, (
+    Player(name: 'Skeleton Player'),
+    1,
+  ));
+  List<(Player, double)> winRates = List.filled(6, (
+    Player(name: 'Skeleton Player'),
+    1,
+  ));
   bool isLoading = true;
 
   @override
@@ -121,7 +130,10 @@ class _StatisticsViewState extends State<StatisticsView> {
         players: players,
         context: context,
       );
-      winRates = computeWinRatePercent(wins: winCounts, matches: matchCounts);
+      winRates = computeWinRatePercent(
+        winCounts: winCounts,
+        matchCounts: matchCounts,
+      );
       setState(() {
         isLoading = false;
       });
@@ -130,47 +142,47 @@ class _StatisticsViewState extends State<StatisticsView> {
 
   /// Calculates the number of wins for each player
   /// and returns a sorted list of tuples (playerName, winCount)
-  List<(String, int)> _calculateWinsForAllPlayers({
+  List<(Player, int)> _calculateWinsForAllPlayers({
     required List<Match> matches,
     required List<Player> players,
     required BuildContext context,
   }) {
-    List<(String, int)> winCounts = [];
+    List<(Player, int)> winCounts = [];
     final loc = AppLocalizations.of(context);
 
     // Getting the winners
     for (var match in matches) {
       final winner = match.winner;
       if (winner != null) {
-        final index = winCounts.indexWhere((entry) => entry.$1 == winner.id);
+        final index = winCounts.indexWhere((entry) => entry.$1.id == winner.id);
         // -1 means winner not found in winCounts
         if (index != -1) {
           final current = winCounts[index].$2;
-          winCounts[index] = (winner.id, current + 1);
+          winCounts[index] = (winner, current + 1);
         } else {
-          winCounts.add((winner.id, 1));
+          winCounts.add((winner, 1));
         }
       }
     }
 
     // Adding all players with zero wins
     for (var player in players) {
-      final index = winCounts.indexWhere((entry) => entry.$1 == player.id);
+      final index = winCounts.indexWhere((entry) => entry.$1.id == player.id);
       // -1 means player not found in winCounts
       if (index == -1) {
-        winCounts.add((player.id, 0));
+        winCounts.add((player, 0));
       }
     }
 
     // Replace player IDs with names
     for (int i = 0; i < winCounts.length; i++) {
-      final playerId = winCounts[i].$1;
+      final playerId = winCounts[i].$1.id;
       final player = players.firstWhere(
         (p) => p.id == playerId,
         orElse: () =>
             Player(id: playerId, name: loc.not_available, description: ''),
       );
-      winCounts[i] = (player.name, winCounts[i].$2);
+      winCounts[i] = (player, winCounts[i].$2);
     }
 
     winCounts.sort((a, b) => b.$2.compareTo(a.$2));
@@ -180,60 +192,51 @@ class _StatisticsViewState extends State<StatisticsView> {
 
   /// Calculates the number of matches played for each player
   /// and returns a sorted list of tuples (playerName, matchCount)
-  List<(String, int)> _calculateMatchAmountsForAllPlayers({
+  List<(Player, int)> _calculateMatchAmountsForAllPlayers({
     required List<Match> matches,
     required List<Player> players,
     required BuildContext context,
   }) {
-    List<(String, int)> matchCounts = [];
+    List<(Player, int)> matchCounts = [];
     final loc = AppLocalizations.of(context);
 
     // Counting matches for each player
     for (var match in matches) {
-      if (match.group != null) {
-        final members = match.group!.members.map((p) => p.id).toList();
-        for (var playerId in members) {
-          final index = matchCounts.indexWhere((entry) => entry.$1 == playerId);
-          // -1 means player not found in matchCounts
-          if (index != -1) {
-            final current = matchCounts[index].$2;
-            matchCounts[index] = (playerId, current + 1);
-          } else {
-            matchCounts.add((playerId, 1));
-          }
-        }
-      }
-      final members = match.players.map((p) => p.id).toList();
-      for (var playerId in members) {
-        final index = matchCounts.indexWhere((entry) => entry.$1 == playerId);
-        // -1 means player not found in matchCounts
-        if (index != -1) {
-          final current = matchCounts[index].$2;
-          matchCounts[index] = (playerId, current + 1);
+      for (Player player in match.players) {
+        // Check if the player is already in matchCounts
+        final index = matchCounts.indexWhere(
+          (entry) => entry.$1.id == player.id,
+        );
+
+        // -1 -> not found
+        if (index == -1) {
+          // Add new entry
+          matchCounts.add((player, 1));
         } else {
-          matchCounts.add((playerId, 1));
+          // Update existing entry
+          final currentMatchAmount = matchCounts[index].$2;
+          matchCounts[index] = (player, currentMatchAmount + 1);
         }
       }
     }
 
     // Adding all players with zero matches
     for (var player in players) {
-      final index = matchCounts.indexWhere((entry) => entry.$1 == player.id);
+      final index = matchCounts.indexWhere((entry) => entry.$1.id == player.id);
       // -1 means player not found in matchCounts
       if (index == -1) {
-        matchCounts.add((player.id, 0));
+        matchCounts.add((player, 0));
       }
     }
 
     // Replace player IDs with names
     for (int i = 0; i < matchCounts.length; i++) {
-      final playerId = matchCounts[i].$1;
+      final playerId = matchCounts[i].$1.id;
       final player = players.firstWhere(
         (p) => p.id == playerId,
-        orElse: () =>
-            Player(id: playerId, name: loc.not_available, description: ''),
+        orElse: () => Player(id: playerId, name: loc.not_available),
       );
-      matchCounts[i] = (player.name, matchCounts[i].$2);
+      matchCounts[i] = (player, matchCounts[i].$2);
     }
 
     matchCounts.sort((a, b) => b.$2.compareTo(a.$2));
@@ -241,25 +244,24 @@ class _StatisticsViewState extends State<StatisticsView> {
     return matchCounts;
   }
 
-  // dart
-  List<(String, double)> computeWinRatePercent({
-    required List<(String, int)> wins,
-    required List<(String, int)> matches,
+  List<(Player, double)> computeWinRatePercent({
+    required List<(Player, int)> winCounts,
+    required List<(Player, int)> matchCounts,
   }) {
-    final Map<String, int> winsMap = {for (var e in wins) e.$1: e.$2};
-    final Map<String, int> matchesMap = {for (var e in matches) e.$1: e.$2};
+    final Map<Player, int> winsMap = {for (var e in winCounts) e.$1: e.$2};
+    final Map<Player, int> matchesMap = {for (var e in matchCounts) e.$1: e.$2};
 
     // Get all unique player names
-    final names = {...winsMap.keys, ...matchesMap.keys};
+    final player = {...matchesMap.keys};
 
     // Calculate win rates
-    final result = names.map((name) {
+    final result = player.map((name) {
       final int w = winsMap[name] ?? 0;
-      final int g = matchesMap[name] ?? 0;
+      final int m = matchesMap[name] ?? 0;
       // Calculate percentage and round to 2 decimal places
       // Avoid division by zero
-      final double percent = (g > 0)
-          ? double.parse(((w / g)).toStringAsFixed(2))
+      final double percent = (m > 0)
+          ? double.parse(((w / m)).toStringAsFixed(2))
           : 0;
       return (name, percent);
     }).toList();

lib/presentation/widgets/player_selection.dart

@@ -1,5 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
+import 'package:tallee/core/common.dart';
 import 'package:tallee/core/constants.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/data/db/database.dart';
@@ -140,6 +141,7 @@ class _PlayerSelectionState extends State<PlayerSelection> {
                               padding: const EdgeInsets.only(right: 8.0),
                               child: TextIconTile(
                                 text: player.name,
+                                suffixText: getNameCountText(player),
                                 onIconTap: () {
                                   setState(() {
                                     // Removes the player from the selection and notifies the parent.
@@ -193,6 +195,7 @@ class _PlayerSelectionState extends State<PlayerSelection> {
                   itemBuilder: (BuildContext context, int index) {
                     return TextIconListTile(
                       text: suggestedPlayers[index].name,
+                      suffixText: getNameCountText(suggestedPlayers[index]),
                       onPressed: () {
                         setState(() {
                           // If the player is not already selected
@@ -282,7 +285,8 @@ class _PlayerSelectionState extends State<PlayerSelection> {
     final loc = AppLocalizations.of(context);
     final playerName = _searchBarController.text.trim();
 
-    final createdPlayer = Player(name: playerName, description: '');
+    int nameCount = _calculateNameCount(playerName);
+    final createdPlayer = Player(name: playerName, nameCount: nameCount);
     final success = await db.playerDao.addPlayer(player: createdPlayer);
 
     if (!context.mounted) return;
@@ -295,6 +299,22 @@ class _PlayerSelectionState extends State<PlayerSelection> {
     }
   }
 
+  int _calculateNameCount(String playerName) {
+    final playersWithSameName =
+        allPlayers.where((player) => player.name == playerName).toList()
+          ..sort((a, b) => a.nameCount.compareTo(b.nameCount));
+
+    if (playersWithSameName.isEmpty) {
+      return 0;
+    } else if (playersWithSameName.length == 1) {
+      // Initialize nameCount
+      playersWithSameName[0].nameCount = 1;
+    }
+
+    // Return following count
+    return playersWithSameName.length + 1;
+  }
+
   /// Updates the state after successfully adding a new player.
   void _handleSuccessfulPlayerCreation(Player player) {
     selectedPlayers.insert(0, player);

lib/presentation/widgets/tiles/group_tile.dart

@@ -1,4 +1,5 @@
 import 'package:flutter/material.dart';
+import 'package:tallee/core/common.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/data/models/group.dart';
 import 'package:tallee/presentation/widgets/tiles/text_icon_tile.dart';
@@ -81,7 +82,11 @@ class _GroupTileState extends State<GroupTile> {
                 for (var member in [
                   ...widget.group.members,
                 ]..sort((a, b) => a.name.compareTo(b.name)))
-                  TextIconTile(text: member.name, iconEnabled: false),
+                  TextIconTile(
+                    text: member.name,
+                    suffixText: getNameCountText(member),
+                    iconEnabled: false,
+                  ),
               ],
             ),
             const SizedBox(height: 2.5),

lib/presentation/widgets/tiles/match_tile.dart

@@ -203,7 +203,11 @@ class _MatchTileState extends State<MatchTile> {
                 spacing: 6,
                 runSpacing: 6,
                 children: players.map((player) {
-                  return TextIconTile(text: player.name, iconEnabled: false);
+                  return TextIconTile(
+                    text: player.name,
+                    suffixText: getNameCountText(player),
+                    iconEnabled: false,
+                  );
                 }).toList(),
               ),
             ],

lib/presentation/widgets/tiles/statistics_tile.dart

@@ -1,6 +1,9 @@
 import 'dart:math';
 
 import 'package:flutter/material.dart';
+import 'package:tallee/core/common.dart';
+import 'package:tallee/core/custom_theme.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/widgets/tiles/info_tile.dart';
 
@@ -32,7 +35,7 @@ class StatisticsTile extends StatelessWidget {
   final double width;
 
   /// A list of tuples containing labels and their corresponding numeric values.
-  final List<(String, num)> values;
+  final List<(Player, num)> values;
 
   /// The maximum number of items to display.
   final int itemCount;
@@ -89,11 +92,29 @@ class StatisticsTile extends StatelessWidget {
                             ),
                             Padding(
                               padding: const EdgeInsets.only(left: 4.0),
-                              child: Text(
-                                values[index].$1,
-                                style: const TextStyle(
-                                  fontSize: 16,
-                                  fontWeight: FontWeight.bold,
+                              child: RichText(
+                                overflow: TextOverflow.ellipsis,
+                                text: TextSpan(
+                                  style: DefaultTextStyle.of(context).style,
+                                  children: [
+                                    TextSpan(
+                                      text: values[index].$1.name,
+                                      style: const TextStyle(
+                                        fontSize: 16,
+                                        fontWeight: FontWeight.bold,
+                                      ),
+                                    ),
+                                    TextSpan(
+                                      text: getNameCountText(values[index].$1),
+                                      style: TextStyle(
+                                        fontSize: 14,
+                                        fontWeight: FontWeight.bold,
+                                        color: CustomTheme.textColor.withAlpha(
+                                          150,
+                                        ),
+                                      ),
+                                    ),
+                                  ],
                                 ),
                               ),
                             ),

lib/presentation/widgets/tiles/text_icon_list_tile.dart

@@ -9,6 +9,7 @@ class TextIconListTile extends StatelessWidget {
   const TextIconListTile({
     super.key,
     required this.text,
+    this.suffixText = '',
     this.iconEnabled = true,
     this.onPressed,
   });
@@ -16,6 +17,9 @@ class TextIconListTile extends StatelessWidget {
   /// The text to display in the tile.
   final String text;
 
+  /// An optional suffix text to display after the main text.
+  final String suffixText;
+
   /// A boolean to determine if the icon should be displayed.
   final bool iconEnabled;
 
@@ -35,12 +39,27 @@ class TextIconListTile extends StatelessWidget {
           Flexible(
             child: Container(
               padding: const EdgeInsets.symmetric(vertical: 12.5),
-              child: Text(
-                text,
+              child: RichText(
                 overflow: TextOverflow.ellipsis,
-                style: const TextStyle(
-                  fontSize: 16,
-                  fontWeight: FontWeight.w500,
+                text: TextSpan(
+                  style: DefaultTextStyle.of(context).style,
+                  children: [
+                    TextSpan(
+                      text: text,
+                      style: const TextStyle(
+                        fontSize: 16,
+                        fontWeight: FontWeight.w500,
+                      ),
+                    ),
+                    TextSpan(
+                      text: suffixText,
+                      style: TextStyle(
+                        fontSize: 14,
+                        fontWeight: FontWeight.w500,
+                        color: CustomTheme.textColor.withAlpha(100),
+                      ),
+                    ),
+                  ],
                 ),
               ),
             ),

lib/presentation/widgets/tiles/text_icon_tile.dart

@@ -9,6 +9,7 @@ class TextIconTile extends StatelessWidget {
   const TextIconTile({
     super.key,
     required this.text,
+    this.suffixText = '',
     this.iconEnabled = true,
     this.onIconTap,
   });
@@ -16,6 +17,8 @@ class TextIconTile extends StatelessWidget {
   /// The text to display in the tile.
   final String text;
 
+  final String suffixText;
+
   /// A boolean to determine if the icon should be displayed.
   final bool iconEnabled;
 
@@ -36,10 +39,28 @@ class TextIconTile extends StatelessWidget {
         children: [
           if (iconEnabled) const SizedBox(width: 3),
           Flexible(
-            child: Text(
-              text,
+            child: RichText(
               overflow: TextOverflow.ellipsis,
-              style: const TextStyle(fontSize: 14, fontWeight: FontWeight.w500),
+              text: TextSpan(
+                style: DefaultTextStyle.of(context).style,
+                children: [
+                  TextSpan(
+                    text: text,
+                    style: const TextStyle(
+                      fontSize: 14,
+                      fontWeight: FontWeight.w500,
+                    ),
+                  ),
+                  TextSpan(
+                    text: suffixText,
+                    style: TextStyle(
+                      fontSize: 13,
+                      fontWeight: FontWeight.w500,
+                      color: CustomTheme.textColor.withAlpha(120),
+                    ),
+                  ),
+                ],
+              ),
             ),
           ),
           if (iconEnabled) ...<Widget>[

lib/services/data_transfer_service.dart

@@ -18,6 +18,7 @@ class DataTransferService {
   /// Deletes all data from the database.
   static Future<void> deleteAllData(BuildContext context) async {
     final db = Provider.of<AppDatabase>(context, listen: false);
+
     await db.matchDao.deleteAllMatches();
     await db.teamDao.deleteAllTeams();
     await db.groupDao.deleteAllGroups();
@@ -70,6 +71,20 @@ class DataTransferService {
               'gameId': m.game.id,
               'groupId': m.group?.id,
               'playerIds': m.players.map((p) => p.id).toList(),
+              'scores': m.scores.map(
+                (playerId, scores) => MapEntry(
+                  playerId,
+                  scores
+                      .map(
+                        (s) => {
+                          'roundNumber': s.roundNumber,
+                          'score': s.score,
+                          'change': s.change,
+                        },
+                      )
+                      .toList(),
+                ),
+              ),
               'notes': m.notes,
             },
           )
@@ -82,8 +97,8 @@ class DataTransferService {
   /// Exports the given JSON string to a file with the specified name.
   /// Returns an [ExportResult] indicating the outcome.
   ///
-  /// [jsonString] The JSON string to be exported.
-  /// [fileName] The desired name for the exported file (without extension).
+  /// - [jsonString]: The JSON string to be exported.
+  /// - [fileName]:  The desired name for the exported file (without extension).
   static Future<ExportResult> exportData(
     String jsonString,
     String fileName,
@@ -124,129 +139,12 @@ class DataTransferService {
       final jsonString = await _readFileContent(path.files.single);
       if (jsonString == null) return ImportResult.fileReadError;
 
-      final isValid = await _validateJsonSchema(jsonString);
+      final isValid = await validateJsonSchema(jsonString);
       if (!isValid) return ImportResult.invalidSchema;
 
-      final Map<String, dynamic> decoded =
-          json.decode(jsonString) as Map<String, dynamic>;
+      final decoded = json.decode(jsonString) as Map<String, dynamic>;
 
-      final List<dynamic> playersJson =
-          (decoded['players'] as List<dynamic>?) ?? [];
-      final List<dynamic> gamesJson =
-          (decoded['games'] as List<dynamic>?) ?? [];
-      final List<dynamic> groupsJson =
-          (decoded['groups'] as List<dynamic>?) ?? [];
-      final List<dynamic> teamsJson =
-          (decoded['teams'] as List<dynamic>?) ?? [];
-      final List<dynamic> matchesJson =
-          (decoded['matches'] as List<dynamic>?) ?? [];
-
-      // Import Players
-      final List<Player> importedPlayers = playersJson
-          .map((p) => Player.fromJson(p as Map<String, dynamic>))
-          .toList();
-
-      final Map<String, Player> playerById = {
-        for (final p in importedPlayers) p.id: p,
-      };
-
-      // Import Games
-      final List<Game> importedGames = gamesJson
-          .map((g) => Game.fromJson(g as Map<String, dynamic>))
-          .toList();
-
-      final Map<String, Game> gameById = {
-        for (final g in importedGames) g.id: g,
-      };
-
-      // Import Groups
-      final List<Group> importedGroups = groupsJson.map((g) {
-        final map = g as Map<String, dynamic>;
-        final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
-            .cast<String>();
-
-        final members = memberIds
-            .map((id) => playerById[id])
-            .whereType<Player>()
-            .toList();
-
-        return Group(
-          id: map['id'] as String,
-          name: map['name'] as String,
-          description: map['description'] as String,
-          members: members,
-          createdAt: DateTime.parse(map['createdAt'] as String),
-        );
-      }).toList();
-
-      final Map<String, Group> groupById = {
-        for (final g in importedGroups) g.id: g,
-      };
-
-      // Import Teams
-      final List<Team> importedTeams = teamsJson.map((t) {
-        final map = t as Map<String, dynamic>;
-        final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
-            .cast<String>();
-
-        final members = memberIds
-            .map((id) => playerById[id])
-            .whereType<Player>()
-            .toList();
-
-        return Team(
-          id: map['id'] as String,
-          name: map['name'] as String,
-          members: members,
-          createdAt: DateTime.parse(map['createdAt'] as String),
-        );
-      }).toList();
-
-      // Import Matches
-      final List<Match> importedMatches = matchesJson.map((m) {
-        final map = m as Map<String, dynamic>;
-
-        final String gameId = map['gameId'] as String;
-        final String? groupId = map['groupId'] as String?;
-        final List<String> playerIds =
-            (map['playerIds'] as List<dynamic>? ?? []).cast<String>();
-        final DateTime? endedAt = map['endedAt'] != null
-            ? DateTime.parse(map['endedAt'] as String)
-            : null;
-
-        final game = gameById[gameId];
-        final group = (groupId == null) ? null : groupById[groupId];
-        final players = playerIds
-            .map((id) => playerById[id])
-            .whereType<Player>()
-            .toList();
-
-        return Match(
-          id: map['id'] as String,
-          name: map['name'] as String,
-          game:
-              game ??
-              Game(
-                name: 'Unknown',
-                ruleset: Ruleset.singleWinner,
-                description: '',
-                color: GameColor.blue,
-                icon: '',
-              ),
-          group: group,
-          players: players,
-          createdAt: DateTime.parse(map['createdAt'] as String),
-          endedAt: endedAt,
-          notes: map['notes'] as String? ?? '',
-        );
-      }).toList();
-
-      // Import all data into the database
-      await db.playerDao.addPlayersAsList(players: importedPlayers);
-      await db.gameDao.addGamesAsList(games: importedGames);
-      await db.groupDao.addGroupsAsList(groups: importedGroups);
-      await db.teamDao.addTeamsAsList(teams: importedTeams);
-      await db.matchDao.addMatchAsList(matches: importedMatches);
+      await importDataToDatabase(db, decoded);
 
       return ImportResult.success;
     } on FormatException catch (e, stack) {
@@ -262,6 +160,167 @@ class DataTransferService {
     }
   }
 
+  /// Imports parsed JSON data into the database.
+  @visibleForTesting
+  static Future<void> importDataToDatabase(
+    AppDatabase db,
+    Map<String, dynamic> decodedJson,
+  ) async {
+    // Fetch all entities first to create lookup maps for relationships
+    final importedPlayers = parsePlayersFromJson(decodedJson);
+    final playerById = {for (final p in importedPlayers) p.id: p};
+
+    final importedGames = parseGamesFromJson(decodedJson);
+    final gameById = {for (final g in importedGames) g.id: g};
+
+    final importedGroups = parseGroupsFromJson(decodedJson, playerById);
+    final groupById = {for (final g in importedGroups) g.id: g};
+
+    final importedTeams = parseTeamsFromJson(decodedJson, playerById);
+
+    final importedMatches = parseMatchesFromJson(
+      decodedJson,
+      gameById,
+      groupById,
+      playerById,
+    );
+
+    await db.playerDao.addPlayersAsList(players: importedPlayers);
+    await db.gameDao.addGamesAsList(games: importedGames);
+    await db.groupDao.addGroupsAsList(groups: importedGroups);
+    await db.teamDao.addTeamsAsList(teams: importedTeams);
+    await db.matchDao.addMatchAsList(matches: importedMatches);
+  }
+
+  /* Parsing Methods */
+
+  @visibleForTesting
+  static List<Player> parsePlayersFromJson(Map<String, dynamic> decodedJson) {
+    final playersJson = (decodedJson['players'] as List<dynamic>?) ?? [];
+    return playersJson
+        .map((p) => Player.fromJson(p as Map<String, dynamic>))
+        .toList();
+  }
+
+  @visibleForTesting
+  static List<Game> parseGamesFromJson(Map<String, dynamic> decodedJson) {
+    final gamesJson = (decodedJson['games'] as List<dynamic>?) ?? [];
+    return gamesJson
+        .map((g) => Game.fromJson(g as Map<String, dynamic>))
+        .toList();
+  }
+
+  @visibleForTesting
+  static List<Group> parseGroupsFromJson(
+    Map<String, dynamic> decodedJson,
+    Map<String, Player> playerById,
+  ) {
+    final groupsJson = (decodedJson['groups'] as List<dynamic>?) ?? [];
+    return groupsJson.map((g) {
+      final map = g as Map<String, dynamic>;
+      final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
+          .cast<String>();
+
+      final members = memberIds
+          .map((id) => playerById[id])
+          .whereType<Player>()
+          .toList();
+
+      return Group(
+        id: map['id'] as String,
+        name: map['name'] as String,
+        description: map['description'] as String,
+        members: members,
+        createdAt: DateTime.parse(map['createdAt'] as String),
+      );
+    }).toList();
+  }
+
+  /// Parses teams from JSON data.
+  @visibleForTesting
+  static List<Team> parseTeamsFromJson(
+    Map<String, dynamic> decodedJson,
+    Map<String, Player> playerById,
+  ) {
+    final teamsJson = (decodedJson['teams'] as List<dynamic>?) ?? [];
+    return teamsJson.map((t) {
+      final map = t as Map<String, dynamic>;
+      final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
+          .cast<String>();
+
+      final members = memberIds
+          .map((id) => playerById[id])
+          .whereType<Player>()
+          .toList();
+
+      return Team(
+        id: map['id'] as String,
+        name: map['name'] as String,
+        members: members,
+        createdAt: DateTime.parse(map['createdAt'] as String),
+      );
+    }).toList();
+  }
+
+  /// Parses matches from JSON data.
+  @visibleForTesting
+  static List<Match> parseMatchesFromJson(
+    Map<String, dynamic> decodedJson,
+    Map<String, Game> gamesMap,
+    Map<String, Group> groupsMap,
+    Map<String, Player> playersMap,
+  ) {
+    final matchesJson = (decodedJson['matches'] as List<dynamic>?) ?? [];
+    return matchesJson.map((m) {
+      final map = m as Map<String, dynamic>;
+
+      // Extract attributes from json
+      final id = map['id'] as String;
+      final name = map['name'] as String;
+      final gameId = map['gameId'] as String;
+      final groupId = map['groupId'] as String?;
+      final createdAt = DateTime.parse(map['createdAt'] as String);
+      final endedAt = map['endedAt'] != null
+          ? DateTime.parse(map['endedAt'] as String)
+          : null;
+      final notes = map['notes'] as String? ?? '';
+
+      // Link attributes to objects
+      final game = gamesMap[gameId] ?? getFallbackGame();
+      final group = groupId != null ? groupsMap[groupId] : null;
+
+      final playerIds = (map['playerIds'] as List<dynamic>? ?? [])
+          .cast<String>();
+      final players = playerIds
+          .map((id) => playersMap[id])
+          .whereType<Player>()
+          .toList();
+
+      return Match(
+        id: id,
+        name: name,
+        game: game,
+        group: group,
+        players: players,
+        createdAt: createdAt,
+        endedAt: endedAt,
+        notes: notes,
+      );
+    }).toList();
+  }
+
+  /// Creates a fallback game when the referenced game is not found.
+  @visibleForTesting
+  static Game getFallbackGame() {
+    return Game(
+      name: 'Unknown',
+      ruleset: Ruleset.singleWinner,
+      description: '',
+      color: GameColor.blue,
+      icon: '',
+    );
+  }
+
   /// Helper method to read file content from either bytes or path
   static Future<String?> _readFileContent(PlatformFile file) async {
     if (file.bytes != null) return utf8.decode(file.bytes!);
@@ -269,8 +328,10 @@ class DataTransferService {
     return null;
   }
 
-  /// Validates the given JSON string against the predefined schema.
-  static Future<bool> _validateJsonSchema(String jsonString) async {
+  /// Validates the given JSON string against the schema
+  /// in `assets/schema.json`.
+  @visibleForTesting
+  static Future<bool> validateJsonSchema(String jsonString) async {
     final String schemaString;
 
     schemaString = await rootBundle.loadString('assets/schema.json');

pubspec.yaml

@@ -1,7 +1,7 @@
 name: tallee
 description: "Tracking App for Card Games"
 publish_to: 'none'
-version: 0.0.19+253
+version: 0.0.20+254
 
 environment:
   sdk: ^3.8.1

test/db_tests/aggregates/match_test.dart

@@ -296,7 +296,7 @@ void main() {
     test('Setting a winner works correctly', () async {
       await database.matchDao.addMatch(match: testMatch1);
 
-      await database.scoreDao.setWinner(
+      await database.scoreEntryDao.setWinner(
         matchId: testMatch1.id,
         playerId: testPlayer5.id,
       );

test/db_tests/entities/player_test.dart

@@ -1,5 +1,5 @@
 import 'package:clock/clock.dart';
-import 'package:drift/drift.dart' hide isNull;
+import 'package:drift/drift.dart' hide isNull, isNotNull;
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:tallee/data/db/database.dart';
@@ -381,5 +381,160 @@ void main() {
       );
       expect(playerExists, true);
     });
+
+    group('Name Count Tests', () {
+      test('Single player gets initialized wih name count  0', () async {
+        await database.playerDao.addPlayer(player: testPlayer1);
+
+        final player = await database.playerDao.getPlayerById(
+          playerId: testPlayer1.id,
+        );
+        expect(player.nameCount, 0);
+      });
+
+      test('Multiple players get initialized wih name count  0', () async {
+        await database.playerDao.addPlayersAsList(
+          players: [testPlayer1, testPlayer2],
+        );
+
+        final players = await database.playerDao.getAllPlayers();
+
+        expect(players.length, 2);
+        for (Player p in players) {
+          expect(p.nameCount, 0);
+        }
+      });
+
+      test(
+        'Seperatly added players nameCount gets increased correctly',
+        () async {
+          await database.playerDao.addPlayer(player: testPlayer1);
+
+          final player1 = Player(name: testPlayer1.name, description: '');
+          await database.playerDao.addPlayer(player: player1);
+
+          var players = await database.playerDao.getAllPlayers();
+
+          expect(players.length, 2);
+          players.sort((a, b) => a.nameCount.compareTo(b.nameCount));
+
+          for (int i = 0; i < players.length - 1; i++) {
+            expect(players[i].nameCount, i + 1);
+          }
+        },
+      );
+
+      test(
+        'Together added players nameCount gets increased correctly',
+        () async {
+          final player1 = Player(name: testPlayer1.name, description: '');
+          final player2 = Player(name: testPlayer1.name, description: '');
+          final player3 = Player(name: testPlayer1.name, description: '');
+
+          // addPlayersAsList() with multiple players and with one player
+          await database.playerDao.addPlayersAsList(players: [testPlayer1]);
+          await database.playerDao.addPlayersAsList(
+            players: [player1, player2, player3],
+          );
+
+          var players = await database.playerDao.getAllPlayers();
+
+          expect(players.length, 4);
+          players.sort((a, b) => a.nameCount.compareTo(b.nameCount));
+
+          for (int i = 0; i < players.length - 1; i++) {
+            expect(players[i].nameCount, i + 1);
+          }
+        },
+      );
+
+      test('getNameCount works  correctly', () async {
+        final player2 = Player(name: testPlayer1.name);
+        final player3 = Player(name: testPlayer1.name);
+
+        await database.playerDao.addPlayersAsList(
+          players: [testPlayer1, player2, player3],
+        );
+
+        final nameCount = await database.playerDao.getNameCount(
+          name: testPlayer1.name,
+        );
+
+        expect(nameCount, 3);
+      });
+
+      test('updateNameCount works correctly', () async {
+        await database.playerDao.addPlayer(player: testPlayer1);
+
+        final success = await database.playerDao.updateNameCount(
+          playerId: testPlayer1.id,
+          nameCount: 2,
+        );
+        expect(success, true);
+
+        final player = await database.playerDao.getPlayerById(
+          playerId: testPlayer1.id,
+        );
+        expect(player.nameCount, 2);
+      });
+
+      test('getPlayerWithHighestNameCount works correctly', () async {
+        final player2 = Player(name: testPlayer1.name, description: '');
+        final player3 = Player(name: testPlayer1.name, description: '');
+
+        await database.playerDao.addPlayersAsList(
+          players: [testPlayer1, player2, player3],
+        );
+
+        final player = await database.playerDao.getPlayerWithHighestNameCount(
+          name: testPlayer1.name,
+        );
+
+        expect(player, isNotNull);
+        expect(player!.nameCount, 3);
+      });
+
+      test('getPlayerWithHighestNameCount with non existing player', () async {
+        final player = await database.playerDao.getPlayerWithHighestNameCount(
+          name: 'non-existing-name',
+        );
+        expect(player, isNull);
+      });
+
+      test('calculateNameCount works correctly', () async {
+        // Case 1: No existing players with the name
+        var count = await database.playerDao.calculateNameCount(
+          name: testPlayer1.name,
+        );
+        expect(count, 0);
+
+        // Case 2: One existing player with the name. Should update that
+        // player's nameCount to 1 and return 2 for the new player
+        await database.playerDao.addPlayer(player: testPlayer1);
+
+        count = await database.playerDao.calculateNameCount(
+          name: testPlayer1.name,
+        );
+        expect(count, 2);
+
+        // Case 3: Multiple existing players with the name.
+        final player2 = Player(name: testPlayer1.name, nameCount: count);
+        await database.playerDao.addPlayer(player: player2);
+
+        count = await database.playerDao.calculateNameCount(
+          name: testPlayer1.name,
+        );
+        expect(count, 3);
+      });
+
+      test('getPlayerWithHighestNameCount with non existing player', () async {
+        await database.playerDao.addPlayer(player: testPlayer1);
+        await database.playerDao.initializeNameCount(name: testPlayer1.name);
+        final player = await database.playerDao.getPlayerById(
+          playerId: testPlayer1.id,
+        );
+        expect(player.nameCount, 1);
+      });
+    });
   });
 }

test/db_tests/relationships/player_match_test.dart

@@ -267,21 +267,6 @@ void main() {
       expect(players, isNull);
     });
 
-    test(
-      'updatePlayerScore returns false for non-existent player-match',
-      () async {
-        await database.matchDao.addMatch(match: testMatchOnlyGroup);
-
-        final updated = await database.scoreDao.updateScore(
-          matchId: testMatchOnlyGroup.id,
-          playerId: 'non-existent-player-id',
-          newScore: 50,
-        );
-
-        expect(updated, false);
-      },
-    );
-
     test('Adding player with teamId works correctly', () async {
       await database.matchDao.addMatch(match: testMatchOnlyGroup);
       await database.teamDao.addTeam(team: testTeam1);

test/db_tests/values/score_test.dart

@@ -7,7 +7,7 @@ import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/models/game.dart';
 import 'package:tallee/data/models/match.dart';
 import 'package:tallee/data/models/player.dart';
-import 'package:tallee/data/models/score.dart';
+import 'package:tallee/data/models/score_entry.dart';
 
 void main() {
   late AppDatabase database;
@@ -69,15 +69,14 @@ void main() {
   group('Score Tests', () {
     group('Adding and Fetching scores', () {
       test('Single Score', () async {
-        await database.scoreDao.addScore(
+        ScoreEntry entry = ScoreEntry(roundNumber: 1, score: 10, change: 10);
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: entry,
         );
 
-        final score = await database.scoreDao.getScore(
+        final score = await database.scoreEntryDao.getScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
           roundNumber: 1,
@@ -91,18 +90,18 @@ void main() {
 
       test('Multiple Scores', () async {
         final entryList = [
-          Score(roundNumber: 1, score: 5, change: 5),
-          Score(roundNumber: 2, score: 12, change: 7),
-          Score(roundNumber: 3, score: 18, change: 6),
+          ScoreEntry(roundNumber: 1, score: 5, change: 5),
+          ScoreEntry(roundNumber: 2, score: 12, change: 7),
+          ScoreEntry(roundNumber: 3, score: 18, change: 6),
         ];
 
-        await database.scoreDao.addScoresAsList(
-          scores: entryList,
+        await database.scoreEntryDao.addScoresAsList(
+          entrys: entryList,
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
         );
 
-        final scores = await database.scoreDao.getAllPlayerScoresInMatch(
+        final scores = await database.scoreEntryDao.getAllPlayerScoresInMatch(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
         );
@@ -120,15 +119,14 @@ void main() {
 
     group('Undesirable values', () {
       test('Score & Round can have negative values', () async {
-        await database.scoreDao.addScore(
+        ScoreEntry entry = ScoreEntry(roundNumber: -2, score: -10, change: -10);
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: -2,
-          score: -10,
-          change: -10,
+          entry: entry,
         );
 
-        final score = await database.scoreDao.getScore(
+        final score = await database.scoreEntryDao.getScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
           roundNumber: -2,
@@ -141,15 +139,14 @@ void main() {
       });
 
       test('Score & Round can have zero values', () async {
-        await database.scoreDao.addScore(
+        ScoreEntry entry = ScoreEntry(roundNumber: 0, score: 0, change: 0);
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 0,
-          score: 0,
-          change: 0,
+          entry: entry,
         );
 
-        final score = await database.scoreDao.getScore(
+        final score = await database.scoreEntryDao.getScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
           roundNumber: 0,
@@ -161,7 +158,7 @@ void main() {
       });
 
       test('Getting score for a non-existent entities returns null', () async {
-        var score = await database.scoreDao.getScore(
+        var score = await database.scoreEntryDao.getScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
           roundNumber: -1,
@@ -169,14 +166,14 @@ void main() {
 
         expect(score, isNull);
 
-        score = await database.scoreDao.getScore(
+        score = await database.scoreEntryDao.getScore(
           playerId: 'non-existin-player',
           matchId: testMatch1.id,
         );
 
         expect(score, isNull);
 
-        score = await database.scoreDao.getScore(
+        score = await database.scoreEntryDao.getScore(
           playerId: testPlayer1.id,
           matchId: 'non-existing-match',
         );
@@ -185,23 +182,20 @@ void main() {
       });
 
       test('Getting score for a non-match player returns null', () async {
-        await database.scoreDao.addScore(
+        ScoreEntry entry = ScoreEntry(roundNumber: 1, score: 10, change: 10);
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: entry,
         );
 
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer3.id,
           matchId: testMatch2.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: entry,
         );
 
-        var score = await database.scoreDao.getScore(
+        var score = await database.scoreEntryDao.getScore(
           playerId: testPlayer1.id,
           matchId: testMatch2.id,
           roundNumber: 1,
@@ -213,29 +207,26 @@ void main() {
 
     group('Scores in matches', () {
       test('getAllMatchScores()', () async {
-        await database.scoreDao.addScore(
+        ScoreEntry entry1 = ScoreEntry(roundNumber: 1, score: 10, change: 10);
+        ScoreEntry entry2 = ScoreEntry(roundNumber: 1, score: 20, change: 20);
+        ScoreEntry entry3 = ScoreEntry(roundNumber: 2, score: 25, change: 15);
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: entry1,
         );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer2.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 20,
-          change: 20,
+          entry: entry2,
         );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 2,
-          score: 25,
-          change: 15,
+          entry: entry3,
         );
 
-        final scores = await database.scoreDao.getAllMatchScores(
+        final scores = await database.scoreEntryDao.getAllMatchScores(
           matchId: testMatch1.id,
         );
 
@@ -245,7 +236,7 @@ void main() {
       });
 
       test('getAllMatchScores() with no scores saved', () async {
-        final scores = await database.scoreDao.getAllMatchScores(
+        final scores = await database.scoreEntryDao.getAllMatchScores(
           matchId: testMatch1.id,
         );
 
@@ -253,32 +244,25 @@ void main() {
       });
 
       test('getAllPlayerScoresInMatch()', () async {
-        await database.scoreDao.addScore(
+        ScoreEntry entry1 = ScoreEntry(roundNumber: 1, score: 10, change: 10);
+        ScoreEntry entry2 = ScoreEntry(roundNumber: 2, score: 25, change: 15);
+        ScoreEntry entry3 = ScoreEntry(roundNumber: 1, score: 30, change: 30);
+        await database.scoreEntryDao.addScoresAsList(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entrys: [entry1, entry2],
         );
-        await database.scoreDao.addScore(
-          playerId: testPlayer1.id,
-          matchId: testMatch1.id,
-          roundNumber: 2,
-          score: 25,
-          change: 15,
-        );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer2.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 30,
-          change: 30,
+          entry: entry3,
         );
 
-        final playerScores = await database.scoreDao.getAllPlayerScoresInMatch(
-          playerId: testPlayer1.id,
-          matchId: testMatch1.id,
-        );
+        final playerScores = await database.scoreEntryDao
+            .getAllPlayerScoresInMatch(
+              playerId: testPlayer1.id,
+              matchId: testMatch1.id,
+            );
 
         expect(playerScores.length, 2);
         expect(playerScores[0].roundNumber, 1);
@@ -290,43 +274,44 @@ void main() {
       });
 
       test('getAllPlayerScoresInMatch() with no scores saved', () async {
-        final playerScores = await database.scoreDao.getAllPlayerScoresInMatch(
-          playerId: testPlayer1.id,
-          matchId: testMatch1.id,
-        );
+        final playerScores = await database.scoreEntryDao
+            .getAllPlayerScoresInMatch(
+              playerId: testPlayer1.id,
+              matchId: testMatch1.id,
+            );
 
         expect(playerScores.isEmpty, true);
       });
 
       test('Scores are isolated across different matches', () async {
-        await database.scoreDao.addScore(
+        ScoreEntry entry1 = ScoreEntry(roundNumber: 1, score: 10, change: 10);
+        ScoreEntry entry2 = ScoreEntry(roundNumber: 1, score: 50, change: 50);
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: entry1,
         );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch2.id,
-          roundNumber: 1,
-          score: 50,
-          change: 50,
+          entry: entry2,
         );
 
-        final match1Scores = await database.scoreDao.getAllPlayerScoresInMatch(
-          playerId: testPlayer1.id,
-          matchId: testMatch1.id,
-        );
+        final match1Scores = await database.scoreEntryDao
+            .getAllPlayerScoresInMatch(
+              playerId: testPlayer1.id,
+              matchId: testMatch1.id,
+            );
 
         expect(match1Scores.length, 1);
         expect(match1Scores[0].score, 10);
         expect(match1Scores[0].change, 10);
 
-        final match2Scores = await database.scoreDao.getAllPlayerScoresInMatch(
-          playerId: testPlayer1.id,
-          matchId: testMatch2.id,
-        );
+        final match2Scores = await database.scoreEntryDao
+            .getAllPlayerScoresInMatch(
+              playerId: testPlayer1.id,
+              matchId: testMatch2.id,
+            );
 
         expect(match2Scores.length, 1);
         expect(match2Scores[0].score, 50);
@@ -336,33 +321,29 @@ void main() {
 
     group('Updating scores', () {
       test('updateScore()', () async {
-        await database.scoreDao.addScore(
+        ScoreEntry entry1 = ScoreEntry(roundNumber: 1, score: 10, change: 10);
+        ScoreEntry entry2 = ScoreEntry(roundNumber: 2, score: 15, change: 5);
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: entry1,
         );
 
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 2,
-          score: 15,
-          change: 5,
+          entry: entry2,
         );
 
-        final updated = await database.scoreDao.updateScore(
+        final updated = await database.scoreEntryDao.updateScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 2,
-          newScore: 50,
-          newChange: 40,
+          newEntry: ScoreEntry(roundNumber: 2, score: 50, change: 40),
         );
 
         expect(updated, true);
 
-        final score = await database.scoreDao.getScore(
+        final score = await database.scoreEntryDao.getScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
           roundNumber: 2,
@@ -374,12 +355,10 @@ void main() {
       });
 
       test('Updating a non-existent score returns false', () async {
-        final updated = await database.scoreDao.updateScore(
+        final updated = await database.scoreEntryDao.updateScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          newScore: 20,
-          newChange: 20,
+          newEntry: ScoreEntry(roundNumber: 1, score: 20, change: 20),
         );
 
         expect(updated, false);
@@ -388,15 +367,13 @@ void main() {
 
     group('Deleting scores', () {
       test('deleteScore() ', () async {
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
         );
 
-        final deleted = await database.scoreDao.deleteScore(
+        final deleted = await database.scoreEntryDao.deleteScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
           roundNumber: 1,
@@ -404,7 +381,7 @@ void main() {
 
         expect(deleted, true);
 
-        final score = await database.scoreDao.getScore(
+        final score = await database.scoreEntryDao.getScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
           roundNumber: 1,
@@ -414,7 +391,7 @@ void main() {
       });
 
       test('Deleting a non-existent score returns false', () async {
-        final deleted = await database.scoreDao.deleteScore(
+        final deleted = await database.scoreEntryDao.deleteScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
           roundNumber: 1,
@@ -424,149 +401,130 @@ void main() {
       });
 
       test('deleteAllScoresForMatch() works correctly', () async {
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
         );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer2.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 20,
-          change: 20,
+          entry: ScoreEntry(roundNumber: 1, score: 20, change: 20),
         );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch2.id,
-          roundNumber: 1,
-          score: 15,
-          change: 15,
+          entry: ScoreEntry(roundNumber: 1, score: 15, change: 15),
         );
 
-        final deleted = await database.scoreDao.deleteAllScoresForMatch(
+        final deleted = await database.scoreEntryDao.deleteAllScoresForMatch(
           matchId: testMatch1.id,
         );
 
         expect(deleted, true);
 
-        final match1Scores = await database.scoreDao.getAllMatchScores(
+        final match1Scores = await database.scoreEntryDao.getAllMatchScores(
           matchId: testMatch1.id,
         );
         expect(match1Scores.length, 0);
 
-        final match2Scores = await database.scoreDao.getAllMatchScores(
+        final match2Scores = await database.scoreEntryDao.getAllMatchScores(
           matchId: testMatch2.id,
         );
         expect(match2Scores.length, 1);
       });
 
       test('deleteAllScoresForPlayerInMatch() works correctly', () async {
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
         );
 
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 2,
-          score: 15,
-          change: 5,
+          entry: ScoreEntry(roundNumber: 2, score: 15, change: 5),
         );
 
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer2.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 6,
-          change: 6,
+          entry: ScoreEntry(roundNumber: 1, score: 6, change: 6),
         );
 
-        final deleted = await database.scoreDao.deleteAllScoresForPlayerInMatch(
-          playerId: testPlayer1.id,
-          matchId: testMatch1.id,
-        );
+        final deleted = await database.scoreEntryDao
+            .deleteAllScoresForPlayerInMatch(
+              playerId: testPlayer1.id,
+              matchId: testMatch1.id,
+            );
 
         expect(deleted, true);
 
-        final player1Scores = await database.scoreDao.getAllPlayerScoresInMatch(
-          playerId: testPlayer1.id,
-          matchId: testMatch1.id,
-        );
+        final player1Scores = await database.scoreEntryDao
+            .getAllPlayerScoresInMatch(
+              playerId: testPlayer1.id,
+              matchId: testMatch1.id,
+            );
         expect(player1Scores.length, 0);
 
-        final player2Scores = await database.scoreDao.getAllPlayerScoresInMatch(
-          playerId: testPlayer2.id,
-          matchId: testMatch1.id,
-        );
+        final player2Scores = await database.scoreEntryDao
+            .getAllPlayerScoresInMatch(
+              playerId: testPlayer2.id,
+              matchId: testMatch1.id,
+            );
         expect(player2Scores.length, 1);
       });
     });
 
     group('Score Aggregations & Edge Cases', () {
       test('getLatestRoundNumber()', () async {
-        var latestRound = await database.scoreDao.getLatestRoundNumber(
+        var latestRound = await database.scoreEntryDao.getLatestRoundNumber(
           matchId: testMatch1.id,
         );
         expect(latestRound, isNull);
 
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
         );
 
-        latestRound = await database.scoreDao.getLatestRoundNumber(
+        latestRound = await database.scoreEntryDao.getLatestRoundNumber(
           matchId: testMatch1.id,
         );
         expect(latestRound, 1);
 
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 5,
-          score: 50,
-          change: 40,
+          entry: ScoreEntry(roundNumber: 5, score: 50, change: 40),
         );
 
-        latestRound = await database.scoreDao.getLatestRoundNumber(
+        latestRound = await database.scoreEntryDao.getLatestRoundNumber(
           matchId: testMatch1.id,
         );
         expect(latestRound, 5);
       });
 
       test('getLatestRoundNumber() with non-consecutive rounds', () async {
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
         );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 5,
-          score: 50,
-          change: 40,
+          entry: ScoreEntry(roundNumber: 5, score: 50, change: 40),
         );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 3,
-          score: 30,
-          change: 20,
+          entry: ScoreEntry(roundNumber: 3, score: 30, change: 20),
         );
 
-        final latestRound = await database.scoreDao.getLatestRoundNumber(
+        final latestRound = await database.scoreEntryDao.getLatestRoundNumber(
           matchId: testMatch1.id,
         );
 
@@ -574,35 +532,29 @@ void main() {
       });
 
       test('getTotalScoreForPlayer()', () async {
-        var totalScore = await database.scoreDao.getTotalScoreForPlayer(
+        var totalScore = await database.scoreEntryDao.getTotalScoreForPlayer(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
         );
         expect(totalScore, 0);
 
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
         );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 2,
-          score: 25,
-          change: 15,
+          entry: ScoreEntry(roundNumber: 2, score: 25, change: 15),
         );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 3,
-          score: 40,
-          change: 15,
+          entry: ScoreEntry(roundNumber: 3, score: 40, change: 15),
         );
 
-        totalScore = await database.scoreDao.getTotalScoreForPlayer(
+        totalScore = await database.scoreEntryDao.getTotalScoreForPlayer(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
         );
@@ -610,29 +562,23 @@ void main() {
       });
 
       test('getTotalScoreForPlayer() ignores round score', () async {
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 2,
-          score: 25,
-          change: 25,
+          entry: ScoreEntry(roundNumber: 2, score: 25, change: 25),
         );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 25,
-          change: 10,
+          entry: ScoreEntry(roundNumber: 1, score: 25, change: 10),
         );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 3,
-          score: 25,
-          change: 25,
+          entry: ScoreEntry(roundNumber: 3, score: 25, change: 25),
         );
 
-        final totalScore = await database.scoreDao.getTotalScoreForPlayer(
+        final totalScore = await database.scoreEntryDao.getTotalScoreForPlayer(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
         );
@@ -642,22 +588,18 @@ void main() {
       });
 
       test('Adding the same score twice replaces the existing one', () async {
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 10,
-          change: 10,
+          entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
         );
-        await database.scoreDao.addScore(
+        await database.scoreEntryDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
-          roundNumber: 1,
-          score: 20,
-          change: 20,
+          entry: ScoreEntry(roundNumber: 1, score: 20, change: 20),
         );
 
-        final score = await database.scoreDao.getScore(
+        final score = await database.scoreEntryDao.getScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
           roundNumber: 1,
@@ -671,100 +613,116 @@ void main() {
 
     group('Handling Winner', () {
       test('hasWinner() works correctly', () async {
-        var hasWinner = await database.scoreDao.hasWinner(
+        var hasWinner = await database.scoreEntryDao.hasWinner(
           matchId: testMatch1.id,
         );
         expect(hasWinner, false);
 
-        await database.scoreDao.setWinner(
+        await database.scoreEntryDao.setWinner(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
         );
 
-        hasWinner = await database.scoreDao.hasWinner(matchId: testMatch1.id);
+        hasWinner = await database.scoreEntryDao.hasWinner(
+          matchId: testMatch1.id,
+        );
         expect(hasWinner, true);
       });
 
       test('getWinnersForMatch() returns correct winner', () async {
-        var winner = await database.scoreDao.getWinner(matchId: testMatch1.id);
+        var winner = await database.scoreEntryDao.getWinner(
+          matchId: testMatch1.id,
+        );
         expect(winner, isNull);
 
-        await database.scoreDao.setWinner(
+        await database.scoreEntryDao.setWinner(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
         );
 
-        winner = await database.scoreDao.getWinner(matchId: testMatch1.id);
+        winner = await database.scoreEntryDao.getWinner(matchId: testMatch1.id);
 
         expect(winner, isNotNull);
         expect(winner!.id, testPlayer1.id);
       });
 
       test('removeWinner() works correctly', () async {
-        var removed = await database.scoreDao.removeWinner(
+        var removed = await database.scoreEntryDao.removeWinner(
           matchId: testMatch1.id,
         );
         expect(removed, false);
 
-        await database.scoreDao.setWinner(
+        await database.scoreEntryDao.setWinner(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
         );
 
-        removed = await database.scoreDao.removeWinner(matchId: testMatch1.id);
+        removed = await database.scoreEntryDao.removeWinner(
+          matchId: testMatch1.id,
+        );
         expect(removed, true);
 
-        var winner = await database.scoreDao.getWinner(matchId: testMatch1.id);
+        var winner = await database.scoreEntryDao.getWinner(
+          matchId: testMatch1.id,
+        );
         expect(winner, isNull);
       });
     });
 
     group('Handling Looser', () {
       test('hasLooser() works correctly', () async {
-        var hasLooser = await database.scoreDao.hasLooser(
+        var hasLooser = await database.scoreEntryDao.hasLooser(
           matchId: testMatch1.id,
         );
         expect(hasLooser, false);
 
-        await database.scoreDao.setLooser(
+        await database.scoreEntryDao.setLooser(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
         );
 
-        hasLooser = await database.scoreDao.hasLooser(matchId: testMatch1.id);
+        hasLooser = await database.scoreEntryDao.hasLooser(
+          matchId: testMatch1.id,
+        );
         expect(hasLooser, true);
       });
 
       test('getLooser() returns correct winner', () async {
-        var looser = await database.scoreDao.getLooser(matchId: testMatch1.id);
+        var looser = await database.scoreEntryDao.getLooser(
+          matchId: testMatch1.id,
+        );
         expect(looser, isNull);
 
-        await database.scoreDao.setLooser(
+        await database.scoreEntryDao.setLooser(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
         );
 
-        looser = await database.scoreDao.getLooser(matchId: testMatch1.id);
+        looser = await database.scoreEntryDao.getLooser(matchId: testMatch1.id);
 
         expect(looser, isNotNull);
         expect(looser!.id, testPlayer1.id);
       });
 
       test('removeLooser() works correctly', () async {
-        var removed = await database.scoreDao.removeLooser(
+        var removed = await database.scoreEntryDao.removeLooser(
           matchId: testMatch1.id,
         );
         expect(removed, false);
 
-        await database.scoreDao.setLooser(
+        await database.scoreEntryDao.setLooser(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
         );
 
-        removed = await database.scoreDao.removeLooser(matchId: testMatch1.id);
+        removed = await database.scoreEntryDao.removeLooser(
+          matchId: testMatch1.id,
+        );
         expect(removed, true);
 
-        var looser = await database.scoreDao.getLooser(matchId: testMatch1.id);
+        var looser = await database.scoreEntryDao.getLooser(
+          matchId: testMatch1.id,
+        );
         expect(looser, isNull);
       });
     });

test/services/data_transfer_service_test.dart

@@ -0,0 +1,926 @@
+import 'dart:convert';
+
+import 'package:clock/clock.dart';
+import 'package:drift/drift.dart' hide isNull, isNotNull;
+import 'package:drift/native.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:provider/provider.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/models/game.dart';
+import 'package:tallee/data/models/group.dart';
+import 'package:tallee/data/models/match.dart';
+import 'package:tallee/data/models/player.dart';
+import 'package:tallee/data/models/score_entry.dart';
+import 'package:tallee/data/models/team.dart';
+import 'package:tallee/services/data_transfer_service.dart';
+
+void main() {
+  late AppDatabase database;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Game testGame;
+  late Group testGroup;
+  late Team testTeam;
+  late Match testMatch;
+  final fixedDate = DateTime(2025, 11, 19, 0, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
+
+  setUp(() {
+    database = AppDatabase(
+      DatabaseConnection(
+        NativeDatabase.memory(),
+        closeStreamsSynchronously: true,
+      ),
+    );
+
+    withClock(fakeClock, () {
+      testPlayer1 = Player(name: 'Alice', description: 'First test player');
+      testPlayer2 = Player(name: 'Bob', description: 'Second test player');
+      testPlayer3 = Player(name: 'Charlie', description: 'Third player');
+
+      testGame = Game(
+        name: 'Chess',
+        ruleset: Ruleset.singleWinner,
+        description: 'Strategic board game',
+        color: GameColor.blue,
+        icon: 'chess_icon',
+      );
+
+      testGroup = Group(
+        name: 'Test Group',
+        description: 'Group for testing',
+        members: [testPlayer1, testPlayer2],
+      );
+
+      testTeam = Team(name: 'Test Team', members: [testPlayer1, testPlayer2]);
+
+      testMatch = Match(
+        name: 'Test Match',
+        game: testGame,
+        group: testGroup,
+        players: [testPlayer1, testPlayer2],
+        notes: 'Test notes',
+        scores: {
+          testPlayer1.id: [
+            ScoreEntry(roundNumber: 1, score: 10, change: 10),
+            ScoreEntry(roundNumber: 2, score: 20, change: 10),
+          ],
+          testPlayer2.id: [
+            ScoreEntry(roundNumber: 1, score: 15, change: 15),
+            ScoreEntry(roundNumber: 2, score: 25, change: 10),
+          ],
+        },
+      );
+    });
+  });
+
+  tearDown(() async {
+    await database.close();
+  });
+
+  // Helper for getting BuildContext
+  Future<BuildContext> getContext(WidgetTester tester) async {
+    // Minimal widget with Provider
+    await tester.pumpWidget(
+      Provider<AppDatabase>.value(
+        value: database,
+        child: MaterialApp(
+          home: Builder(
+            builder: (context) {
+              return Container();
+            },
+          ),
+        ),
+      ),
+    );
+    final BuildContext context = tester.element(find.byType(Container));
+    return context;
+  }
+
+  group('DataTransferService Tests', () {
+    testWidgets('deleteAllData()', (tester) async {
+      await database.playerDao.addPlayer(player: testPlayer1);
+      await database.gameDao.addGame(game: testGame);
+      await database.groupDao.addGroup(group: testGroup);
+      await database.teamDao.addTeam(team: testTeam);
+      await database.matchDao.addMatch(match: testMatch);
+
+      var playerCount = await database.playerDao.getPlayerCount();
+      var gameCount = await database.gameDao.getGameCount();
+      var groupCount = await database.groupDao.getGroupCount();
+      var teamCount = await database.teamDao.getTeamCount();
+      var matchCount = await database.matchDao.getMatchCount();
+
+      expect(playerCount, greaterThan(0));
+      expect(gameCount, greaterThan(0));
+      expect(groupCount, greaterThan(0));
+      expect(teamCount, greaterThan(0));
+      expect(matchCount, greaterThan(0));
+
+      final ctx = await getContext(tester);
+      await DataTransferService.deleteAllData(ctx);
+
+      playerCount = await database.playerDao.getPlayerCount();
+      gameCount = await database.gameDao.getGameCount();
+      groupCount = await database.groupDao.getGroupCount();
+      teamCount = await database.teamDao.getTeamCount();
+      matchCount = await database.matchDao.getMatchCount();
+
+      expect(playerCount, 0);
+      expect(gameCount, 0);
+      expect(groupCount, 0);
+      expect(teamCount, 0);
+      expect(matchCount, 0);
+    });
+
+    group('getAppDataAsJson()', () {
+      group('Whole export', () {
+        testWidgets('Exporting app data works correctly', (tester) async {
+          await database.playerDao.addPlayer(player: testPlayer1);
+          await database.playerDao.addPlayer(player: testPlayer2);
+          await database.gameDao.addGame(game: testGame);
+          await database.groupDao.addGroup(group: testGroup);
+          await database.teamDao.addTeam(team: testTeam);
+          await database.matchDao.addMatch(match: testMatch);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+
+          expect(jsonString, isNotEmpty);
+
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+
+          expect(decoded.containsKey('players'), true);
+          expect(decoded.containsKey('games'), true);
+          expect(decoded.containsKey('groups'), true);
+          expect(decoded.containsKey('teams'), true);
+          expect(decoded.containsKey('matches'), true);
+
+          final players = decoded['players'] as List<dynamic>;
+          final games = decoded['games'] as List<dynamic>;
+          final groups = decoded['groups'] as List<dynamic>;
+          final teams = decoded['teams'] as List<dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+
+          expect(players.length, 2);
+          expect(games.length, 1);
+          expect(groups.length, 1);
+          expect(teams.length, 1);
+          expect(matches.length, 1);
+        });
+
+        testWidgets('Exporting empty data works correctly', (tester) async {
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+
+          final players = decoded['players'] as List<dynamic>;
+          final games = decoded['games'] as List<dynamic>;
+          final groups = decoded['groups'] as List<dynamic>;
+          final teams = decoded['teams'] as List<dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+
+          expect(players, isEmpty);
+          expect(games, isEmpty);
+          expect(groups, isEmpty);
+          expect(teams, isEmpty);
+          expect(matches, isEmpty);
+        });
+      });
+
+      group('Checking specific data', () {
+        testWidgets('Player data is correct', (tester) async {
+          await database.playerDao.addPlayer(player: testPlayer1);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final players = decoded['players'] as List<dynamic>;
+          final playerData = players[0] as Map<String, dynamic>;
+
+          expect(playerData['id'], testPlayer1.id);
+          expect(playerData['name'], testPlayer1.name);
+          expect(playerData['description'], testPlayer1.description);
+          expect(
+            playerData['createdAt'],
+            testPlayer1.createdAt.toIso8601String(),
+          );
+        });
+
+        testWidgets('Game data is correct', (tester) async {
+          await database.gameDao.addGame(game: testGame);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final games = decoded['games'] as List<dynamic>;
+          final gameData = games[0] as Map<String, dynamic>;
+
+          expect(gameData['id'], testGame.id);
+          expect(gameData['name'], testGame.name);
+          expect(gameData['ruleset'], testGame.ruleset.name);
+          expect(gameData['description'], testGame.description);
+          expect(gameData['color'], testGame.color.name);
+          expect(gameData['icon'], testGame.icon);
+        });
+
+        testWidgets('Group data is correct', (tester) async {
+          await database.playerDao.addPlayer(player: testPlayer1);
+          await database.playerDao.addPlayer(player: testPlayer2);
+          await database.groupDao.addGroup(group: testGroup);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final groups = decoded['groups'] as List<dynamic>;
+          final groupData = groups[0] as Map<String, dynamic>;
+
+          expect(groupData['id'], testGroup.id);
+          expect(groupData['name'], testGroup.name);
+          expect(groupData['description'], testGroup.description);
+          expect(groupData['memberIds'], isA<List>());
+
+          final memberIds = groupData['memberIds'] as List<dynamic>;
+          expect(memberIds.length, 2);
+          expect(memberIds, containsAll([testPlayer1.id, testPlayer2.id]));
+        });
+
+        testWidgets('Team data is correct', (tester) async {
+          await database.teamDao.addTeam(team: testTeam);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final teams = decoded['teams'] as List<dynamic>;
+
+          expect(teams.length, 1);
+
+          final teamData = teams[0] as Map<String, dynamic>;
+
+          expect(teamData['id'], testTeam.id);
+          expect(teamData['name'], testTeam.name);
+          expect(teamData['memberIds'], isA<List>());
+
+          // Note: In this system, teams don't have independent members.
+          // Team members are only tracked through matches via PlayerMatchTable.
+          // Therefore, memberIds will be empty for standalone teams.
+          final memberIds = teamData['memberIds'] as List<dynamic>;
+          expect(memberIds, isEmpty);
+        });
+
+        testWidgets('Match data is correct', (tester) async {
+          await database.playerDao.addPlayersAsList(
+            players: [testPlayer1, testPlayer2],
+          );
+          await database.gameDao.addGame(game: testGame);
+          await database.groupDao.addGroup(group: testGroup);
+          await database.matchDao.addMatch(match: testMatch);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+          final matchData = matches[0] as Map<String, dynamic>;
+
+          expect(matchData['id'], testMatch.id);
+          expect(matchData['name'], testMatch.name);
+          expect(matchData['gameId'], testGame.id);
+          expect(matchData['groupId'], testGroup.id);
+          expect(matchData['playerIds'], isA<List>());
+          expect(matchData['notes'], testMatch.notes);
+
+          // Check player ids
+          final playerIds = matchData['playerIds'] as List<dynamic>;
+          expect(playerIds.length, 2);
+          expect(playerIds, containsAll([testPlayer1.id, testPlayer2.id]));
+
+          // Check scores structure
+          final scoresJson = matchData['scores'] as Map<String, dynamic>;
+          expect(scoresJson, isA<Map<String, dynamic>>());
+
+          final scores = scoresJson.map(
+            (playerId, scoreList) => MapEntry(
+              playerId,
+              (scoreList as List)
+                  .map((s) => ScoreEntry.fromJson(s as Map<String, dynamic>))
+                  .toList(),
+            ),
+          );
+
+          expect(scores, isA<Map<String, List<ScoreEntry>>>());
+
+          /* Player 1 scores */
+          // General structure
+          expect(scores[testPlayer1.id], isNotNull);
+          expect(scores[testPlayer1.id]!.length, 2);
+
+          // Round 1
+          expect(scores[testPlayer1.id]![0].roundNumber, 1);
+          expect(scores[testPlayer1.id]![0].score, 10);
+          expect(scores[testPlayer1.id]![0].change, 10);
+
+          // Round 2
+          expect(scores[testPlayer1.id]![1].roundNumber, 2);
+          expect(scores[testPlayer1.id]![1].score, 20);
+          expect(scores[testPlayer1.id]![1].change, 10);
+
+          /* Player 2 scores */
+          // General structure
+          expect(scores[testPlayer2.id], isNotNull);
+          expect(scores[testPlayer2.id]!.length, 2);
+
+          // Round 1
+          expect(scores[testPlayer2.id]![0].roundNumber, 1);
+          expect(scores[testPlayer2.id]![0].score, 15);
+          expect(scores[testPlayer2.id]![0].change, 15);
+
+          // Round 2
+          expect(scores[testPlayer2.id]![1].roundNumber, 2);
+          expect(scores[testPlayer2.id]![1].score, 25);
+          expect(scores[testPlayer2.id]![1].change, 10);
+        });
+
+        testWidgets('Match without group is handled correctly', (tester) async {
+          final matchWithoutGroup = Match(
+            name: 'No Group Match',
+            game: testGame,
+            group: null,
+            players: [testPlayer1],
+            notes: 'No group',
+          );
+
+          await database.playerDao.addPlayer(player: testPlayer1);
+          await database.gameDao.addGame(game: testGame);
+          await database.matchDao.addMatch(match: matchWithoutGroup);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+          final matchData = matches[0] as Map<String, dynamic>;
+
+          expect(matchData['groupId'], isNull);
+        });
+
+        testWidgets('Match with endedAt is handled correctly', (tester) async {
+          final endedDate = DateTime(2025, 12, 1, 10, 0, 0);
+          final endedMatch = Match(
+            name: 'Ended Match',
+            game: testGame,
+            players: [testPlayer1],
+            endedAt: endedDate,
+            notes: 'Finished',
+          );
+
+          await database.playerDao.addPlayer(player: testPlayer1);
+          await database.gameDao.addGame(game: testGame);
+          await database.matchDao.addMatch(match: endedMatch);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+          final matchData = matches[0] as Map<String, dynamic>;
+
+          expect(matchData['endedAt'], endedDate.toIso8601String());
+        });
+
+        testWidgets('Structure is consistent', (tester) async {
+          await database.playerDao.addPlayer(player: testPlayer1);
+          await database.gameDao.addGame(game: testGame);
+
+          final ctx = await getContext(tester);
+          final jsonString1 = await DataTransferService.getAppDataAsJson(ctx);
+          final jsonString2 = await DataTransferService.getAppDataAsJson(ctx);
+
+          expect(jsonString1, equals(jsonString2));
+        });
+
+        testWidgets('Empty match notes is handled correctly', (tester) async {
+          final matchWithEmptyNotes = Match(
+            name: 'Empty Notes Match',
+            game: testGame,
+            players: [testPlayer1],
+            notes: '',
+          );
+
+          await database.playerDao.addPlayer(player: testPlayer1);
+          await database.gameDao.addGame(game: testGame);
+          await database.matchDao.addMatch(match: matchWithEmptyNotes);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+          final matchData = matches[0] as Map<String, dynamic>;
+
+          expect(matchData['notes'], '');
+        });
+
+        testWidgets('Multiple players in match is handled correctly', (
+          tester,
+        ) async {
+          final multiPlayerMatch = Match(
+            name: 'Multi Player Match',
+            game: testGame,
+            players: [testPlayer1, testPlayer2, testPlayer3],
+            notes: 'Three players',
+          );
+
+          await database.playerDao.addPlayersAsList(
+            players: [testPlayer1, testPlayer2, testPlayer3],
+          );
+          await database.gameDao.addGame(game: testGame);
+          await database.matchDao.addMatch(match: multiPlayerMatch);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+          final matchData = matches[0] as Map<String, dynamic>;
+
+          final playerIds = matchData['playerIds'] as List<dynamic>;
+          expect(playerIds.length, 3);
+          expect(
+            playerIds,
+            containsAll([testPlayer1.id, testPlayer2.id, testPlayer3.id]),
+          );
+        });
+
+        testWidgets('All game colors are handled correctly', (tester) async {
+          final games = [
+            Game(
+              name: 'Red Game',
+              ruleset: Ruleset.singleWinner,
+              color: GameColor.red,
+              icon: 'icon',
+            ),
+            Game(
+              name: 'Blue Game',
+              ruleset: Ruleset.singleWinner,
+              color: GameColor.blue,
+              icon: 'icon',
+            ),
+            Game(
+              name: 'Green Game',
+              ruleset: Ruleset.singleWinner,
+              color: GameColor.green,
+              icon: 'icon',
+            ),
+          ];
+
+          await database.gameDao.addGamesAsList(games: games);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final gamesJson = decoded['games'] as List<dynamic>;
+
+          expect(gamesJson.length, 3);
+          expect(
+            gamesJson.map((g) => g['color']),
+            containsAll(['red', 'blue', 'green']),
+          );
+        });
+
+        testWidgets('All rulesets are handled correctly', (tester) async {
+          final games = [
+            Game(
+              name: 'Highest Score Game',
+              ruleset: Ruleset.highestScore,
+              color: GameColor.blue,
+              icon: 'icon',
+            ),
+            Game(
+              name: 'Lowest Score Game',
+              ruleset: Ruleset.lowestScore,
+              color: GameColor.blue,
+              icon: 'icon',
+            ),
+            Game(
+              name: 'Single Winner',
+              ruleset: Ruleset.singleWinner,
+              color: GameColor.blue,
+              icon: 'icon',
+            ),
+          ];
+
+          await database.gameDao.addGamesAsList(games: games);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final gamesJson = decoded['games'] as List<dynamic>;
+
+          expect(gamesJson.length, 3);
+          expect(
+            gamesJson.map((g) => g['ruleset']),
+            containsAll(['highestScore', 'lowestScore', 'singleWinner']),
+          );
+        });
+      });
+    });
+
+    group('Parse Methods', () {
+      test('parsePlayersFromJson()', () {
+        final jsonMap = {
+          'players': [
+            {
+              'id': testPlayer1.id,
+              'name': testPlayer1.name,
+              'description': testPlayer1.description,
+              'createdAt': testPlayer1.createdAt.toIso8601String(),
+            },
+            {
+              'id': testPlayer2.id,
+              'name': testPlayer2.name,
+              'description': testPlayer2.description,
+              'createdAt': testPlayer2.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final players = DataTransferService.parsePlayersFromJson(jsonMap);
+
+        expect(players.length, 2);
+        expect(players[0].id, testPlayer1.id);
+        expect(players[0].name, testPlayer1.name);
+        expect(players[1].id, testPlayer2.id);
+        expect(players[1].name, testPlayer2.name);
+      });
+
+      test('parsePlayersFromJson() empty list', () {
+        final jsonMap = {'players': []};
+        final players = DataTransferService.parsePlayersFromJson(jsonMap);
+        expect(players, isEmpty);
+      });
+
+      test('parsePlayersFromJson() missing key', () {
+        final jsonMap = <String, dynamic>{};
+        final players = DataTransferService.parsePlayersFromJson(jsonMap);
+        expect(players, isEmpty);
+      });
+
+      test('parseGamesFromJson()', () {
+        final jsonMap = {
+          'games': [
+            {
+              'id': testGame.id,
+              'name': testGame.name,
+              'ruleset': testGame.ruleset.name,
+              'description': testGame.description,
+              'color': testGame.color.name,
+              'icon': testGame.icon,
+              'createdAt': testGame.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final games = DataTransferService.parseGamesFromJson(jsonMap);
+
+        expect(games.length, 1);
+        expect(games[0].id, testGame.id);
+        expect(games[0].name, testGame.name);
+        expect(games[0].ruleset, testGame.ruleset);
+      });
+
+      test('parseGamesFromJson() empty list', () {
+        final jsonMap = {'games': []};
+        final games = DataTransferService.parseGamesFromJson(jsonMap);
+        expect(games, isEmpty);
+      });
+
+      test('parseGamesFromJson() missing key', () {
+        final jsonMap = <String, dynamic>{};
+        final games = DataTransferService.parseGamesFromJson(jsonMap);
+        expect(games, isEmpty);
+      });
+
+      test('parseGroupsFromJson()', () {
+        final playerById = {
+          testPlayer1.id: testPlayer1,
+          testPlayer2.id: testPlayer2,
+        };
+
+        final jsonMap = {
+          'groups': [
+            {
+              'id': testGroup.id,
+              'name': testGroup.name,
+              'description': testGroup.description,
+              'memberIds': [testPlayer1.id, testPlayer2.id],
+              'createdAt': testGroup.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final groups = DataTransferService.parseGroupsFromJson(
+          jsonMap,
+          playerById,
+        );
+
+        expect(groups.length, 1);
+        expect(groups[0].id, testGroup.id);
+        expect(groups[0].name, testGroup.name);
+        expect(groups[0].members.length, 2);
+        expect(groups[0].members[0].id, testPlayer1.id);
+        expect(groups[0].members[1].id, testPlayer2.id);
+      });
+
+      test('parseGroupsFromJson() empty list', () {
+        final jsonMap = {'groups': []};
+        final groups = DataTransferService.parseGroupsFromJson(jsonMap, {});
+        expect(groups, isEmpty);
+      });
+
+      test('parseGroupsFromJson() missing key', () {
+        final jsonMap = <String, dynamic>{};
+        final groups = DataTransferService.parseGroupsFromJson(jsonMap, {});
+        expect(groups, isEmpty);
+      });
+
+      test('parseGroupsFromJson() ignores invalid player ids', () {
+        final playerById = {testPlayer1.id: testPlayer1};
+
+        final jsonMap = {
+          'groups': [
+            {
+              'id': testGroup.id,
+              'name': testGroup.name,
+              'description': testGroup.description,
+              'memberIds': [testPlayer1.id, 'invalid-id'],
+              'createdAt': testGroup.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final groups = DataTransferService.parseGroupsFromJson(
+          jsonMap,
+          playerById,
+        );
+
+        expect(groups.length, 1);
+        expect(groups[0].members.length, 1);
+        expect(groups[0].members[0].id, testPlayer1.id);
+      });
+
+      test('parseTeamsFromJson()', () {
+        final playerById = {testPlayer1.id: testPlayer1};
+
+        final jsonMap = {
+          'teams': [
+            {
+              'id': testTeam.id,
+              'name': testTeam.name,
+              'memberIds': [testPlayer1.id],
+              'createdAt': testTeam.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final teams = DataTransferService.parseTeamsFromJson(
+          jsonMap,
+          playerById,
+        );
+
+        expect(teams.length, 1);
+        expect(teams[0].id, testTeam.id);
+        expect(teams[0].name, testTeam.name);
+        expect(teams[0].members.length, 1);
+        expect(teams[0].members[0].id, testPlayer1.id);
+      });
+
+      test('parseTeamsFromJson() empty list', () {
+        final jsonMap = {'teams': []};
+        final teams = DataTransferService.parseTeamsFromJson(jsonMap, {});
+        expect(teams, isEmpty);
+      });
+
+      test('parseTeamsFromJson() missing key', () {
+        final jsonMap = <String, dynamic>{};
+        final teams = DataTransferService.parseTeamsFromJson(jsonMap, {});
+        expect(teams, isEmpty);
+      });
+
+      test('parseMatchesFromJson()', () {
+        final playerById = {
+          testPlayer1.id: testPlayer1,
+          testPlayer2.id: testPlayer2,
+        };
+        final gameById = {testGame.id: testGame};
+        final groupById = {testGroup.id: testGroup};
+
+        final jsonMap = {
+          'matches': [
+            {
+              'id': testMatch.id,
+              'name': testMatch.name,
+              'gameId': testGame.id,
+              'groupId': testGroup.id,
+              'playerIds': [testPlayer1.id, testPlayer2.id],
+              'notes': testMatch.notes,
+              'createdAt': testMatch.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final matches = DataTransferService.parseMatchesFromJson(
+          jsonMap,
+          gameById,
+          groupById,
+          playerById,
+        );
+
+        expect(matches.length, 1);
+        expect(matches[0].id, testMatch.id);
+        expect(matches[0].name, testMatch.name);
+        expect(matches[0].game.id, testGame.id);
+        expect(matches[0].group?.id, testGroup.id);
+        expect(matches[0].players.length, 2);
+      });
+
+      test('parseMatchesFromJson() empty list', () {
+        final jsonMap = {'teams': []};
+        final matches = DataTransferService.parseMatchesFromJson(
+          jsonMap,
+          {},
+          {},
+          {},
+        );
+        expect(matches, isEmpty);
+      });
+
+      test('parseMatchesFromJson() missing key', () {
+        final jsonMap = <String, dynamic>{};
+        final matches = DataTransferService.parseMatchesFromJson(
+          jsonMap,
+          {},
+          {},
+          {},
+        );
+        expect(matches, isEmpty);
+      });
+
+      test('parseMatchesFromJson() creates unknown game for missing game', () {
+        final playerById = {testPlayer1.id: testPlayer1};
+        final gameById = <String, Game>{};
+        final groupById = <String, Group>{};
+
+        final jsonMap = {
+          'matches': [
+            {
+              'id': testMatch.id,
+              'name': testMatch.name,
+              'gameId': 'non-existent-game-id',
+              'playerIds': [testPlayer1.id],
+              'notes': '',
+              'createdAt': testMatch.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final matches = DataTransferService.parseMatchesFromJson(
+          jsonMap,
+          gameById,
+          groupById,
+          playerById,
+        );
+
+        expect(matches.length, 1);
+        expect(matches[0].game.name, 'Unknown');
+        expect(matches[0].game.ruleset, Ruleset.singleWinner);
+      });
+
+      test('parseMatchesFromJson() handles null group', () {
+        final playerById = {testPlayer1.id: testPlayer1};
+        final gameById = {testGame.id: testGame};
+        final groupById = <String, Group>{};
+
+        final jsonMap = {
+          'matches': [
+            {
+              'id': testMatch.id,
+              'name': testMatch.name,
+              'gameId': testGame.id,
+              'groupId': null,
+              'playerIds': [testPlayer1.id],
+              'notes': '',
+              'createdAt': testMatch.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final matches = DataTransferService.parseMatchesFromJson(
+          jsonMap,
+          gameById,
+          groupById,
+          playerById,
+        );
+
+        expect(matches.length, 1);
+        expect(matches[0].group, isNull);
+      });
+
+      test('parseMatchesFromJson() handles endedAt', () {
+        final playerById = {testPlayer1.id: testPlayer1};
+        final gameById = {testGame.id: testGame};
+        final groupById = <String, Group>{};
+        final endedDate = DateTime(2025, 12, 1, 10, 0, 0);
+
+        final jsonMap = {
+          'matches': [
+            {
+              'id': testMatch.id,
+              'name': testMatch.name,
+              'gameId': testGame.id,
+              'playerIds': [testPlayer1.id],
+              'notes': '',
+              'createdAt': testMatch.createdAt.toIso8601String(),
+              'endedAt': endedDate.toIso8601String(),
+            },
+          ],
+        };
+
+        final matches = DataTransferService.parseMatchesFromJson(
+          jsonMap,
+          gameById,
+          groupById,
+          playerById,
+        );
+
+        expect(matches.length, 1);
+        expect(matches[0].endedAt, endedDate);
+      });
+    });
+
+    test('validateJsonSchema()', () async {
+      final validJson = json.encode({
+        'players': [
+          {
+            'id': testPlayer1.id,
+            'name': testPlayer1.name,
+            'description': testPlayer1.description,
+            'createdAt': testPlayer1.createdAt.toIso8601String(),
+          },
+        ],
+        'games': [
+          {
+            'id': testGame.id,
+            'name': testGame.name,
+            'ruleset': testGame.ruleset.name,
+            'description': testGame.description,
+            'color': testGame.color.name,
+            'icon': testGame.icon,
+            'createdAt': testGame.createdAt.toIso8601String(),
+          },
+        ],
+        'groups': [
+          {
+            'id': testGroup.id,
+            'name': testGroup.name,
+            'description': testGroup.description,
+            'memberIds': [testPlayer1.id, testPlayer2.id],
+            'createdAt': testGroup.createdAt.toIso8601String(),
+          },
+        ],
+        'teams': [
+          {
+            'id': testTeam.id,
+            'name': testTeam.name,
+            'memberIds': [testPlayer1.id, testPlayer2.id],
+            'createdAt': testTeam.createdAt.toIso8601String(),
+          },
+        ],
+        'matches': [
+          {
+            'id': testMatch.id,
+            'name': testMatch.name,
+            'gameId': testGame.id,
+            'groupId': testGroup.id,
+            'playerIds': [testPlayer1.id, testPlayer2.id],
+            'notes': testMatch.notes,
+            'scores': {
+              testPlayer1.id: [
+                {'roundNumber': 1, 'score': 10, 'change': 10},
+                {'roundNumber': 2, 'score': 20, 'change': 10},
+              ],
+              testPlayer2.id: [
+                {'roundNumber': 1, 'score': 15, 'change': 15},
+                {'roundNumber': 2, 'score': 25, 'change': 10},
+              ],
+            },
+            'createdAt': testMatch.createdAt.toIso8601String(),
+            'endedAt': null,
+          },
+        ],
+      });
+
+      final isValid = await DataTransferService.validateJsonSchema(validJson);
+      expect(isValid, true);
+    });
+  });
+}