LeStorage/LeStorage/ApiCallCollection.swift

//
//  ApiCallCollection.swift
//  LeStorage
//
//  Created by Laurent Morvillier on 17/06/2024.
//

import Foundation

protocol SomeCallCollection {

    func findCallById(_ id: String) async -> (any SomeCall)?
    func deleteById(_ id: String) async

    func hasPendingCalls() async -> Bool
    func contentOfFile() async -> String?

    func reset() async

}

/// ApiCallCollection is an object communicating with a server to synchronize data managed locally
/// The Api calls are serialized and stored in a JSON file
/// Failing Api calls are stored forever and will be executed again later
actor ApiCallCollection<T: SyncedStorable>: SomeCallCollection {

    /// The list of api calls
    fileprivate(set) var items: [ApiCall<T>] = []

    /// The number of time an execution loop has been called
    fileprivate var _attemptLoops: Int = 0

    /// Indicates if the collection is currently retrying ApiCalls
    fileprivate var _isRescheduling: Bool = false

    /// Indicates whether the collection content has changed
    /// Initiates a write when true
    fileprivate var _hasChanged: Bool = false {
        didSet {
            if self._hasChanged {
                self._write()
                self._hasChanged = false
            }
        }
    }

    /// Starts the JSON file decoding synchronously or asynchronously
    /// Reschedule Api calls if not empty
    func loadFromFile() throws {
        try self._decodeJSONFile()
        self.rescheduleApiCallsIfNecessary()
    }

    /// Returns the file URL of the collection
    fileprivate func _urlForJSONFile() throws -> URL {
        return try ApiCall<T>.urlForJSONFile()
    }

    /// Decodes the json file into the items array
    fileprivate func _decodeJSONFile() throws {
        let fileURL = try self._urlForJSONFile()

        if FileManager.default.fileExists(atPath: fileURL.path()) {
            let jsonString: String = try FileUtils.readFile(fileURL: fileURL)
            let decoded: [ApiCall<T>] = try jsonString.decodeArray() ?? []
            //            Logger.log("loaded \(fileURL.lastPathComponent) with \(decoded.count) items")
            self.items = decoded
        }
    }

    /// Writes the content of the data
    fileprivate func _write() {
        let fileName = ApiCall<T>.fileName()
        DispatchQueue(label: "lestorage.queue.write", qos: .utility).asyncAndWait {
            //            Logger.log("Start write to \(fileName)...")
            do {
                let jsonString: String = try self.items.jsonString()
                try T.writeToStorageDirectory(content: jsonString, fileName: fileName)
            } catch {
                Logger.error(error)
            }
            //            Logger.log("End write")
        }
    }

    /// Adds or update an API call instance
    func addOrUpdate(_ instance: ApiCall<T>) {
        if let index = self.items.firstIndex(where: { $0.id == instance.id }) {
            self.items[index] = instance
        } else {
            self.items.append(instance)
        }
        self._hasChanged = true
    }

    /// Deletes an API call by [id]
    func deleteById(_ id: String) {
        self.items.removeAll(where: { $0.id == id })
//        Logger.log("\(T.resourceName()) > Delete by id, count after deletion = \(self.items.count)")
        self._hasChanged = true
    }

    /// Deletes a call by a data id
    func deleteByDataId(_ dataId: String) {
        if let apiCallIndex = self.items.firstIndex(where: { $0.dataId == dataId }) {
            self.items.remove(at: apiCallIndex)
            self._hasChanged = true
        }
    }

//    func hasDeleteCallForDataId(_ dataId: String) -> Bool {
//        if let apiCall = self.items.first(where: { $0.dataId == dataId }) {
//            return apiCall.method == .delete
//        }
//        return false
//    }
    
    /// Returns the Api call associated with the provided id
    func findById(_ id: String) -> ApiCall<T>? {
        return self.items.first(where: { $0.id == id })
    }

    /// Returns the Api call associated with the provided id
    func findCallById(_ id: String) async -> (any SomeCall)? {
        return self.findById(id)
    }

    /// Removes all objects in memory and deletes the JSON file
    func reset() {
        self._isRescheduling = false
        self.items.removeAll()

        do {
            let url: URL = try self._urlForJSONFile()
            if FileManager.default.fileExists(atPath: url.path()) {
                try FileManager.default.removeItem(at: url)
            }
        } catch {
            Logger.error(error)
        }
    }

    /// Wait for an exponentionnaly long time depending on the number of attemps
    fileprivate func _wait() async {
        
        let delay = pow(2, self._attemptLoops)
        let seconds = NSDecimalNumber(decimal: delay).intValue
        Logger.log("\(T.resourceName()): wait for \(seconds) sec")
        do {
            try await Task.sleep(until: .now + .seconds(seconds))
        } catch {
            Logger.w("*** WAITING CRASHED !!!")
            Logger.error(error)
        }
    }
    
    /// Reschedule API calls if necessary
    func rescheduleApiCallsIfNecessary() {
        Task {
            await self._rescheduleApiCalls()
        }
    }

    /// Reschedule the execution of API calls
    fileprivate func _rescheduleApiCalls() async {
                
//        Logger.log("\(T.resourceName()) > RESCHED")
        guard !self._isRescheduling, StoreCenter.main.collectionsCanSynchronize else { return }
        guard self.items.isNotEmpty else { return }
        
        self._isRescheduling = true

        self._attemptLoops += 1

        await self._wait()
        
        let apiCallsCopy = self.items
        for apiCall in apiCallsCopy {
            apiCall.attemptsCount += 1
            apiCall.lastAttemptDate = Date()

            do {
                switch apiCall.method {
                case .post:
                    let result: T = try await self._executeApiCall(apiCall)
                    StoreCenter.main.updateFromServerInstance(result)
//                    Logger.log("\(T.resourceName()) > SUCCESS!")
                case .put:
                    let _: T = try await self._executeApiCall(apiCall)
                case .delete:
                    let _: Empty = try await self._executeApiCall(apiCall)
                case .get:
                    if T.self == GetSyncData.self {
                        let _: Empty = try await self._executeApiCall(apiCall)
                    } else {
                        let _: [T] = try await self._executeApiCall(apiCall)
                    }
                    // process GET
                    // what if it is a sync GET
                }
            } catch {
//                Logger.log("\(T.resourceName()) > API CALL RETRY ERROR:")
                Logger.error(error)
            }
        }

//        Logger.log("\(T.resourceName()) > STOP RESCHED")

        self._isRescheduling = false
        if self.items.isNotEmpty {
            await self._rescheduleApiCalls()
        }

//        Logger.log("\(T.resourceName()) > isRescheduling = \(self._isRescheduling)")
    }

    // MARK: - Synchronization

    /// Returns an APICall instance for the Storable [instance] and an HTTP [method]
    /// The method updates existing calls or creates a new one
    fileprivate func _callForInstance(_ instance: T, method: HTTPMethod) throws -> ApiCall<T>? {

        if let existingCall = self.items.first(where: { $0.dataId == instance.stringId }) {
            switch method {
            case .delete:
                self.deleteById(existingCall.id)  // delete the existing call as we don't need it
                if existingCall.method == HTTPMethod.post {
                    return nil  // if the post has not been done, we can just stop here
                } else {
                    return try self._createCall(instance, method: method)  // otherwise it's a put and we want to send the delete
                }
            default:  // here we should only trying to PUT, so we update the existing POST/PUT with the instance new values
                existingCall.body = try instance.jsonString()
                return existingCall
            }
        } else {
            return try self._createCall(instance, method: method)
        }
    }

    /// Creates an API call for the Storable [instance] and an HTTP [method]
    fileprivate func _createCall(_ instance: T, method: HTTPMethod) throws -> ApiCall<T> {
        let jsonString = try instance.jsonString()
        return ApiCall(method: method, dataId: instance.stringId, body: jsonString)
    }

    /// Prepares a call for execution by updating its properties and adding it to its collection for storage
    fileprivate func _prepareCall(apiCall: ApiCall<T>) throws {
        apiCall.lastAttemptDate = Date()
        apiCall.attemptsCount += 1
        self.addOrUpdate(apiCall)
    }

    /// Sends an insert api call for the provided [instance]
    func sendInsertion(_ instance: T) async throws -> T? {
        do {
            return try await self._synchronize(instance, method: HTTPMethod.post)
        } catch {
            self.rescheduleApiCallsIfNecessary()
            Logger.error(error)
        }
        return nil

    }

    /// Sends an update api call for the provided [instance]
    func sendUpdate(_ instance: T) async throws -> T? {
        do {
            return try await self._synchronize(instance, method: HTTPMethod.put)
        } catch {
            self.rescheduleApiCallsIfNecessary()
            Logger.error(error)
        }
        return nil
    }

    /// Sends an delete api call for the provided [instance]
    func sendDeletion(_ instance: T) async throws {
        do {
            let _: Empty? = try await self._synchronize(instance, method: HTTPMethod.delete)
        } catch {
            self.rescheduleApiCallsIfNecessary()
            Logger.error(error)
        }
        return
    }

    /// Initiates the process of sending the data with the server
    fileprivate func _synchronize<V: Decodable>(_ instance: T, method: HTTPMethod) async throws -> V? {
        if let apiCall = try self._callForInstance(instance, method: method) {
            try self._prepareCall(apiCall: apiCall)
            return try await self._executeApiCall(apiCall)
        } else {
            return nil
        }
    }

    /// Executes an API call
    /// For POST requests, potentially copies additional data coming from the server during the insert
//    fileprivate func _executeApiCall(_ apiCall: ApiCall<T>) async throws -> T {
//        return try await StoreCenter.main.execute(apiCall: apiCall)
//    }
    
    /// Executes an API call
    /// For POST requests, potentially copies additional data coming from the server during the insert
    fileprivate func _executeApiCall<V: Decodable>(_ apiCall: ApiCall<T>) async throws -> V {
        return try await StoreCenter.main.execute(apiCall: apiCall)
    }

    /// Returns the content of the API call file as a String
    func contentOfFile() -> String? {
        guard let fileURL = try? self._urlForJSONFile() else { return nil }
        if FileManager.default.fileExists(atPath: fileURL.path()) {
            return try? FileUtils.readFile(fileURL: fileURL)
        }
        return nil
    }

    /// Returns if the API call collection is not empty
    func hasPendingCalls() -> Bool {
        return self.items.isNotEmpty
    }

}