DP44/Common/DTS.Common.Serialization/IRIGCH10/Packets/TimePacketFormat2.cs

using DTS.Common.Utilities;
using System;
using System.Collections;

namespace DTS.Serialization.IRIGCH10.Packets
{
    public class TimePacketFormat2 : AbstractDataPacket, IDataPacket
    {
        public DateTime LocalTimeOfFirstSample
        {
            get;
            private set;
        }

        public enum NetworkTimeFormats
        {
            NetworkTimeProtocolVersion3 = 0x00,
            IEEE1588_2002 = 0x01,
            IEEE1588_2008 = 0x02,
            RESERVED
        }
        //bits 7-4
        public NetworkTimeFormats NetworkTimeFormat
        {
            get
            {
                var channelSpecificDataWord = BitConverter.GetBytes(ChannelSpecificDataWord);
                var bits = new BitArray(channelSpecificDataWord);
                var ntf = Utils.Utils.BitArrayToInt32(bits, 4, 7);
                switch (ntf)
                {
                    case 0: return NetworkTimeFormats.NetworkTimeProtocolVersion3;
                    case 1: return NetworkTimeFormats.IEEE1588_2002;
                    case 2: return NetworkTimeFormats.IEEE1588_2008;
                    default: return NetworkTimeFormats.RESERVED;
                }
            }
            set
            {
                var channelSpecificDataWord = BitConverter.GetBytes(ChannelSpecificDataWord);
                var b = new BitArray(channelSpecificDataWord);
                Utils.Utils.SetBits(b, (uint)value, 4, 7);
                var ret = new byte[sizeof(uint)];
                b.CopyTo(ret, 0);
                ChannelSpecificDataWord = BitConverter.ToUInt32(ret, 0);
            }
        }


        public enum TimeStatuses
        {
            TimeNotValid,
            TimeValid,
            Reserved
        }
        //bits 3-0

        public TimeStatuses TimeStatus
        {
            get
            {
                var channelSpecificDataWord = BitConverter.GetBytes(ChannelSpecificDataWord);
                var bits = new BitArray(channelSpecificDataWord);
                var ts = Utils.Utils.BitArrayToInt32(bits, 0, 3);
                switch (ts)
                {
                    case 0: return TimeStatuses.TimeNotValid;
                    case 1: return TimeStatuses.TimeValid;
                    default: return TimeStatuses.Reserved;
                }
            }
            set
            {
                var channelSpecificDataWord = BitConverter.GetBytes(ChannelSpecificDataWord);
                var b = new BitArray(channelSpecificDataWord);
                Utils.Utils.SetBits(b, (uint)value, 0, 3);
                var ret = new byte[sizeof(uint)];
                b.CopyTo(ret, 0);
                ChannelSpecificDataWord = BitConverter.ToUInt32(ret, 0);
            }
        }
        public uint UnsignedSeconds
        {
            get;
            private set;
        }
        public uint UnsignedNanoSeconds
        {
            get;
            private set;
        }

        public string PTPTime
        {
            get; private set;
        }
        private const byte DATA_VERSION_TIME_FORMAT2 = 0x08;
        public TimePacketFormat2(byte sequenceNumber, bool rtcSyncError, int nanoseconds, int seconds, long rtc,
            bool includeSecondaryHeader) : base(Enums.DataFileDataTypes.TimeDataFormat2, includeSecondaryHeader)
        {
            NetworkTimeFormat = NetworkTimeFormats.IEEE1588_2008;
            TimeStatus = rtcSyncError ? TimeStatuses.TimeNotValid : TimeStatuses.TimeValid;
            //CSDW+CRC+TimeData (32 bitsx2)
            var dataLength = Convert.ToUInt32(4 + sizeof(uint) * 2);
            var offset = CommonHeaderWork(1, DATA_VERSION_TIME_FORMAT2, sequenceNumber, rtc, dataLength, nanoseconds, seconds);
            var bytes = BitConverter.GetBytes(seconds);
            Buffer.BlockCopy(bytes, 0, _dataBytes, offset, bytes.Length);
            offset += bytes.Length;
            bytes = BitConverter.GetBytes(nanoseconds);
            Buffer.BlockCopy(bytes, 0, _dataBytes, offset, bytes.Length);
        }
        public TimePacketFormat2(byte[] bytes) : base(bytes)
        {
            var offset = IRIGCH10.PacketHeader.PACKET_HEADER_LENGTH;

            if (PacketHeader.SecondaryHeaderPresent)
            {
                var secondaryHeaderBytes = new byte[SecondaryTimeFormatHeader.SECONDARY_TIME_HEADER_LENGTH];
                Buffer.BlockCopy(bytes, offset,
                    secondaryHeaderBytes, 0, SecondaryTimeFormatHeader.SECONDARY_TIME_HEADER_LENGTH);
                var secondaryHeader = new SecondaryTimeFormatHeader(secondaryHeaderBytes);
                LocalTimeOfFirstSample = secondaryHeader.LocalTime;
                offset += SecondaryTimeFormatHeader.SECONDARY_TIME_HEADER_LENGTH;
            }

            ChannelSpecificDataWord = BitConverter.ToUInt32(bytes, offset);
            offset += sizeof(uint);
            var channelSpecificDataWord = BitConverter.GetBytes(ChannelSpecificDataWord);
            var bits = new BitArray(channelSpecificDataWord);
            var ntf = Utils.Utils.BitArrayToInt32(bits, 4, 7);
            switch (ntf)
            {
                case 0: NetworkTimeFormat = NetworkTimeFormats.NetworkTimeProtocolVersion3; break;
                case 1: NetworkTimeFormat = NetworkTimeFormats.IEEE1588_2002; break;
                case 2: NetworkTimeFormat = NetworkTimeFormats.IEEE1588_2008; break;
                default: NetworkTimeFormat = NetworkTimeFormats.RESERVED; break;
            }
            var ts = Utils.Utils.BitArrayToInt32(bits, 0, 3);
            switch (ts)
            {
                case 0: TimeStatus = TimeStatuses.TimeNotValid; break;
                case 1: TimeStatus = TimeStatuses.TimeValid; break;
                case 2: TimeStatus = TimeStatuses.Reserved; break;
            }

            UnsignedSeconds = BitConverter.ToUInt32(bytes, offset);
            offset += sizeof(uint);
            UnsignedNanoSeconds = BitConverter.ToUInt32(bytes, offset);
            offset += sizeof(uint);
            PTPTime = PTP1588Timestamps.ToDateTimeString((decimal)UnsignedSeconds, (decimal)UnsignedNanoSeconds);
        }
    }
}