using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using Facebook.MiniJSON;
using ThinkingAnalytics;

namespace BF
{
    internal partial class TCPChannel
    {
        private const uint Reconnect_Req_Group = 1068769299;
        private const uint Reconnect_Rsp_Group = 1068771132;
        private const byte Reconnect_Req_Cmd = 0;
        private const int Reconnect_Rsp_OK = 0;

        private enum SmartReconnectStatus
        {
            None,
            Countdown,
            TryReconnect,
        }

        private readonly object mSmartReconnectLock = new object();

        /// <summary>
        /// 缓存一定数量已经发送的消息，为重连成功后，重发发送失败的数据包
        /// </summary>
        private NetSafeQueue<NetOutgoingMessage> alreadySendMessagesQueue;
        private Stack<NetOutgoingMessage> alreadySendExchangeStack;

        /// <summary>
        /// 缓存重连期间，所有的外部发送消息；重连成功后，继续发送
        /// </summary>
        private Queue<NetOutgoingMessage> waitingSendMessagesQueue;

        /// <summary>
        /// 记录尝试重连的次数
        /// </summary>
        private int tryReconnectCount = 0;

        /// <summary>
        /// 用于区分是外部调用的重连逻辑，还是内部自动重连逻辑
        /// </summary>
        private bool internalReconnectFlag = true;

        #region Smart Reconnect

        private float smartReconnectInterval = 5;
        private double lastSmartStartTime = 0;
        private SmartReconnectStatus smartStatus;

        #endregion

        private void InitializeReconnect()
        {
            int cacheSize = ownerConnection.configuration.AlreadySendMessageCacheCount;
            alreadySendMessagesQueue = new NetSafeQueue<NetOutgoingMessage>(cacheSize);
            alreadySendExchangeStack = new Stack<NetOutgoingMessage>();
            waitingSendMessagesQueue = new Queue<NetOutgoingMessage>(cacheSize);
            internalReconnectFlag = true;
        }

        /// <summary>
        /// 连接成功后，调用，重置重连信息
        /// </summary>
        private void ResetTryReconnectCount()
        {
            tryReconnectCount = 0;
            internalReconnectFlag = true;
        }

        /// <summary>
        /// 重连失败后，调用
        /// </summary>
        private void TryReconnectFailed()
        {
            if (connectContext != NetConnectContext.Reconnect)
            {
                return;
            }

        }

        /// <summary>
        /// 尝试重连，达到最大重连次数后，通知应用层
        /// </summary>
        private bool TryReconnect()
        {
            if (!ownerConnection.configuration.EnableSilenceReconnect)
            {
                SetConnectContext(NetConnectContext.Invalid);
                Disconnect();
                LogError(NetErrorCode.PeerDisconnect, "TryReconnect, Disable silence reconnect, connect disconnect !!!");
                return false;
            }

            // 必须在玩家连接成功后，重连才有意义；否则直接失败！！
            if (visibleStatus != NetConnectStatus.Connected)
            {
                SetConnectContext(NetConnectContext.Invalid);
                Disconnect();
                LogError(NetErrorCode.PeerDisconnect, "TryReconnect, visibleStatus is connected, connect disconnect !!!");
                return false;
            }

            if (connectContext == NetConnectContext.Reconnect)
            {
                var now = NetTime.Now;
                if (tryReconnectCount >= ownerConnection.configuration.AutoReconnectCount)
                {
                    SetConnectContext(NetConnectContext.Invalid);
                    Disconnect();
                    ResetTryReconnectCount();
                    LogError(NetErrorCode.PeerDisconnect, "Try reconnect failed, channel disconnect.");
                    return false;
                }
            }

            // BFLog.Log($"Begin try reconnect : {tryReconnectCount}");

            PrepareReconnect();

            return true;
        }

        /// <summary>
        /// 重置状态，准备重连
        /// </summary>
        private void PrepareReconnect()
        {
            //进入重连上下文
            SetConnectContext(NetConnectContext.Reconnect);

            //断开现有连接
            Disconnect();

            //缓存已经在sendMessageQueue中的消息，并清空sendMessageQueue；等待重连成功后，再继续发送
            CacheAlreadyInSendMessageQueueMessage(sendMessageQueue);
            //清除上一个TCP连接的发送接受消息队列，不要继续发送接受数据；等待重连成功后再次进行收发数据
            ClearSendReceiveMessageQueue();
        }

        /// <summary>
        /// 重连，创建新连接
        /// </summary>
        private void TryConnectNewConnect()
        {
            if (connectContext != NetConnectContext.Reconnect || actualStatus != NetConnectStatus.Disconnected)
            {
                return;
            }

            tryReconnectCount += 1;

            //开始新的连接
            ConnectInternalAsync();
        }

        /// <summary>
        /// 检测收到的消息是否是重连消息
        /// </summary>
        /// <param name="incomingMessage"></param>
        /// <returns>true: 是重连消息；false: 其他消息</returns>
        private bool FilterReconnectIncomingMessage(NetIncomingMessage incomingMessage)
        {
            if (connectContext != NetConnectContext.Reconnect)
            {
                return false;
            }

            if (incomingMessage.Group != Reconnect_Rsp_Group)
            {
                return false;
            }

            actualStatus = NetConnectStatus.Decoding2;
            visibleStatus = NetConnectStatus.Decoding2;
            incomingMessage.MessageType = NetIncomingMessageType.StatusChange;
            incomingMessage.ConnectStatus = NetConnectStatus.Decoding2;
            ReleaseMessage(incomingMessage);
            decoding = false;
            return true;
        }

        private bool FilterReconnectIncomingMessage2()
        {
            var isSuccess = DeserializeReconnectRsp(out var status, out var seqCs);
            if (!isSuccess)
            {
                SetActualStatus(NetConnectStatus.Unauthorized);
                return true;
            }

            if (status != Reconnect_Rsp_OK)
            {
                SetActualStatus(NetConnectStatus.Unauthorized);
                return true;
            }

            //检查等待重新发送的消息
            ResendMissingOutgoingMessage(seqCs);

            // BFLog.Log($"End try reconnect : {tryReconnectCount}, success !!!");

            ResetTryReconnectCount();
            ResetSmartReconnect();
            SetConnectContext(NetConnectContext.NewConnect);
            SetActualStatus(NetConnectStatus.Connected);
            ResetConnectTimeout();
            ResetHeartBeatStatus();
            // ResetOldSessionRc4Key();

            ForceSendHeartBeatImmediately();
            if(ownerConnection.UniqueIdentifier.CompareTo(BF.NetManager.MAIN_SOCKET_NAME) == 0)
            {
                BF.BFMain.Instance.NetMgr.decodeFinish = false;
            }
            else
            {
                BF.BFMain.Instance.NetMgr.decodeChatFinish = false;
            }

            return true;
        }

        /// <summary>
        /// 重连成功后，重新发送丢失的消息
        /// </summary>
        /// <param name="serverReceiveSeq">服务器接受到的最大 Seq</param>
        private void ResendMissingOutgoingMessage(long serverReceiveSeq)
        {
            BFLog.Log($"ResendMissingOutgoingMessage : serverReceiveSeq = {serverReceiveSeq}, sendMessageQueue = {sendMessageQueue.Count}");

            List<INetOutgoingMessage> pendingResendMessages = new List<INetOutgoingMessage>();

            alreadySendExchangeStack.Clear();
            while (alreadySendMessagesQueue.Count > 0)
            {
                alreadySendMessagesQueue.TryDequeue(out var outgoingMessage);
                if (outgoingMessage.Seq <= serverReceiveSeq)
                {
                    ownerConnection.Recycle(outgoingMessage);
                    continue;
                }
                // seq为0的一定是重连后发送的第一条loginReq,除此以外的消息添加到发送队列
                if (outgoingMessage.Seq != 0 && outgoingMessage.Group != HeartBeat_Req_Group)
                {
                    pendingResendMessages.Add(outgoingMessage);
                }
            }

            while (waitingSendMessagesQueue.Count > 0)
            {
                var outgoingMessage = waitingSendMessagesQueue.Dequeue();
                //添加到发送队列
                pendingResendMessages.Add(outgoingMessage);

                // BFLog.Log($"ResendMissingOutgoingMessage waitingSendMessagesQueue : {outgoingMessage.Group}, {outgoingMessage.Cmd}, {outgoingMessage.Seq}");
            }

            List<List<byte>> msgsPack = new List<List<byte>>();
            foreach (NetOutgoingMessage message in pendingResendMessages)
            {
                // byte[] data = messageService.SerializeRaw(message);
                // msgsPack.Add(data.ToList());
                for (int index = 0; index < message.Data.Length; ++ index)
                {
                    if (message.Data[index] == 0)
                    {
                        message.PackDataLength = index;
                        break;
                    }
                }
                byte[] data = new byte[message.PackDataLength];
                Array.Copy(message.Data, data, message.PackDataLength);

                BFLog.Log($"ResendMissingOutgoingMessage SerializeRaw : {message.Group}, {message.Cmd}, {message.Seq}");
                var outgoingMsg = ownerConnection.CreateOutgoingMessage(NetOutgoingMessageType.UserData);
                outgoingMsg.Encode(message.Group, message.Cmd, data);
                outgoingMsg.Seq = message.Seq;
                EnqueueRawSendMessage(outgoingMsg);
                // BFLog.Log("==================================== message.PackDataLength = " + message.PackDataLength.ToString());
                // int min = Math.Min(message.PackDataLength, 10);
                // for (int index = 0; index < min; ++ index)
                // {
                //     BFLog.Log("message.Data[{0}] = {1}", index, message.Data[index]);
                // }
                // BFLog.Log("==================================== message.Data.Length = " + message.Data.Length.ToString());
            }
        }

        /// <summary>
        /// 发送重连请求
        /// </summary>
        private void SendReconnectMessage()
        {
            if (connectContext != NetConnectContext.Reconnect)
            {
                return;
            }

            // var reconnectReq = SerializeReconnectReq();
            var outgoingMsg = ownerConnection.CreateOutgoingMessage(NetOutgoingMessageType.UserData);
            var bytes = BF.BFMain.Instance.NetMgr.GetLoginReqData();
            outgoingMsg.Encode(Reconnect_Req_Group, Reconnect_Req_Cmd, bytes);
            // BFLog.Log("===============  SendReconnectMessage");
            EnqueueRawSendMessage(outgoingMsg);
        }

        /// <summary>
        /// @TODO Temp
        /// </summary>
        /// <returns></returns>
        private bool DeserializeReconnectRsp(out long status, out long seqCs)
        {
            // BFLog.Log("==================================== DeserializeReconnectRsp");
            string pbData;
            if(ownerConnection.UniqueIdentifier.CompareTo(BF.NetManager.MAIN_SOCKET_NAME) == 0)

            {
                pbData = BF.BFMain.Instance.NetMgr.GetDecodePbStr();
            }
            else
            {
                pbData = BF.BFMain.Instance.NetMgr.GetDecodeChatPbStr();
            }
            Dictionary<string, object> dict = Json.Deserialize(pbData) as Dictionary<string, object>;
            // BFLog.Log("==================================== DeserializeReconnectRsp  pbData = " + pbData);
            // BFLog.Log("==================================== DeserializeReconnectRsp  status = " + (long)dict["status"]);
            // BFLog.Log("==================================== DeserializeReconnectRsp  send_id = " + (long)dict["send_id"]);

            status = (long)dict["status"];
            seqCs = (long)dict["send_id"];
            return status == 0;
        }

        #region Reconnect message sync

        private bool FilterMissingDataSyncIncomingMessage(NetIncomingMessage incomingMessage)
        {
            if (incomingMessage.Group != 0 || incomingMessage.CMD != 3)
            {
                return false;
            }

            var isSuccess = DeserializeMissingMessageSync(incomingMessage.Data, out var missingReceiveData);
            if (!isSuccess)
            {
                //重连消息解析失败，判定为重连不成功，不做任何其他处理，继续等待到连接超时；
                return true;
            }

            //接收到补发消息，解析协议后，直接release
            foreach (var receiveData in missingReceiveData)
            {
                var incomingMsg = ownerConnection.CreateIncomingMessage(NetIncomingMessageType.Data, receiveData);
                messageService.DeserializeRaw(incomingMsg, receiveSeq);
                ReleaseMessage(incomingMsg);

                // BFLog.Log($"FilterMissingDataSyncIncomingMessage: {incomingMsg.Group}, {incomingMsg.CMD}, {incomingMsg.Seq}");
            }

            //reconnect success
            ResetTryReconnectCount();
            ResetSmartReconnect();
            SetConnectContext(NetConnectContext.NewConnect);
            SetActualStatus(NetConnectStatus.Connected);
            ResetConnectTimeout();
            ResetHeartBeatStatus();
            ResetOldSessionRc4Key();

            ForceSendHeartBeatImmediately();

            return true;
        }

        private bool DeserializeMissingMessageSync(byte[] data, out List<byte[]> missingReceiveData)
        {
            missingReceiveData = new List<byte[]>();

            string syncString = Encoding.UTF8.GetString(data);
            Dictionary<string, object> syncObj = Json.Deserialize(syncString) as Dictionary<string, object>;
            if (syncObj == null)
            {
                return false;
            }

            if (syncObj.Count <= 0)
            {
                return true;
            }

            List<object> packArray = (List<object>)syncObj["pack"];
            foreach (var pack in packArray)
            {
                missingReceiveData.Add(Encoding.UTF8.GetBytes((string)pack));
            }

            return true;
        }

        private byte[] SerializeMissingMessageSync( List<List<byte>> missingMessageData)
        {
            Dictionary<string, object> syncMessageDic = new Dictionary<string, object>();
            syncMessageDic["pack"] = missingMessageData;

            string syncString = Json.Serialize(syncMessageDic);
            byte[] syncData = Encoding.UTF8.GetBytes(syncString);

            return syncData;
        }

        #endregion

        #region Smart Reconnect

        private void HandleSocketError(SocketError socketError, string errorMessage)
        {
            switch (socketError)
            {
                case SocketError.Shutdown:
                case SocketError.NetworkDown:
                case SocketError.NetworkReset:
                case SocketError.TimedOut:
                case SocketError.ConnectionReset:
                case SocketError.ConnectionAborted:
                case SocketError.NetworkUnreachable:
                    // StartSmartReconnectCountdown();
                    break;

                default:
                    break;
            }

            LogError($"socketError = {(int)socketError}, {errorMessage}");
        }

        private void StartSmartReconnectCountdown()
        {
            // BFLog.Log($"StartSmartReconnectCountdown call...");

            lock (mSmartReconnectLock)
            {
                if (!ownerConnection.configuration.EnableSilenceReconnect)
                {
                    if (socket == null)
                    {
                        //已经调用Disconnect()断开了连接，不要再次抛出异常消息
                        // BFLog.Log($"Disconnect() already call...");
                        return;
                    }

                    SetConnectContext(NetConnectContext.Invalid);
                    Disconnect();
                    LogError(NetErrorCode.PeerDisconnect, "Disable silence reconnect, connect disconnect !!!");
                    return;
                }

                if (smartStatus == SmartReconnectStatus.Countdown)
                {
                    return;
                }

                //进入重连状态
                if (TryReconnect())
                {
                    smartReconnectInterval =
                        ownerConnection.configuration.ReconnectBaseInterval * (tryReconnectCount + 1);
                    lastSmartStartTime = NetTime.Now;
                    SetSmartReconnectStatus(SmartReconnectStatus.Countdown);

                    // BFLog.Log($"SmartReconnectStatus.Countdown : {smartReconnectInterval}");
                }
                else
                {
                    ResetSmartReconnect();
                }
            }
        }

        /// <summary>
        /// 重连成功后后，调用
        /// </summary>
        private void ResetSmartReconnect()
        {
            SetSmartReconnectStatus(SmartReconnectStatus.None);
            smartReconnectInterval = ownerConnection.configuration.ReconnectBaseInterval;
        }

        private void SetSmartReconnectStatus(SmartReconnectStatus newStatus)
        {
            smartStatus = newStatus;
        }

        private void UpdateSmartReconnect()
        {
            if (smartStatus != SmartReconnectStatus.Countdown)
            {
                return;
            }

            if (NetTime.Now - lastSmartStartTime < smartReconnectInterval)
            {
                return;
            }

            SetSmartReconnectStatus(SmartReconnectStatus.TryReconnect);

            TryConnectNewConnect();
        }

        #endregion

    }
}