using RealTimeGraphX.DataPoints;
using RealTimeGraphX.WPF;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media;
using System.Windows.Threading;
using System.Xml.Serialization;
using Tango.BL.Entities;
using Tango.Core.Commands;
using Tango.MachineStudio.Technician.Editors;
using Tango.MachineStudio.Technician.Helpers;
using Tango.SharedUI.Helpers;

namespace Tango.MachineStudio.Technician.TechItems
{
    /// <summary>
    /// Represents a single channel real-time graph item.
    /// </summary>
    /// <seealso cref="Tango.MachineStudio.Technician.TechItems.TechItem" />
    [TechItem(4, true)]
    public class SingleGraphItem : TechItem
    {
        private DispatcherTimer _timer;
        private DateTime _recording_start_time;

        public event Action RecordingStarted;
        public event Action RecordingStopped;

        private TechMonitor _techMonitor;
        /// <summary>
        /// Gets or sets the db tech monitor.
        /// </summary>
        [XmlIgnore]
        public TechMonitor TechMonitor
        {
            get { return _techMonitor; }
            set
            {
                TechMonitor old = _techMonitor;

                _techMonitor = value;
                RaisePropertyChangedAuto();

                ItemGuid = value != null ? value.Guid : null;
                TechName = _techMonitor != null ? _techMonitor.Description : null;

                OnTechMonitorChanged();
            }
        }

        private SingleGraphElementEditor _editor;
        /// <summary>
        /// Gets or sets the item editor.
        /// </summary>
        [XmlIgnore]
        public SingleGraphElementEditor Editor
        {
            get { return _editor; }
            set
            {
                _editor = value;
                SetEditorSettings();
            }
        }

        private int _duration;
        public int Duration
        {
            get { return _duration; }
            set
            {
                _duration = value;
                RaisePropertyChangedAuto();
                SetEditorSettings();
            }
        }

        private double _min;
        /// <summary>
        /// Gets or sets the minimum graph value.
        /// </summary>
        public double Min
        {
            get { return _min; }
            set
            {
                _min = value; RaisePropertyChangedAuto();
                SetEditorSettings();
            }
        }

        private double _max;
        /// <summary>
        /// Gets or sets the maximum graph value.
        /// </summary>
        public double Max
        {
            get { return _max; }
            set
            {
                _max = value; RaisePropertyChangedAuto();
                SetEditorSettings();
            }
        }

        private bool _useAutoRange;
        /// <summary>
        /// Gets or sets a value indicating whether [use automatic range].
        /// </summary>
        public bool UseAutoRange
        {
            get { return _useAutoRange; }
            set
            {
                _useAutoRange = value; RaisePropertyChangedAuto();
                SetEditorSettings();
            }
        }

        private int _decimalPlaces;
        /// <summary>
        /// Gets or sets the decimal places of y-axis.
        /// </summary>
        public int DecimalPlaces
        {
            get { return _decimalPlaces; }
            set { _decimalPlaces = value; RaisePropertyChangedAuto(); }
        }

        private bool _isPaused;
        /// <summary>
        /// Gets or sets a value indicating whether this instance is paused.
        /// </summary>
        [XmlIgnore]
        public bool IsPaused
        {
            get { return _isPaused; }
            set
            {
                _isPaused = value; RaisePropertyChangedAuto();
                SetEditorSettings();
            }
        }

        private bool _isRecording;
        /// <summary>
        /// Gets or sets a value indicating whether this instance is recording.
        /// </summary>
        [XmlIgnore]
        public bool IsRecording
        {
            get { return _isRecording; }
            set { _isRecording = value; RaisePropertyChangedAuto(); }
        }

        private TimeSpan _recordingTime;
        [XmlIgnore]
        public TimeSpan RecordingTime
        {
            get { return _recordingTime; }
            set { _recordingTime = value; RaisePropertyChangedAuto(); }
        }

        [XmlIgnore]
        public RelayCommand ClearCommand { get; set; }

        [XmlIgnore]
        public RelayCommand ToggleRecordingCommand { get; set; }

        /// <summary>
        /// Gets or sets the reset minimum maximum to default command.
        /// </summary>
        [XmlIgnore]
        public RelayCommand ResetMinMaxToDefaultCommand { get; set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="SingleGraphItem"/> class.
        /// </summary>
        public SingleGraphItem() : base()
        {
            _useAutoRange = true;
            DecimalPlaces = 1;
            _duration = 10;
            _timer = new DispatcherTimer();
            _timer.Tick += _timer_Tick;
            _timer.Interval = TimeSpan.FromSeconds(1);
            Max = 100;
            Name = "Single Channel Graph";
            Description = "Single channel real-time graph";
            Image = ResourceHelper.GetImageFromResources("Images/single-graph.png");
            Color = Colors.DodgerBlue;

            ClearCommand = new RelayCommand(() =>
            {
                if (Editor != null)
                {
                    Editor.InnerGraph.Controller.Clear();
                }
            });

            ToggleRecordingCommand = new RelayCommand(ToggleRecording);

            ResetMinMaxToDefaultCommand = new RelayCommand(() => 
            {
                if (TechMonitor != null)
                {
                    Min = TechMonitor.Min;
                    Max = TechMonitor.Max;
                }
            });
        }

        private void SetEditorSettings()
        {
            if (Editor != null)
            {
                var controller = Editor.InnerGraph.Controller as WpfGraphController<TimeSpanDataPoint, DoubleDataPoint>; ;

                controller.Range.MaximumX = new TimeSpanDataPoint(TimeSpan.FromSeconds(_duration));
                controller.Range.MinimumY = new DoubleDataPoint(_min);
                controller.Range.MaximumY = new DoubleDataPoint(_max);
                controller.Range.AutoY = _useAutoRange;
                controller.IsPaused = _isPaused;
                controller.DataSeriesCollection[0].Stroke = Color;
            }
        }

        private void _timer_Tick(object sender, EventArgs e)
        {
            RecordingTime = DateTime.Now - _recording_start_time;
        }

        private void ToggleRecording()
        {
            if (!IsRecording)
            {
                RecordingStarted?.Invoke();
            }
            else
            {
                RecordingStopped?.Invoke();
            }
        }

        public void StartRecording()
        {
            _recording_start_time = DateTime.Now;
            IsRecording = true;
            _timer.Start();
        }

        public void StopRecording()
        {
            _timer.Stop();
            IsRecording = false;
            RecordingTime = TimeSpan.FromSeconds(0);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SingleGraphItem"/> class.
        /// </summary>
        /// <param name="techMonitor">The db tech monitor.</param>
        public SingleGraphItem(TechMonitor techMonitor) : this()
        {
            TechMonitor = techMonitor;
        }

        private void OnTechMonitorChanged()
        {
            if (TechMonitor != null)
            {
                Min = TechMonitor.Min;
                Max = TechMonitor.Max;
            }
        }

        /// <summary>
        /// Clones this instance.
        /// </summary>
        /// <returns></returns>
        public override TechItem Clone()
        {
            SingleGraphItem cloned = base.Clone() as SingleGraphItem;
            cloned.TechMonitor = TechMonitor;
            cloned.Min = Min;
            cloned.Max = Max;
            cloned.UseAutoRange = UseAutoRange;
            cloned.Duration = Duration;
            cloned.DecimalPlaces = DecimalPlaces;
            return cloned;
        }

        protected override void RaisePropertyChanged(string propName)
        {
            base.RaisePropertyChanged(propName);

            if (propName == nameof(Color))
            {
                SetEditorSettings();
            }
        }
    }
}