using MECF.Framework.Common.Communications;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Lifetime;
using Aitex.Core.RT.Log;

namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.EndPoints.CytEndPoints
{
    public class CytEndPointMessage : BinaryMessage
    {
        public ResponseHeader Header { get; set; }
        public ByteReader DataReader { get; set; }
    }

    public class CytEndPointConnection : TCPPortConnectionBase
    {
        private List<byte> _lstCacheBuffer = new List<byte>();
        private HandlerBase _eventHandler ;
        private object _locker = new object();

        public CytEndPointConnection(string address)
            : base(address, "", false)
        {

        }

        public void SetEventHandler(CytEndPointHandler handler)
        {
            _eventHandler = handler;
        }

        public override bool SendMessage(byte[] message)
        {
            lock (_locker)
            {
                _lstCacheBuffer.Clear();
            }
            return base.SendMessage(message);
        }

        public override void _port_HandleBinarayData(byte[] binaryData)
        {
            MessageBase msg = ParseResponse(binaryData);
            ProceedTransactionMessage(msg);

            lock (_locker)
            {
                while (_lstCacheBuffer.Count > 0)
                {
                    msg = ParseResponse(new byte[0]);
                    if (!msg.IsComplete)
                        break;
                    ProceedTransactionMessage(msg);
                }
            }


        }


        protected override MessageBase ParseResponse(byte[] rawMessage)
        {
            lock (_locker)
            {
                //LOG.Write($"=========ParseResponse, cache length: {_lstCacheBuffer.Count}, receive length: {rawMessage.Length}");

                if (rawMessage != null && rawMessage.Length>0)
                {
                    _lstCacheBuffer.AddRange(rawMessage);
                }
                byte[] temps = _lstCacheBuffer.ToArray();

                CytEndPointMessage msg = new CytEndPointMessage();
                msg.IsResponse = false;
                msg.IsAck = false;
                msg.IsComplete = false;

                if (temps.Length < 14) return msg;

                msg.DataReader = new ByteReader(temps, temps.Length);
                var buf = new byte[ResponseHeader.Size];
                msg.DataReader.ReadBytes(buf, ResponseHeader.Size);
                msg.Header = ByteStructConverter.ToStruct<ResponseHeader>(buf);

                if (msg.Header.command == (byte)EPDCommand.QueryCfgList)
                {
                    if (!msg.DataReader.ReadInt(out int count))
                        return msg;

                    if (msg.DataReader.Length < (14 + 256 * count))
                        return msg;

                    msg.RawMessage = _lstCacheBuffer.Take(14 + 256 * count).ToArray();

                    msg.DataReader.Reset(ResponseHeader.Size);
                    _lstCacheBuffer.RemoveRange(0, 14 + 256 * count);
                    //LOG.Write($"=========msg QueryCfgList, header length: {msg.Header.length}");
                }
                else if (msg.Header.command == (byte)EPDCommand.Event)
                {
                    if (msg.DataReader.Length < (14 + 4 + 8 + 16 + 256))
                        return msg;

                    msg.RawMessage = _lstCacheBuffer.Take(14 + 4 + 8 + 16 + 256).ToArray();

                    msg.DataReader.Reset(ResponseHeader.Size);
                    _lstCacheBuffer.RemoveRange(0, 14 + 4 + 8 + 16 + 256);
                    //LOG.Write($"=========msg Event , header length: {msg.Header.length}");
                }
                else if (msg.Header.command == (byte)EPDCommand.QueryCurrentConfig)
                {
                    if (msg.DataReader.Length < (14 + msg.Header.length))
                        return msg;
                    msg.RawMessage = _lstCacheBuffer.Take(14 + msg.Header.length).ToArray();
                    msg.DataReader.Reset(ResponseHeader.Size);
                    _lstCacheBuffer.RemoveRange(0, 14 + msg.Header.length);
                    //LOG.Write($"=========msg QueryCurrentConfig, header length: {msg.Header.length}");
                }
                else
                {
                    if (msg.DataReader.Length < (14 + msg.Header.length))
                        return msg;
                    msg.RawMessage = _lstCacheBuffer.Take(14 + msg.Header.length).ToArray();
                    msg.DataReader.Reset(ResponseHeader.Size);
                    _lstCacheBuffer.RemoveRange(0, 14 + msg.Header.length);
                    //LOG.Write($"=========msg command {msg.Header.command} , header length: {msg.Header.length}");
                }

                msg.IsResponse = true;
                msg.IsAck = true;
                msg.IsComplete = true;

                msg.IsEvent = msg.Header.command == (int)EPDCommand.Event;

                msg.IsError = msg.Header.errorcode != 0;

                

                return msg;
            }

        }

        protected override void OnEventArrived(MessageBase msg)
        {
            _eventHandler.HandleMessage(msg, out _);
        }
    }
}