import PushKit
import ImSDK_Plus

extension VoIPPushManager: PKPushRegistryDelegate {
    
    // 获取到 VoIP Token 后保存（不立即上报）
    func pushRegistry(_ registry: PKPushRegistry, 
                     didUpdate pushCredentials: PKPushCredentials, 
                     for type: PKPushType) {
        
        guard type == .voIP else { return }
        
        // 保存 token
        voipToken = pushCredentials.token
        
        // 将 token 转换为字符串（用于日志）
        let tokenString = pushCredentials.token.map { String(format: "%02.2hhx", $0) }.joined()
        //  VoIP Token 已获取:
        
        // 如果 TUILogin 已经完成，立即上报；否则等待 TUILoginSuccess 通知
        uploadVoIPToken()
    }
    
    // Token 失效
    func pushRegistry(_ registry: PKPushRegistry,
                     didInvalidatePushTokenFor type: PKPushType) {
        //  VoIP Token 已失效
    }
}

import TUICore
import AtomicXCore

// 步骤1：登录 Chat SDK（AtomicXCore 的 LoginStore）
LoginStore.shared.login(
    sdkAppID: sdkAppID,
    userID: userID,
    userSig: userSig
) { result in
    switch result {
    case .success:
        // Chat SDK 登录成功
        
        // 步骤2：登录 TUICore
        TUILogin.login(
            sdkAppID,
            userID: userID,
            userSig: userSig
        ) {
            // TUICore 登录成功
            // 发送通知，触发 VoIP Token 上报
            NotificationCenter.default.post(
                name: NSNotification.Name("TUILoginSuccess"), 
                object: nil
            )
        } fail: { code, message in
            // TUICore 登录失败
        }
        
    case .failure(let error):
        // Chat SDK 登录失败
    }
}

extension VoIPPushManager: PKPushRegistryDelegate {
    
    // 收到 VoIP 推送
    func pushRegistry(_ registry: PKPushRegistry, 
                     didReceiveIncomingPushWith payload: PKPushPayload, 
                     for type: PKPushType) {
        
        guard type == .voIP else { return } 
        // 必须在 5 秒内向系统报告来电，否则会 crash
        showIncomingCall(with: payload) // 步骤 7
    }
}

import LiveCommunicationKit

extension VoIPPushManager {
    // 向系统报告来电
    private func showIncomingCall(with payload: PKPushPayload) {
        
        // 解析推送数据
        let payloadDict = payload.dictionaryPayload
        
        // 1. 获取来电者名称（必需字段）
        guard let callerName = payloadDict["voip_caller_name"] as? String else {
            // 缺少 voip_caller_name 字段
            return
        }
        
        // 2. 解析 ext 字段获取通话类型（音频/视频）
        var isVideoCall = false
        if let extString = payloadDict["ext"] as? String,
           let extData = extString.data(using: .utf8),
           let extDic = try? JSONSerialization.jsonObject(with: extData) as? [String: Any],
           let voipExtDic = extDic["voip_ext"] as? [String: String],
           let mediaType = voipExtDic["voip_media_type"] {
            isVideoCall = (mediaType == "video")
        }
        
        // 创建来电通知内容
        let uuid = UUID()
        currentCallUUID = uuid  // 保存 UUID，用于后续操作
        var update = Conversation.Update(
            members: [Handle(type: .generic, value: callerName, displayName: callerName)]
        )
        update.capabilities = isVideoCall ? .video : .playingTones
        
        // 向系统报告来电（系统自动展示原生来电界面）
        Task {
            do {
                try await conversationManager.reportNewIncomingConversation(uuid: uuid, update: update)
                // 报告成功
            } catch {
                // 报告失败
            }
        }
    }
}

// MARK: - ConversationManagerDelegate
extension VoIPPushManager: ConversationManagerDelegate {
    func conversationManager(_ manager: ConversationManager, perform action: ConversationAction) {
        if action is JoinConversationAction {
            // 用户点击"接听"，调用 CallStore 接听通话
            CallStore.shared.accept { result in
                switch result {
                case .success:
                    // 接听成功，可以在这里跳转到通话页面
                case .failure(let error):
                }
            }
        } else if action is EndConversationAction {
            // 用户点击"挂断"，调用 CallStore 挂断通话
            CallStore.shared.hangup { result in
                switch result {
                case .success:
                case .failure(let error):
                }
            }
        }
        
        // 必须调用 fulfill() 通知系统操作已完成
        action.fulfill()
    }
}

import AtomicXCore
import Combine

class YourViewController: UIViewController {
    
    private var cancellables = Set<AnyCancellable>()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // 监听来电事件
        CallStore.shared.callEventPublisher
            .receive(on: DispatchQueue.main)
            .sink { [weak self] event in
                guard let self = self else { return }
                
                switch event {
                case .onCallReceived(let callId, let mediaType, let userData):
                    // 收到来电，跳转到您自己的通话页面
                    self.showCallViewController(callId: callId, mediaType: mediaType, userData: userData)
                    
                case .onCallEnded(let callId, let mediaType, let reason, let userId):
                    // 通话结束，返回或更新 UI
                    self.dismissCallViewController()
                    
                case .onCallStarted(let callId, let mediaType):
                    // 通话已开始
                    break
                }
            }
            .store(in: &cancellables)
    }
    
    private func showCallViewController(callId: String, mediaType: CallMediaType, userData: String) {
        // 跳转到您自己实现的通话页面
        let callVC = YourCallViewController()
        callVC.callId = callId
        callVC.mediaType = mediaType
        callVC.userData = userData
        callVC.modalPresentationStyle = .fullScreen
        present(callVC, animated: true)
    }
    
    private func dismissCallViewController() {
        // 关闭通话页面
        dismiss(animated: true)
    }
}