ConnectionManaging.swift

import Foundation
import LiveKit

enum ConnectionManagerError: Error {
    case notConnected
}

@MainActor
protocol ConnectionManaging: AnyObject {
    var onEventReceived: (@Sendable (IncomingEvent) -> Void)? { get set }
    var onDisconnected: (() async -> Void)? { get set }
    var onStartupPhaseChange: ((StartupPhase) -> Void)? { get set }

    func connect(auth: ConversationAuth, config: ConversationConfig) async throws
    func disconnect() async
    func send(data: Data) async throws
}

@MainActor
protocol WebSocketConnectionManaging: ConnectionManaging {}

@MainActor
protocol WebRTCConnectionManaging: ConnectionManaging {
    var onRemoteSpeakingChanged: (@Sendable (Bool) -> Void)? { get set }
    var inputTrack: LocalAudioTrack? { get }
    var agentAudioTrack: RemoteAudioTrack? { get }
    var isMicrophoneMuted: Bool { get }

    func setMicrophoneMuted(_ muted: Bool) async throws
}

extension ConnectionManaging {
    func handleIncomingData(_ data: Data, logger: any Logging) {
        do {
            if let event = try EventParser.parseIncomingEvent(from: data) {
                onEventReceived?(event)
            }
        } catch let EventParseError.unknownEventType(type) {
            // Unrecognized event types are expected (newer server) — not errors.
            logger.debug("Ignoring unknown incoming event type", context: ["type": type])
        } catch {
            logger.error("Failed to parse incoming event", context: ["error": "\(error)"])
            logger.debug("Incoming raw data bytes", context: ["bytes": "\(data.count)"])
        }
    }

    func send(event: OutgoingEvent) async throws {
        let data = try EventSerializer.serializeOutgoingEvent(event)

        do {
            try await send(data: data)
        } catch ConnectionManagerError.notConnected {
            throw ConversationError.notConnected
        }
    }
}