LeStorage/LeStorage/WebSocketManager.swift

//
//  WebSocketManager.swift
//  WebSocketTest
//
//  Created by Laurent Morvillier on 30/08/2024.
//

import Foundation
import SwiftUI
import Combine

class WebSocketManager: ObservableObject {

    fileprivate(set) var storeCenter: StoreCenter
    
    fileprivate var _webSocketTask: URLSessionWebSocketTask?
    fileprivate var _timer: Timer?
    fileprivate var _url: String
    
    fileprivate var _reconnectAttempts = 0
    fileprivate var _failure = false
    fileprivate var _error: Error? = nil
    fileprivate var _pingOk = false
    
    init(storeCenter: StoreCenter, urlString: String) {
        self.storeCenter = storeCenter
        self._url = urlString
        _setupWebSocket()
    }

    deinit {
        disconnect()
    }

    private func _setupWebSocket() {
        
//        guard let url = URL(string: "ws://127.0.0.1:8000/ws/user/test/") else {
        guard let url = URL(string: self._url) else {
            Logger.w("Invalid URL: \(self._url)")
            return
        }
        
        Logger.log(">>> configure websockets with: \(url)")
        
        let session = URLSession(configuration: .default)
        _webSocketTask = session.webSocketTask(with: url)
        _webSocketTask?.resume()
        
        self._receiveMessage()
        
        // Setup a ping timer to keep the connection alive
        self._timer?.invalidate()
        _timer = Timer.scheduledTimer(withTimeInterval: 10, repeats: true) { _ in
            self._ping()
        }
    }

    private func _receiveMessage() {
        _webSocketTask?.receive { result in
            switch result {
            case .failure(let error):
                self._failure = true
                self._error = error
                print("Error in receiving message: \(error)")
                self._handleWebSocketError(error)
            case .success(let message):
                self._failure = false
                self._reconnectAttempts = 0
                switch message {
                case .string(let deviceId):
//                    print("device id = \(StoreCenter.main.deviceId()), origin id: \(deviceId)")
                    guard self.storeCenter.deviceId() != deviceId else {
                        break
                    }
                    
                    Task {
                        await self.storeCenter.synchronizeLastUpdates()
                    }
                    
                case .data(let data):
                    print("Received binary message: \(data)")
                    break
                @unknown default:
                    print("received other = \(message)")
                    break
                }
                
                self._receiveMessage()
            }
        }
    }
    
    private func _handleWebSocketError(_ error: Error) {
//        print("WebSocket error: \(error)")
        
        // up to 10 seconds of reconnection
        let delay = min(Double(self._reconnectAttempts), 10.0)
        self._reconnectAttempts += 1
        
        DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
            guard let self = self else { return }
            Logger.log("Attempting to reconnect... (Attempt #\(self._reconnectAttempts))")
            _setupWebSocket()
        }
    }
    
    func send(_ message: String) {
        self._webSocketTask?.send(.string(message)) { error in
            if let error = error {
                print("Error in sending message: \(error)")
            }
        }
    }

    private func _ping() {
        self._webSocketTask?.sendPing { error in
            
            if let error: NSError = error as NSError?,
                error.domain == NSPOSIXErrorDomain && error.code == 57 {
                Logger.log("ping sent. Error?: \(error.localizedDescription) ")
                self._setupWebSocket()
                self._pingOk = false
            } else {
                self._pingOk = true
            }
        }
    }

    func disconnect() {
        self._webSocketTask?.cancel(with: .goingAway, reason: nil)
        self._timer?.invalidate()
    }
 
    var pingStatus: Bool {
        return self._pingOk
    }
    
    var failure: Bool {
        return self._failure
    }
    
    var error: Error? {
        return self._error
    }
    
    var reconnectAttempts: Int {
        return self._reconnectAttempts
    }
    
}