//
//  PlayerDetailView.swift
//  PadelClub
//
//  Created by Razmig Sarkissian on 17/04/2024.
//

import SwiftUI
import LeStorage

struct PlayerDetailView: View {

    @Environment(Tournament.self) var tournament: Tournament
    @EnvironmentObject var dataStore: DataStore

    @Bindable var player: PlayerRegistration
    @State private var licenceId: String
    @State private var phoneNumber: String
    @State private var email: String
    @FocusState var focusedField: PlayerRegistration.CodingKeys?

    var tournamentStore: TournamentStore? {
        return self.tournament.tournamentStore
    }
    
    init(player: PlayerRegistration) {
        self.player = player
        _licenceId = .init(wrappedValue: player.licenceId ?? "")
        _email = .init(wrappedValue: player.email ?? "")
        _phoneNumber = .init(wrappedValue: player.phoneNumber ?? "")
    }

    var body: some View {
        Form {
            Section {
                Text(player.localizedSourceLabel().firstCapitalized)
            } header: {
                Text("Source des informations")
            }
            
            if tournament.enableOnlineRegistration {
                Section {
                    LabeledContent {
                        Text(player.registeredOnline ? "Oui" : "Non")
                    } label: {
                        Text("Inscription en ligne")
                    }
                }
            }
            
            Section {
                Toggle("Joueur sur place", isOn: $player.hasArrived)
                Toggle("Capitaine", isOn: $player.captain)
                Toggle("Coach", isOn: $player.coach)
            }
            
            Section {
                LabeledContent {
                    TextField("Nom", text: $player.lastName)
                        .keyboardType(.alphabet)
                        .multilineTextAlignment(.trailing)
                        .frame(maxWidth: .infinity)
                        .onSubmit(of: .text) {
                            player.lastName = player.lastName.prefixTrimmed(50)
                            _save()
                        }
                } label: {
                    Text("Nom")
                }
                
                LabeledContent {
                    TextField("Prénom", text: $player.firstName)
                        .keyboardType(.alphabet)
                        .multilineTextAlignment(.trailing)
                        .frame(maxWidth: .infinity)
                        .onSubmit(of: .text) {
                            player.firstName = player.firstName.prefixTrimmed(50)
                            _save()
                        }
                } label: {
                    Text("Prénom")
                }
                
                PlayerSexPickerView(player: player)
                
                if let birthdate = player.birthdate {
                    Text(birthdate)
                }
            }
            
            Section {
                LabeledContent {
                    TextField("Rang", value: $player.rank, format: .number)
                        .keyboardType(.decimalPad)
                        .multilineTextAlignment(.trailing)
                        .frame(maxWidth: .infinity)
                        .focused($focusedField, equals: ._rank)
                } label: {
                    Text("Rang")
                }
            } header: {
                Text("Classement actuel")
            } footer: {
                if player.rank == nil {
                    Text("Classement calculé : " + player.computedRank.formatted())
                }
            }
            
            if player.isMalePlayer() == false && tournament.tournamentCategory == .men, let rank = player.rank {
                Section {
                    let value = PlayerRegistration.addon(for: rank, manMax: tournament.maleUnrankedValue ?? 0, womanMax: tournament.femaleUnrankedValue ?? 0)
                    LabeledContent {
                        Text(value.formatted())
                    } label: {
                        Text("Valeur à rajouter")
                    }
                    LabeledContent {
                        TextField("Rang", value: $player.computedRank, format: .number)
                            .keyboardType(.decimalPad)
                            .multilineTextAlignment(.trailing)
                            .frame(maxWidth: .infinity)
                            .focused($focusedField, equals: ._computedRank)
                    } label: {
                        Text("Poids re-calculé")
                    }
                } header: {
                    Text("Ré-assimilation")
                } footer: {
                    Text("Calculé en fonction du sexe")
                }
            }
            
            Section {
                LabeledContent {
                    TextField("Licence", text: $licenceId)
                        .focused($focusedField, equals: ._licenceId)
                        .keyboardType(.alphabet)
                        .textContentType(nil)
                        .multilineTextAlignment(.trailing)
                        .autocorrectionDisabled()
                        .frame(maxWidth: .infinity)
                        .onSubmit(of: .text) {
                            player.licenceId = licenceId.prefixTrimmed(50)
                            _save()
                        }
                } label: {
                    Menu {
                        CopyPasteButtonView(pasteValue: player.licenceId)
                        PasteButtonView(text: $licenceId)
                            .onChange(of: licenceId) {
                                player.licenceId = licenceId.prefixTrimmed(50)
                                _save()
                            }
                    } label: {
                        Text("Licence")
                    }
                }
                
                LabeledContent {
                    TextField("Téléphone", text: $phoneNumber)
                        .focused($focusedField, equals: ._phoneNumber)
                        .keyboardType(.namePhonePad)
                        .textContentType(nil)
                        .multilineTextAlignment(.trailing)
                        .autocorrectionDisabled()
                        .frame(maxWidth: .infinity)
                        .onSubmit(of: .text) {
                            player.phoneNumber = phoneNumber.prefixTrimmed(50)
                            _save()
                        }
                } label: {
                    Menu {
                        CopyPasteButtonView(pasteValue: player.phoneNumber)
                        PasteButtonView(text: $phoneNumber)
                    } label: {
                        Text("Téléphone")
                    }
                }
                
                LabeledContent {
                    TextField("Email", text: $email)
                        .focused($focusedField, equals: ._email)
                        .keyboardType(.emailAddress)
                        .textContentType(nil)
                        .multilineTextAlignment(.trailing)
                        .autocorrectionDisabled()
                        .frame(maxWidth: .infinity)
                        .onSubmit(of: .text) {
                            player.email = email.prefixTrimmed(50)
                            _save()
                        }
                } label: {
                    Menu {
                        CopyPasteButtonView(pasteValue: player.email)
                        PasteButtonView(text: $email)
                    } label: {
                        Text("Email")
                    }
                }
            }
            
            Section {
                if let number = player.phoneNumber?.replacingOccurrences(of: " ", with: "") {
                    if let url = URL(string: "tel:\(number)") {
                        Link(destination: url) {
                            Label("Appeler", systemImage: "phone")
                        }
                    }
                    if let url = URL(string: "sms:\(number)") {
                        Link(destination: url) {
                            Label("Message", systemImage: "message")
                        }
                    }
                }
                
                if let mail = player.email, let mailURL = URL(string: "mail:\(mail)") {
                    Link(destination: mailURL) {
                        Label("Mail", systemImage: "mail")
                    }
                }
            }
            
//            Section {
//                NavigationLink {
//                    PlayerStatisticView(player: player)
//                } label: {
//                    Text("Statistiques de participations")
//                }
//            }
        }
        .onChange(of: [player.hasArrived, player.captain, player.coach]) {
            _save()
        }
        .onChange(of: player.sex) {
            _save()
        }
        .navigationBarBackButtonHidden(focusedField != nil)
        .headerProminence(.increased)
        .navigationTitle("Édition")
        .navigationBarTitleDisplayMode(.inline)
        .toolbarBackground(.visible, for: .navigationBar)
        .toolbar {
            ToolbarItem(placement: .topBarTrailing) {
                ShareLink(item: player.pasteData()) {
                    Label("Partager", systemImage: "square.and.arrow.up")
                }
            }

            if focusedField != nil {
                ToolbarItem(placement: .topBarLeading) {
                    Button("Annuler", role: .cancel) {
                        focusedField = nil
                    }
                }
            }
            if focusedField == ._rank || focusedField == ._computedRank || focusedField == ._phoneNumber {
                ToolbarItemGroup(placement: .keyboard) {
                    Spacer()
                    Button("Valider") {
                        if focusedField == ._rank {
                            player.setComputedRank(in: tournament)
                            player.team()?.updateWeight(inTournamentCategory: tournament.tournamentCategory)
                            _save()
                        } else if focusedField == ._computedRank {
                            player.team()?.updateWeight(inTournamentCategory: tournament.tournamentCategory)
                            _save()
                        } else if focusedField == ._phoneNumber {
                            player.phoneNumber = phoneNumber.prefixTrimmed(50)
                            _save()
                        }
                        focusedField = nil
                    }
                }
            }
        }
    }
    
    private func _save() {
        do {
            try self.tournamentStore?.playerRegistrations.addOrUpdate(instance: player)
        } catch {
            Logger.error(error)
        }
        if let team = player.team() {
            do {
                try self.tournamentStore?.teamRegistrations.addOrUpdate(instance: team)
            } catch {
                Logger.error(error)
            }
        }
    }
}

//#Preview {
//    PlayerDetailView(player: PlayerRegistration.mock())
//}
