using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MECF.Framework.Common.Communications;

namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.FlowMeters
{
    public class Usf500NMessage : BinaryMessage
    {
        public byte Address { get; set; }
        public byte FunctionCode { get; set; }
        public byte ReadOutByteNumber { get; set; }

        public byte[] RegisterAddress { get; set; }
        public byte[] WriteData { get; set; }
        public byte[] ReadOutData { get; set; }
    }

    public class Usf500NConnection : SerialPortConnectionBase
    {
        private List<byte> _lstCacheBuffer = new List<byte>();
        public Usf500NConnection(string portName) : base(portName,9600,8, System.IO.Ports.Parity.None, System.IO.Ports.StopBits.One,"\r",false)
        {

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


        protected override MessageBase ParseResponse(byte[] rawMessage)
        {
            _lstCacheBuffer.AddRange(rawMessage);
            byte[] temps = _lstCacheBuffer.ToArray();

            Usf500NMessage msg = new Usf500NMessage();
            msg.IsResponse = false;
            msg.IsAck = false;
            msg.IsComplete = false;
            msg.RawMessage = _lstCacheBuffer.ToArray();

            if (temps.Length < 6) return msg;
            msg.FunctionCode = rawMessage[1];

            if (msg.FunctionCode == 3 || msg.FunctionCode == 4)
            {
                msg.ReadOutByteNumber = temps[2];

                if (temps.Length < 5 + msg.ReadOutByteNumber)
                    return msg;

                msg.ReadOutData = temps.Skip(3).Take(msg.ReadOutByteNumber*2).ToArray();
            }



            if (temps.LastOrDefault() != Calculate_CRC(temps.Take(temps.Length - 2).ToArray())[1]
                || temps[temps.Length - 2] != Calculate_CRC(temps.Take(temps.Length - 2).ToArray())[0])
                return msg;          

            msg.Address = temps[0];
            msg.FunctionCode = temps[1];           

            if (msg.FunctionCode == 6)
            {
                msg.RegisterAddress = temps.Skip(2).Take(2).ToArray();
                msg.WriteData = temps.Skip(4).Take(2).ToArray();

            }

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

            return msg;
        }

        protected override void ActiveHandlerProceedMessage(MessageBase msg)
        {
            base.ActiveHandlerProceedMessage(msg);
        }

        private static byte[] Calculate_CRC(byte[] buffer)
        {
            ushort X = 0xFFFF;

            for (int i = 0; i < buffer.Length; i++)
            {
                int timeNo = 0;

                while (timeNo < 9)
                {
                    timeNo++;

                    X = (ushort)(X ^ buffer[i]);

                    ushort tempValue = (ushort)(X & 1);

                    X = (ushort)(X >> 1);

                    if (tempValue == 1)
                    {
                        X = (ushort)(X ^ 0xA001);
                    }
                }
            }

            return new byte[] {(byte)(X>>8), (byte)(X &0xFF) };


        }

    }
}