import PushKit
import ImSDK_Plus

extension VoIPPushManager: PKPushRegistryDelegate {
    
    // Save VoIP Token after obtaining (do not report immediately)
    func pushRegistry(_ registry: PKPushRegistry, 
                     didUpdate pushCredentials: PKPushCredentials, 
                     for type: PKPushType) {
        
        guard type == .voIP else { return }
        
        // Save token
        voipToken = pushCredentials.token
        
        // Convert token to string (for logging)
        let tokenString = pushCredentials.token.map { String(format: "%02.2hhx", $0) }.joined()
        //  VoIP Token obtained:
        
        // If TUILogin is already completed, report immediately; otherwise, wait for TUILoginSuccess notification
        uploadVoIPToken()
    }
    
    // Token invalidated
    func pushRegistry(_ registry: PKPushRegistry,
                     didInvalidatePushTokenFor type: PKPushType) {
        //  VoIP Token invalidated
    }
}

import TUICore
import AtomicXCore

// Step 1: Log in to Chat SDK (AtomicXCore -- LoginStore)
LoginStore.shared.login(
    sdkAppID: sdkAppID,
    userID: userID,
    userSig: userSig
) { result in
    switch result {
    case .success:
        // Chat SDK login succeeded
        
        // Step 2: Log in to TUICore
        TUILogin.login(
            sdkAppID,
            userID: userID,
            userSig: userSig
        ) {
            // TUICore login succeeded
            // Send notification to trigger VoIP Token reporting
            NotificationCenter.default.post(
                name: NSNotification.Name("TUILoginSuccess"), 
                object: nil
            )
        } fail: { code, message in
            // TUICore login failed
        }
        
    case .failure(let error):
        // Chat SDK login failed
    }
}

extension VoIPPushManager: PKPushRegistryDelegate {
    
    // Receive VoIP Push
    func pushRegistry(_ registry: PKPushRegistry, 
                     didReceiveIncomingPushWith payload: PKPushPayload, 
                     for type: PKPushType) {
        
        guard type == .voIP else { return } 
        // You must report the incoming call to the system within 5 seconds, or the app will crash
        showIncomingCall(with: payload) // Step 7
    }
}

import LiveCommunicationKit

extension VoIPPushManager {
    // Report incoming call to the system
    private func showIncomingCall(with payload: PKPushPayload) {
        
        // Parse push data
        let payloadDict = payload.dictionaryPayload
        
        // 1. Get caller name (required field)
        guard let callerName = payloadDict["voip_caller_name"] as? String else {
            // Missing voip_caller_name field
            return
        }
        
        // 2. Parse ext field to get call type (audio/video)
        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")
        }
        
        // Create incoming call notification content
        let uuid = UUID()
        currentCallUUID = uuid  // Save UUID for subsequent operations
        var update = Conversation.Update(
            members: [Handle(type: .generic, value: callerName, displayName: callerName)]
        )
        update.capabilities = isVideoCall ? .video : .playingTones
        
        // Report incoming call to the system (system automatically displays native incoming call interface)
        Task {
            do {
                try await conversationManager.reportNewIncomingConversation(uuid: uuid, update: update)
                // Report succeeded
            } catch {
                // Report failed
            }
        }
    }
}

// MARK: - ConversationManagerDelegate
extension VoIPPushManager: ConversationManagerDelegate {
    func conversationManager(_ manager: ConversationManager, perform action: ConversationAction) {
        if action is JoinConversationAction {
            // User taps "Answer", call CallStore to accept the call
            CallStore.shared.accept { result in
                switch result {
                case .success:
                    // Answer succeeded, navigate to your call page here
                case .failure(let error):
                }
            }
        } else if action is EndConversationAction {
            // User taps "Hang Up", call CallStore to end the call
            CallStore.shared.hangup { result in
                switch result {
                case .success:
                case .failure(let error):
                }
            }
        }
        
        // You must call fulfill() to notify the system that the operation is complete
        action.fulfill()
    }
}

import AtomicXCore
import Combine

class YourViewController: UIViewController {
    
    private var cancellables = Set<AnyCancellable>()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Listen for incoming call events
        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):
                    // Incoming call received, navigate to your call page
                    self.showCallViewController(callId: callId, mediaType: mediaType, userData: userData)
                    
                case .onCallEnded(let callId, let mediaType, let reason, let userId):
                    // Call ended, update or close UI
                    self.dismissCallViewController()
                    
                case .onCallStarted(let callId, let mediaType):
                    // Call started
                    break
                }
            }
            .store(in: &cancellables)
    }
    
    private func showCallViewController(callId: String, mediaType: CallMediaType, userData: String) {
        // Navigate to your call page
        let callVC = YourCallViewController()
        callVC.callId = callId
        callVC.mediaType = mediaType
        callVC.userData = userData
        callVC.modalPresentationStyle = .fullScreen
        present(callVC, animated: true)
    }
    
    private func dismissCallViewController() {
        // Close call page
        dismiss(animated: true)
    }
}