namespace BF
{
    internal partial class TCPConnection
    {
        private NetSafeQueue<NetIncomingMessage> incomingMessagesPool;
        private NetSafeQueue<NetOutgoingMessage> outgoingMessagePool;

        private void InitializeMessagePools()
        {
            //finally from configuration
            incomingMessagesPool = new NetSafeQueue<NetIncomingMessage>(configuration.MessagePoolCapacity);
            outgoingMessagePool = new NetSafeQueue<NetOutgoingMessage>(configuration.MessagePoolCapacity);
        }

        internal NetOutgoingMessage CreateOutgoingMessage(NetOutgoingMessageType msgType)
        {
            NetOutgoingMessage outgoingMessage = null;
            if (outgoingMessagePool == null || !outgoingMessagePool.TryDequeue(out outgoingMessage))
            {
                outgoingMessage = new NetOutgoingMessage();
            }

            outgoingMessage.Reset();
            outgoingMessage.MessageType = msgType;

            return outgoingMessage;
        }

        internal void Recycle(NetOutgoingMessage message)
        {
            if (outgoingMessagePool == null || message == null)
                return;

            NetException.Assert(outgoingMessagePool.Contains(message) == false, "Recyling already recycled outgoing message! Thread race?");

            message.Reset();
            if (outgoingMessagePool.Count < configuration.MessagePoolCapacity)
            {
                outgoingMessagePool.Enqueue(message);
            }
        }

        #region Incoming message

        internal NetIncomingMessage CreateIncomingMessage(NetIncomingMessageType msgType, byte[] data)
        {
            NetIncomingMessage incomingMessage = null;
            if (incomingMessagesPool == null || !incomingMessagesPool.TryDequeue(out incomingMessage))
            {
                incomingMessage = new NetIncomingMessage(msgType);
            }
            else
            {
                incomingMessage.MessageType = msgType;
            }

            incomingMessage.SetBuffer(data);

            return incomingMessage;
        }

        internal NetIncomingMessage CreateLoggingMessage(NetIncomingMessageType msgType, string message)
        {
            var incomingMessage = CreateIncomingMessage(msgType, null);
            incomingMessage.ErrorMsg = message;
            return incomingMessage;
        }

        private void Recycle(NetIncomingMessage message)
        {
            if (incomingMessagesPool == null || message == null)
                return;

            NetException.Assert(incomingMessagesPool.Contains(message) == false, "Recyling already recycled incoming message! Thread race?");

            message.Reset();
            if (incomingMessagesPool.Count < configuration.MessagePoolCapacity)
            {
                incomingMessagesPool.Enqueue(message);
            }
        }

        #endregion

    }
}