virtual-controller/remote-client-ios/remote-client-ios/Core/VC-Arrange/Arrange-Functions-WebSocket.swift

import UIKit

extension ArrangeObjects {

    // MARK: - WebSocket

    func connectWebSocket(url: URL) {
        self.urlSession = URLSession(configuration: .default, delegate: self, delegateQueue: .main)
        self.wsClient = self.urlSession?.webSocketTask(with: url)
        self.wsClient?.resume()
        self.updateUIFromConnectionState(.connected)
        self.wsClientReceiveMessage()
    }

    func wsClientReceiveMessage() {
        self.wsClient?.receive { [weak self] result in
            guard let self = self else { return }
            switch result {
            case .success(let message):
                switch message {
                case .string(let text): self.wsClientHandleIncomingJSON(text)
                default: break
                }
                self.wsClientReceiveMessage()
            case .failure:
                DispatchQueue.main.async {
                    self.updateUIFromConnectionState(.disconnected)
                }
            }
        }
    }

    func wsClientHandleIncomingJSON(_ text: String) {
        self.loggingView.log(text, category: .incoming)
        guard let data = text.data(using: .utf8),
              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
              let event = json["event"] as? String else { return }

        switch event {
        case "preset":
            guard self.autoSwitchEnabled else {
                self.loggingView.log("preset event ignored — auto switch is off", category: .local)
                return
            }
            guard let presetData = json["data"] as? [String: Any],
                  let presetBytes = try? JSONSerialization.data(withJSONObject: presetData) else {
                let msg = "preset: missing or malformed 'data' field in envelope"
                self.loggingView.log(msg, category: .local)
                DispatchQueue.main.async {
                    let alert = UIAlertController(title: "Preset Load Error", message: msg, preferredStyle: .alert)
                    alert.addAction(UIAlertAction(title: "OK", style: .default))
                    self.present(alert, animated: true)
                }
                return
            }
            do {
                let decoder = JSONDecoder()
                decoder.keyDecodingStrategy = .convertFromSnakeCase
                let preset = try decoder.decode(ModelPresetLoadToRemoteDevice.self, from: presetBytes)
                self.loggingView.log(
                    "✓ preset loaded: '\(preset.presetName)'  uuid=\(preset.presetUuid)  faders=\(preset.faders.count)  toggles=\(preset.toggles.count)  transports=\(preset.transports.count)",
                    category: .local
                )
                if let encoded = try? JSONEncoder().encode(preset),
                   let jsonStr = String(data: encoded, encoding: .utf8) {
                    self.loggingView.log(jsonStr, category: .local)
                }
                DispatchQueue.main.async {
                    self.currentPreset = preset
                    guard self.isChannelFocusMode == false else {
                        self.loggingView.log("preset event cached but not rendered — channel focus is active", category: .local)
                        return
                    }
                    let isNewPreset = preset.presetUuid != self.presetUuid
                    if self.isLocked == false && isNewPreset {
                        let alert = UIAlertController(
                            title: "Preset Switched",
                            message: "Switching to:\n\"\(preset.presetName)\" — \(preset.displayTitle)\n\nSave your current layout before switching?",
                            preferredStyle: .alert
                        )
                        alert.addAction(UIAlertAction(title: "Save & Switch", style: .default) { _ in
                            self.saveLayout()
                            self.buildUIFromPreset(preset)
                        })
                        alert.addAction(UIAlertAction(title: "Discard & Switch", style: .destructive) { _ in
                            self.buildUIFromPreset(preset)
                        })
                        self.present(alert, animated: true)
                    } else {
                        self.buildUIFromPreset(preset)
                    }
                }
            } catch {
                let msg = "preset decode failed: \(error.localizedDescription)"
                self.loggingView.log(msg, category: .local)
                DispatchQueue.main.async {
                    let alert = UIAlertController(title: "Preset Load Error", message: msg, preferredStyle: .alert)
                    alert.addAction(UIAlertAction(title: "OK", style: .default))
                    self.present(alert, animated: true)
                }
            }
        case "widget_update":
            if let uid = json["uid"] as? String, let value = json["value"] as? Int {
                DispatchQueue.main.async { self.updateWidget(uid: uid, value: value) }
            }
        case "widget_label":
            if let uid = json["uid"] as? String, let label = json["label"] as? String {
                DispatchQueue.main.async { self.updateWidgetLabel(uid: uid, label: label) }
            }
        case "widget_update_f":
            if let uid = json["uid"] as? String, let value = json["value"] as? Double {
                DispatchQueue.main.async { self.widgets[uid]?.applyFloatValue(value) }
            }
        case "widget_feedback":
            if let uid = json["uid"] as? String, let text = json["text"] as? String {
                DispatchQueue.main.async { self.widgets[uid]?.applyFeedbackText(text) }
            }
        case "daw_state":
            DispatchQueue.main.async { self.updateUIFromDawState(json) }
        default:
            break
        }
    }

    func wsClientSendJSON(_ dict: [String: Any]) {
        guard let data = try? JSONSerialization.data(withJSONObject: dict),
              let text = String(data: data, encoding: .utf8) else { return }
        self.loggingView.log(text, category: .outgoing)
        self.wsClient?.send(.string(text)) { _ in }
    }

}

// MARK: - WebSocket Delegate
extension ArrangeObjects: URLSessionWebSocketDelegate {

    func urlSession(_ session: URLSession, webSocketTask: URLSessionWebSocketTask, didOpenWithProtocol protocol: String?) {
        self.updateUIFromConnectionState(.connected)
    }

    func urlSession(_ session: URLSession, webSocketTask: URLSessionWebSocketTask, didCloseWith closeCode: URLSessionWebSocketTask.CloseCode, reason: Data?) {
        self.updateUIFromConnectionState(.disconnected)
    }

}