using DTS.Serialization.IRIGCh10.Attributes;
using DTS.Serialization.IRIGCH10.Enums;
using System;
using System.Collections;
using System.ComponentModel;
using System.IO;
using System.Linq;

namespace DTS.Serialization.IRIGCH10
{
    /// <summary>
    /// implements the packet header portion of a packet
    /// </summary>
    public class PacketHeader : IPacketHeader
    {
        /// <summary>
        /// used to indicate the start of a packet, is defined to 0x25, 0xEB by chapter10.pdf
        /// </summary>
        public ushort PacketSyncPattern { get; set; } = BitConverter.ToUInt16(new byte[] { 0x25, 0xEB }, 0);
        /// <summary>
        /// this is just a shortcut to avoid calculating the ushort value for 0x25,0xEB
        /// this is the ushort pattern expected for pattern sync
        /// </summary>
        public const ushort EXPECTED_SYNC_PATTERN = 60197;
        /// <summary>
        /// channel id, default to 0
        /// </summary>
        public ushort ChannelId { get; set; } = BitConverter.ToUInt16(new byte[] { 0x00, 0x00 }, 0);
        /// <summary>
        /// total length of the packet including header, data, and filler, and any checksums
        /// </summary>
        public uint PacketLength { get; set; } = 0;
        /// <summary>
        /// length of the data portion of the packet, so sans filler and checksums
        /// </summary>
        public uint DataLength { get; set; } = 0;
        public byte DataVersion { get; set; } = 0;
        public byte SequenceNum { get; set; } = 0;
        [Browsable(false)]
        public byte PacketFlags { get; private set; } = 0;

        public bool SecondaryHeaderPresent
        {
            get
            {
                var b = new BitArray(new[] { PacketFlags });
                return b.Get(7);
            }
            set
            {
                PacketFlags = SetBit(PacketFlags, 7, value);
            }
        }
        public bool IPTSTimeSource
        {
            get
            {
                var b = new BitArray(new[] { PacketFlags });
                return b.Get(6);
            }
            set
            {
                PacketFlags = SetBit(PacketFlags, 6, value);
            }
        }

        public bool RTCSyncError
        {
            get
            {
                var b = new BitArray(new[] { PacketFlags });
                return b.Get(5);
            }
            set
            {
                PacketFlags = SetBit(PacketFlags, 5, value);
            }
        }
        public enum SecondaryHeaderTimeFormats
        {
            Chapter4 = 0,
            IEEE1588 = 1,
            ExtendedRelativeTimeCounter = 2,
            Reserved = 3
        }
        public SecondaryHeaderTimeFormats SecondaryHeaderTimeFormat
        {
            get
            {
                var b = new BitArray(new[] { PacketFlags });
                return (SecondaryHeaderTimeFormats)Utils.Utils.BitArrayToInt32(b, 2, 3);
            }
            set
            {
                var b = new BitArray(new[] { PacketFlags });
                Utils.Utils.SetBits(b, (uint)value, 2, 3);
                var ret = new byte[1];
                b.CopyTo(ret, 0);
                PacketFlags = ret[0];
            }
        }
        public bool DataOverflowError
        {
            get
            {
                var b = new BitArray(new[] { PacketFlags });
                return b.Get(4);
            }
            set
            {
                PacketFlags = SetBit(PacketFlags, 4, value);
            }
        }

        private byte SetBit(byte input, int bit, bool bVal)
        {
            var b = new BitArray(new[] { input });
            b.Set(bit, bVal);
            var ret = new byte[1];
            b.CopyTo(ret, 0);
            return ret[0];
        }
        public enum DataCheckSumPresences
        {
            NotPresent = 0,
            EightBit = 1,
            SixteenBit = 2,
            ThirtyTwoBit = 3
        }

        public DataCheckSumPresences CheckSumPresence
        {
            get
            {
                var b = new BitArray(new[] { PacketFlags });
                return (DataCheckSumPresences)Utils.Utils.BitArrayToInt32(b, 0, 1);
            }
            set
            {
                var b = new BitArray(new[] { PacketFlags });
                Utils.Utils.SetBits(b, (uint)value, 0, 1);
                var ret = new byte[1];
                b.CopyTo(ret, 0);
                PacketFlags = ret[0];
            }
        }
        [Browsable(false)]
        public byte DataType { get; set; } = 0;

        public DataFileDataTypes DataFileType
        {
            get
            {
                var all = Enum.GetValues(typeof(DataFileDataTypes)).Cast<DataFileDataTypes>().ToArray();
                foreach (var datatype in all)
                {
                    var b = PacketHeaderValueAttribute.GetPacketHeaderValue(datatype);
                    if (b == DataType) { return datatype; }
                }
                return DataFileDataTypes.ComputerGeneratedDataFormat0;
            }
        }

        //10 MHz Relative Time Counter
        [Browsable(false)]
        public byte[] RTC { get; set; } = new byte[6];

        public long RTCLong
        {
            get
            {
                var bytes = new byte[8];
                Buffer.BlockCopy(RTC, 0, bytes, 0, 6);
                return BitConverter.ToInt64(bytes, 0);
            }
        }

        public ushort CheckSum { get; set; }

        /// <summary>
        /// the RealtimeCounter in the packet header is a 6 byte field
        /// for convenience we'll use a long to interact with it
        /// even though we are only using 6 bytes
        /// </summary>
        /// <param name="rtc"></param>
        public void SetRTC(long rtc)
        {
            var bytes = GetRTCBytes(rtc);
            Buffer.BlockCopy(bytes, 0, RTC, 0, RTC.Length);
        }
        private const int RTC_SIZE_BYTES = 6;
        public static byte[] GetRTCBytes(long rtc)
        {
            var s = rtc.ToString("X");
            var buffer = new byte[RTC_SIZE_BYTES];
            for (int i = 0; i < RTC_SIZE_BYTES; i++)
            {
                string sVal = s.Substring(i * 2, 2);
                var val = Convert.ToInt16(sVal, 16);
                buffer[buffer.Length - 1 - i] = BitConverter.GetBytes(val)[0];
            }
            return buffer;
        }
        public PacketHeader(DataFileDataTypes dataType)
        {
            DataType = PacketHeaderValueAttribute.GetPacketHeaderValue(dataType);
        }
        public PacketHeader(byte[] bytes)
        {
            if (null == bytes) { throw new NullReferenceException("no bytes received"); }
            if (PACKET_HEADER_LENGTH != bytes.Length) { throw new Exception($"Expected {PACKET_HEADER_LENGTH} bytes, received: {bytes.Length}"); }
            PacketSyncPattern = BitConverter.ToUInt16(bytes, 0);
            if (PacketSyncPattern != EXPECTED_SYNC_PATTERN)
            {
                System.Diagnostics.Trace.WriteLine("Expected sync pattern not found");
            }
            ChannelId = BitConverter.ToUInt16(bytes, 2);
            PacketLength = BitConverter.ToUInt32(bytes, 4);
            DataLength = BitConverter.ToUInt32(bytes, 8);
            DataVersion = bytes[12];
            SequenceNum = bytes[13];
            PacketFlags = bytes[14];
            DataType = bytes[15];
            RTC = new byte[6];
            Array.Copy(bytes, 16, RTC, 0, 6);
            CheckSum = BitConverter.ToUInt16(bytes, 22);
            var computedCRC = ComputeCheckSum();
            if (CheckSum != computedCRC)
            {
                System.Diagnostics.Trace.WriteLine("Checksum doesn't match");
            }
        }
        public byte[] GetBytes()
        {
            using (var sw = new MemoryStream())
            {
                using (var bw = new BinaryWriter(sw))
                {
                    bw.Write(PacketSyncPattern);
                    bw.Write(ChannelId);
                    bw.Write(PacketLength);
                    bw.Write(DataLength);
                    bw.Write(DataVersion);
                    bw.Write(SequenceNum);
                    bw.Write(PacketFlags);
                    bw.Write(DataType);
                    bw.Write(RTC);
                    bw.Write(ComputeCheckSum());
                }
                return sw.ToArray();
            }
        }

        public void SetDataVersion(DataTypeVersion version)
        {
            DataVersion = PacketHeaderValueAttribute.GetPacketHeaderValue(version);
        }

        public void SetPacketFlags(bool SecondaryHeaderPresent,
            bool SecondaryHeaderTime,
            bool RTCSyncerror,
            bool DataOverflow,
            SecondaryHeaderTimeFormat fmt,
            DataCheckSumType checkSum
        )
        {
            var bitArray = new BitArray(new[] { PacketFlags });

            bitArray[7] = SecondaryHeaderPresent;
            bitArray[6] = SecondaryHeaderTime;
            bitArray[5] = RTCSyncerror;
            bitArray[4] = DataOverflow;

            var byteValue = new BitArray(new[] { PacketHeaderValueAttribute.GetPacketHeaderValue(fmt) });
            bitArray[3] = byteValue[0];
            bitArray[2] = byteValue[1];

            byteValue = new BitArray(new[] { PacketHeaderValueAttribute.GetPacketHeaderValue(checkSum) });
            bitArray[1] = byteValue[0];
            bitArray[0] = byteValue[1];
            var bytes = new byte[1];
            bitArray.CopyTo(bytes, 0);
            PacketFlags = bytes[0];
        }

        public ushort ComputeCheckSum()
        {
            byte[] bytesToCompute;
            using (var ms = new MemoryStream())
            {
                using (var bw = new BinaryWriter(ms))
                {
                    bw.Write(PacketSyncPattern);
                    bw.Write(ChannelId);
                    bw.Write(PacketLength);
                    bw.Write(DataLength);
                    bw.Write(DataVersion);
                    bw.Write(SequenceNum);
                    bw.Write(PacketFlags);
                    bw.Write(DataType);
                    bw.Write(RTC);
                }
                bytesToCompute = ms.ToArray();
            }
            return Utils.Utils.GetCheckSum16(bytesToCompute);
        }
        public const int PACKET_HEADER_LENGTH = 24;
    }

    public interface IPacketHeader
    {
        ushort PacketSyncPattern { get; set; }
        ushort ChannelId { get; set; }
        uint PacketLength { get; set; }
        uint DataLength { get; set; }
        byte DataVersion { get; set; }
        byte SequenceNum { get; set; }
        [Browsable(false)]
        byte PacketFlags { get; }

        bool SecondaryHeaderPresent { get; set; }
        bool IPTSTimeSource { get; set; }

        bool RTCSyncError { get; set; }

        PacketHeader.SecondaryHeaderTimeFormats SecondaryHeaderTimeFormat { get; set; }

        bool DataOverflowError { get; set; }

        PacketHeader.DataCheckSumPresences CheckSumPresence { get; set; }


        [Browsable(false)]
        byte DataType { get; set; }
        DataFileDataTypes DataFileType { get; }
        [Browsable(false)]
        byte[] RTC { get; set; }
        long RTCLong { get; }
        ushort CheckSum { get; set; }
        void SetRTC(long rtc);

        void SetDataVersion(DataTypeVersion version);

        void SetPacketFlags(bool SecondaryHeaderPresent,
            bool SecondaryHeaderTime,
            bool RTCSyncerror,
            bool DataOverflow,
            SecondaryHeaderTimeFormat fmt,
            DataCheckSumType checkSum
        );

        byte[] GetBytes();
        ushort ComputeCheckSum();
    }
}