using System;
using System.Collections.Generic;
using System.Text;
using Facebook.MiniJSON;

namespace BF
{
    internal partial class TCPChannel
    {
        private const uint Auth_Req_Group = 3607879254;
        private const uint Auth_Rsp_Group = 3607881087;
        private const uint Chat_Auth_Req_Group = 1770455238;
        private const uint Chat_Auth_Rsp_Group = 1770457071;
        private const byte Auth_Req_Cmd = 0;
        private const int Auth_Rsp_OK = 0;

        /// <summary>
        /// 检测接收的消息是否是心跳包
        /// </summary>
        /// <param name="incomingMessage"></param>
        /// <returns>true: 是心跳包；false: 其他消息</returns>

        private bool FilterAuthIncomingMessage(NetIncomingMessage incomingMessage)
        {
            if (incomingMessage.Group != Auth_Rsp_Group && incomingMessage.Group != Chat_Auth_Rsp_Group)
            {
                return false;
            }

            actualStatus = NetConnectStatus.Decoding;
            visibleStatus = NetConnectStatus.Decoding;
            // BFLog.Log("actualStatus = " + actualStatus + "visibleStatus = " + visibleStatus);
            incomingMessage.MessageType = NetIncomingMessageType.StatusChange;
            incomingMessage.ConnectStatus = NetConnectStatus.Decoding;
            ReleaseMessage(incomingMessage);
            decoding = false;
            return true;
        }

        private bool FilterAuthIncomingMessage2()
        {
            var isSuccess = DeserializeAuthRsp(out var status);
            if (!isSuccess)
            {
                SetActualStatus(NetConnectStatus.Unauthorized);
                return true;
            }

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

            if (connectContext == NetConnectContext.Reconnect)
            {
                SetActualStatus(NetConnectStatus.Reconnecting);
                SendReconnectMessage();
            }
            else
            {
                ownerConnection.ChannelConnectVerifySuccess(this);
                SetActualStatus(NetConnectStatus.Connected);
                ResetConnectTimeout();
                ForceSendHeartBeatImmediately();
            }
            return true;
        }

        private void SendAuthMessage()
        {
            if(this.ownerConnection.UniqueIdentifier.CompareTo(BF.NetManager.MAIN_SOCKET_NAME) == 0)
            {
                var outgoingMsg = ownerConnection.CreateOutgoingMessage(NetOutgoingMessageType.UserData);
                var bytes = BF.BFMain.Instance.NetMgr.GetAuthReqData();
                outgoingMsg.Encode(Auth_Req_Group, Auth_Req_Cmd, bytes);
                EnqueueRawSendMessage(outgoingMsg);
            }
            else
            {
                var outgoingMsg = ownerConnection.CreateOutgoingMessage(NetOutgoingMessageType.UserData);
                var bytes = BF.BFMain.Instance.NetMgr.GetChatAuthReqData();
                outgoingMsg.Encode(Chat_Auth_Req_Group, Auth_Req_Cmd, bytes);
                EnqueueRawSendMessage(outgoingMsg);
            }
        }

        /// <summary>
        /// @TODO Temp
        /// </summary>
        /// <returns></returns>
        private byte[] SerializeAuthReq()
        {
            byte[] data = {};

            return data;
        }

        /// <summary>
        /// @TODO Temp
        /// </summary>
        /// <param name="incomingMessage"></param>
        /// <param name="status"></param>
        /// <returns></returns>
        private bool DeserializeAuthRsp(out long status)
        {
            string pbData = BF.BFMain.Instance.NetMgr.GetDecodePbStr();
            Dictionary<string, object> dict = Json.Deserialize(pbData) as Dictionary<string, object>;

            status = (long)dict["status"];

            return status == 0;
        }
    }
}