using Newtonsoft.Json;
using RealTimeGraphX.DataPoints;
using RealTimeGraphX.WPF;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core.Commands;
using Tango.FSE.Common.Diagnostics;

namespace Tango.FSE.Diagnostics.Project.Widgets.RealTimeGraph
{
    public abstract class RealTimeGraphWidgetBase<T> : DiagnosticsConfigurableWidget<T>, ISupportsComponentSelection<TechMonitors> where T : RealTimeGraphWidgetSettings, new()
    {
        public TechMonitors Monitor { get; set; }

        private TechMonitor _techMonitor;
        [JsonIgnore]
        public TechMonitor TechMonitor
        {
            get { return _techMonitor; }
            set { _techMonitor = value; RaisePropertyChangedAuto(); RaisePropertyChanged(nameof(DisplayName)); }
        }

        [JsonIgnore]
        public override string DisplayName
        {
            get
            {
                return this.TechMonitor != null ? this.TechMonitor.Description : String.Empty;
            }
        }

        [JsonIgnore]
        public WpfGraphController<TimeSpanDataPoint, DoubleDataPoint> Controller { get; set; }

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

        public RealTimeGraphWidgetBase()
        {
            Controller = new WpfGraphController<TimeSpanDataPoint, DoubleDataPoint>();
            Controller.Range.MinimumY = Settings.Min;
            Controller.Range.MaximumY = Settings.Max;
            Controller.Range.AutoY = Settings.AutoRange;
            Controller.Range.MaximumX = Settings.Duration;
            Controller.RefreshRate = TimeSpan.FromMilliseconds(300);
            Controller.DisableRendering = true;

            Controller.DataSeriesCollection.Add(new WpfGraphDataSeries()
            {
                Stroke = Settings.Color
            });

            ClearCommand = new RelayCommand(Clear);
        }

        public void Clear()
        {
            Controller?.Clear();
        }

        public override async Task Init()
        {
            Clear();
            int monitor = (int)Monitor;
            TechMonitor = await Services.TechComponentsService.Monitors.FindOne(x => x.Code == monitor);
        }

        public override FrameworkElement GetView()
        {
            return new RealTimeGraphWidgetView();
        }

        protected override void OnVisibleChanged(bool isVisible)
        {
            base.OnVisibleChanged(isVisible);
            Controller.DisableRendering = !isVisible;
        }

        protected override void OnSettingsChanged()
        {
            base.OnSettingsChanged();

            if (Controller != null)
            {
                Controller.Range.MinimumY = Settings.Min;
                Controller.Range.MaximumY = Settings.Max;
                Controller.Range.AutoY = Settings.AutoRange;
                Controller.Range.MaximumX = Settings.Duration;

                if (Controller.DataSeriesCollection.Count > 0)
                {
                    Controller.DataSeriesCollection[0].Stroke = Settings.Color;
                }
            }
        }

        public override void OnDiagnosticsData(DiagnosticsPackage package)
        {
            var points = package.GetMonitorArray(Monitor);

            if (points.Count > 0)
            {
                List<TimeSpanDataPoint> dates = new List<TimeSpanDataPoint>();
                var dPoints = points.Select(x => new DoubleDataPoint(x)).ToList();

                DateTime dayStart = new DateTime(package.Frame.DiagnosticsTime.Year, package.Frame.DiagnosticsTime.Month, package.Frame.DiagnosticsTime.Day);
                TimeSpan offset = package.Frame.DiagnosticsTime - dayStart;

                for (int i = 0; i < points.Count; i++)
                {
                    dates.Add(
                        offset
                        .Add(TimeSpan.FromMilliseconds(-package.Frame.Delta.TotalMilliseconds))
                        .Add(TimeSpan.FromMilliseconds(package.Frame.Delta.TotalMilliseconds * (i / (double)points.Count))));
                }

                Controller.PushData(dates, dPoints);
            }
        }

        #region Component Selection

        public virtual List<DiagnosticsWidgetComponent<TechMonitors>> Components
        {
            get
            {
                return Services.TechComponentsService.Monitors.FindAll().Result.Where(x => !x.MultiChannel).Select(x => new DiagnosticsWidgetComponent<TechMonitors>()
                {
                    DisplayName = x.Description,
                    Object = (TechMonitors)x.Code,
                }).OrderByAlphaNumeric(x => x.DisplayName).ToList();
            }
        }

        public TechMonitors SelectedComponent
        {
            get
            {
                return Monitor;
            }
            set
            {
                if (Monitor != value)
                {
                    Monitor = value;
                    InitAsync();
                }
            }
        }

        public bool EnableComponentSelection { get; set; }

        #endregion
    }
}