Lanu_iOS/Lanu/Manager/IM/LNIMManager.swift

//
//  LNIMManager.swift
//  Lanu
//
//  Created by OneeChan on 2025/11/12.
//

import Foundation
import TUICallEngine


protocol LNIMManagerNotify {
    func onConversationListChanged()
    func onIMUserStatusChanged(uid: String, status: V2TIMUserStatusType)
    
    func onVoiceCallBegin()
    func onVoiceCallEnd()
    func onVoiceCallInfoChanged()
}
extension LNIMManagerNotify {
    func onConversationListChanged() {}
    func onIMUserStatusChanged(uid: String, status: V2TIMUserStatusType) {}
    
    func onVoiceCallBegin() { }
    func onVoiceCallEnd() { }
    func onVoiceCallInfoChanged() { }
}

extension String {
    var isImOfficialId: Bool {
        guard let intValue = Int(self) else { return false }
        return intValue <= LNIMManager.maxOfficialId
    }
}

enum LNIMCustomErrorCode: Int {
    case inBlackList = 120001
    case userNotExist = 120002
}

enum LNIMOfficialIds: String {
    case officialMessage = "9998"
}

class LNIMVoiceCallInfo {
    let uid: String
    var isInCome = false
    var beginTime: TimeInterval = 0
    var isMute = false
    var isSpeaker = false
    
    init(uid: String) {
        self.uid = uid
    }
}

class LNIMManager: NSObject {
    private static var appId: Int32 {
        if LNAppConfig.shared.curEnv == .test {
            20030346
        } else {
            80000456
        }
    }
    
    static var shared = LNIMManager()
    
    static let maxOfficialId = 10000
    static let maxMessageInput = 200
    
    private(set) var conversationList: [V2TIMConversation] = []
    private(set) var userStatus: [String: V2TIMUserStatusType] = [:]
    
    private(set) var voiceCallAvailable = false
    
    private(set) var curCallInfo: LNIMVoiceCallInfo?
    
    private override init() {
        super.init()
        _ = LNIMEmojiManager.shared
        LNEventDeliver.addObserver(self)
        V2TIMManager.sharedInstance().addConversationListener(listener: self)
        V2TIMManager.sharedInstance().addIMSDKListener(listener: self)
    }
}

extension LNIMManager {
    func reloadConversationList(handler: ((Bool) -> Void)? = nil) {
        let filter = V2TIMConversationListFilter()
        filter.type = .C2C
        V2TIMManager.sharedInstance().getConversationListByFilter(
            filter: filter,
            nextSeq: 0, count: 1000)
        { [weak self] list, nextTag, isFinish in
            guard let self else { return }
            guard var list else {
                handler?(false)
                return
            }
            // 按照时间排序
            list.sort { $0.userID?.isImOfficialId == true || $0.orderKey > $1.orderKey }
            
            if list.firstIndex(where: { $0.userID?.isImOfficialId == true }) == nil {
                // 插入官方消息
                let officialId = "c2c_" + LNIMOfficialIds.officialMessage.rawValue
                saveDraftFor(officialId, draft: " ")
                saveDraftFor(officialId, draft: nil)
            }
            
            for item in list {
                if let old = conversationList.first(where: { $0.conversationID == item.conversationID }),
                   let userInfo = old.userInfo {
                    item.userInfo = userInfo
                }
            }
            
            conversationList = list
            handler?(true)
            notifyConversationListChanged()
            
            V2TIMManager.sharedInstance().subscribeUserStatus(userIDList: list.compactMap({ $0.userID }), succ: nil)
            loadUsersOnlineStatus()
        } fail: { code, err in
            handler?(false)
        }
    }
    
    func cleanConversationUnread(uid: String) {
        let conversationId = "c2c_" + uid
        V2TIMManager.sharedInstance().cleanConversationUnreadMessageCount(
            conversationID: conversationId,
            cleanTimestamp: 0, cleanSequence: 0, succ: nil)
    }
    
    func saveDraftFor(_ conversationId: String?, draft: String?) {
        guard let conversationId else { return }
        V2TIMManager.sharedInstance().setConversationDraft(conversationID: conversationId, draftText: draft, succ: nil)
    }
}

extension LNIMManager {
    func isUserOnline(uid: String) -> Bool {
        userStatus[uid] == .USER_STATUS_ONLINE
    }
    
    func getUserOnlineState(uid: String, handler: @escaping (Bool) -> Void) {
        V2TIMManager.sharedInstance().getUserStatus(userIDList: [uid])
        { [weak self] userStatusList in
            guard let self else { return }
            userStatusList?.forEach {
                if let uid = $0.userID {
                    self.userStatus[uid] = $0.statusType
                    self.notifyUserStatusChanged(uid: uid, status: $0.statusType)
                }
            }
            handler(userStatusList?.first(where: { $0.userID == uid })?.statusType == .USER_STATUS_ONLINE)
        } fail: { _, _ in }
    }
    
    private func loadUsersOnlineStatus() {
        let uids = conversationList.compactMap { $0.userID }
        guard !uids.isEmpty else { return }
        V2TIMManager.sharedInstance().getUserStatus(userIDList: uids)
        { [weak self] userStatusList in
            guard let self else { return }
            userStatusList?.forEach {
                if let uid = $0.userID {
                    self.userStatus[uid] = $0.statusType
                    self.notifyUserStatusChanged(uid: uid, status: $0.statusType)
                }
            }
        } fail: { _, _ in }
    }
}

extension LNIMManager {
    func makeVoiceCall(uid: String) {
        guard curCallInfo == nil else { return }
        
        curCallInfo = .init(uid: uid)
        curCallInfo?.isInCome = false
        
        let panel = LNVoiceCallPanel()
        panel.toCallOut(uid: uid)
        panel.popup()
        
        let param = TUICallParams()
        TUICallEngine.createInstance().call(userId: uid, callMediaType: .audio, params: param) {
        } fail: { _, err in
            showToast(err)
        }
    }
    
    func rejectVoiceCall() {
        TUICallEngine.createInstance().reject { }
        fail: { _, err in
            showToast(err)
        }
    }
    
    func acceptVoiceCall() {
        TUICallEngine.createInstance().accept { }
        fail: { _, err in
            showToast(err)
        }
    }
    
    func hangupVoiceCall() {
        TUICallEngine.createInstance().hangup { }
        fail: { _, err in
            showToast(err)
        }
    }
    
    func switchVoiceCallMicrophone() {
        if curCallInfo?.isMute == true {
            TUICallEngine.createInstance().openMicrophone { [weak self] in
                guard let self else { return }
                curCallInfo?.isMute = false
                LNEventDeliver.notifyEvent {
                    ($0 as? LNIMManagerNotify)?.onVoiceCallInfoChanged()
                }
            }
            fail: { _, err in
                showToast(err)
            }
        } else {
            TUICallEngine.createInstance().closeMicrophone()
            curCallInfo?.isMute = true
            LNEventDeliver.notifyEvent {
                ($0 as? LNIMManagerNotify)?.onVoiceCallInfoChanged()
            }
        }
    }
    
    func switchVoiceCallSpeakerType() {
        let isSpeaker = curCallInfo?.isSpeaker == true
        TUICallEngine.createInstance().selectAudioPlaybackDevice(isSpeaker ? .earpiece : .speakerphone)
        curCallInfo?.isSpeaker = !isSpeaker
        LNEventDeliver.notifyEvent {
            ($0 as? LNIMManagerNotify)?.onVoiceCallInfoChanged()
        }
    }
}

extension LNIMManager: V2TIMConversationListener {
    func onNewConversation(conversationList: [V2TIMConversation]!) {
        reloadConversationList()
        loadUsersOnlineStatus()
    }
    
    func onConversationChanged(conversationList: [V2TIMConversation]!) {
        var isChanged = false
        for item in conversationList {
            let old = self.conversationList.first(where: { $0.conversationID == item.conversationID })
            if let old, old.unreadCount != item.unreadCount
                || old.lastDisplayDate != item.lastDisplayDate
                || old.lastMessage?.msgID != item.lastMessage?.msgID {
                isChanged = true
                break
            }
        }
        if isChanged {
            reloadConversationList()
        }
    }
    
    func onConversationDeleted(conversationIDList: [String]!) {
        reloadConversationList()
        loadUsersOnlineStatus()
    }
}

extension LNIMManager: V2TIMSDKListener {
    func onUserStatusChanged(userStatusList: [V2TIMUserStatus]!) {
        userStatusList.forEach {
            if let uid = $0.userID {
                userStatus[uid] = $0.statusType
                notifyUserStatusChanged(uid: uid, status: $0.statusType)
            }
        }
    }
}

extension LNIMManager: TUICallObserver {
    func onCallReceived(callerId: String, calleeIdList: [String],
                        groupId: String?, callMediaType: TUICallMediaType,
                        userData: String?)
    {
        guard curCallInfo == nil else {
            return
        }
        curCallInfo = .init(uid: callerId)
        curCallInfo?.isInCome = true
        
        let panel = LNVoiceCallPanel()
        panel.onCallIn(uid: callerId)
        panel.popup()
    }
    
    func onCallCancelled(callerId: String) {
        curCallInfo = nil
        LNEventDeliver.notifyEvent { ($0 as? LNIMManagerNotify)?.onVoiceCallEnd() }
    }
    
    func onCallBegin(roomId: TUIRoomId, callMediaType: TUICallMediaType, callRole: TUICallRole) {
        curCallInfo?.beginTime = curTime
        LNEventDeliver.notifyEvent { ($0 as? LNIMManagerNotify)?.onVoiceCallBegin() }
    }
    
    func onCallEnd(roomId: TUIRoomId, callMediaType: TUICallMediaType, callRole: TUICallRole, totalTime: Float) {
        curCallInfo = nil
        LNEventDeliver.notifyEvent { ($0 as? LNIMManagerNotify)?.onVoiceCallEnd() }
    }
    
    func onUserReject(userId: String) {
        // 会同步回调 onCallCancelled
//        curCallInfo = nil
//        LNEventDeliver.notifyEvent { ($0 as? LNIMManagerNotify)?.onVoiceCallEnd() }
    }
    
    func onUserNoResponse(userId: String) {
        // 会同步回调 onCallCancelled
//        curCallInfo = nil
//        LNEventDeliver.notifyEvent { ($0 as? LNIMManagerNotify)?.onVoiceCallEnd() }
    }
    
    func onUserLineBusy(userId: String) {
        curCallInfo = nil
        LNEventDeliver.notifyEvent { ($0 as? LNIMManagerNotify)?.onVoiceCallEnd() }
    }
}

extension LNIMManager: LNAccountManagerNotify {
    func onUserLogin() {
        // 初始化 SDK
        let config = V2TIMSDKConfig()
        config.logLevel = .LOG_INFO
        guard V2TIMManager.sharedInstance().initSDK(Self.appId, config: config) else {
            return
        }
        
        // 登录
        let loginSuccessBlock = { [weak self] in
            guard let self else { return }
            reloadConversationList()
        }
        
        getIMSignToken { token in
            guard let token else { return }
            if V2TIMManager.sharedInstance().getLoginUser()?.isMyUid == true {
                loginSuccessBlock()
            } else {
                V2TIMManager.sharedInstance().login(userID: myUid, userSig: token, succ: loginSuccessBlock)
            }
            
            TUICallEngine.createInstance().`init`(Self.appId, userId: myUid, userSig: token) { [weak self] in
                guard let self else { return }
                voiceCallAvailable = true
                TUICallEngine.createInstance().addObserver(self)
            } fail: { _, _ in
            }
        }
    }
    
    func onUserLogout() {
        V2TIMManager.sharedInstance().logout(succ: nil)
        TUICallEngine.destroyInstance()
        
        Self.shared = LNIMManager()
    }
}

extension LNIMManager {
    private func getIMSignToken(handler: @escaping (String?) -> Void) {
        LNHttpManager.shared.getIMSign { token, err in
            handler(token)
        }
    }
}

extension LNIMManager {
    private func notifyConversationListChanged() {
        LNEventDeliver.notifyEvent {
            ($0 as? LNIMManagerNotify)?.onConversationListChanged()
        }
    }
    
    private func notifyUserStatusChanged(uid: String, status: V2TIMUserStatusType) {
        LNEventDeliver.notifyEvent {
            ($0 as? LNIMManagerNotify)?.onIMUserStatusChanged(uid: uid, status: status)
        }
    }
}