PadelClub/PadelClub/Data/DataStore.swift

//
//  DataStore.swift
//  PadelClub
//
//  Created by Laurent Morvillier on 02/02/2024.
//

import Foundation
import LeStorage
import SwiftUI

class DataStore: ObservableObject {
    
//    fileprivate var _store: Store
    static let shared = DataStore()
    
    @Published var user: User = User.placeHolder() {
        didSet {
            Store.main.collectionsCanSynchronize = (user.username.count > 0)
            do {
                if self.user.id != self.userStorage.item()?.id {
                    try self.userStorage.setItemNoSync(self.user)
                    if Store.main.collectionsCanSynchronize {
                        Store.main.loadCollectionFromServer()
                    }
                }
            } catch {
                Logger.error(error)
            }
        }
    }
    
    fileprivate(set) var tournaments: StoredCollection<Tournament>
    fileprivate(set) var clubs: StoredCollection<Club>
    fileprivate(set) var courts: StoredCollection<Court>
    fileprivate(set) var events: StoredCollection<Event>
    fileprivate(set) var groupStages: StoredCollection<GroupStage>
    fileprivate(set) var matches: StoredCollection<Match>
    fileprivate(set) var teamRegistrations: StoredCollection<TeamRegistration>
    fileprivate(set) var playerRegistrations: StoredCollection<PlayerRegistration>
    fileprivate(set) var rounds: StoredCollection<Round>
    fileprivate(set) var teamScores: StoredCollection<TeamScore>
    fileprivate(set) var monthData: StoredCollection<MonthData>
    fileprivate(set) var dateIntervals: StoredCollection<DateInterval>
    
    fileprivate(set) var userStorage: StoredSingleton<User>
    
//    fileprivate var _userStorage: OptionalStorage<User> = OptionalStorage<User>(fileName: "user.json")
    fileprivate var _appSettingsStorage: MicroStorage<AppSettings> = MicroStorage()

    var appSettings: AppSettings {
        _appSettingsStorage.item
    }
    
    func updateSettings() {
        _appSettingsStorage.update { settings in
            settings.lastDataSource = appSettings.lastDataSource
            settings.callMessageBody = appSettings.callMessageBody
            settings.callDisplayFormat = appSettings.callDisplayFormat
            settings.callMessageSignature = appSettings.callMessageSignature
            settings.callDisplayEntryFee = appSettings.callDisplayEntryFee
            settings.callUseFullCustomMessage = appSettings.callUseFullCustomMessage
            settings.matchFormatsDefaultDuration = appSettings.matchFormatsDefaultDuration
            settings.bracketMatchFormatPreference = appSettings.bracketMatchFormatPreference
            settings.groupStageMatchFormatPreference = appSettings.groupStageMatchFormatPreference
            settings.loserBracketMatchFormatPreference = appSettings.loserBracketMatchFormatPreference
        }
    }
    
    init() {
        let store = Store.main
        store.synchronizationApiURL = "https://xlr.alwaysdata.net/api/"
        var synchronized : Bool = true

        #if DEBUG
        if let server = PListReader.readString(plist: "local", key: "server") {
            store.synchronizationApiURL = server
        }
        if let sync = PListReader.readBool(plist: "local", key: "synchronized") {
            synchronized = sync
        }
        #endif
        
        Logger.log("Sync URL: \(store.synchronizationApiURL ?? "none"), sync: \(synchronized) ")
        
        let indexed : Bool = true
        self.clubs = store.registerCollection(synchronized: synchronized, indexed: indexed)
        self.courts = store.registerCollection(synchronized: synchronized, indexed: indexed)
        self.tournaments = store.registerCollection(synchronized: synchronized, indexed: indexed)
        self.events = store.registerCollection(synchronized: synchronized, indexed: indexed)
        self.groupStages = store.registerCollection(synchronized: synchronized, indexed: indexed)
        self.teamScores = store.registerCollection(synchronized: synchronized, indexed: indexed)
        self.teamRegistrations = store.registerCollection(synchronized: synchronized, indexed: indexed)
        self.playerRegistrations = store.registerCollection(synchronized: synchronized, indexed: indexed)
        self.rounds = store.registerCollection(synchronized: synchronized, indexed: indexed)
        self.matches = store.registerCollection(synchronized: synchronized, indexed: indexed)
        self.monthData = store.registerCollection(synchronized: false, indexed: indexed)
        self.dateIntervals = store.registerCollection(synchronized: synchronized, indexed: indexed)
        
        self.userStorage = store.registerObject(synchronized: synchronized)
        
        NotificationCenter.default.addObserver(self, selector: #selector(collectionDidLoad), name: NSNotification.Name.CollectionDidLoad, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(collectionDidUpdate), name: NSNotification.Name.CollectionDidChange, object: nil)
        
    }
    
    @objc func collectionDidLoad(notification: Notification) {
        self.objectWillChange.send()
        if let object: StoredSingleton<User> = notification.object as? StoredSingleton<User> {
            Logger.log("StoredObject<User> loaded with user = \(String(describing: object.item()))")
            
            if let user = object.item() {
                self.user = user
            }
        }
    }
    
    @objc func collectionDidUpdate(notification: Notification) {
        self.objectWillChange.send()
    }
    
//    var user: User {
//        if let user = self.userStorage.item() {
//            return user
//        } else {
//            let user = User(username: "", email: "", firstName: "", lastName: "", phone: nil, country: "")
//            do {
//                try self.userStorage.setItem(user)
//            } catch {
//                Logger.error(error)
//            }
//            return user
//        }
//    }
    
//    func setUser(_ user: User) {
//        do {
//            try self.userStorage.setItem(user)
//            Store.main.collectionsCanSynchronize = user.username.count > 0
//            self._loadCollections()
//        } catch {
//            Logger.error(error)
//        }
////        self._userStorage.item = user
//    }
    
//    var globalRights: UserRight {
//        if let _ = Guard.main.currentPlan {
//            return .creation
//        }
//        if self.user.umpireCode != nil {
//            return .creation
//        } else {
//            return .edition
//        }
//        
//        // TODO what are the rules when testing the app?
//        // scenario example: one cancelled tournament
//        
//        
//        return .none
//    }
    
    func disconnect() {
        Store.main.disconnect(resetAll: true)
        Store.main.collectionsCanSynchronize = false
    }
    
    fileprivate func _loadCollections() {
        Store.main.loadCollectionFromServer()
    }
    
}