using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;

namespace BF
{

#if BF_DEBUG
    public class NetStatistics
    {
        public class SessionPair
        {
            public string ConnectId { get; set; }

            public long CurrentSessionId { get; set; }
            public long OldSessionId { get; set; }

            public long CurrentReceiveDataSeq{ get; set; }
            public long CurrentSendDataSeq{ get; set; }

            private bool enableSendData;
            public bool EnableSendData
            {
                get => enableSendData;
                set
                {
                    if (!enableSendData && value)
                    {
                        DequeueCacheSendMessage(ConnectId);
                    }

                    enableSendData = value;
                }
            }

            private bool enableReceiveData;
            public bool EnableReceiveData
            {
                get => enableReceiveData;
                set
                {
                    if (!enableReceiveData && value)
                    {
                        DequeueCacheReceiveMessage(ConnectId);
                    }

                    enableReceiveData = value;
                }
            }

            internal ConcurrentQueue<NetIncomingMessage> receiveMessageCacheQueues = new ConcurrentQueue<NetIncomingMessage>();
            internal ConcurrentQueue<NetOutgoingMessage> sendMessageCacheQueues = new ConcurrentQueue<NetOutgoingMessage>();
            internal readonly Action<object> receiveCacheCallback;
            internal readonly Action<object> sendCacheCallback;

            public SessionPair(string connectId)
            {
                enableSendData = true;
                enableReceiveData = true;
                ConnectId = connectId;
            }

            public SessionPair(string connectId, Action<object> sendCallback, Action<object> receiveCallback)
            {
                enableSendData = true;
                enableReceiveData = true;
                ConnectId = connectId;

                receiveCacheCallback = receiveCallback;
                sendCacheCallback = sendCallback;
            }

        }

        public static ConcurrentDictionary<string, SessionPair> CurrentSessionIds = new ConcurrentDictionary<string, SessionPair>();

        static NetStatistics()
        {

        }

        public static void RegisterConnect(string connectId, Action<object> sendCallback, Action<object> receiveCallback)
        {
            if (!CurrentSessionIds.TryGetValue(connectId, out var sessionPair))
            {
                sessionPair = new SessionPair(connectId, sendCallback, receiveCallback);
                CurrentSessionIds.TryAdd(connectId, sessionPair);
            }
        }

        public static void UnRegisterConnect(string connectId)
        {
            CurrentSessionIds.TryRemove(connectId, out var sessionPair);
        }

        [Conditional("BF_DEBUG")]
        public static void SetSessionId(string connectId, long sessionId, long oldSessionId)
        {
            if (!CurrentSessionIds.TryGetValue(connectId, out var sessionPair))
            {
                return;
            }

            sessionPair.CurrentSessionId = sessionId;
            sessionPair.OldSessionId = oldSessionId;
        }

        [Conditional("BF_DEBUG")]
        public static void SetReceiveDataSeq(string connectId, long seq)
        {
            if (!CurrentSessionIds.TryGetValue(connectId, out var sessionPair))
            {
                return;
            }

            sessionPair.CurrentReceiveDataSeq = seq;
        }

        [Conditional("BF_DEBUG")]
        public static void SetSendDataSeq(string connectId, long seq)
        {
            if (!CurrentSessionIds.TryGetValue(connectId, out var sessionPair))
            {
                return;
            }

            sessionPair.CurrentSendDataSeq = seq;

        }

        public static bool CheckEnableSendData(string connectId)
        {
            if (!CurrentSessionIds.TryGetValue(connectId, out var sessionPair))
            {
                return true;
            }

            return sessionPair.EnableSendData;
        }

        public static bool CheckEnableReceiveData(string connectId)
        {
            if (!CurrentSessionIds.TryGetValue(connectId, out var sessionPair))
            {
                return true;
            }

            return sessionPair.EnableReceiveData;
        }

        public static void EnqueueCacheReceiveMessage(string connectId, object obj)
        {
            if (!CurrentSessionIds.TryGetValue(connectId, out var sessionPair))
            {
                return;
            }

            sessionPair.receiveMessageCacheQueues.Enqueue(obj as NetIncomingMessage);
        }

        public static void DequeueCacheReceiveMessage(string connectId)
        {
            if (!CurrentSessionIds.TryGetValue(connectId, out var sessionPair))
            {
                return;
            }

            while (sessionPair.receiveMessageCacheQueues.Count > 0)
            {
                var result = sessionPair.receiveMessageCacheQueues.TryDequeue(out var cacheMessage);
                if (result)
                {
                    sessionPair.receiveCacheCallback?.Invoke(cacheMessage);
                }
            }
        }

        public static void EnqueueCacheSendMessage(string connectId, object obj)
        {
            if (string.IsNullOrEmpty(connectId))
            {
                return;
            }

            if (!CurrentSessionIds.TryGetValue(connectId, out var sessionPair))
            {
                return;
            }

            sessionPair.sendMessageCacheQueues.Enqueue(obj as NetOutgoingMessage);
        }

        public static void DequeueCacheSendMessage(string connectId)
        {
            if (string.IsNullOrEmpty(connectId))
            {
                return;
            }

            if (!CurrentSessionIds.TryGetValue(connectId, out var sessionPair))
            {
                return;
            }

            while (sessionPair.sendMessageCacheQueues.Count > 0)
            {
                var result = sessionPair.sendMessageCacheQueues.TryDequeue(out var cacheMessage);
                if (result)
                {
                    sessionPair.sendCacheCallback?.Invoke(cacheMessage);
                }
            }
        }

    }
#endif
}