using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Media;
using DTS.Common.Enums.Sensors;
using DTS.Common.Interface;
using DTS.Common.Strings;

// ReSharper disable UnassignedGetOnlyAutoProperty

namespace DTS.Viewer.Graph.Model
{
    public class TestDataSeries : Common.Base.BasePropertyChanged, ITestDataSeries
    {
        private bool _HIC = false;
        public bool HIC
        {
            get => _HIC;
            set => SetProperty(ref _HIC, value, "HIC");
        }

        private string _hicValue;
        public string HICValue
        {
            get => _hicValue;
            set => SetProperty(ref _hicValue, value, "HICValue");
        }

        private string _T1Time;

        public string T1Time
        {
            get => _T1Time;
            set => SetProperty(ref _T1Time, value, "T1Time");
        }

        private string _T2Time;

        public string T2Time
        {
            get => _T2Time;
            set => SetProperty(ref _T2Time, value, "T2Time");
        }

        private string _testGroup = string.Empty;
        public string TestGroup
        {
            get => _testGroup;
            set => SetProperty(ref _testGroup, value, "TestGroup");
        }

        private string _testId = string.Empty;

        public string TestId
        {
            get => _testId;
            set => SetProperty(ref _testId, value, "TestId");
        }

        private string _testSetupName = string.Empty;

        public string TestSetupName
        {
            get => _testSetupName;
            set => SetProperty(ref _testSetupName, value, "TestSetupName");
        }

        private string _channelId = string.Empty;
        public string ChannelId
        {
            get => _channelId;
            set => SetProperty(ref _channelId, value, "ChannelId");
        }

        private double[] _x = new double[0];
        public double[] Xvalue
        {
            get => _x;
            set => SetProperty(ref _x, value, "X");
        }

        private double[] _y = new double[0];
        public double[] Yvalue
        {
            get => _y;
            set => SetProperty(ref _y, value, "Y");
        }

        // 34455: Move from Brush to byte[] to make it thread-safe
        private byte[] _graphColorARGB = new byte[] { Colors.Blue.A, Colors.Blue.R, Colors.Blue.G, Colors.Blue.B };
        public Brush GraphColor
        {
            get => new SolidColorBrush(Color.FromArgb(_graphColorARGB[0], _graphColorARGB[1], _graphColorARGB[2], _graphColorARGB[3]));
            set
            {
                var valueColor = ((SolidColorBrush)value).Color;
                var colorValues = new byte[] { valueColor.A, valueColor.R, valueColor.G, valueColor.B };
                SetProperty(ref _graphColorARGB, colorValues, "GraphColor");
            }
        }

        public bool IsSaved { get; }

        public string HardwareChannel { get; set; }
        public string GroupName { get; set; }
        public string SWAAF { get; set; }
        public string Bridge { get; set; }
        public string HWAAF { get; set; }
        public string SampleRate { get; set; }
        public string ISOCode { get; set; }
        public string ISOChannelName { get; set; }
        public string UserCode { get; set; }
        public string UserChannelName { get; set; }
        public string ChannelName { get; set; }
        public string Description { get; set; }
        public string SensorSN { get; set; }
        public string SensorSNDisplay
        {
            get => SensorConstants.IsTestSpecificEmbedded(SensorSN) ? Strings.Table_NA : SensorSN;
        }
        public string EngineeringUnits { get; set; }
        public string Excitation { get; set; }
        public string Polarity { get; set; }

        private string _minY = Strings.Table_NA;
        public string MinY
        {
            get => _minY;
            set => SetProperty(ref _minY, value, "MinY");
        }

        private string _maxY = Strings.Table_NA;
        public string MaxY
        {
            get => _maxY;
            set => SetProperty(ref _maxY, value, "MaxY");
        }
        private string _avgY = Strings.Table_NA;
        public string AvgY
        {
            get => _avgY;
            set => SetProperty(ref _avgY, value, "AvgY");
        }

        private string _stdDevY;
        public string StdDevY
        {
            get => _stdDevY;
            set => SetProperty(ref _stdDevY, value, "StdDevY");
        }

        private double _peakMagnitude = 0;
        /// <summary>
        /// holds the peak magnitude of frequencies in signal
        /// only valid when FFT true
        /// 6402 Implement ability to switch to FFT live in the Review
        /// </summary>
        public double PeakMagnitude
        {
            get => _peakMagnitude;
            set => SetProperty(ref _peakMagnitude, value, "PeakMagnitude");
        }

        private double _peakFrequency = 0;
        /// <summary>
        /// holds the frequency of the highest magnitude in signal
        /// only valid when FFT true
        /// 6402 Implement ability to switch to FFT live in the Review
        /// </summary>
        public double PeakFrequency
        {
            get => _peakFrequency;
            set => SetProperty(ref _peakFrequency, value, "PeakFrequency");
        }

        private double _grms = 0;
        /// <summary>
        /// holds the root-mean-squared acceleration
        /// only calculated in PSD results graphs
        /// </summary>
        public double GRMS
        {
            get => _grms;
            set => SetProperty(ref _grms, value, "GRMS");
        }

        private bool _fft = false;
        /// <summary>
        /// holds whether series is an FFT of signal data
        /// 6402 Implement ability to switch to FFT live in the Review
        /// </summary>
        public bool FFT
        {
            get => _fft;
            set => SetProperty(ref _fft, value, "FFT");
        }

        private string _T0EUValue = "";
        /// <summary>
        /// this is the T0 value regardless of units ... it's not really EU but since it's already in use I'm not going to change it
        /// </summary>
        public string T0EUValue
        {
            get => _T0EUValue;
            set => SetProperty(ref _T0EUValue, value, "T0EUValue");
        }

        private double CalculateStdDev(double[] values)
        {
            double ret = 0;
            if (!values.Any()) return ret;
            //Compute the Average      
            var avg = values.Average();
            //Perform the Sum of (value-avg)_2_2      
            var sum = values.Sum(d => Math.Pow(d - avg, 2));
            //Put it all together      
            ret = Math.Sqrt(sum / (values.Length - 1));
            return ret;
        }
        private const string STAT_FORMAT = "G5";
        /// <summary>
        /// sets Ave/StdDev/Min/MaxT0 stats using internal YValues (something like PSD or FFT)
        /// </summary>
        public void SetStatsFromYValues()
        {
            SetStatsFromYValues(Yvalue);
        }
        /// <summary>
        /// sets Ave/StdDev/Min/Max/T0 stats using the passed in input range (something like PSD or FFT)
        /// </summary>
        /// <param name="values"></param>
        public void SetStatsFromYValues(double[] values)
        {
            if (null == values || 0 == values.Length)
            {
                SetStatsFromYValues(double.NaN, double.NaN, double.NaN, double.NaN, double.NaN);
            }
            else
            {
                SetStatsFromYValues(values.Min(), values.Max(), values.Average(), CalculateStdDev(values), double.NaN);
            }
        }
        /// <summary>
        /// formats and sets the current unit stats
        /// </summary>
        /// <param name="min"></param>
        /// <param name="max"></param>
        /// <param name="ave"></param>
        /// <param name="stdDev"></param>
        /// <param name="t0Value"></param>
        private void SetStatsFromYValues(double min, double max, double ave, double stdDev, double t0Value)
        {
            StdDevY = double.IsNaN(stdDev) ? Strings.Table_NA : stdDev.ToString(STAT_FORMAT);
            AvgY = double.IsNaN(ave) ? Strings.Table_NA : ave.ToString(STAT_FORMAT);
            MinY = double.IsNaN(min) ? Strings.Table_NA : min.ToString(STAT_FORMAT);
            MaxY = double.IsNaN(max) ? Strings.Table_NA : max.ToString(STAT_FORMAT);
            T0EUValue = double.IsNaN(t0Value) ? Strings.Table_NA : t0Value.ToString(STAT_FORMAT);
        }
        /// <summary>
        /// sets stats (ave/min/max) using values from passed in channel where it was already calculated when reading data
        /// </summary>
        /// <param name="channel"></param>
        public void SetStatsFromChannel(ITestChannel channel)
        {
            SetStatsFromYValues(channel.MinY, channel.MaxY, channel.AveY, channel.StdDevY, channel.T0Value);
        }
        public string RecordingMode { get; set; }
    }
}