LeStorage/LeStorage/Store.swift

//
//  Store.swift
//  LeStorage
//
//  Created by Laurent Morvillier on 02/02/2024.
//

import Foundation
import UIKit

//public enum ResetOption {
//    case all
//    case synchronizedOnly
//}

public enum StoreError: Error {
    case missingService
    case missingUserId
    case unexpectedCollectionType(name: String)
    case apiCallCollectionNotRegistered(type: String)
    case collectionNotRegistered(type: String)
    case unSynchronizedCollection
}

public struct StoreIdentifier {
    var value: String
    var parameterName: String
    
    var urlComponent: String {
        return "?\(self.parameterName)=\(self.value)"
    }
}

open class Store {
    
    /// The Store singleton
    public static let main = Store()
    
    /// The dictionary of registered StoredCollections
    fileprivate var _collections: [String : any SomeCollection] = [:]
    
    /// The name of the directory to store the json files
    static let storageDirectory = "storage"

    fileprivate(set) var identifier: StoreIdentifier? = nil
    
    public init() {
        self._createDirectory(directory: Store.storageDirectory)
    }
    
    public required init(identifier: String, parameter: String) {
        self.identifier = StoreIdentifier(value: identifier, parameterName: parameter)
        let directory = "\(Store.storageDirectory)/\(identifier)"
        self._createDirectory(directory: directory)
    }
    
    fileprivate func _createDirectory(directory: String) {
        FileManager.default.createDirectoryInDocuments(directoryName: directory)
    }
    
    /// A method to provide ids corresponding to the django storage
    public static func randomId() -> String {
        return UUID().uuidString.lowercased()
    }
    
    /// Registers a collection
    /// [synchronize] denotes a collection which modification will be sent to the django server
    public func registerCollection<T : Storable>(synchronized: Bool, indexed: Bool = false, inMemory: Bool = false, sendsUpdate: Bool = true) -> StoredCollection<T> {
        
        // register collection
        let collection = StoredCollection<T>(synchronized: synchronized, store: self, indexed: indexed, inMemory: inMemory, sendsUpdate: sendsUpdate)
        self._collections[T.resourceName()] = collection
        
        return collection
    }
    
    /// Registers a StoredSingleton instance
    public func registerObject<T : Storable>(synchronized: Bool, inMemory: Bool = false, sendsUpdate: Bool = true) -> StoredSingleton<T> {
        
        // register collection
        let storedObject = StoredSingleton<T>(synchronized: synchronized, store: self, inMemory: inMemory, sendsUpdate: sendsUpdate)
        self._collections[T.resourceName()] = storedObject
        
        return storedObject
    }
    
    // MARK: - Convenience
    
    /// Looks for an instance by id
    public func findById<T: Storable>(_ id: String) -> T? {
        guard let collection = self._collections[T.resourceName()] as? StoredCollection<T> else {
            Logger.w("Collection \(T.resourceName()) not registered")
            return nil
        }
        return collection.findById(id)
    }
    
    /// Filters a collection with a [isIncluded] predicate
    public func filter<T: Storable>(isIncluded: (T) throws -> (Bool)) rethrows -> [T] {
        do {
            return try self.collection().filter(isIncluded)
        } catch {
            return []
        }
    }
    
    /// Returns a collection by type
    func collection<T: Storable>() throws -> StoredCollection<T> {
        if let collection = self._collections[T.resourceName()] as? StoredCollection<T> {
            return collection
        }
        throw StoreError.collectionNotRegistered(type: T.resourceName())
    }
    
    /// Loads all collection with the data from the server
    public func loadCollectionFromServer() {
        for collection in self._collections.values {
            Task {
                try? await collection.loadDataFromServerIfAllowed()
            }
        }
    }
    
    /// Resets all registered collection
    public func reset() {
        for collection in self._collections.values {
            collection.reset()
        }
    }

    /// Returns the names of all collections
    public func collectionNames() -> [String] {
        return self._collections.values.map { $0.resourceName }
    }
    
    // MARK: - Write
    
    fileprivate func _directoryPath() throws -> URL {
        var url = try FileUtils.pathForDirectoryInDocuments(directory: Store.storageDirectory)
        if let identifier = self.identifier?.value {
            url.append(component: identifier)
        }
        return url
    }
    
    func write(content: String, fileName: String) throws {
        var fileURL = try self._directoryPath()
        fileURL.append(component: fileName)
        try content.write(to: fileURL, atomically: false, encoding: .utf8)
    }
    
    func fileURL<T: Storable>(type: T.Type) throws -> URL {
        let fileURL = try self._directoryPath()
        return fileURL.appending(component: T.fileName())
    }
    
    func removeFile<T: Storable>(type: T.Type) {
        do {
            let url: URL = try self.fileURL(type: type)
            if FileManager.default.fileExists(atPath: url.path()) {
                try FileManager.default.removeItem(at: url)
            }
        } catch {
            Logger.error(error)
        }
    }
    
    /// Retrieves all the items on the server
    public func getItems<T: Storable>() async throws -> [T] {
        if T.filterByStoreIdentifier() {
            return try await StoreCenter.main.getItems(identifier: self.identifier)
        } else {
            return try await StoreCenter.main.getItems()
        }
    }

    func sendInsertion<T: Storable>(_ instance: T) async throws {
        try await StoreCenter.main.sendInsertion(instance)
    }
    
    func sendUpdate<T: Storable>(_ instance: T) async throws {
        try await StoreCenter.main.sendUpdate(instance)
    }
    
    func sendDeletion<T: Storable>(_ instance: T) async throws {
        try await StoreCenter.main.sendDeletion(instance)
    }
    
}