package com.aiosman.ravenow.im

import android.app.Application
import android.content.Context
import android.util.Log
import io.openim.android.sdk.OpenIMClient
import io.openim.android.sdk.listener.*
import io.openim.android.sdk.models.*

/**
 * OpenIM SDK 管理器
 * 负责 OpenIM SDK 的初始化和各种监听器的设置
 */
object OpenIMManager {
    
    private const val TAG = "OpenIMManager"
    
    /**
     * 初始化 OpenIM SDK
     * @param context Android上下文
     * @param initConfig SDK初始化配置
     */
    fun initSDK(context: Context, initConfig: InitConfig) {
        try {
            OpenIMClient.getInstance().initSDK(
                context.applicationContext as Application,
                initConfig,
                object : OnConnListener {
                    override fun onConnectFailed(code: Int, error: String?) {
                        Log.e(TAG, "连接服务器失败: code=$code, error=$error")

                    }

                    override fun onConnectSuccess() {
                        //连接服务器成功
                        Log.d(TAG, "连接服务器成功")
                    }

                    override fun onConnecting() {
                        //连接服务器中...
                        Log.d(TAG, "连接服务器中...")
                    }

                    override fun onKickedOffline() {
                        //当前用户被踢下线
                        Log.w(TAG, "当前用户被踢下线")
                        // 可以在这里处理用户被踢下线的逻辑，比如跳转到登录页面
                    }

                    override fun onUserTokenExpired() {
                        //登录票据已经过期
                        Log.w(TAG, "登录票据已经过期")
                        // 可以在这里处理token过期的逻辑，比如重新登录
                    }
                }
            )
            
            // 初始化完成后设置各种监听器
            initListeners()
            
            Log.d(TAG, "OpenIM SDK 初始化成功")
        } catch (e: Exception) {
            Log.e(TAG, "OpenIM SDK 初始化失败", e)
        }
    }
    
    /**
     * 初始化所有监听器
     */
    private fun initListeners() {
        setUserListener()
        setMessageListener()
        setFriendshipListener()
        setConversationListener()
        setGroupListener()
        setSignalingListener()
    }
    
    /**
     * 设置用户信息监听器
     */
    private fun setUserListener() {
        OpenIMClient.getInstance().userInfoManager.setOnUserListener(object : OnUserListener {
            override fun onSelfInfoUpdated(userInfo: UserInfo?) {
                Log.d(TAG, "用户信息更新: ${userInfo?.nickname}")
                // 处理用户信息更新
            }
        })
    }
    
    /**
     * 设置消息监听器
     */
    private fun setMessageListener() {
        OpenIMClient.getInstance().messageManager.setAdvancedMsgListener(object : OnAdvanceMsgListener {
            override fun onRecvNewMessage(msg: Message?) {
                Log.d(TAG, "收到新消息: ${msg?.toString()}")
                // 处理新消息
            }
            
            override fun onRecvC2CReadReceipt(list: List<C2CReadReceiptInfo>?) {
                Log.d(TAG, "收到C2C已读回执，数量: ${list?.size}")
                // 处理C2C已读回执
            }
            
            override fun onRecvGroupMessageReadReceipt(groupMessageReceipt: GroupMessageReceipt?) {
                Log.d(TAG, "收到群组消息已读回执")
                // 处理群组消息已读回执
            }
            
            override fun onRecvMessageRevokedV2(info: RevokedInfo?) {
                Log.d(TAG, "消息被撤回: ${info?.clientMsgID}")
                // 处理消息撤回
            }
            
            override fun onRecvMessageExtensionsChanged(msgID: String?, list: List<KeyValue>?) {
                Log.d(TAG, "消息扩展信息变更: $msgID")
                // 处理消息扩展信息变更
            }
            
            override fun onRecvMessageExtensionsDeleted(msgID: String?, list: List<String>?) {
                Log.d(TAG, "消息扩展信息删除: $msgID")
                // 处理消息扩展信息删除
            }
            
            override fun onRecvMessageExtensionsAdded(msgID: String?, list: List<KeyValue>?) {
                Log.d(TAG, "消息扩展信息添加: $msgID")
                // 处理消息扩展信息添加
            }
            
            override fun onMsgDeleted(message: Message?) {
                Log.d(TAG, "消息被删除: ${message?.clientMsgID}")
                // 处理消息删除
            }
            
            override fun onRecvOfflineNewMessage(msg: List<Message>?) {
                Log.d(TAG, "收到离线新消息，数量: ${msg?.size}")
                // 处理离线新消息
            }
            
            override fun onRecvOnlineOnlyMessage(s: String?) {
                Log.d(TAG, "收到仅在线消息: $s")
                // 处理仅在线消息
            }
        })
    }
    
    /**
     * 设置好友关系监听器
     */
    private fun setFriendshipListener() {
        OpenIMClient.getInstance().friendshipManager.setOnFriendshipListener(object : OnFriendshipListener {
            override fun onFriendApplicationAdded(friendApplication: FriendApplicationInfo?) {
                Log.d(TAG, "收到好友申请")
                // 处理好友申请
            }
            
            override fun onFriendApplicationDeleted(friendApplication: FriendApplicationInfo?) {
                Log.d(TAG, "好友申请被删除")
                // 处理好友申请删除
            }
            
            override fun onFriendApplicationAccepted(friendApplication: FriendApplicationInfo?) {
                Log.d(TAG, "好友申请被接受")
                // 处理好友申请接受
            }
            
            override fun onFriendApplicationRejected(friendApplication: FriendApplicationInfo?) {
                Log.d(TAG, "好友申请被拒绝")
                // 处理好友申请拒绝
            }
            
            override fun onFriendAdded(friendInfo: FriendInfo?) {
                Log.d(TAG, "添加好友: ${friendInfo?.nickname}")
                // 处理添加好友
            }
            
            override fun onFriendDeleted(friendInfo: FriendInfo?) {
                Log.d(TAG, "删除好友: ${friendInfo?.nickname}")
                // 处理删除好友
            }
            
            override fun onFriendInfoChanged(friendInfo: FriendInfo?) {
                Log.d(TAG, "好友信息变更: ${friendInfo?.nickname}")
                // 处理好友信息变更
            }
            
            override fun onBlacklistAdded(blackInfo: BlacklistInfo) {
                Log.d(TAG, "添加黑名单")
                // 处理添加黑名单
            }
            
            override fun onBlacklistDeleted(blackInfo: BlacklistInfo) {
                Log.d(TAG, "移除黑名单")
                // 处理移除黑名单
            }
        })
    }
    
    /**
     * 设置会话监听器
     */
    private fun setConversationListener() {
        OpenIMClient.getInstance().conversationManager.setOnConversationListener(object : OnConversationListener {
            override fun onConversationChanged(conversationList: MutableList<ConversationInfo>?) {
                Log.d(TAG, "会话发生变化，数量: ${conversationList?.size}")
                // 处理会话变化
            }
            
            override fun onNewConversation(conversationList: MutableList<ConversationInfo>?) {
                Log.d(TAG, "新增会话，数量: ${conversationList?.size}")
                // 处理新增会话
            }
            
            override fun onSyncServerFailed(reinstalled:Boolean) {
                Log.e(TAG, "同步服务器失败")
                // 处理同步失败
            }
            
            override fun onSyncServerFinish(reinstalled:Boolean) {
                Log.d(TAG, "同步服务器完成")
                // 处理同步完成
            }
            
            override fun onSyncServerStart(reinstalled:Boolean) {
                Log.d(TAG, "开始同步服务器")
                // 处理开始同步
            }
            
            override fun onTotalUnreadMessageCountChanged(totalUnreadCount: Int) {
                Log.d(TAG, "总未读消息数变化: $totalUnreadCount")
                // 处理总未读数变化
            }
        })
    }
    
    /**
     * 设置群组监听器
     */
    private fun setGroupListener() {
        OpenIMClient.getInstance().groupManager.setOnGroupListener(object : OnGroupListener {
            override fun onGroupApplicationAdded(groupApplication: GroupApplicationInfo?) {
                Log.d(TAG, "收到入群申请")
                // 处理入群申请
            }
            
            override fun onGroupApplicationDeleted(groupApplication: GroupApplicationInfo?) {
                Log.d(TAG, "入群申请被删除")
                // 处理入群申请删除
            }
            
            override fun onGroupApplicationAccepted(groupApplication: GroupApplicationInfo?) {
                Log.d(TAG, "入群申请被接受")
                // 处理入群申请接受
            }
            
            override fun onGroupApplicationRejected(groupApplication: GroupApplicationInfo?) {
                Log.d(TAG, "入群申请被拒绝")
                // 处理入群申请拒绝
            }
            
            override fun onGroupInfoChanged(groupInfo: GroupInfo?) {
                Log.d(TAG, "群信息变更: ${groupInfo?.groupName}")
                // 处理群信息变更
            }
            
            override fun onGroupMemberAdded(groupMemberInfo: GroupMembersInfo?) {
                Log.d(TAG, "群成员加入")
                // 处理群成员加入
            }
            
            override fun onGroupMemberDeleted(groupMemberInfo: GroupMembersInfo?) {
                Log.d(TAG, "群成员退出")
                // 处理群成员退出
            }
            
            override fun onGroupMemberInfoChanged(groupMemberInfo: GroupMembersInfo?) {
                Log.d(TAG, "群成员信息变更")
                // 处理群成员信息变更
            }
            
            override fun onJoinedGroupAdded(groupInfo: GroupInfo?) {
                Log.d(TAG, "加入新群: ${groupInfo?.groupName}")
                // 处理加入新群
            }
            
            override fun onJoinedGroupDeleted(groupInfo: GroupInfo?) {
                Log.d(TAG, "退出群聊: ${groupInfo?.groupName}")
                // 处理退出群聊
            }
        })
    }
    
    /**
     * 设置信令监听器
     */
    private fun setSignalingListener() {
//        OpenIMClient.getInstance(). .setSignalingListener(object : OnSignalingListener {
//            override fun onInvitationReceived(signalInvitationInfo: SignalInvitationInfo?) {
//                Log.d(TAG, "收到信令邀请")
//                // 处理信令邀请
//            }
//
//            override fun onInvitationCancelled(signalInvitationInfo: SignalInvitationInfo?) {
//                Log.d(TAG, "信令邀请被取消")
//                // 处理信令邀请取消
//            }
//
//            override fun onInvitationTimeout(signalInvitationInfo: SignalInvitationInfo?) {
//                Log.d(TAG, "信令邀请超时")
//                // 处理信令邀请超时
//            }
//
//            override fun onInviteeAccepted(signalInvitationInfo: SignalInvitationInfo?) {
//                Log.d(TAG, "信令邀请被接受")
//                // 处理信令邀请接受
//            }
//
//            override fun onInviteeRejected(signalInvitationInfo: SignalInvitationInfo?) {
//                Log.d(TAG, "信令邀请被拒绝")
//                // 处理信令邀请拒绝
//            }
//        })
    }
    
    /**
     * 获取SDK数据库存储目录
     * @param context Android上下文
     * @return 存储目录路径
     */
    fun getStorageDir(context: Context): String {
        // 使用应用的内部存储目录下的im_sdk文件夹
        val storageDir = context.filesDir.resolve("im_sdk")
        
        // 如果目录不存在，创建它
        if (!storageDir.exists()) {
            storageDir.mkdirs()
        }
        
        return storageDir.absolutePath
    }
}
