using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using DTS.Common.Enums;
using DTS.Common.Enums.DASFactory;
using DTS.Common.Enums.Hardware;
using DTS.Common.ICommunication;
using DTS.Common.Interface.Connection;
using DTS.Common.Interface.DASFactory;
using DTS.Common.Utilities.Logging;
using DTS.DASLib.Command.TDAS;

namespace DTS.DASLib.Service
{
    public partial class TDAS<T> : Communication<T>,
                           IDASCommunication,
                           IConfigurationActions,
                           IDiagnosticsActions,
                           ITriggerCheckActions,
                           IRealTimeActions,
                           IArmActions,
                           IDownloadActions where T : IConnection, new()
    {
        #region Real time
        public bool ControlsDAQ() { return false; }
        public bool SupportsHardwareInputCheck() { return false; }
        public bool InvertStart
        {
            get { return false; }
            set { if (value) { throw new NotSupportedException("TDAS does not support inverted start"); } }
        }
        public bool InvertTrigger
        {
            get { return false; }
            set { if (value) { throw new NotSupportedException("TDAS does not support inverted trigger"); } }
        }
        public bool SupportsTriggerInversion() => HardwareConstants.SupportsTriggerInversion(GetHardwareType(), ProtocolVersion);
        public bool SupportsStartInversion() => HardwareConstants.SupportsStartInversion(GetHardwareType(), ProtocolVersion);
        public bool SupportsRealtime()
        {
            if (DFConstantsAndEnums.ModuleType.G5Analog == DASInfo.Modules[0].TypeOfModule)
            {
                return true;
            }
            else
            {
                foreach (var module in DASInfo.Modules)
                {
                    switch (module.TypeOfModule)
                    {
                        case DFConstantsAndEnums.ModuleType.ProDIM:
                        case DFConstantsAndEnums.ModuleType.ProSIM:
                            return true;
                    }
                }
            }
            return false;
        }
        public bool IgnoreShortedStart
        {
            get { return false; }
            set { if (value) { throw new NotSupportedException("TDAS does not support ignore shorted start"); } }
        }
        public bool IgnoreShortedTrigger
        {
            get { return false; }
            set { if (value) { throw new NotSupportedException("TDAS does not support ignore shorted trigger"); } }
        }
        public bool SupportsAutoArm() { return false; }
        public bool SupportsLevelTrigger() { return false; }
        public bool SupportsMultipleEvents() { return false; }
        public bool SupportsMultipleSampleRealtime() { return false; }
        public bool SupportsMultiChannelRealtime() { return false; }

        private class RealTimeAsyncPacket
        {
            public TDASServiceAsyncInfo info { get; set; }
            public System.Threading.Timer timer { get; set; }
            public int samplesPerSecond { get; set; }
            public int millisecBetweenSamples { get; set; }
            public bool realtimeMultipleSamplesEnabled { get; set; }
            public int ModuleIndex { get; set; }
            public System.Threading.ManualResetEvent StopEvent { get; set; }
            public bool CareAboutSampleNumber { get; set; }
            public int minCallbackUpdateTimeMs { get; set; }
        }

        void IRealTimeActions.RealTimePolling(ServiceCallback callback,
            object userData,
            ManualResetEvent mre,
            byte[] channels)
        {
            var packet = new RealTimeAsyncPacket();
            packet.info = new TDASServiceAsyncInfo(callback, userData);
            packet.StopEvent = mre;
            if (IsG5())
            {
                packet.millisecBetweenSamples = 50;
                packet.samplesPerSecond = 1000;
                packet.CareAboutSampleNumber = false;
                LaunchAsyncWorker("TDAS.Realtime", new WaitCallback(AsyncRealTime), packet);
            }
            else
            {
                LaunchAsyncWorker("TDAS.RealtimePolling", new WaitCallback(AsyncRealTimePolling), packet);
            }
        }

        void IRealTimeActions.RealTime(int samplesPerSecond,
            int millisecBetweenSamples,
            ServiceCallback callback,
            object userData,
            bool realtimeMultipleSamplesEnabled,
            int moduleIndex,
            ManualResetEvent stopEvent,
            byte[] channels,
            double aaf,
            int minCallbackUpdateTimeMs,
            bool UseUDPStreaming,
            string hostIPAddress)
        {

            var packet = new RealTimeAsyncPacket
            {
                info = new TDASServiceAsyncInfo(callback, userData),
                millisecBetweenSamples = millisecBetweenSamples,
                samplesPerSecond = samplesPerSecond,
                realtimeMultipleSamplesEnabled = realtimeMultipleSamplesEnabled,
                ModuleIndex = moduleIndex,
                CareAboutSampleNumber = true,
                StopEvent = stopEvent,
                minCallbackUpdateTimeMs = minCallbackUpdateTimeMs
            };
            LaunchAsyncWorker("TDAS.RealTime", new WaitCallback(AsyncRealTime), packet);
        }

        void IRealTimeActions.RealTimeTiltPolling(ServiceCallback callback, object userData, ManualResetEvent stopEvent)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);
            info.Success();
        }

        public string UDPStreamAddress { get; }
        void IRealTimeActions.SetUDPStreamProfile(ServiceCallback callback, object userData, UDPStreamProfile streamProfile, string udpAddress, ushort timeChannelId, ushort dataChannelId, uint[] tmnsConfig, ushort irigTimeDataPacketIntervalMs)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);
            info.Success();
        }
        void IRealTimeActions.GetUDPStreamProfile(ServiceCallback callback, object userData)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);
            info.Success();
        }

        private object CallbackLock = new object();
        private DateTime lastUpdate = DateTime.MinValue;
        private const int MIN_CALLBACK_UPDATE_TIME = 10;
        private List<UInt64> _timeStamps = new List<ulong>();
        private List<UInt64> _sequenceNumbers = new List<ulong>();
        private List<UInt64> _sampleNumbers = new List<ulong>();
        private List<short[][]> _dataSamples = new List<short[][]>();

        private const int BufferSize = 4096;
        private readonly byte[] _buffer = new byte[BufferSize];
        private RealTimeAsyncPacket _packet;
        private const int NumChannels = 8;
        private const int StartChannel = 0;

        private void ProcessData(IAsyncResult ar)
        {
            lock (CallbackLock)
            {
                var bytes = sock.EndReceive(ar);
                if (0 == bytes) { return; }
                var s = Encoding.ASCII.GetString(_buffer, 0, bytes);
                s = s.Replace("\r\n", Convert.ToChar(0xBF).ToString());
                var lines = s.Split(Convert.ToChar(0xBF));
                foreach (var line in lines)
                {
                    var rtData = new short[NumChannels][];
                    if (!line.Contains("MD")) { continue; }
                    var tokens = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                    if (tokens.Length < 8) { continue; }
                    //0 = command, 1 = time, 2 = channel 0, etc
                    for (var i = 0; i < NumChannels; i++)
                    {
                        rtData[i] = new short[1];
                        rtData[i][0] = short.MaxValue;
                        if (i >= StartChannel)
                        {
                            var index = i - StartChannel + 2;
                            if (index < tokens.Length)
                            {
                                short.TryParse(tokens[i - StartChannel + 2], out rtData[i][0]);
                            }
                        }
                    }
                    _dataSamples.Add(rtData);
                }
                //TDAS reporting interval is slow enough, don't restrict it further!
                //if (DateTime.Now.Subtract(lastUpdate).TotalMilliseconds > MIN_CALLBACK_UPDATE_TIME)
                {
                    _packet.info.NewData(_dataSamples, _sampleNumbers, _timeStamps, _sequenceNumbers);

                    _dataSamples.Clear();
                    //lastUpdate = DateTime.Now;
                }
            }
            sock.BeginReceive(_buffer, 0, BufferSize, new AsyncCallback(ProcessData), null);
        }
        /// <summary>
        /// only used with RACK,
        /// is a polling (sampleaverage/single sample) realtime mode
        /// </summary>
        /// <param name="asyncInfo"></param>
        private void AsyncRealTimePolling(object asyncInfo)
        {
            var packet = asyncInfo as RealTimeAsyncPacket;

            //List<ulong> sampleNumbers = new List<ulong>();
            //List<short[][]> data = new List<short[][]>();
            const int numTDASDIMChannels = 16;

            ulong sampleNumber = 0;
            var numChannels = ConfigData.Modules.Sum(module => module.NumberOfChannels());

            while (!(this as DTS.Common.Interface.DASFactory.ICommunication).IsCanceled() && !packet.StopEvent.WaitOne(0))
            {
                var curChannel = 0;
                //first array is channels, second array are samples
                var rtData = new short[numChannels][];

                foreach (var module in DASInfo.Modules)
                {
                    try
                    {
                        switch (module.TypeOfModule)
                        {
                            case DFConstantsAndEnums.ModuleType.EMPTYBANK:
                                continue;
                            case DFConstantsAndEnums.ModuleType.ProTOM:
                                {
                                    curChannel += 16; //8squibs, 8 digitals
                                    continue;
                                }

                        }

                        var ss = new SampleAverage(this)
                        {
                            ModuleIndex = module.ModuleArrayIndex
                        };
                        ss.SyncExecute();
                        if (module.TypeOfModule == DFConstantsAndEnums.ModuleType.ProDIM)
                        {
                            //apparently the DIM for SA just returns 1.0, 0
                            for (int ch = 0; ch < numTDASDIMChannels; ch++)
                            {
                                rtData[curChannel++] = new short[]
                                {
                                    0 == ss.ChannelValues[ch] ? short.MinValue : short.MaxValue
                                };
                            }
                        }
                        else
                        {
                            for (int ch = 0; ch < 8; ch++)
                            {
                                rtData[curChannel++] = new short[] { Convert.ToInt16(ss.ChannelValues[ch]) };
                            }
                        }

                        //if (IsG5() && i == 0)
                        //{
                        //    int digitalbits = (ss.ChannelValues[9] << 16) | ss.ChannelValues[8];
                        //    BitVector32 bv = new BitVector32(digitalbits);
                        //    for (int digCh = 0; digCh < 16; digCh++)
                        //    {
                        //        if (bv[(1 << digCh)])
                        //        {
                        //            rtData[32 + digCh] = new short[] {short.MinValue};
                        //        }
                        //        else
                        //        {
                        //            rtData[32 + digCh] = new short[] {short.MaxValue};
                        //        }
                        //    }
                        //}

                    }
                    catch (Exception ex)
                    {
                        APILogger.Log(ex);
                    }
                }
                packet.info.NewData(new List<short[][]>() { rtData }, new List<ulong>(new ulong[] { sampleNumber }), new List<ulong>(new ulong[] { ulong.MinValue }), new List<ulong>(new ulong[] { ulong.MinValue }));
                Thread.Sleep(50);
                sampleNumber++;
                //if (DateTime.Now.Subtract(lastUpdate).TotalMilliseconds >= MIN_CALLBACK_UPDATE_TIME)
                //{
                //    lastUpdate = DateTime.Now;
                //    packet.info.NewData(data, sampleNumbers);
                //    sampleNumbers.Clear();
                //    data.Clear();
                //}
            }
            packet.info.Success();
        }
        /// <summary>
        /// indicates whether the DAS supports streaming
        /// 10572 implement SW side for single command streaming realtime
        /// </summary>
        public bool SupportsIndividualChannelRealtimeStreaming => false;

        /// <summary>
        /// this is used to space out the samples in a multiple sample packet of g5 realtime
        /// I based it on the max SPS, which is what we always send to the g5 (1k SPS)
        /// through empirical testing with the sig-gen, I changed to 1/978 for U5
        /// </summary>
        private const double _g5RealtimeInterval = 1 / 978D;
        //private DateTime _lastRTLogTime = DateTime.MinValue;
        //private int _samplesProcessed = 0;
        /// <summary>
        /// The worker for realtime service.
        /// </summary>
        /// <param name="asyncInfo">A RealTimeAsyncPacket for responses</param>
        private void AsyncRealTime(object asyncInfo)
        {
            var packet = asyncInfo as RealTimeAsyncPacket;
            _packet = packet;

            //tdas devices for realtime have both a sampling rate and a reporting rate
            //ultimately the reporting rate will drive what we see in realtime
            //the user has requested a specific realtime rate, however right now
            //we just force the rate on TDAS equipment, this means we have to go and
            //adjust our sample numbers as if we were running at the requested rate.
            double expectedSampleRate = packet.samplesPerSecond;
            bool bG5 = IsG5();
            try
            {
                if (!SupportsRealtime()) { packet.info.Success(); return; }

                FlushTimeoutMilliSec = 0;
                var sampleNumbers = new List<ulong>();
                var timeStamps = new List<ulong>();
                var sequenceNumbers = new List<ulong>();
                var data = new List<short[][]>();
                var dtSTart = DateTime.Now;
                var sampleNumberCarryover = 0;

                if (bG5)
                {
                    var mdx = new G5MonitorData(this);
                    mdx.SyncExecute();
                }
                else
                {
                    Command.TDAS.ProMonitorData md = new Command.TDAS.ProMonitorData(this, DASInfo.Modules[packet.ModuleIndex].TypeOfModule == DFConstantsAndEnums.ModuleType.ProSIM);
                    md.ModuleIndex = packet.ModuleIndex;
                    md.SyncExecute();
                }


                // Then consume the constant responses.  Be sure to turn off logging for performance.
                Command.TDAS.MonitorDataNextSampleBase.MonitorType mt;
                if (IsG5())
                {
                    mt = Command.TDAS.MonitorDataNextSampleBase.MonitorType.G5;
                }
                else
                {
                    if (DASInfo.Modules[packet.ModuleIndex].TypeOfModule == DFConstantsAndEnums.ModuleType.ProDIM)
                    {
                        mt = MonitorDataNextSampleBase.MonitorType.DIM;
                    }
                    else
                    {
                        mt = MonitorDataNextSampleBase.MonitorType.Pro;
                    }
                }

                Command.TDAS.MonitorDataNextSampleBase next = new Command.TDAS.MonitorDataNextSampleBase(this, mt);

                next.LogCommands = false;
                while (true && !(this as DTS.Common.Interface.DASFactory.ICommunication).IsCanceled() && !packet.StopEvent.WaitOne(1))
                {
                    Thread.Sleep(50);
                    sampleNumbers.Clear();
                    timeStamps.Clear();
                    data.Clear();

                    // get the next response(s)
                    next.SyncExecute();

                    var moreData = next.RTData;
                    var timeSamples = next.Times;
                    // Maybe we're ahead of the das.
                    if (0 == moreData.Count())
                    {
                        continue;
                    }

                    if (bG5)
                    {
                        for (int currentSample = 0; currentSample < moreData.Count; currentSample++)
                        {
                            short digitalBits = moreData[currentSample][32];
                            short[] newData = new short[48];
                            Array.Copy(moreData[currentSample], newData, 32);

                            System.Collections.Specialized.BitVector32 bv = new System.Collections.Specialized.BitVector32(Convert.ToInt32(digitalBits));

                            for (int iChannelIdx = 0; iChannelIdx < 16; iChannelIdx++)
                            {
                                //also note that the bitvector [] operator expects a bitmask, not an index ...
                                if (bv[(1 << iChannelIdx)]) { newData[32 + iChannelIdx] = short.MinValue; }
                                else { newData[32 + iChannelIdx] = short.MaxValue; }
                            }
                            moreData[currentSample] = newData;
                        }
                    }
                    else
                    {
                        //the service is expecting a DAS full of realtime sample data,
                        //however with realtime on a rack, we're only going to have one module responding with data, so we need to fake data from the other modules
                        //for now since the first SIM module is the only module we're accepting data from I can spoof data from all other channels
                        bool bFound = false;
                        List<List<short>> largerDataArray = new List<List<short>>();

                        for (int sample = 0; sample < moreData.Count; sample++)
                        {
                            bFound = false;
                            for (int iModule = 0; iModule < DASInfo.Modules.Length; iModule++)
                            {
                                if (largerDataArray.Count <= sample) { largerDataArray.Add(new List<short>()); }
                                switch (DASInfo.Modules[iModule].TypeOfModule)
                                {
                                    case DFConstantsAndEnums.ModuleType.EMPTYBANK://ignore
                                        break;
                                    case DFConstantsAndEnums.ModuleType.ProDIM:
                                        if (!bFound && iModule == packet.ModuleIndex)
                                        {
                                            bFound = true;
                                            foreach (var d in moreData[sample])
                                            {
                                                System.Collections.Specialized.BitVector32 bv = new System.Collections.Specialized.BitVector32(d);
                                                short[] array = new short[16];
                                                for (int i = 0; i < 16; i++)
                                                {
                                                    if (bv[1 << i])
                                                    {
                                                        if (!IsG5())
                                                        {
                                                            array[i] = short.MaxValue;
                                                        }
                                                        else
                                                        {
                                                            array[i] = short.MaxValue;
                                                        }
                                                    }
                                                    else
                                                    {
                                                        if (!IsG5())
                                                        {
                                                            array[i] = short.MinValue;
                                                        }
                                                        else
                                                        {
                                                            array[i] = short.MinValue;
                                                        }
                                                    }
                                                }
                                                largerDataArray[sample].AddRange(array);
                                            }
                                        }
                                        else
                                        {
                                            largerDataArray[sample].AddRange(new short[]
                                            {
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue
                                            });
                                        }
                                        break;
                                    case DFConstantsAndEnums.ModuleType.ProSIM:
                                        if (!bFound && iModule == packet.ModuleIndex)
                                        {
                                            bFound = true;
                                            largerDataArray[sample].AddRange(moreData[sample]);
                                        }
                                        else
                                        {
                                            //add 8 channels of short.minvalue
                                            largerDataArray[sample].AddRange(new short[]
                                            {
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue,
                                                short.MinValue
                                            });
                                        }
                                        break;
                                    default:
                                        for (int i = 0; i < DASInfo.Modules[iModule].NumberOfChannels; i++)
                                        {
                                            largerDataArray[sample].Add(short.MinValue);
                                        }
                                        break;
                                }
                            }
                        }
                        moreData = new List<short[]>(largerDataArray.Count);
                        for (int sample = 0; sample < largerDataArray.Count; sample++)
                        {
                            moreData.Add(largerDataArray[sample].ToArray());
                        }

                    }
                    // Need to transpose the data to comply with the service interface.
                    int maxSample = moreData.Count();
                    if (!packet.CareAboutSampleNumber)
                    {
                        maxSample = 1;//just do one sample back, we are in meter table mode and don't need the update speed...
                    }
                    for (int currentSample = 0; currentSample < maxSample; currentSample++)
                    {
                        short[][] transposedData = new short[moreData[0].Count()][];
                        for (int currentChannel = 0; currentChannel < transposedData.Length; currentChannel++)
                        {
                            transposedData[currentChannel] = new short[1];
                            transposedData[currentChannel][0] = moreData[currentSample][currentChannel];
                        }
                        data.Add(transposedData.ToArray());
                        if (packet.CareAboutSampleNumber)
                        {
                            if (IsG5())
                            {
                                //compute sample numbers by starting at 0 and then just incrementing
                                //finally, convert from that number to what the requested rate is.  ideally the request rate is faster to prevent sample
                                //number overlap, but it's more important the time scale is correct
                                //this should just cause aliasing if the sample numbers overlap
                                sampleNumbers.Add(
                                    Convert.ToUInt64(Convert.ToDouble(sampleNumberCarryover * _g5RealtimeInterval) *
                                                     expectedSampleRate));
                                timeStamps.Add(ulong.MinValue);
                                if (sampleNumberCarryover == Int32.MaxValue)
                                {
                                    sampleNumberCarryover = 0;
                                }
                                sampleNumberCarryover++;
                            }
                            else
                            {
                                sampleNumbers.Add(Convert.ToUInt64(timeSamples[currentSample] * expectedSampleRate));
                                timeStamps.Add(ulong.MinValue);
                            }
                        }
                        else
                        {
                            if (sampleNumberCarryover == Int32.MaxValue)
                            {
                                sampleNumberCarryover = 0;
                            }
                            else
                            {
                                sampleNumberCarryover++;
                            }
                            sampleNumbers.Add(Convert.ToUInt64(sampleNumberCarryover));
                            timeStamps.Add(ulong.MinValue);
                        }
                    }


                    // Send the data to the caller.
                    packet.info.NewData(data, sampleNumbers, timeStamps, sequenceNumbers);
                }
                if ((this as DTS.Common.Interface.DASFactory.ICommunication).IsCanceled())
                {
                    packet.info.Cancel();
                }
                StopRealtime();
                packet.info.Success();
            }
            catch (CanceledException)
            {
                // We land here when the user cancels real time.
                packet.info.Cancel();
            }
            catch (System.Exception ex)
            {
                packet.info.Error(ex.Message, ex);
            }
        }

        /// <summary>
        /// Call this service to terminate real time streaming.
        /// </summary>
        /// <param name="callback">User provided callback</param>
        /// <param name="userData">User provided data object</param>
        void IRealTimeActions.ExitRealTimeMode(ServiceCallback callback, object userData)
        {
            var info = new TDASServiceAsyncInfo(callback, userData);

            LaunchAsyncWorker("TDAS.ExitRealTimeMode", new WaitCallback(AsyncExitRealTimeMode), info);
        }

        private void StopRealtime()
        {
            if (!SupportsRealtime()) { return; }
            else
            {

                if (IsG5())
                {
                    QuitG5Monitoring qm = new QuitG5Monitoring(this);
                    qm.SyncExecute();
                }
                else
                {
                    try
                    {
                        QuerySerialNumber qs = new QuerySerialNumber(this, 2000);
                        qs.SyncExecute();
                    }
                    catch (Exception ex)
                    {
                        APILogger.Log(ex);
                    }
                }
            }
        }
        private void AsyncExitRealTimeMode(object asyncInfo)
        {
            var info = asyncInfo as TDASServiceAsyncInfo;

            try
            {
                StopRealtime();
                if (null != DASArmStatus) DASArmStatus.IsInRealtime = false;// FB15550: Update IsInRealtime flag if we exit RT so DataPRO is aware
                info.Success();
            }
            catch (CanceledException)
            {
                info.Cancel();
            }
            catch (System.Exception ex)
            {
                info.Error(ex.Message, ex);
            }
        }

        #endregion
    }
}