using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using Hardware.misc;
using Hardware.processing.math;
using Hardware.messenger;

namespace Hardware.processing.recognition
{
    public class SubstanceDetectionProcessor : IDataProcessor
    {
        private readonly DataStreamDifferentiator[] _differentiators;
        private readonly DataStreamDifferentiator[] _prefetchDifferentiators;
        private const int DifferentiatorWindowLength = 60;
        private const double RecognitionTime = 10000;
        private const double WarmupThresholdTime = 6e4;
        private const double MinimumCleanupTime = 0;//6e4;

        private double _lastEventDuringWarmup = 0;
        private ISubstanceRecognitionProcessor _recognitionProcessor = null;

        public ISubstanceRecognitionProcessor RecognitionProcessor
        {
            get { return _recognitionProcessor; }
            set { _recognitionProcessor = value; }
        }

        //StreamWriter sr = new StreamWriter(@"D:\tmp_data_" + TimestampHelper.DateTimeToTimestamp(DateTime.Now) + ".csv");
        //StreamWriter srd = new StreamWriter(@"D:\tmp_diff_" + TimestampHelper.DateTimeToTimestamp(DateTime.Now) + ".csv");
        //StreamWriter srt = new StreamWriter(@"D:\tmp_evts_" + TimestampHelper.DateTimeToTimestamp(DateTime.Now) + ".csv");


        private enum State
        {
            Stabilizing, // Waiting for sensors to settle (warmup)
            Waiting, // Currently in clean athmosphere, waiting for contaminant
            Recognizing, // Contaminant detected, waiting for sensors to settle
            Exposed // Currently in contaminated athmosphere, waiting for a contaminant to disappear
        } ;

        private readonly double[] _zeros; // Unexposed state of sensors
        private double _lockinTimestamp;
        private State _currentState;


        public SubstanceDetectionProcessor()
        {
            _differentiators = new DataStreamDifferentiator[SensorDataHelper.GetParticipatingSensorNum()];
            _prefetchDifferentiators = new DataStreamDifferentiator[SensorDataHelper.GetParticipatingSensorNum()];

            for (var i = 0; i < _differentiators.Length; ++i)
            {
                _differentiators[i] = new DataStreamDifferentiator(DifferentiatorWindowLength);
                _prefetchDifferentiators[i] = new DataStreamDifferentiator(DifferentiatorWindowLength);
            }

            _zeros = new double[SensorDataHelper.GetParticipatingSensorNum()];
            _currentState = State.Waiting;
        }

        public void Process(double timestamp, double[] readings)
        {
            var workingSet = GetWorkingSet(readings);

            if (_differentiators[0].Length == 0)
            {
                for (var i = 0; i < workingSet.Length; ++i)
                {
                    _differentiators[i].Fill(workingSet[i]);
                    _prefetchDifferentiators[i].Fill(workingSet[i]);
                }

                _lastEventDuringWarmup = timestamp;

                Messenger.EnqueueMessage(new FasolMessage("Ожидание окончания прогрева сенсоров.", "Fasol", 5));

                return;
            }

            for (var i = 0; i < workingSet.Length; ++i)
            {
                _prefetchDifferentiators[i].AddNewPoint(timestamp, _differentiators[i].FirstY);
                _differentiators[i].AddNewPoint(timestamp, workingSet[i]);
            }

/*            sr.Write(timestamp.ToString() + "\t");
            srd.Write(timestamp.ToString() + "\t");

            foreach (var d in workingSet)
            {
                sr.Write(d.ToString());
                sr.Write("\t");
            }

            foreach (var dataStreamDifferentiator in _differentiators)
            {
                srd.Write(dataStreamDifferentiator.Derivative);
                srd.Write("\t");
            }
            sr.WriteLine();
            srd.WriteLine();
            sr.Flush();
            srd.Flush();*/


            ProcessStateMachine(timestamp);
        }

        private void ProcessStateMachine(double timestamp)
        {
            //srt.Write(timestamp.ToString() + " ");
            switch (_currentState)
            {
                case State.Stabilizing:
                    {
                        //srt.WriteLine("S");
                        if (timestamp - _lastEventDuringWarmup >= WarmupThresholdTime)
                        {
                            Messenger.EnqueueMessage(new FasolMessage("Прогрев сенсоров завершен.", "Fasol", 5));
                            _currentState = State.Waiting;
                        }
                        else if (CheckRisingThresholds(timestamp))
                        {
                            _lastEventDuringWarmup = timestamp;
                        }
                    }
                    break;

                case State.Waiting:
                    {
                        //srt.WriteLine("W");
                        if (CheckRisingThresholds(timestamp))
                        {
                            for (var i = 0; i < _differentiators.Length; ++i)
                            {
                                _zeros[i] = _prefetchDifferentiators[i].GetLinearApproximation((_prefetchDifferentiators[i].LastX + _prefetchDifferentiators[i].FirstX) / 2);
                            }
                            _lockinTimestamp = timestamp;
                            _currentState = State.Recognizing;
                            Messenger.EnqueueMessage(new FasolMessage("Изменился состав атмосферы...", "Fasol", 5));
                        }
                    }
                    break;

                case State.Recognizing:
                    {
                        //srt.WriteLine("R");
                        if (timestamp - _lockinTimestamp >= RecognitionTime)
                        {
                            double[] set = GenerateNeuralInput();

                            _recognitionProcessor.Recognize(timestamp, set);
                            //Console.WriteLine("Some shit recognized with imaginary recognizer");
                            _currentState = State.Exposed;
                        }
                    }


                    break;

                case State.Exposed:
                    {
                        //srt.WriteLine("E");
                        if ((timestamp - _lockinTimestamp) >= MinimumCleanupTime && CheckForCleanAir(timestamp))
                        {
                            //Console.WriteLine("Some shit disappeared");
                            Messenger.EnqueueMessage(
                                new FasolMessage("Атмосфера очистилась. Возможно детектирование нового вещества...",
                                                 "Fasol", 5));
                            _currentState = State.Waiting;
                        }
                    }
                    break;
            }

            //srt.Flush();
        }

        private bool CheckForCleanAir(double timestamp)
        {
            var deltaT = timestamp - _lockinTimestamp;

            if (deltaT < MinimumCleanupTime)
            {
                return false;
            }

            for (var i = 0; i < _zeros.Length; ++i)
            {
                var deltaR = _differentiators[i].LastY - _zeros[i];

                if (Math.Abs(deltaR) >
                    SensorDataHelper.GetReleaseThreshold(i) + SensorDataHelper.GetReleaseDrift(i)*deltaT)
                {
                    return false;
                }
            }

            return true;
        }

        private bool CheckRisingThresholds(double timestamp)
        {

            for (var i = 0; i < _differentiators.Length; ++i)
            {
                if (Math.Abs(_differentiators[i].Derivative) > SensorDataHelper.GetDetectionThreshold(i))
                {
                    return true;
                }
            }

            return false;
        }

        private static double[] GetWorkingSet(double[] readings)
        {
            var ret = new double[SensorDataHelper.GetParticipatingSensorNum()];

            var j = 0;

            for (var i = 0; i < SensorDataHelper.GetInstalledSensorNum(); ++i)
            {
                if (SensorDataHelper.IsParticipatingInRecognition(i))
                {
                    ret[j] = readings[i]; // 65535.0 / (readings[i] + 1); // Ololo
                    ++j;
                }
            }

            return ret;
        }

        private double[] GenerateNeuralInput()
        {
            var neuralInput = new double[_zeros.Length];

            for (var i = 0; i < _zeros.Length; ++i)
            {
                neuralInput[i] = _differentiators[i].GetLinearApproximation(_differentiators[i].LastX) - _zeros[i];
            }

            double max = Math.Max(neuralInput.Max(), -neuralInput.Min());

            for (var i = 0; i < _zeros.Length; ++i)
            {
                neuralInput[i] /= max;
            }

            return neuralInput;
        }
    }
}