//
//  DataAccessSyncTests.swift
//  PadelClubDataTests
//
//  Created by Laurent Morvillier on 02/05/2025.
//

import Testing
@testable import PadelClubData
@testable import LeStorage

struct SyncDataAccessTests {
    
    let username1: String = "UserDataTests"
    let password1: String = "MyPass1234--"
    
    let username2: String = "seconduser"
    let password2: String = "MyPass1234--"
    
    var storeCenterA: StoreCenter
    var storeCenterB: StoreCenter
    
    init() async throws {
        
        let conf = Config.server

        let dir = "storage"
        let dirA = "storageA"
        let dirB = "storageB"
        
        FileManager.default.deleteDirectoryInDocuments(directoryName: dir)
        FileManager.default.deleteDirectoryInDocuments(directoryName: dirA)
        FileManager.default.deleteDirectoryInDocuments(directoryName: dirB)
        
        self.storeCenterA = StoreCenter(directoryName: dirA)
        self.storeCenterB = StoreCenter(directoryName: dirB)

        // StoreCenter.main
        StoreCenter.main.configureURLs(secureScheme: conf.secure, domain: conf.domain, webSockets: false, useSynchronization: true)
        StoreCenter.main.tokenKeychain = MockKeychainStore(fileName: "\(dir)/token.json")
        StoreCenter.main.deviceKeychain = MockKeychainStore(fileName: "\(dir)/device.json")
        try StoreCenter.main.deviceKeychain.add(value: UUID().uuidString)
        StoreCenter.main.classProject = "PadelClubData"
        
        let token = try? StoreCenter.main.rawTokenShouldNotBeUsed()
        if token == nil {
            try await self.login(storeCenter: StoreCenter.main, username: self.username1, password: self.password1)
        }

        // StoreCenter A
        self.storeCenterA.configureURLs(secureScheme: conf.secure, domain: conf.domain, webSockets: false, useSynchronization: true)
        self.storeCenterA.tokenKeychain = MockKeychainStore(fileName: "\(dirA)/token.json")
        self.storeCenterA.deviceKeychain = MockKeychainStore(fileName: "\(dirA)/device.json")
        try self.storeCenterA.deviceKeychain.add(value: UUID().uuidString)
        self.storeCenterA.classProject = "PadelClubData"
        
        let tokenA = try? self.storeCenterA.rawTokenShouldNotBeUsed()
        if tokenA == nil {
            try await self.login(storeCenter: self.storeCenterA, username: self.username1, password: self.password1)
        }
        
        // StoreCenter B
        self.storeCenterB.configureURLs(secureScheme: conf.secure, domain: conf.domain, webSockets: false, useSynchronization: true)
        self.storeCenterB.tokenKeychain = MockKeychainStore(fileName: "\(dirB)/token.json")
        self.storeCenterB.deviceKeychain = MockKeychainStore(fileName: "\(dirB)/device.json")
        try self.storeCenterB.deviceKeychain.add(value: UUID().uuidString)
        
        self.storeCenterB.classProject = "PadelClubData"
        
        let tokenB = try? self.storeCenterB.rawTokenShouldNotBeUsed()
        if tokenB == nil {
            try await self.login(storeCenter: self.storeCenterB, username: self.username2, password: self.password2)
        }
        
    }
    
    mutating func login(storeCenter: StoreCenter, username: String, password: String) async throws {
        let _: CustomUser = try await storeCenter.service().login(username: username, password: password)
    }
    
    @Test func testSetup() async throws {
        #expect(self.storeCenterA.isAuthenticated)
        #expect(self.storeCenterB.isAuthenticated)
        
        guard let userId1 = self.storeCenterA.userId else {
            throw TestError.notAuthenticated
        }
        guard let userId2 = self.storeCenterB.userId else {
            throw TestError.notAuthenticated
        }
        #expect(userId1 != userId2)
    }
    
    /// In this test, the first user:
    /// - creates an event and a tournament
    /// - shares the tournament with a second user
    /// - remove the sharing with the second user
    /// We test that the data is properly received and removed upon the sharing actions
    @Test func testTournamentSharing() async throws {

        guard let userId1 = self.storeCenterA.userId else {
            throw TestError.notAuthenticated
        }
        guard let userId2 = self.storeCenterB.userId else {
            throw TestError.notAuthenticated
        }

        // Setup
        let eventColA: SyncedCollection<Event> = await self.storeCenterA.mainStore.asyncLoadingSynchronizedCollection()
        let tournamentColA: SyncedCollection<Tournament> = await self.storeCenterA.mainStore.asyncLoadingSynchronizedCollection()
        let eventColB: SyncedCollection<Event> = await self.storeCenterB.mainStore.asyncLoadingSynchronizedCollection()
        let tournamentColB: SyncedCollection<Tournament> = await self.storeCenterB.mainStore.asyncLoadingSynchronizedCollection()
        
        var dataAccesses: [DataAccess] = try await self.storeCenterA.service().get()
        if let dataAccessCollection = self.storeCenterA.dataAccessCollection {
            try await dataAccessCollection.deleteAsync(contentOfs: dataAccesses)
        } else {
            Issue.record("dataAccessCollection should not be nil")
        }
        
        try await eventColA.deleteAsync(contentOfs: Array(eventColA))
        try await tournamentColA.deleteAsync(contentOfs: Array(tournamentColA))
        
        let _ = try await self.storeCenterB.testSynchronizeOnceAsync()
        
        #expect(eventColB.count == 0)
        #expect(tournamentColB.count == 0)
        
        // Create
        let eventA = Event(creator: userId1)
        try await eventColA.addOrUpdateAsync(instance: eventA)
        let tournamentA = Tournament(event: eventA.id, name: "P100")
        try await tournamentColA.addOrUpdateAsync(instance: tournamentA)
        
        // Share with user2
        try await self.storeCenterA.setAuthorizedUsersAsync(for: tournamentA, users: [userId2])
        
        var dataB = try await self.storeCenterB.testSynchronizeOnceAsync()
        var syncDataB = try SyncData(data: dataB, storeCenter: self.storeCenterB)
        #expect(syncDataB.shared.count == 1) // the tournament
        #expect(syncDataB.grants.count == 1) // the granted event

        #expect(eventColB.count == 1)
        #expect(eventColB.first?.sharing == .granted)
        #expect(tournamentColB.count == 1)
        #expect(tournamentColB.first?.sharing == .shared)
        
        // Remove sharing from user2
        try await self.storeCenterA.setAuthorizedUsersAsync(for: tournamentA, users: [])
        
        dataB = try await self.storeCenterB.testSynchronizeOnceAsync()
        syncDataB = try SyncData(data: dataB, storeCenter: self.storeCenterB)
        #expect(syncDataB.revocations.count == 1)
        #expect(syncDataB.revocationParents.count == 1)
        
        #expect(eventColB.count == 0)
        #expect(tournamentColB.count == 0)
        
        dataAccesses = try await self.storeCenterA.service().get()
        #expect(dataAccesses.count == 0)
    }
    
    /// In this test, the first user:
    /// - creates a club and 2 events in that club
    /// - shares both events with a second user
    /// - removes the sharing of 1 event
    /// Here we want to test that the Club instance remains even if one event is removed from the second user
    @Test func testSharedRelationship() async throws {

        guard let userId1 = self.storeCenterA.userId else {
            throw TestError.notAuthenticated
        }
        guard let userId2 = self.storeCenterB.userId else {
            throw TestError.notAuthenticated
        }

        // Setup
        let eventColA: SyncedCollection<Event> = await self.storeCenterA.mainStore.asyncLoadingSynchronizedCollection()
        let clubColA: SyncedCollection<Club> = await self.storeCenterA.mainStore.asyncLoadingSynchronizedCollection()
        let eventColB: SyncedCollection<Event> = await self.storeCenterB.mainStore.asyncLoadingSynchronizedCollection()
        let clubColB: SyncedCollection<Club> = await self.storeCenterB.mainStore.asyncLoadingSynchronizedCollection()
        
        if let dataAccessCollection = self.storeCenterA.dataAccessCollection {
            try await dataAccessCollection.deleteAsync(contentOfs: Array(dataAccessCollection))
        }
        
        try await eventColA.deleteAsync(contentOfs: Array(eventColA))
        try await clubColA.deleteAsync(contentOfs: Array(clubColA))
        
        let _ = try await self.storeCenterB.testSynchronizeOnceAsync()
        
        #expect(eventColB.count == 0)
        #expect(clubColB.count == 0)
        
        // Create
        let clubA = Club(creator: userId1, name: "Club A", acronym: "CA")
        try await clubColA.addOrUpdateAsync(instance: clubA)
        
        let event1A = Event(creator: userId1, club: clubA.id, name: "event 1")
        let event2A = Event(creator: userId1, club: clubA.id, name: "event 2")
        try await eventColA.addOrUpdateAsync(contentOfs: [event1A, event2A])
        
        // Share with user2
        try await self.storeCenterA.setAuthorizedUsersAsync(for: event1A, users: [userId2])
        try await self.storeCenterA.setAuthorizedUsersAsync(for: event2A, users: [userId2])

        var dataB = try await self.storeCenterB.testSynchronizeOnceAsync()
        var syncDataB = try SyncData(data: dataB, storeCenter: self.storeCenterB)
        
        #expect(syncDataB.shared.count == 1)
        #expect(syncDataB.grants.count == 1)
        
        let clubGrants = syncDataB.grants.first { $0.type == Club.self }
        let eventGrants = syncDataB.shared.first { $0.type == Event.self }
        #expect(clubGrants?.items.count == 1)
        #expect(eventGrants?.items.count == 2)
        
        #expect(eventColB.count == 2)
        #expect(clubColB.count == 1)
        
        // Remove sharing from user2
        try await self.storeCenterA.setAuthorizedUsersAsync(for: event1A, users: [])
        
        dataB = try await self.storeCenterB.testSynchronizeOnceAsync()
        syncDataB = try SyncData(data: dataB, storeCenter: self.storeCenterB)
        #expect(syncDataB.revocations.count == 1)
        #expect(syncDataB.revocationParents.count == 1)
        
        #expect(eventColB.count == 1)
        #expect(clubColB.count == 1) // club remains because used in event2A
    }
    
    /// In this test, the first user:
    /// - creates one event and 2 clubs
    /// - shares the event with a second user
    /// - changes the club on the event
    /// Here we want to test that the first Club is removed and the second one is received
    @Test func testRelationshipChange() async throws {

        guard let userId1 = self.storeCenterA.userId else {
            throw TestError.notAuthenticated
        }
        guard let userId2 = self.storeCenterB.userId else {
            throw TestError.notAuthenticated
        }

        // Setup
        let eventColA: SyncedCollection<Event> = await self.storeCenterA.mainStore.asyncLoadingSynchronizedCollection()
        let clubColA: SyncedCollection<Club> = await self.storeCenterA.mainStore.asyncLoadingSynchronizedCollection()
        let eventColB: SyncedCollection<Event> = await self.storeCenterB.mainStore.asyncLoadingSynchronizedCollection()
        let clubColB: SyncedCollection<Club> = await self.storeCenterB.mainStore.asyncLoadingSynchronizedCollection()
        
        if let dataAccessCollection = self.storeCenterA.dataAccessCollection {
            try await dataAccessCollection.deleteAsync(contentOfs: Array(dataAccessCollection))
        }
        
        try await eventColA.deleteAsync(contentOfs: Array(eventColA))
        try await clubColA.deleteAsync(contentOfs: Array(clubColA))
        
        let _ = try await self.storeCenterB.testSynchronizeOnceAsync()
        
        #expect(eventColB.count == 0)
        #expect(clubColB.count == 0)
        
        // Create
        let club1A = Club(creator: userId1, name: "Club 1", acronym: "C1")
        try await clubColA.addOrUpdateAsync(instance: club1A)
        let club2A = Club(creator: userId1, name: "Club 2", acronym: "C2")
        try await clubColA.addOrUpdateAsync(instance: club2A)
        
        let eventA = Event(creator: userId1, club: club1A.id, name: "event 1")
        try await eventColA.addOrUpdateAsync(instance: eventA)
        
        // Share with user2
        try await self.storeCenterA.setAuthorizedUsersAsync(for: eventA, users: [userId2])
        let _ = try await self.storeCenterB.testSynchronizeOnceAsync()
        #expect(eventColB.count == 1)
        #expect(clubColB.count == 1)
        
        // Change the club
        eventA.club = club2A.id
        try await eventColA.addOrUpdateAsync(instance: eventA)
        
        let dataB = try await self.storeCenterB.testSynchronizeOnceAsync()
        
        let syncDataB = try SyncData(data: dataB, storeCenter: self.storeCenterB)

        #expect(syncDataB.updates.count == 1) // event update
        #expect(syncDataB.sharedRelationshipSets.count == 1)
        #expect(syncDataB.sharedRelationshipRemovals.count == 1)
        
        print("club1A = \(club1A.id)")
        #expect(eventColB.first?.club == club2A.id)
    }
    
    /// In this test, the first user:
    /// - creates one event
    /// - shares the event with a second user
    /// The second user:
    /// - changes the club
    /// Here we want to test that the first Club is removed and the second one is received
    @Test func testRelationshipChangesByAgent() async throws {

        guard let userId1 = self.storeCenterA.userId else {
            throw TestError.notAuthenticated
        }
        guard let userId2 = self.storeCenterB.userId else {
            throw TestError.notAuthenticated
        }

        // Setup
        let eventColA: SyncedCollection<Event> = await self.storeCenterA.mainStore.asyncLoadingSynchronizedCollection()
        let clubColA: SyncedCollection<Club> = await self.storeCenterA.mainStore.asyncLoadingSynchronizedCollection()
        let courtsColA: SyncedCollection<Court> = await self.storeCenterA.mainStore.asyncLoadingSynchronizedCollection()
        let eventColB: SyncedCollection<Event> = await self.storeCenterB.mainStore.asyncLoadingSynchronizedCollection()
        let clubColB: SyncedCollection<Club> = await self.storeCenterB.mainStore.asyncLoadingSynchronizedCollection()
        let courtsColB: SyncedCollection<Court> = await self.storeCenterB.mainStore.asyncLoadingSynchronizedCollection()

        if let dataAccessCollection = self.storeCenterA.dataAccessCollection {
            try await dataAccessCollection.deleteAsync(contentOfs: Array(dataAccessCollection))
        }
        
        try await eventColA.deleteAsync(contentOfs: Array(eventColA))
        try await clubColA.deleteAsync(contentOfs: Array(clubColA))
        
        let _ = try await self.storeCenterB.testSynchronizeOnceAsync()
        
        #expect(eventColB.count == 0)
        #expect(clubColB.count == 0)
        
        // Create
        let clubA = Club(creator: userId1, name: "Club 1", acronym: "C1")
        try await clubColA.addOrUpdateAsync(instance: clubA)
        
        let eventA = Event(creator: userId1, club: clubA.id, name: "event 1")
        try await eventColA.addOrUpdateAsync(instance: eventA)
        
        let court1A = Court(index: 0, club: clubA.id)
        let court2A = Court(index: 1, club: clubA.id)
        try await courtsColA.addOrUpdateAsync(contentOfs: [court1A, court2A])
        
        // Share with user2
        try await self.storeCenterA.setAuthorizedUsersAsync(for: eventA, users: [userId2])
        let _ = try await self.storeCenterB.testSynchronizeOnceAsync()
        
        guard let eventB = eventColB.first else {
            throw TestError.missingEvent
        }
        #expect(eventA.id == eventB.id)
        #expect(clubColB.count == 1)

        // Second user changes the club
        let club2B = Club(creator: userId2, name: "Club 2", acronym: "C2")
        try await clubColB.addOrUpdateAsync(instance: club2B)
        eventB.club = club2B.id
        try await eventColB.addOrUpdateAsync(instance: eventB)

        let _ = try await self.storeCenterA.testSynchronizeOnceAsync()
        
        #expect(eventA.club == club2B.id)
        #expect(clubColB.count == 1)
        #expect(courtsColB.count == 0)

    }
    
    @Test func testBuildEverything() async throws {
        
        guard let _ = StoreCenter.main.userId else {
            throw TestError.notAuthenticated
        }
        guard let userId2 = self.storeCenterB.userId else {
            throw TestError.notAuthenticated
        }
        
        // Cleanup

        let tournamentColA: SyncedCollection<Tournament> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
        let tournamentColB: SyncedCollection<Tournament> = await self.storeCenterB.mainStore.asyncLoadingSynchronizedCollection()

        let tournamentsToDelete: [Tournament] = try await StoreCenter.main.service().get()
        try await tournamentColA.deleteAsync(contentOfs: tournamentsToDelete)
        
        // Setup tournament + build everything
        let tournament = Tournament()

        try await tournamentColA.addOrUpdateAsync(instance: tournament)
        try await tournament.deleteAndBuildEverythingAsync()
        let tourStoreA = try StoreCenter.main.store(identifier: tournament.id)
        
        let gsColA: SyncedCollection<GroupStage> = try tourStoreA.syncedCollection()
        let roundColA: SyncedCollection<Round> = try tourStoreA.syncedCollection()
        let matchesColA: SyncedCollection<Match> = try tourStoreA.syncedCollection()
        #expect(gsColA.count == 4)
        #expect(roundColA.count == 15)
        #expect(matchesColA.count == 56)
        
        // todo add sharing
        try await StoreCenter.main.setAuthorizedUsersAsync(for: tournament, users: [userId2])
        
        // Sync with 2nd store
        try await self.storeCenterB.testSynchronizeOnceAsync()
        #expect(tournamentColB.count == 1)
        
        let tourStoreB = try self.storeCenterB.store(identifier: tournament.id)

        let gsColB: SyncedCollection<GroupStage> = try tourStoreB.syncedCollection()
        let roundColB: SyncedCollection<Round> = try tourStoreB.syncedCollection()
        let matchesColB: SyncedCollection<Match> = try tourStoreB.syncedCollection()
        #expect(gsColB.count == 4)
        #expect(roundColB.count == 15)
        #expect(matchesColB.count == 56)

        // change setup + build everything
        tournament.groupStageCount = 2
        tournament.teamCount = 20
        try await tournamentColA.addOrUpdateAsync(instance: tournament)
        try await tournament.deleteAndBuildEverythingAsync()

        #expect(gsColA.count == 2)
        #expect(roundColA.count == 15)
        #expect(matchesColA.count == 44)

        // Sync with 2nd store
        let data = try await self.storeCenterB.testSynchronizeOnceAsync()
        let _ = try SyncData(data: data, storeCenter: self.storeCenterB)
        
        #expect(gsColB.count == 2)
        #expect(roundColB.count == 15)
        #expect(matchesColB.count == 44)

    }

    // needs to run on a postgreSQL, otherwise fails because of sqlite database locks
    @Test func testDataAccessForChildren() async throws {
        
        guard let userId2 = self.storeCenterB.userId else {
            throw TestError.notAuthenticated
        }
        // Setup tournament
        let tournamentColA: SyncedCollection<Tournament> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
        let tournamentColB: SyncedCollection<Tournament> = await self.storeCenterB.mainStore.asyncLoadingSynchronizedCollection()

        let tournament = Tournament(name: "test_data_access_children")
        try await tournamentColA.addOrUpdateAsync(instance: tournament)

        let tourStoreA = try StoreCenter.main.store(identifier: tournament.id)
        let teamRegColA: SyncedCollection<TeamRegistration> = await tourStoreA.asyncLoadingSynchronizedCollection()
        let playerRegColA: SyncedCollection<PlayerRegistration> = await tourStoreA.asyncLoadingSynchronizedCollection()

        // cleanup sync residues
        let _ = try await self.storeCenterB.testSynchronizeOnceAsync()
        
        try await StoreCenter.main.setAuthorizedUsersAsync(for: tournament, users: [userId2])
        
        var teamRegistrations: [TeamRegistration] = []
        var playerRegistrations: [PlayerRegistration] = []
        
        let count = 5
        for i in (0..<count) {
            let tr = TeamRegistration(tournament: tournament.id, name: "Team \(i)")
            let pr1 = PlayerRegistration(teamRegistration: tr.id, firstName: "f1\(i)", lastName: "l1\(i)")
            let pr2 = PlayerRegistration(teamRegistration: tr.id, firstName: "f2\(i)", lastName: "l2\(i)")
            teamRegistrations.append(tr)
            playerRegistrations.append(contentsOf: [pr1, pr2])
        }
        
        try await teamRegColA.addOrUpdateAsync(contentOfs: teamRegistrations)
        try await playerRegColA.addOrUpdateAsync(contentOfs: playerRegistrations)

        let _ = try await self.storeCenterB.testSynchronizeOnceAsync()

        let tourStoreB = try self.storeCenterB.store(identifier: tournament.id)
        let teamRegColB: SyncedCollection<TeamRegistration> = await tourStoreB.asyncLoadingSynchronizedCollection()
        let playerRegColB: SyncedCollection<PlayerRegistration> = await tourStoreB.asyncLoadingSynchronizedCollection()

        #expect(tournamentColB.count == 1)
        #expect(teamRegColB.count == count)
        #expect(playerRegColB.count == count * 2)

        for team in teamRegistrations {
            try await teamRegColA.deleteAsync(instance: team)
        }
        
        try await Task.sleep(for: .milliseconds(100)) // without this, it looks like the sync date is smaller than the ModelLogs, so we don't get them all
        
        let data = try await self.storeCenterB.testSynchronizeOnceAsync()
        let syncData = try SyncData(data: data, storeCenter: self.storeCenterB)

        #expect(syncData.deletions.count == 2)
        
        let teamRegDeletions = syncData.deletions.first(where: { $0.type == TeamRegistration.self })
        #expect(teamRegDeletions?.items.count == 5)
        let playerRegDeletions = syncData.deletions.first(where: { $0.type == PlayerRegistration.self })
        #expect(playerRegDeletions?.items.count == 10)
        
        #expect(teamRegColB.count == 0)
        #expect(playerRegColB.count == 0)
        
    }
    
}


extension Tournament {
    
    @MainActor
    public func deleteAndBuildEverythingAsync(preset: PadelTournamentStructurePreset = .manual) async throws {
        resetBracketPosition()
        try await deleteStructureAsync()
        try await deleteGroupStagesAsync()

        switch preset {
        case .doubleGroupStage:
            try await buildGroupStagesAsync()
            try await addNewGroupStageStepAsync()
            qualifiedPerGroupStage = 0
            groupStageAdditionalQualified = 0
        default:
            try await buildGroupStagesAsync()
            try await buildBracketAsync()
        }
    }
    
    public func addNewGroupStageStepAsync() async throws {
        let lastStep = lastStep() + 1
        for i in 0..<teamsPerGroupStage {
            let gs = GroupStage(tournament: id, index: i, size: groupStageCount, step: lastStep)
            try await self.tournamentStore?.groupStages.addOrUpdateAsync(instance: gs)
        }

        groupStages(atStep: 1).forEach { $0.buildMatches() }
    }

    public func deleteStructureAsync() async throws {
        try await self.tournamentStore?.rounds.deleteAsync(contentOfs: rounds())
    }

    public func deleteGroupStagesAsync() async throws {
        try await self.tournamentStore?.groupStages.deleteAsync(contentOfs: allGroupStages())
    }
    
    func buildGroupStagesAsync() async throws {
        guard groupStages().isEmpty, let _ = self.tournamentStore else {
            return
        }

        var _groupStages = [GroupStage]()
        for index in 0..<groupStageCount {
            let groupStage = GroupStage(tournament: id, index: index, size: teamsPerGroupStage, format: groupStageFormat)
            _groupStages.append(groupStage)
        }

        try await self.tournamentStore?.groupStages.addOrUpdateAsync(contentOfs: _groupStages)
        try await refreshGroupStagesAsync()
    }
    
    public func refreshGroupStagesAsync(keepExistingMatches: Bool = false) async throws {
        unsortedTeams().forEach { team in
            team.groupStage = nil
            team.groupStagePosition = nil
        }

        if groupStageCount > 0 {
            switch groupStageOrderingMode {
            case .random:
                try await setGroupStageAsync(randomize: true, keepExistingMatches: keepExistingMatches)
            case .snake:
                try await setGroupStageAsync(randomize: false, keepExistingMatches: keepExistingMatches)
            case .swiss:
                try await setGroupStageAsync(randomize: true, keepExistingMatches: keepExistingMatches)
            }
        }
    }

    public func setGroupStageAsync(randomize: Bool, keepExistingMatches: Bool = false) async throws {
        let groupStages = groupStages()
        let numberOfBracketsAsInt = groupStages.count
//        let teamsPerBracket = teamsPerBracket
        if groupStageCount != numberOfBracketsAsInt {
            try await deleteGroupStagesAsync()
            try await buildGroupStagesAsync()
        } else {
//            setGroupStageTeams(randomize: randomize)
            for groupStage in groupStages {
                try await groupStage.buildMatchesAsync(keepExistingMatches: keepExistingMatches)
            }
        }
    }
    
    public func buildBracketAsync(minimalBracketTeamCount: Int? = nil) async throws {
        guard rounds().isEmpty else { return }
        let roundCount = RoundRule.numberOfRounds(forTeams: minimalBracketTeamCount ?? bracketTeamCount())
        let matchCount = RoundRule.numberOfMatches(forTeams: minimalBracketTeamCount ?? bracketTeamCount())

        let rounds = (0..<roundCount).map { //index 0 is the final
            return Round(tournament: id, index: $0, matchFormat: matchFormat, loserBracketMode: loserBracketMode)
        }

        if rounds.isEmpty {
            return
        }

        try await self.tournamentStore?.rounds.addOrUpdateAsync(contentOfs: rounds)

        let matches = (0..<matchCount).map { //0 is final match
            let roundIndex = RoundRule.roundIndex(fromMatchIndex: $0)
            let round = rounds[roundIndex]
            return Match(round: round.id, index: $0, format: round.matchFormat, name: Match.setServerTitle(upperRound: round, matchIndex: RoundRule.matchIndexWithinRound(fromMatchIndex: $0)))
        }

        try await self.tournamentStore?.matches.addOrUpdateAsync(contentOfs: matches)

        for round in rounds {
            try await round.buildLoserBracketAsync()
        }
    }

}

extension GroupStage {
    public func buildMatchesAsync(keepExistingMatches: Bool = false) async throws {
        var teamScores = [TeamScore]()
        var matches = [Match]()
        clearScoreCache()
        
        if keepExistingMatches == false {
            _removeMatches()
            
            for i in 0..<_numberOfMatchesToBuild() {
                let newMatch = self.createMatch(index: i)
    //            let newMatch = Match(groupStage: self.id, index: i, matchFormat: self.matchFormat, name: localizedMatchUpLabel(for: i))
                teamScores.append(contentsOf: newMatch.createTeamScores())
                matches.append(newMatch)
            }
        } else {
            for match in self.matches() {
                match.resetTeamScores(outsideOf: [])
                teamScores.append(contentsOf: match.createTeamScores())
            }
        }
        
        try await self.tournamentStore?.matches.addOrUpdateAsync(contentOfs: matches)
        try await self.tournamentStore?.teamScores.addOrUpdateAsync(contentOfs: teamScores)
    }

}

extension Round {
    
    public func buildLoserBracketAsync() async throws {
        guard loserRounds().isEmpty else { return }
        self.invalidateCache()
        let currentRoundMatchCount = RoundRule.numberOfMatches(forRoundIndex: index)
        guard currentRoundMatchCount > 1 else { return }
        guard let tournamentStore else { return }
        let roundCount = RoundRule.numberOfRounds(forTeams: currentRoundMatchCount)
        let loserBracketMatchFormat = tournamentObject()?.loserBracketMatchFormat

        let rounds = (0..<roundCount).map { //index 0 is the final
            let round = Round(tournament: tournament, index: $0, matchFormat: loserBracketMatchFormat)
            round.parent = id //parent
            //titles[round.id] = round.roundTitle(initialMode: true)
            return round
        }
        try await tournamentStore.rounds.addOrUpdateAsync(contentOfs: rounds)
        let matchCount = RoundRule.numberOfMatches(forTeams: currentRoundMatchCount)

        let matches = (0..<matchCount).map { //0 is final match
            let roundIndex = RoundRule.roundIndex(fromMatchIndex: $0)
            let round = rounds[roundIndex]
            //let title = titles[round.id]
            return Match(round: round.id, index: $0, format: loserBracketMatchFormat)
            //initial mode let the roundTitle give a name without considering the playable match
        }
        
        try await tournamentStore.matches.addOrUpdateAsync(contentOfs: matches)
        
        for round in rounds {
            try await round.buildLoserBracketAsync()
        }
    }
}