using System;
using System.Collections.Generic;
using System.Globalization;
using Xylem.Common.Hardware.WaterMeter.Genesis.DataPackages.MeasurementRecords;
using Xylem.Common.Utils.Crc16Ccitt;


// ReSharper disable UnusedMember.Local

namespace Xylem.Common.Hardware.WaterMeter.Genesis.Protocols.StreamingProtocol
{
    /// <summary>
    ///     Data fields and definitions for GENESIS streaming protocol
    /// </summary>
    public class StreamingDecoder
    {
        private const Double MilliLitersToQmFactor = 1.0E-6;
        private const Double DefaultVolumeScaleRawPerMl = 1024.0;
        private const Double DefaultVolumeFactorRawToQm = MilliLitersToQmFactor /
            DefaultVolumeScaleRawPerMl;
        private const Double MaxAccuVolumeRaw = 0x100000000; //2^32
        private const Double DefaultAccuDutOverflowVolumeCm = MaxAccuVolumeRaw *
            DefaultVolumeFactorRawToQm;

        private const Double CpuTimeToSecondsFactor = 1.0 / 0x10000;
        private const Double CpuTimeOverflowS = 0x100000000 * CpuTimeToSecondsFactor;
        private const Double DisplayMlSetupDutOverflowVolumeCm = 1000.0; //overflow of LCD if set to ml
        private const Double TofToSecondsFactor38Bit = 1.0 / 0x4000000000; // 2^38
        private const Double AmplitudeToVoltFactor = 1.0 / 0x400000 / 1000.0; // 2^22
        private const Double PulseWidthToRelFactor = 1.0 / 0x100; // 2^8
        private const UInt16 IsValidProtG = 1;
        private const UInt16 IsValidProtH = 0;
        private CalibrationRecord _dataCalibRec;

        /// <summary>
        ///     Default data for
        /// </summary>
        private readonly FlowTestRecord _dataDefault = new FlowTestRecord
        {
            VolumeCm = 0.0,
            OverflowVolumeCm = DisplayMlSetupDutOverflowVolumeCm,
            TimeS = 0.0,
            OverflowTimeS = CpuTimeOverflowS,
            Crc = 0xFFFF,
            IsValid = false
        };

        private readonly CalibrationRecord _rawDataDefault = new CalibrationRecord
        {
            Channel = 0,
            Validation = 0xFFFF,
            TotalTimeOfFlightS = 0.0,
            DeltaTimeOfFlightS = 0.0,

            VolumeScaleRawPerMl = DefaultVolumeScaleRawPerMl,
            VolumeFactorRawToQm = DefaultVolumeFactorRawToQm,
            DeltaVolumeRaw = 0.0,
            DeltaVolumeQm = 0.0,
            AccuVolumeRaw = 0.0,
            VolumeCm = 0.0,
            OverflowVolumeCm = DefaultAccuDutOverflowVolumeCm,

            SampleIntervalS = 0.0,
            AmplitudeUpV = 0.0,
            AmplitudeDownV = 0.0,
            PulseWidthRatioUp = 0.0,
            PulseWidthRatioDown = 0.0,
            TemperatureRaw = 20.0,
            TemperaturePowFactor = 1.0,
            TemperatureDegC = 20.0,
            TimeS = 0.0,
            OverflowTimeS = CpuTimeOverflowS,
            Crc = 0xFFFF,
            IsValid = false
        };

        private readonly FlowTestRecord _dataFlowTestRec;

        private String _rawMsgForCrc;
        /// <summary>
        ///     Calibration data
        /// </summary>
        public CalibrationRecord DataCalib = new CalibrationRecord();
        private readonly Boolean _ignoreCorruptedData;

        /// <summary>
        ///     Constructor initializes all decoded members with default values
        /// </summary>
        public StreamingDecoder(Boolean ignoreCorruptedData = true)
        {
            _dataFlowTestRec = _dataDefault;
            _dataCalibRec = _rawDataDefault;
            _ignoreCorruptedData = ignoreCorruptedData;
        }

        /// <summary>
        ///     Flow test data
        /// </summary>
        public FlowTestRecord DataFlowTest { get; private set; }

        /// <summary>
        ///     Decoding the raw message
        /// </summary>
        /// <param name="rawMsg">message received as one line delimited with LF</param>
        /// <returns>true if decoding was successful and data has been validated</returns>
        public Boolean DecodeMsg(String rawMsg)
        {
            var isSuccessfulDecoded = false;
            try
            {
                // save the raw message for CRC calculation before separation to fields
                _rawMsgForCrc = rawMsg;
                // extract message and split it to fields


                //Dn 50
                //2022-07-21 07:22:06.9871 | @f 8497D 062E4216 9B2A 
                //2022-07-21 07:22:06.9871 | @h 1 0 0A1F59C4 00017A43 00115C45 72E1596B 00000400 00001998 7D91B652 7D4F37E6 000191E6 0C 062E4A9C 5331 
                //2022-07-21 07:22:07.0171 | @h 2 0 0A1B1FE8 00017B7F 00116B56 72B77427 00000400 0000199A 7DC09688 7B570006 000191E6 0C 062E5326 95BD 
                //rawMsg = "@h 3 0 0A1DF1D5 00017EA8 00118037 741F80F3 00000400 00001998 7E58A62E 7CC2C606 000191E6 0C 062E5BAE D40E"; 
                //DN80
                //                2022-04-28 15:19:54.9167 | @f AA754B 4D0CEE78 5D89 
                //2022-04-28 15:19:54.9337 | @h 1 0 0EF4A130 0002AAB8 000DAC8C 02B98FBD 00000200 00000FFC 643BCF30 63C9CFF6 00015096 0C 4D0CF3CC 3E87 
                //2022-04-28 15:19:54.9497 | @h 2 0 0EFA3000 000283E7 000CE580 E3D5EFFA 00000200 00001000 6DC0A84E 6CD462C2 00015096 0C 4D0CF922 1646 
                //2022-04-28 15:19:54.9627 | @h 3 0 0EFF7F91 0002AC39 000DB43D FE1C0254 00000200 00000FFE 6C932DE6 6D20005D 00015096 0C 4D0CFE76 868A 
                //2022-04-28 15:19:54.9787 | @f AA7C01 4D0CFE76 B08F 
                // rawMsg = "@h 3 0 0EFF7F91 0002AC39 000DB43D FE1C0254 00000200 00000FFE 6C932DE6 6D20005D 00015096 0C 4D0CFE76 868A ";

                rawMsg = rawMsg.Replace('\n', ' ');
                var field = rawMsg.Split(' ');

                switch (field[0])
                {
                    case "@f":
                        isSuccessfulDecoded = DecodeProtocolF(field);
                        if (isSuccessfulDecoded || !_ignoreCorruptedData)
                        {
                            DataFlowTest = _dataFlowTestRec;
                        }

                        break;
                    case "@g":
                        {
                            isSuccessfulDecoded = DecodeProtocolG(ref _dataCalibRec, field);
                            if (isSuccessfulDecoded || !_ignoreCorruptedData)
                            {
                                DataCalib = _dataCalibRec;
                            }

                            break;
                        }
                    case "@h":
                        {


                            isSuccessfulDecoded = DecodeProtocolH(ref _dataCalibRec, field);
                            if (isSuccessfulDecoded || !_ignoreCorruptedData)
                            {
                                DataCalib = _dataCalibRec;
                            }

                            break;
                        }
                }
            }
            catch (Exception)
            {
                // ignored
            }
            return isSuccessfulDecoded;
        }

        /// <summary>
        ///     Extracting message from string fields for protocol 'f'
        /// </summary>
        /// <param name="field">Separated fields containing the measurement as string</param>
        /// <returns></returns>
        private Boolean DecodeProtocolF(IList<String> field)
        {
            _dataFlowTestRec.DecodedTime = DateTimeOffset.UtcNow;
            _dataFlowTestRec.IsValid = true;
            //extract bytes of raw message for CRC calculation each character removing CRC (4 char)
            var byteArraySize = _rawMsgForCrc.Length - 4;
            var byteArray = new Byte[byteArraySize];
            for (var i = 0; i < byteArraySize; i++)
            {
                byteArray[i] = (Byte)_rawMsgForCrc[i];
            }

            _rawMsgForCrc = null;
            var calculatedCrc = Crc16Ccitt.CalculateMsb1021(byteArray);

            //extract received CRC
            _dataFlowTestRec.Crc = ushort.Parse(field[(Int32)ProtFsubString.Crc],
                NumberStyles.HexNumber);
            //compare received with calculated CRC
            if (calculatedCrc != _dataFlowTestRec.Crc)
            {
                _dataFlowTestRec.IsValid = false;
                return false;
            }
            _dataFlowTestRec.IsValid = true;
            //build result values, the display volume can be positive or negative!
            _dataFlowTestRec.VolumeCm = int.Parse(field[(Int32)ProtFsubString.DisplayVolume],
                                               NumberStyles.AllowHexSpecifier) * MilliLitersToQmFactor;
            _dataFlowTestRec.TimeS = uint.Parse(field[(Int32)ProtFsubString.CpuTime],
                                            NumberStyles.AllowHexSpecifier) * CpuTimeToSecondsFactor;
            return _dataFlowTestRec.IsValid;
        }

        /// <summary>
        ///     Extracting message from string fields to individual raw channel for protocol 'g'
        /// </summary>
        /// <param name="dataProtGRec">Reference to result structure for raw data for one channel</param>
        /// <param name="field">Separated fields containing the measurement as string</param>
        /// <returns>true if protocol is valid</returns>
        /// <remarks date="2018-Mar-22" author="T.Wiedebusch">
        /// - Usage of VolumeFactorRawToQm and calculation of AccuDutOverflowVolumeCm
        /// </remarks>
        private Boolean DecodeProtocolG(ref CalibrationRecord dataProtGRec, IList<String> field)
        {
            dataProtGRec.DecodedTime = DateTimeOffset.UtcNow;
            dataProtGRec.IsValid = false;

            //extract bytes of raw message for CRC calculation each character removing CRC (4 char)
            var byteArraySize = _rawMsgForCrc.Length - 4;
            var byteArray = new Byte[byteArraySize];
            for (var i = 0; i < byteArraySize; i++)
            {
                byteArray[i] = (Byte)_rawMsgForCrc[i];
            }

            _rawMsgForCrc = null;
            var calculatedCrc = Crc16Ccitt.CalculateMsb1021(byteArray);

            //extract received CRC
            dataProtGRec.Crc = ushort.Parse(field[(Int32)ProtGsubString.Crc],
                NumberStyles.HexNumber);

            dataProtGRec.Channel = ushort.Parse(field[(Int32)ProtGsubString.ChanNo],
                NumberStyles.HexNumber);
            dataProtGRec.Validation = ushort.Parse(field[(Int32)ProtGsubString.Validation],
                NumberStyles.HexNumber);

            //compare received with calculated CRC
            if (calculatedCrc != dataProtGRec.Crc || IsValidProtG != dataProtGRec.Validation)
            {
                return false;
            }

            //decode rest of message only if CRC and mode are valid
            dataProtGRec.IsValid = true;

            // Delta time of flight
            dataProtGRec.DeltaTimeOfFlightS = int.Parse(field[(Int32)ProtGsubString.Dtof],
                NumberStyles.AllowHexSpecifier) * TofToSecondsFactor38Bit;

            // Delta raw volume between last sample
            dataProtGRec.DeltaVolumeRaw = uint.Parse(field[(Int32)ProtGsubString.RawDVolume],
                NumberStyles.AllowHexSpecifier);

            //volume scaling
            var volumeRawScale = uint.Parse(field[(Int32)ProtGsubString.VolumeScale],
                NumberStyles.AllowHexSpecifier);

            dataProtGRec.VolumeScaleRawPerMl = volumeRawScale != 0 ? volumeRawScale : DefaultVolumeScaleRawPerMl;
            dataProtGRec.VolumeFactorRawToQm = MilliLitersToQmFactor / dataProtGRec.VolumeScaleRawPerMl;
            dataProtGRec.OverflowVolumeCm = MaxAccuVolumeRaw * dataProtGRec.VolumeFactorRawToQm;

            //Calculate volume in cubic meters out of the raw volume
            dataProtGRec.DeltaVolumeQm = dataProtGRec.DeltaVolumeRaw * dataProtGRec.VolumeFactorRawToQm;

            //accumulated volume for each channel received from water meter scaled with volumeScale
            //the volume can just be positive
            dataProtGRec.AccuVolumeRaw = uint.Parse(field[(Int32)ProtGsubString.AccuVolume],
                NumberStyles.AllowHexSpecifier);
            dataProtGRec.VolumeCm = dataProtGRec.AccuVolumeRaw * dataProtGRec.VolumeFactorRawToQm;

            //Sample interval
            dataProtGRec.SampleIntervalS = uint.Parse(field[(Int32)ProtGsubString.SampleInterval],
                NumberStyles.AllowHexSpecifier) * CpuTimeToSecondsFactor;

            //amplitude for high threshold in V
            dataProtGRec.AmplitudeUpV = uint.Parse(field[(Int32)ProtGsubString.AmplitudeUp],
                NumberStyles.AllowHexSpecifier) * AmplitudeToVoltFactor;

            //amplitude for low threshold in V
            dataProtGRec.AmplitudeDownV = uint.Parse(field[(Int32)ProtGsubString.AmplitudeDown],
                NumberStyles.AllowHexSpecifier) * AmplitudeToVoltFactor;

            //pulse width ratio high threshold
            dataProtGRec.PulseWidthRatioUp = uint.Parse(field[(Int32)ProtGsubString.PulseWidthRatioUp],
                NumberStyles.AllowHexSpecifier) * PulseWidthToRelFactor;

            //pulse width ratio low threshold
            dataProtGRec.PulseWidthRatioDown = uint.Parse(field[(Int32)ProtGsubString.PulseWidthRatioDown],
                NumberStyles.AllowHexSpecifier) * PulseWidthToRelFactor;

            //raw temperature
            dataProtGRec.TemperatureRaw = int.Parse(field[(Int32)ProtGsubString.RawTemperature],
                NumberStyles.AllowHexSpecifier);

            //temperature scaling
            dataProtGRec.TemperaturePowFactor = uint.Parse(field[(Int32)ProtGsubString.TemperatureScale],
                NumberStyles.AllowHexSpecifier);

            //Calculate temperature
            dataProtGRec.TemperatureDegC = dataProtGRec.TemperatureRaw /
                Math.Pow(2.0, dataProtGRec.TemperaturePowFactor);

            //absolute CPU time, started at LED mode 3 activation
            dataProtGRec.TimeS = uint.Parse(field[(Int32)ProtGsubString.CpuTime],
                NumberStyles.AllowHexSpecifier) * CpuTimeToSecondsFactor;
            return true;
        }

        /// <summary>
        ///     Extracting message from string fields to individual raw channel for protocol 'g'
        /// </summary>
        /// <param name="dataProtHRec">Reference to result structure for raw data for one channel</param>
        /// <param name="field">Separated fields containing the measurement as string</param>
        /// <returns>true if protocol is valid</returns>
        /// <remarks date="2018-Mar-22" author="T.Wiedebusch">
        /// - Usage of VolumeFactorRawToQm and calculation of AccuDutOverflowVolumeCm
        /// </remarks>
        private Boolean DecodeProtocolH(ref CalibrationRecord dataProtHRec, IList<String> field)
        {


            dataProtHRec.DecodedTime = DateTimeOffset.UtcNow;
            dataProtHRec.IsValid = false;

            //extract bytes of raw message for CRC calculation each character removing CRC (4 char)
            var byteArraySize = _rawMsgForCrc.Length - 4;
            var byteArray = new Byte[byteArraySize];
            for (var i = 0; i < byteArraySize; i++)
            {
                byteArray[i] = (Byte)_rawMsgForCrc[i];
            }

            _rawMsgForCrc = null;
            var calculatedCrc = Crc16Ccitt.CalculateMsb1021(byteArray);

            //extract received CRC
            dataProtHRec.Crc = ushort.Parse(field[(Int32)ProtHsubString.Crc],
                NumberStyles.HexNumber);

            dataProtHRec.Channel = ushort.Parse(field[(Int32)ProtHsubString.ChanNo],
                NumberStyles.HexNumber);
            dataProtHRec.Validation = ushort.Parse(field[(Int32)ProtHsubString.Validation],
                NumberStyles.HexNumber);


            //compare received with calculated CRC
            if (_ignoreCorruptedData &&
                (calculatedCrc != dataProtHRec.Crc || IsValidProtH != dataProtHRec.Validation))
            {
                return false;
            }
            // decode rest of message only if CRC and mode are valid
            dataProtHRec.IsValid = true;


            // Total time of flight
            dataProtHRec.TotalTimeOfFlightS = int.Parse(field[(Int32)ProtHsubString.Ttof],
                                        NumberStyles.AllowHexSpecifier) * TofToSecondsFactor38Bit;
            //Delta time of flight
            dataProtHRec.DeltaTimeOfFlightS = int.Parse(field[(Int32)ProtHsubString.Dtof],
                                        NumberStyles.AllowHexSpecifier) * TofToSecondsFactor38Bit;




            dataProtHRec.RAWTotalTimeOfFlight =
                int.Parse(field[(Int32)ProtHsubString.Ttof], NumberStyles.AllowHexSpecifier);
            dataProtHRec.RAWDeltaTimeOfFlight = int.Parse(field[(Int32)ProtHsubString.Dtof], NumberStyles.AllowHexSpecifier);

            //Delta raw volume between two samples
            dataProtHRec.DeltaVolumeRaw = uint.Parse(field[(Int32)ProtHsubString.RawDVolume],
                NumberStyles.AllowHexSpecifier);

            //volume scaling
            var volumeRawScale = uint.Parse(field[(Int32)ProtHsubString.VolumeScale],
                NumberStyles.AllowHexSpecifier);

            dataProtHRec.VolumeScaleRawPerMl = volumeRawScale != 0 ? volumeRawScale : DefaultVolumeScaleRawPerMl;
            dataProtHRec.VolumeFactorRawToQm = MilliLitersToQmFactor / dataProtHRec.VolumeScaleRawPerMl;
            dataProtHRec.OverflowVolumeCm = MaxAccuVolumeRaw * dataProtHRec.VolumeFactorRawToQm;

            //Calculate volume in cubic meters out of the raw volume
            dataProtHRec.DeltaVolumeQm = dataProtHRec.DeltaVolumeRaw * dataProtHRec.VolumeFactorRawToQm;

            //accumulated volume for each channel received from water meter scaled with volumeScale
            //the volume can just be positive
            dataProtHRec.AccuVolumeRaw = uint.Parse(field[(Int32)ProtHsubString.AccuVolume],
                NumberStyles.AllowHexSpecifier);
            dataProtHRec.VolumeCm = dataProtHRec.AccuVolumeRaw * dataProtHRec.VolumeFactorRawToQm;

            //Sample interval
            dataProtHRec.SampleIntervalS = uint.Parse(field[(Int32)ProtHsubString.SampleInterval],
                NumberStyles.AllowHexSpecifier) * CpuTimeToSecondsFactor;

            //amplitude for high threshold in V
            dataProtHRec.AmplitudeUpV = uint.Parse(field[(Int32)ProtHsubString.AmplitudeUp],
                NumberStyles.AllowHexSpecifier) * AmplitudeToVoltFactor;

            //amplitude for low threshold in V
            dataProtHRec.AmplitudeDownV = uint.Parse(field[(Int32)ProtHsubString.AmplitudeDown],
                NumberStyles.AllowHexSpecifier) * AmplitudeToVoltFactor;

            //raw temperature
            dataProtHRec.TemperatureRaw = int.Parse(field[(Int32)ProtHsubString.RawTemperature],
                NumberStyles.AllowHexSpecifier);

            //temperature scaling
            dataProtHRec.TemperaturePowFactor = uint.Parse(field[(Int32)ProtHsubString.TemperatureScale],
                NumberStyles.AllowHexSpecifier);

            //Calculate temperature
            dataProtHRec.TemperatureDegC = dataProtHRec.TemperatureRaw / (
                Math.Pow(2.0, dataProtHRec.TemperaturePowFactor));

            //absolute CPU time, started at LED mode 3 activation
            dataProtHRec.TimeS = uint.Parse(field[(Int32)ProtHsubString.CpuTime],
                NumberStyles.AllowHexSpecifier) * CpuTimeToSecondsFactor;
            return true;
        }

        /// field position in protocol 'f'
        private enum ProtFsubString
        {
            //do not remove this needed for position in record
            ProtType,
            DisplayVolume,
            CpuTime,
            Crc
        }

        /// field position in protocol 'g'
        private enum ProtGsubString
        {
            //do not remove this needed for position in record
            ProtType,
            ChanNo,
            Validation,
            Dtof,
            RawDVolume,
            AccuVolume,
            VolumeScale,
            SampleInterval,
            AmplitudeUp,
            AmplitudeDown,
            PulseWidthRatioUp,
            PulseWidthRatioDown,
            RawTemperature,
            TemperatureScale,
            CpuTime,
            Crc
        }

        /// field position in protocol 'h'
        private enum ProtHsubString
        {
            //do not remove this needed for position in record
            ProtType,
            ChanNo,
            Validation,
            Ttof,
            Dtof,
            RawDVolume,
            AccuVolume,
            VolumeScale,
            SampleInterval,
            AmplitudeUp,
            AmplitudeDown,
            RawTemperature,
            TemperatureScale,
            CpuTime,
            Crc
        }
    }
}