using Chat.Framework.QQSdk.Events;
using Chat.Framework.Utils;
using Robot.Framework;
using Robot.Framework.SDK;
using System;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using LoginStatus = Robot.Framework.Entities.LoginStatus;

namespace Chat.Framework.QQSdk.QPlus
{
    /// <summary>
    /// QQ客户端管理
    /// </summary>
    public class QQClientImpl_QQPlus : QQBase, IDisposable
    {
        /// <summary>
        /// QQ客户端
        /// </summary>
        public QQClient QQClient { get; internal set; }

        /// <summary>
        /// 启动时间
        /// </summary>
        private DateTime StartTime = DateTime.MinValue;

        private QQClientImpl_QQPlus() { }

        int register = 1;
        internal QQClientImpl_QQPlus(QQClient QQClient)
        {
            this.QQClient = QQClient;
            this.QQ = QQClient.User?.QQ ?? 0;
            this.Nickname = QQClient.User?.NickName ??string.Empty;
            this.IsLogin = (QQClient.User?.LoginStatus ?? LoginStatus.Logout) == LoginStatus.Login;
            //this.Password = Robot.Framework.Utils.Util.ToHex(QQClient.User.md5_1, "", "{0}");
            //this.Password = QQClient.ToString();
            this.IsEQQ = QQClient.QQProtocol != "PCQQ";
            if (QQClient != null)
            {
                LogHelper.GetSingleObj().Debug("登录日志", $"账号:{QQ},注册事件 {register}");
                register++;
                StartTime = DateTime.Now;
                QQClient.LoginStatusChanged += client_LoginStatusChanged;
                //QQClient.LoginSuccessed += client_LoginSuccessed;
                QQClient.SystemMessage += client_SystemMessage;
                QQClient.ReceiveNormalIM += client_ReceiveNormalIM;
                QQClient.AddedToCluster += client_AddedToCluster;
                QQClient.AddedToClusterInvite += client_AddedToClusterInvite;
                QQClient.AddMeFriend += client_AddMeFriend;
                QQClient.AddMeFriendNeedAuth += client_AddMeFriendNeedAuth;
                QQClient.AddToClusterNeedAuth += client_AddToClusterNeedAuth;
                QQClient.CardChanged += client_CardChanged;
                QQClient.ClusterAdminChanged += client_ClusterAdminChanged;
                QQClient.KeepAlive += client_KeepAlive;
                QQClient.LostConnection += client_LostConnection;
                QQClient.MemberExitCluster += client_MemberExitCluster;
                QQClient.QQLevel += client_QQLevel;
                QQClient.ReceiveClusterIM += client_ReceiveClusterIM;
                QQClient.ReceiveSubjectIM += client_ReceiveSubjectIM;
                QQClient.ReceiveTempIM += client_ReceiveTempIM;
                QQClient.ReceiveVibration += client_ReceiveVibration;
                QQClient.RejectJoinCluster += client_RejectJoinCluster;
                QQClient.SignatureChanged += client_SignatureChanged;
                QQClient.StatusChanged += client_StatusChanged;
                QQClient.ClusterEvent += client_ClusterEvent;
                QQClient.ClusterNoticeChanged += client_ClusterNoticeChanged;
                QQClient.VerifyImage += client_VerifyImage;
                QQClient.AddMeSubject += client_AddMeSubject;
                QQClient.QQClientStatusChanged += client_QQClientStatusChanged;
                QQClient.SilencedQQEvent += client_SilencedQQEvent;
                QQClient.SignQQEvent += client_SignQQEvent;
                QQClient.QQPayEvent += client_QQPayEvent;
                QQClient.RecallEvent += client_RecallEvent;
                QQClient.RedBagEvent += Client_RedBagEvent;
            }
        }

        //public override void Login(string Username, string Userpass)
        //{
        //    QQClient.Login();
        //}

        public override void Login()
        {
            QQClient.Login();
        }

        public override void Logout()
        {
            Dispose();
            QQClient.Logout();
        }

        public override void SendTempMessage(uint QQ, string Message)
        {
            QQClient.SendTempMessage(QQ, Message);
        }

        public override void SendTempMessage(uint QQ, string Message, byte[] Token)
        {
            QQClient.SendTempMessage(QQ, Message);
        }

        public override void SendFriendImage(uint QQ, string ImageSrc)
        {
            QQClient.SendMessage(QQ, $"[图片={ImageSrc}/]");
        }

        public override void SendFriendMessage(uint QQ, string Message)
        {
            QQClient.SendMessage(QQ, Message);
            LogHelper.GetSingleObj().Debug("发送私聊消息", $"接收:{QQ},内容:{Message}");
        }

        public override void SendGroupImage(uint GroupId, string ImageSrc)
        {
            count++;
            StringBuilder strb = new StringBuilder();
            strb.AppendLine($"发送群图片:群:{GroupId},内容:{ImageSrc}");
            var flag = QQClient.SendClusterMessage(GroupId, ImageSrc);
            strb.AppendLine($"发送状态:{flag}");
            LogHelper.GetSingleObj().Debug("发送群图片", $"{strb} -> {count}");
        }
        public int count = 0;
        public override void SendGroupMessage(uint GroupId, string Message)
        {
            count++;
            StringBuilder strb = new StringBuilder();
            strb.AppendLine($"发送群消息:群:{GroupId},内容:{Message}");
            var flag = QQClient.SendClusterMessage(GroupId, Message);
            strb.AppendLine($"发送状态:{flag} -> " + count);
            LogHelper.GetSingleObj().Debug("发送群消息", $"{strb}");
        }

        //---------------

        private void client_SystemMessage(object sender, SystemMessageQQEventArgs e)
        {
            try
            {
                Console.WriteLine("##########" + e.Message);
            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_LoginStatusChanged(object sender, LoginStatusChangedQQEventArgs e)
        {
            try
            {
                if (sender is QQClient)
                {
                    var client = sender as QQClient;
                    ChatClient.QQEvents.OnEvent(new QQLogEvents(null) { Message = $"QQ({client.User.NickName}【{client.User.QQ}】) {e.LoginStatus} {e.Other}" });

                    var logstatusTmp = client.User.LoginStatus;
                    this.QQClient = client;
                    if (e.LoginStatus == LoginStatus.Login)
                    {
                        this.QQ = QQClient.User.QQ;
                        this.Nickname = QQClient.User.NickName;
                        this.IsLogin = QQClient.User.LoginStatus == LoginStatus.Login;
                        //this.Password = Robot.Framework.Utils.Util.ToHex(QQClient.User.md5_1, "", "{0}");
                        ChatClient.UpdateQQClient(this);

                        //if (client != null && logstatusTmp != e.LoginStatus)
                        {
                            QQBase qBase = null;
                            if (ChatClient.QQClients.ContainsKey(client.QQ.ToString()))
                                qBase = ChatClient.QQClients[client.QQ.ToString()];
                            else
                                qBase = new QQClientImpl_QQPlus(client);
                            var x = new QQLoginChangeEvents(qBase, true, "在线");
                            ChatClient.QQEvents.OnEvent(x);
                        }
                    }
                    else if (e.LoginStatus == LoginStatus.Logout || e.LoginStatus == LoginStatus.WrongPassword || e.LoginStatus == LoginStatus.JiHuo)
                    {
                        this.IsLogin = QQClient.User.LoginStatus == LoginStatus.Login;
                        ChatClient.LoginOutQQ(this.QQ.ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 用户被邀请进群
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_AddedToCluster(object sender, AddedToClusterQQEventArgs e)
        {
            try
            {
                QQNewGroupMemberEvents evt = null;
                if (e.IsInvite)
                {
                    evt = new QQNewGroupMemberEvents(this) { GroupId = e.Cluster.ExternalId, GroupName = e.Cluster.Name, Creator = e.ClusterMemberAdmin.QQ, InviteQQ = e.ClusterMemberInviter.QQ, InviteNick = e.ClusterMemberInviter.OldCard, NewFriendNick = e.ClusterMember.Nick, NewFriendQQ = e.ClusterMember.QQ };
                }
                else
                {
                    evt = new QQNewGroupMemberEvents(this) { GroupId = e.Cluster.ExternalId, GroupName = e.Cluster.Name, Creator = e.ClusterMemberAdmin.QQ, InviteQQ = 0, NewFriendNick = e.ClusterMember.Nick, NewFriendQQ = e.ClusterMember.QQ };
                }
                ChatClient.QQEvents.OnEvent(evt);
            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 用户进群
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_AddedToClusterInvite(object sender, AddedToClusterInviteQQEventArgs e)
        {
            try
            {
                var evt = new QQNewGroupMemberEvents(this) { GroupId = e.Cluster.ExternalId, GroupName = e.Cluster.Name, Creator = e.ClusterMemberAdmin.QQ, InviteQQ = e.ClusterMemberAdmin.QQ, InviteNick = e.ClusterMemberAdmin.CardOrName, NewFriendNick = e.ClusterMember.Nick, NewFriendQQ = e.ClusterMember.QQ };
                ChatClient.QQEvents.OnEvent(evt);
            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_AddMeFriend(object sender, AddMeFriendQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 添加好友需要审核
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_AddMeFriendNeedAuth(object sender, AddMeFriendNeedAuthQQEventArgs e)
        {
            try
            {
                //OnLog($"QQ({this.QQ})->用户【{e.Nick}({e.QQ})】申请添加好友！");
                var evt = new QQAddMeNeedAuthEvents(this) { QQ = e.QQ, Message = e.Message, Nickname = e.Nick };
                ChatClient.QQEvents.OnEvent(evt);
            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 添加群需要审核
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_AddToClusterNeedAuth(object sender, AddToClusterNeedAuthQQEventArgs e)
        {
            try
            {
                //OnLog($"QQ({this.QQ})->用户({e.QQ})申请加入群 {e.Cluster.Name}({e.Cluster.ExternalId}) 申请内容:{e.Message}");
                var evt = new QQAddToClusterNeedAuthEvents(this) { QQ = e.QQ, Message = e.Message, Nickname = string.Empty, ClusterId = e.Cluster.ExternalId, GroupId = e.Cluster.GroupId, Creator = e.Cluster.Creator, GroupName = e.Cluster.Name };
                ChatClient.QQEvents.OnEvent(evt);
            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public override void AerifyAddMe(uint QQ, byte Agree = 4, string Message = "")
        {
            QQClient.AgreeFriendInvite(QQ, Agree, Message);
        }

        public override void AerifyAddGroup(uint groupId, uint QQ, bool Agree = true, string Message = "")
        {
            QQClient.AgreeJoinCluster(groupId, QQ);
        }

        private void client_CardChanged(object sender, CardChangedQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 群管理变更
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_ClusterAdminChanged(object sender, ClusterAdminChangedQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 心跳
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_KeepAlive(object sender, KeepAliveQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_LostConnection(object sender, LostConnectionQQEventArgs e)
        {
            try
            {
                this.Login();
            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 用户退出群
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_MemberExitCluster(object sender, MemberExitClusterQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_QQLevel(object sender, QQLevelQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 群消息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_ReceiveClusterIM(object sender, ReceiveClusterIMQQEventArgs e)
        {
            try
            {
                if (StartTime.AddSeconds(20) > DateTime.Now)
                    return;
                if (e.SendTime.AddSeconds(60) < DateTime.Now)
                    return;

                QQClient q = null;
                if (sender is QQClient)
                {
                    q = sender as QQClient;
                    if (q != null && q.QQ == e.ClusterMember.QQ)
                        return;
                }
                var nickname = string.Empty;
                if (e.ClusterMember != null && !string.IsNullOrWhiteSpace(e.ClusterMember.CardOrName))
                {
                    nickname = e.ClusterMember.CardOrName;
                }
                else
                {
                    if (q != null && q.User.Friends != null)
                    {
                        var friend = q.User.Friends.FirstOrDefault(f => f.QQ == e.ClusterMember.QQ);
                        if (friend != null)
                            nickname = friend.NickName;
                    }
                }
                var mess = QQMessReplace(e.Message);
                if (string.IsNullOrWhiteSpace(mess)) return;
                ChatClient.QQEvents.OnEvent(new Events.QQReceiveGroupMsgEvents(this) { QQ = e.ClusterMember.QQ, GroupId = e.Cluster.ExternalId, GroupName = e.Cluster.Name, Nickname = nickname, Message = mess });
            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_ReceiveSubjectIM(object sender, ReceiveSubjectIMQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 正常私人消息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_ReceiveNormalIM(object sender, ReceiveNormalIMQQEventArgs e)
        {
            try
            {
                if (StartTime.AddSeconds(20) > DateTime.Now)
                    return;
                if (e.SendTime.AddSeconds(60) < DateTime.Now)
                    return;

                var nickname = string.Empty;
                if (sender is QQClient)
                {
                    var q = sender as QQClient;
                    if (q != null && q.User.Friends != null)
                    {
                        var friend = q.User.Friends.FirstOrDefault(f => f.QQ == e.QQ);
                        if (friend != null)
                            nickname = friend.NickName;
                    }
                }
                //你的QQ暂不支持查看视频短片，请期待后续版本。[视频=51A933ED15D1F8969C0D12CD423F54F5.mp4/]
                var mess = QQMessReplace(e.Message);
                if (string.IsNullOrWhiteSpace(mess)) return;
                ChatClient.QQEvents.OnEvent(new Events.QQReceiveFriendMsgEvents(this) { QQ = e.QQ, Nickname = nickname, Message = mess });
            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 过来QQ的消息
        /// </summary>
        /// <param name="_mess"></param>
        /// <returns></returns>
        private string QQMessReplace(string _mess)
        {
            try
            {
                var mess = _mess;
                mess = mess.Replace("你的QQ暂不支持查看视频短片，请期待后续版本。", "");
                mess = Regex.Replace(mess, @"(\[(?:声音|图片|视频)=.+?/\])", "", RegexOptions.IgnoreCase);
                return mess;
            }
            catch (Exception ex)
            { }
            return _mess;
        }

        private void client_ReceiveTempIM(object sender, ReceiveTempIMQQEventArgs e)
        {
            try
            {
                if (StartTime.AddSeconds(20) > DateTime.Now)
                    return;
                if (e.SendTime.AddSeconds(60) < DateTime.Now)
                    return;

                var nickname = string.Empty;
                if (sender is QQClient)
                {
                    var q = sender as QQClient;
                    if (q != null && q.User.Friends != null)
                    {
                        var friend = q.User.Friends.FirstOrDefault(f => f.QQ == e.QQ);
                        if (friend != null)
                            nickname = friend.NickName;
                    }
                }
                var mess = QQMessReplace(e.Message);
                if (string.IsNullOrWhiteSpace(mess)) return;
                ChatClient.QQEvents.OnEvent(new Events.QQReceiveFriendMsgEvents(this) { QQ = e.QQ, Nickname = nickname, Message = mess, IsTemp = true });
            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 震动
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_ReceiveVibration(object sender, ReceiveVibrationQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_RejectJoinCluster(object sender, RejectJoinClusterQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_SignatureChanged(object sender, SignatureChangedQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_StatusChanged(object sender, StatusChangedQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_ClusterEvent(object sender, ClusterEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 群公告修改
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_ClusterNoticeChanged(object sender, ClusterNoticeChangedEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_VerifyImage(object sender, VerifyImageQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_AddMeSubject(object sender, AddMeSubjectQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_QQClientStatusChanged(object sender, QQClientStatusChangedQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_SilencedQQEvent(object sender, SilencedQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void client_SignQQEvent(object sender, SignQQEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// QQ支付
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_QQPayEvent(object sender, QQPayEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 撤回
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void client_RecallEvent(object sender, RecallEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        /// <summary>
        /// 红包
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Client_RedBagEvent(object sender, RedBagEventArgs e)
        {
            try
            {

            }
            catch (Exception ex)
            {
                OnLog(System.Reflection.MethodBase.GetCurrentMethod().Name + " : " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void Dispose()
        {
            if (QQClient != null)
            {
                QQClient.LoginStatusChanged -= client_LoginStatusChanged;
                //QQClient.LoginSuccessed -= client_LoginSuccessed;
                QQClient.SystemMessage -= client_SystemMessage;
                QQClient.ReceiveNormalIM -= client_ReceiveNormalIM;
                QQClient.AddedToCluster -= client_AddedToCluster;
                QQClient.AddedToClusterInvite -= client_AddedToClusterInvite;
                QQClient.AddMeFriend -= client_AddMeFriend;
                QQClient.AddMeFriendNeedAuth -= client_AddMeFriendNeedAuth;
                QQClient.AddToClusterNeedAuth -= client_AddToClusterNeedAuth;
                QQClient.CardChanged -= client_CardChanged;
                QQClient.ClusterAdminChanged -= client_ClusterAdminChanged;
                QQClient.KeepAlive -= client_KeepAlive;
                QQClient.LostConnection -= client_LostConnection;
                QQClient.MemberExitCluster -= client_MemberExitCluster;
                QQClient.QQLevel -= client_QQLevel;
                QQClient.ReceiveClusterIM -= client_ReceiveClusterIM;
                QQClient.ReceiveSubjectIM -= client_ReceiveSubjectIM;
                QQClient.ReceiveTempIM -= client_ReceiveTempIM;
                QQClient.ReceiveVibration -= client_ReceiveVibration;
                QQClient.RejectJoinCluster -= client_RejectJoinCluster;
                QQClient.SignatureChanged -= client_SignatureChanged;
                QQClient.StatusChanged -= client_StatusChanged;
                QQClient.ClusterEvent -= client_ClusterEvent;
                QQClient.ClusterNoticeChanged -= client_ClusterNoticeChanged;
                QQClient.VerifyImage -= client_VerifyImage;
                QQClient.AddMeSubject -= client_AddMeSubject;
                QQClient.QQClientStatusChanged -= client_QQClientStatusChanged;
                QQClient.SilencedQQEvent -= client_SilencedQQEvent;
                QQClient.SignQQEvent -= client_SignQQEvent;
                QQClient.QQPayEvent -= client_QQPayEvent;
                QQClient.RecallEvent -= client_RecallEvent;
                QQClient.RedBagEvent -= Client_RedBagEvent;
            }
        }

        public override Task<bool> SendMessage(uint _username, string _content, bool _isGroup = false, bool _isTemp = false)
        {
            uint username = _username;
            string content = _content;
            bool isGroup = _isGroup;
            bool isTemp = _isTemp;

            return Task.Run(() =>
            {
                if (string.IsNullOrEmpty(content)) return true;
                content = content.Replace("\r\n", "\n").Trim().Replace("[时间]", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                var msgs = content.Split(new string[] { "[分段]" }, StringSplitOptions.RemoveEmptyEntries);

                try
                {
                    foreach (var msg in msgs)
                    {
                        var m = msg.Trim();
                        if (string.IsNullOrEmpty(m)) continue;

                        var message = m.RandomMess();

                        message = message.Contains("[随机表情]") ? message.Replace("[随机表情]", "") : message;

                        message = DelayMess(message);

                        //发送XML消息
                        //if (message.StartsWith("<appmsg appid=") && message.EndsWith("</appmsg>"))
                        //{
                        //    WechatPack pack = new WechatPack(this);
                        //    var sendJson = new
                        //    {
                        //        ToUserName = username,
                        //        AppId = "",
                        //        Type = 5,
                        //        Content = message
                        //    };
                        //    pack.SendAll(WechatCmd.发送XML消息, false, sendJson);
                        //    return true;
                        //}

                        ////发送公告消息
                        //var matchs = Regex.Matches(message, @"\[公告\=([^\]]+)\]", RegexOptions.IgnoreCase);
                        //if (username.Contains("@"))
                        //{
                        //    foreach (Match match in matchs)
                        //    {
                        //        SetRoomNotice(match.Groups[1].Value, username);
                        //    }
                        //}
                        //message = Regex.Replace(message, @"\[公告\=([^\]]+)\]", "");
                        //message = DelayMess(message);

                        //发送图片消息
                        var matchs = Regex.Matches(message, @"\[图片\=([^\]]+)\]", RegexOptions.IgnoreCase);
                        foreach (Match match in matchs)
                        {
                            if (isGroup)
                                SendGroupMessage(username, $"[图片={match.Groups[1].Value}/]");
                            else
                            {
                                if (isTemp)
                                    SendTempMessage(username, $"[图片={match.Groups[1].Value}/]");
                                else
                                    SendFriendMessage(username, $"[图片={match.Groups[1].Value}/]");
                            }
                        }
                        message = Regex.Replace(message, @"\[图片\=([^\]]+)\]", "");
                        message = DelayMess(message);

                        //发送语音消息
                        matchs = Regex.Matches(message, @"\[语音\=([^\]]+)\]", RegexOptions.IgnoreCase);
                        foreach (Match item in matchs)
                        {
                            if (isGroup)
                            {
                                var g = QQClient.GetCluster(username);
                                QQClient.SendClusterAudio(g, $"{item.Groups[1].Value}");
                            }
                            else
                            {
                                if (isTemp)
                                {
                                    //SendTempMessage(username, $"[语音={item.Groups[1].Value}/]");
                                }
                                else
                                    QQClient.SendAudio(username, $"{item.Groups[1].Value}");
                            }
                        }
                        message = Regex.Replace(message, @"\[语音\=([^\]]+)\]", "");
                        message = DelayMess(message);
                        matchs = Regex.Matches(message, @"\[视频\=([^\]]+)\]", RegexOptions.IgnoreCase);
                        //foreach (Match item in matchs)
                        //{
                        //    var temp = item.Groups[1].Value;
                        //    if (!File.Exists(temp)) continue;
                        //    if (isGroup)
                        //        SendGroupMessage(username, $"[视频={item.Groups[1].Value}/]");
                        //    else
                        //    {
                        //        if (isTemp)
                        //            SendTempMessage(username, $"[视频={item.Groups[1].Value}/]");
                        //        else
                        //            SendFriendMessage(username, $"[视频={item.Groups[1].Value}]");
                        //    }
                        //}
                        message = Regex.Replace(message, @"\[视频\=([^\]]+)\]", "");
                        message = DelayMess(message);

                        matchs = Regex.Matches(message, @"\[卡片\=([^\]]+)\]", RegexOptions.IgnoreCase);
                        foreach (Match item in matchs)
                        {
                            //SendCard(username, item.Groups[1].Value == "自己" ? User.Username : item.Groups[1].Value);
                        }
                        message = Regex.Replace(message, @"\[卡片\=([^\]]+)\]", "");
                        message = DelayMess(message);
                        if (string.IsNullOrWhiteSpace(message)) continue;
                        if (message.StartsWith("\r\n")) message = message.Substring("\r\n".Length);
                        if (message.StartsWith("\n")) message = message.Substring("\n".Length);

                        //QQchatPack send = new QQchatPack(this);

                        #region 提取艾特用户id

                        //List<string> atWxidList = new List<string>();
                        //var regTmp = Regex.Matches(message, @"(?<全部>\[@(?<账号>[A-Za-z0-9_]+)\])");
                        //foreach (Match item in regTmp)
                        //{
                        //    if (item.Success)
                        //    {
                        //        var name = item.Groups["账号"].Value;
                        //        atWxidList.Add(name);
                        //        var friend = GetContact(name);
                        //        if (friend != null)
                        //            message = message.Replace(item.Groups["全部"].Value, $"@{friend.NickName} ");
                        //    }
                        //}

                        //if (atWxidList.Count != 0)
                        //{
                        //    atUsername = string.Join(",", atWxidList);
                        //}
                        #endregion

                        //var sendData = new { ToUserName = username, Content = message.Trim(), Type = 0, MsgSource = atUsername };
                        //send.SetNextData(new WechatPack.PackMsg() { cmd = WechatCmd.发送文本消息, data = sendData });
                        //RunSendMessageQueue(send);

                        if (isGroup)
                            SendGroupMessage(username, message.Trim());
                        else
                        {
                            if (isTemp)
                                SendTempMessage(username, message.Trim());
                            else
                                SendFriendMessage(username, message.Trim());
                        }
                    }
                    return true;
                }
                catch (Exception ex)
                {
                    this.OnLog("QQSendMessage ERROR:" + ex.Message + "," + ex.StackTrace);
                    return false;
                }
            });
        }

        /// <summary>
        /// 消息延迟
        /// </summary>
        /// <param name="message"></param>
        public string DelayMess(string message)
        {
            try
            {
                message = message.Trim();
                if (message.StartsWith("[延迟="))
                {
                    var reg = Regex.Match(message, @"\[延迟=(\d+)\]");
                    if (reg.Success)
                    {
                        message = Regex.Replace(message, @"\[延迟=(\d+)\]", "").Trim();
                        // this.WriteLog($"需要延迟{reg.Groups[1].Value}秒，再发送：{message}");
                        Thread.Sleep(int.Parse(reg.Groups[1].Value) * 1000);
                    }
                }
            }
            catch (Exception ex)
            { }
            return message;
        }

        /// <summary>
        /// 需要发送的消息队列
        /// </summary>
        //private ConcurrentQueue<QQchatPack> SendMessageQueue { get; set; } = new ConcurrentQueue<QQchatPack>();
        //private object lock_sendmessage = new object();
        //private bool lock_sendmessage_ing = false;
        //Thread SendMessageThread;
        //private DateTime fragmentTime = DateTime.MinValue;
        //private int fragmentCount = 0;

        //private void RunSendMessageQueue(QQchatPack sendPack)
        //{
        //    SendMessageQueue.Enqueue(sendPack);
        //    if (lock_sendmessage_ing) return;

        //    lock (lock_sendmessage)
        //    {
        //        if (lock_sendmessage_ing) return;
        //        lock_sendmessage_ing = true;
        //        ThreadPool.QueueUserWorkItem(x =>
        //        {
        //            try
        //            {
        //                QQchatPack pack = null;
        //                while (SendMessageQueue.TryDequeue(out pack))
        //                {
        //                    if (this.IsLogin)
        //                    {
        //                        pack.SendNextData();

        //                        #region 消息防止频繁,休眠操作
        //                        if (ChatClient.MessFrequentSleepTime != 0)
        //                        {
        //                            fragmentCount++;
        //                            var totalSeconds = (DateTime.Now - fragmentTime).TotalSeconds;//上次休眠的时间差
        //                            bool rest = totalSeconds > 10;
        //                            if (fragmentCount >= 10 && totalSeconds <= 10)
        //                            {
        //                                rest = true;
        //                                Thread.Sleep(ChatClient.MessFrequentSleepTime * 1000);
        //                            }

        //                            if (rest)
        //                            {
        //                                fragmentCount = 1;
        //                                fragmentTime = DateTime.Now;
        //                            }
        //                        }
        //                        #endregion
        //                    }
        //                }
        //            }
        //            catch (Exception)
        //            {
        //            }
        //            finally
        //            {
        //                lock_sendmessage_ing = false;
        //            }
        //        });
        //    }
        //}

    }
}