PadelClub/PadelClub/Views/Round/RoundView.swift

//
//  RoundView.swift
//  PadelClub
//
//  Created by Razmig Sarkissian on 30/03/2024.
//

import SwiftUI
import LeStorage

struct RoundView: View {
    @Environment(\.isEditingTournamentSeed) private var isEditingTournamentSeed
    @Environment(Tournament.self) var tournament: Tournament
    @EnvironmentObject var dataStore: DataStore
    @State private var selectedSeedGroup: SeedInterval?
    var showVisualDrawView: Binding<Bool> { Binding(
        get: { selectedSeedGroup != nil },
        set: {
            if $0 == false {
                selectedSeedGroup = nil
            }
        }
    )}

    var round: Round
    
    var body: some View {
        List {
            
            let loserRounds = round.loserRounds()
            let availableQualifiedTeams = tournament.availableQualifiedTeams()
            let displayableMatches = round.displayableMatches().sorted(by: \.index)
            let spaceLeft = displayableMatches.filter({ $0.hasSpaceLeft() })
            if isEditingTournamentSeed.wrappedValue == false {
                //(where: { $0.isDisabled() == false || isEditingTournamentSeed.wrappedValue })
                if loserRounds.isEmpty == false {
                    let correspondingLoserRoundTitle = round.correspondingLoserRoundTitle()
                    Section {
                        NavigationLink {
                            LoserRoundsView(upperBracketRound: round)
                                .environment(tournament)
                                .navigationTitle(correspondingLoserRoundTitle)
                        } label: {
                            Text(correspondingLoserRoundTitle)
                        }
                    }
                }
            } else if availableQualifiedTeams.isEmpty == false && spaceLeft.isEmpty == false {
                NavigationLink("Tirer au sort la position d'un qualifié") {
                    SpinDrawView(drawees: availableQualifiedTeams, segments: spaceLeft) { results in
                        results.forEach { drawResult in
                            print(availableQualifiedTeams[drawResult.drawee].teamLabel())
                            print(spaceLeft[drawResult.drawIndex].matchTitle())
                            availableQualifiedTeams[drawResult.drawee].setSeedPosition(inSpot: spaceLeft[drawResult.drawIndex], slot: nil, opposingSeeding: true)
                        }
                        _save()
                        if tournament.availableSeeds().isEmpty && tournament.availableQualifiedTeams().isEmpty {
                            self.isEditingTournamentSeed.wrappedValue = false
                        }
                    }
                }
            } else if let availableSeedGroup = tournament.seedGroupAvailable(atRoundIndex: round.index) {

                Section {                    
                    RowButtonView("Placer \(availableSeedGroup.localizedLabel())" + ((availableSeedGroup.isFixed() == false) ? " au hasard" : ""))  {
                        tournament.setSeeds(inRoundIndex: round.index, inSeedGroup: availableSeedGroup)
                        _save()
                        if tournament.availableSeeds().isEmpty && tournament.availableQualifiedTeams().isEmpty {
                            self.isEditingTournamentSeed.wrappedValue = false
                        }
                    }
                }
                
                if (availableSeedGroup.isFixed() == false) {
                    Section {
                        RowButtonView("Tirage au sort \(availableSeedGroup.localizedLabel()) visuel") {
                            self.selectedSeedGroup = availableSeedGroup
                        }
                    }
                }
            }
            
            ForEach(displayableMatches) { match in
                Section {
                    MatchRowView(match: match, matchViewStyle: .sectionedStandardStyle)
                } header: {
                    HStack {
                        Text(round.roundTitle(.wide))
                        if round.index > 0 {
                            Text(match.matchTitle(.short))
                        } else {
                            let tournamentTeamCount = tournament.teamCount
                            if let seedIntervalPointRange = loserRounds.first?.seedInterval()?.pointsRange(tournamentLevel: tournament.tournamentLevel, teamsCount: tournamentTeamCount) {
                                Spacer()
                                Text(seedIntervalPointRange)
                                    .font(.caption)
                            }
                        }
                    }
                }
            }
        }
        .sheet(isPresented: showVisualDrawView) {
            if let availableSeedGroup = selectedSeedGroup {
                let seeds = tournament.seeds(inSeedGroup: availableSeedGroup)
                let availableSeedSpot = tournament.availableSeedSpot(inRoundIndex: round.index)
                NavigationStack {
                    SpinDrawView(drawees: seeds, segments: availableSeedSpot) { draws in
                        draws.forEach { drawResult in
                            print(seeds[drawResult.drawee].teamLabel())
                            print(availableSeedSpot[drawResult.drawIndex].matchTitle())
                            seeds[drawResult.drawee].setSeedPosition(inSpot: availableSeedSpot[drawResult.drawIndex], slot: nil, opposingSeeding: false)
                        }
                        _save()
                        if tournament.availableSeeds().isEmpty && tournament.availableQualifiedTeams().isEmpty {
                            self.isEditingTournamentSeed.wrappedValue = false
                        }
                    }
                }
            }
        }
        .headerProminence(.increased)
        .toolbar {
            ToolbarItem(placement: .topBarTrailing) {
                Button(isEditingTournamentSeed.wrappedValue == true ? "Valider" : "Modifier") {
                    if isEditingTournamentSeed.wrappedValue {
                        _save()
                    }
                    isEditingTournamentSeed.wrappedValue.toggle()
                }
            }
        }
    }
    
    private func _save() {
        do {
            try dataStore.teamRegistrations.addOrUpdate(contentOfs: tournament.unsortedTeams())
        } catch {
            Logger.error(error)
        }
        
        //todo should be done server side
        let rounds = tournament.rounds()
        rounds.forEach { round in
            let matches = round.playedMatches()
            matches.forEach { match in
                match.name = Match.setServerTitle(upperRound: round, matchIndex: match.indexInRound())
            }
        }
        let allRoundMatches = tournament.allRoundMatches()
        do {
            try DataStore.shared.matches.addOrUpdate(contentOfs: allRoundMatches)
        } catch {
            Logger.error(error)
        }
    }
}

#Preview {
    RoundView(round: Round.mock())
        .environment(Tournament.mock())
}