LiveCommunicationKit

import LiveCommunicationKit
import PushKit
import UIKit

// MARK: - App-level manager created at launch

final class ConversationCoordinator: NSObject {
    static let shared = ConversationCoordinator()

    let manager: ConversationManager

    private override init() {
        let config = ConversationManager.Configuration(
            localizedName: "FriendChat",
            ringtoneSound: .init(named: "ringtone"),
            iconImage: UIImage(named: "AppIcon"),
            maximumGroups: 2,
            maximumConversationsPerGroup: 5,
            includesConversationsInRecents: true,
            supportsVideo: false,
            supportedHandleTypes: [.phoneNumber]
        )
        manager = ConversationManager(configuration: config)
        super.init()
        manager.delegate = self
    }
}

// MARK: - PushKit integration

extension ConversationCoordinator: PKPushRegistryDelegate {
    func pushRegistry(
        _ registry: PKPushRegistry,
        didReceiveIncomingPushWith payload: PKPushPayload,
        for type: PKPushType,
        completion: @escaping () -> Void
    ) {
        guard type == .voIP else { completion(); return }

        let dict = payload.dictionaryPayload
        guard
            let uuidString = dict["uuid"] as? String,
            let uuid = UUID(uuidString: uuidString),
            let phoneNumber = dict["caller"] as? String
        else { completion(); return }

        let handle = Conversation.Handle(
            kind: .phoneNumber,
            value: phoneNumber,
            displayName: "Unknown Caller"
        )

        let update = Conversation.Update(
            handles: [handle],
            capabilities: [.video, .pausing]
        )

        // Must be called before this method returns
        manager.reportIncomingConversation(uuid: uuid, update: update)
        completion()
    }

    func pushRegistry(_ registry: PKPushRegistry,
                      didUpdate credentials: PKPushCredentials,
                      for type: PKPushType) {}
}

// MARK: - Conversation lifecycle handling

extension ConversationCoordinator: ConversationManagerDelegate {
    func conversationManager(
        _ manager: ConversationManager,
        perform action: ConversationAction
    ) {
        switch action {
        case let join as JoinConversationAction:
            handleJoin(join)
        case let end as EndConversationAction:
            handleEnd(end)
        default:
            action.fail()
        }
    }

    private func handleJoin(_ action: JoinConversationAction) {
        guard manager.conversations.contains(where: { $0.uuid == action.uuid }) else {
            action.fail(); return
        }

        manager.reportConversationConnecting(uuid: action.uuid)

        Task {
            do {
                try await MediaStreamService.shared.connect(conversationID: action.uuid)
                manager.reportConversationConnected(uuid: action.uuid)
                action.fulfill()
            } catch {
                action.fail()
            }
        }
    }

    private func handleEnd(_ action: EndConversationAction) {
        manager.reportConversationLeaving(uuid: action.uuid)
        Task {
            await MediaStreamService.shared.disconnect(conversationID: action.uuid)
            manager.reportConversationLeft(uuid: action.uuid)
            action.fulfill()
        }
    }
}

// MARK: - Stub for compilation

final class MediaStreamService {
    static let shared = MediaStreamService()
    func connect(conversationID: UUID) async throws {}
    func disconnect(conversationID: UUID) async {}
}