using GalaSoft.MvvmLight.Ioc;
using RealTimeGraphEx.Controllers;
using RealTimeGraphEx.DataSeries;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media;
using Tango.Core.Commands;
using Tango.Integration.Observables;
using Tango.MachineStudio.Common.Controls;
using Tango.MachineStudio.Common.Notifications;
using Tango.MachineStudio.Common.StudioApplication;
using Tango.SharedUI;

namespace Tango.MachineStudio.Developer.ViewModels
{
    /// <summary>
    /// Represents the developer module main view, view model.
    /// </summary>
    /// <seealso cref="Tango.SharedUI.ViewModel" />
    public class MainViewVM : ViewModel
    {
        private INotificationProvider _notification;

        #region Properties

        /// <summary>
        /// Gets or sets the application manager.
        /// </summary>
        public IStudioApplicationManager ApplicationManager { get; set; }

        /// <summary>
        /// Gets or sets observable entites database the adapter.
        /// </summary>
        public ObservablesEntitiesAdapter Adapter { get; set; }

        protected Machine _selectedMachine;
        /// <summary>
        /// Gets or sets the selected machine.
        /// </summary>
        public Machine SelectedMachine
        {
            get { return _selectedMachine; }
            set
            {
                _selectedMachine = value;
                OnMachineChanged();
                RaisePropertyChangedAuto();
                InvalidateRelayCommands();

                if (_selectedMachine != null)
                {
                    _selectedMachine.Saved -= SelectedMachine_Saved;
                    _selectedMachine.Saved += SelectedMachine_Saved;
                }
            }
        }

        private List<LiquidTypesRml> _liquidTypesRmls;
        /// <summary>
        /// Gets or sets the liquid types RMLS.
        /// </summary>
        public List<LiquidTypesRml> LiquidTypesRmls
        {
            get { return _liquidTypesRmls; }
            set { _liquidTypesRmls = value; RaisePropertyChangedAuto(); }
        }

        private ProcessParametersTablesGroup _rmlProcessParametersTablesGroup;
        /// <summary>
        /// Gets or sets the RML process parameters table group (cloned).
        /// </summary>
        public ProcessParametersTablesGroup RmlProcessParametersTableGroup
        {
            get { return _rmlProcessParametersTablesGroup; }
            set
            { _rmlProcessParametersTablesGroup = value; RaisePropertyChangedAuto(); OnProcessParametersTableGroupChanged(); }
        }

        private ObservableCollection<ProcessParametersTablesGroup> _groupsHistory;
        /// <summary>
        /// Gets or sets the RML process parameters groups history.
        /// </summary>
        public ObservableCollection<ProcessParametersTablesGroup> GroupsHistory
        {
            get { return _groupsHistory; }
            set { _groupsHistory = value; RaisePropertyChangedAuto(); }
        }

        private ProcessParametersTablesGroup _selectedGroupHistory;

        /// <summary>
        /// Gets or sets the selected process parameters tables group history.
        /// </summary>
        public ProcessParametersTablesGroup SelectedGroupHistory
        {
            get { return _selectedGroupHistory; }
            set { _selectedGroupHistory = value; RaisePropertyChangedAuto(); OnSelectedGroupHistoryChanged(); }
        }

        private ProcessParametersTable _selectedProcessParametersTable;
        /// <summary>
        /// Gets or sets the selected process parameters table.
        /// </summary>
        public ProcessParametersTable SelectedProcessParametersTable
        {
            get { return _selectedProcessParametersTable; }
            set { _selectedProcessParametersTable = value; RaisePropertyChangedAuto(); }
        }

        private Job _selectedJob;
        /// <summary>
        /// Gets or sets the selected machine job.
        /// </summary>
        public Job SelectedJob
        {
            get { return _selectedJob; }
            set
            {
                _selectedJob = value;
                RaisePropertyChangedAuto();
                OnSelectedJobChanged();
            }
        }

        private Segment _selectedSegment;
        /// <summary>
        /// Gets or sets the job selected segment.
        /// </summary>
        public Segment SelectedSegment
        {
            get { return _selectedSegment; }
            set { _selectedSegment = value; RaisePropertyChangedAuto(); OnSelectedSegmentChanged(); }
        }

        private BrushStop _selectedBrushStop;
        /// <summary>
        /// Gets or sets the selected segment selected brush stop.
        /// </summary>
        public BrushStop SelectedBrushStop
        {
            get { return _selectedBrushStop; }
            set { _selectedBrushStop = value; RaisePropertyChangedAuto(); }
        }

        private Rml _selectedRML;
        /// <summary>
        /// Gets or sets the selected RML.
        /// </summary>
        public Rml SelectedRML
        {
            get { return _selectedRML; }
            set
            {
                _selectedRML = value;
                InvalidateLiquidFactorsAndProcessTables();
                RaisePropertyChangedAuto();
                InvalidateRelayCommands();
            }
        }

        private bool _isSideBarOpened;
        /// <summary>
        /// Gets or sets a value indicating whether the configuration panels are opened.
        /// </summary>
        public bool IsSideBarOpened
        {
            get { return _isSideBarOpened; }
            set { _isSideBarOpened = value; RaisePropertyChangedAuto(); }
        }

        private ObservableCollection<Sensor> _availableSensors;
        /// <summary>
        /// Gets or sets the available sensors.
        /// </summary>
        public ObservableCollection<Sensor> AvailableSensors
        {
            get { return _availableSensors; }
            set { _availableSensors = value; RaisePropertyChangedAuto(); }
        }

        private ObservableCollection<IRealTimeGraph> _graphs;
        /// <summary>
        /// Gets or sets the collection of displayed graph controls.
        /// </summary>
        public ObservableCollection<IRealTimeGraph> Graphs
        {
            get { return _graphs; }
            set { _graphs = value; RaisePropertyChangedAuto(); }
        }

        private TimeSpan _estimatedDuration;
        /// <summary>
        /// Gets or sets the estimated duration for the selected job.
        /// </summary>
        public TimeSpan EstimatedDuration
        {
            get { return _estimatedDuration; }
            set { _estimatedDuration = value; RaisePropertyChangedAuto(); }
        }

        #endregion

        #region Commands

        /// <summary>
        /// Gets or sets the edit machine command.
        /// </summary>
        public RelayCommand EditMachineCommand { get; set; }

        /// <summary>
        /// Gets or sets the edit RML command.
        /// </summary>
        public RelayCommand EditRMLCommand { get; set; }

        /// <summary>
        /// Gets or sets the toggle side bar command.
        /// </summary>
        public RelayCommand ToggleSideBarCommand { get; set; }

        /// <summary>
        /// Gets or sets the save process parameters command.
        /// </summary>
        public RelayCommand SaveProcessParametersCommand { get; set; }

        /// <summary>
        /// Gets or sets the save liquid factors command.
        /// </summary>
        public RelayCommand SaveLiquidFactorsCommand { get; set; }

        /// <summary>
        /// Gets or sets the add segment command.
        /// </summary>
        public RelayCommand AddSegmentCommand { get; set; }

        /// <summary>
        /// Gets or sets the remove segment command.
        /// </summary>
        public RelayCommand RemoveSegmentCommand { get; set; }

        /// <summary>
        /// Gets or sets the add job command.
        /// </summary>
        public RelayCommand AddJobCommand { get; set; }

        /// <summary>
        /// Gets or sets the remove job command.
        /// </summary>
        public RelayCommand RemoveJobCommand { get; set; }

        /// <summary>
        /// Gets or sets the add brush stop command.
        /// </summary>
        public RelayCommand AddBrushStopCommand { get; set; }

        /// <summary>
        /// Gets or sets the remove brush stop command.
        /// </summary>
        public RelayCommand RemoveBrushStopCommand { get; set; }

        #endregion

        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="MainViewVM"/> class.
        /// </summary>
        public MainViewVM()
        {
            IsSideBarOpened = true;

            if (!this.DesignMode)
            {
                Adapter = ObservablesEntitiesAdapter.Instance;
                AvailableSensors = Adapter.Sensors.ToObservableCollection();
            }

            Graphs = new ObservableCollection<IRealTimeGraph>();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MainViewVM"/> class.
        /// </summary>
        /// <param name="applicationManager">The application manager.</param>
        /// <param name="notificationProvider">The notification provider.</param>
        [PreferredConstructor]
        public MainViewVM(IStudioApplicationManager applicationManager, INotificationProvider notificationProvider) : this()
        {
            _notification = notificationProvider;
            EditMachineCommand = new RelayCommand(EditMachine, (x) => SelectedMachine != null);
            ApplicationManager = applicationManager;
            EditRMLCommand = new RelayCommand(EditRML, (x) => SelectedRML != null);
            ToggleSideBarCommand = new RelayCommand(() => IsSideBarOpened = !IsSideBarOpened);
            SaveProcessParametersCommand = new RelayCommand(SaveProcessParameters);
            SaveLiquidFactorsCommand = new RelayCommand(SaveLiquidFactors);
            AddSegmentCommand = new RelayCommand(AddSegment);
            RemoveSegmentCommand = new RelayCommand(RemoveSegment);
            AddJobCommand = new RelayCommand(AddJob);
            RemoveJobCommand = new RelayCommand(RemoveJob);
            AddBrushStopCommand = new RelayCommand(AddBrushStop);
            RemoveBrushStopCommand = new RelayCommand(RemoveBrushStop);
        }

        #endregion

        #region Event Handlers

        /// <summary>
        /// Handles the Saved event of the SelectedMachine.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
        private void SelectedMachine_Saved(object sender, EventArgs e)
        {
            InvalidateLiquidFactorsAndProcessTables();
        }

        private void SelectedJob_LengthChanged(object sender, EventArgs e)
        {
            UpdateEstimatedDuration();
        }

        private void SelectedProcessParametersTable_DyeingSpeedChanged(object sender, EventArgs e)
        {
            UpdateEstimatedDuration();
        }

        #endregion

        #region Virtual Methods

        /// <summary>
        /// Called when the process parameters table group has been changed
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void OnProcessParametersTableGroupChanged()
        {
            if (RmlProcessParametersTableGroup != null && RmlProcessParametersTableGroup.ProcessParametersTables.Count > 0)
            {
                SelectedProcessParametersTable = RmlProcessParametersTableGroup.ProcessParametersTables.First();

                SelectedProcessParametersTable.DyeingSpeedChanged -= SelectedProcessParametersTable_DyeingSpeedChanged;
                SelectedProcessParametersTable.DyeingSpeedChanged += SelectedProcessParametersTable_DyeingSpeedChanged;
            }

            UpdateEstimatedDuration();
        }

        /// <summary>
        /// Called when the selected segment has been changed
        /// </summary>
        protected virtual void OnSelectedSegmentChanged()
        {
            if (SelectedSegment != null)
            {
                SetSegmentBrushStopsLiquidVolumes(SelectedSegment);
                SelectedBrushStop = SelectedSegment.BrushStops.FirstOrDefault();
            }
        }

        /// <summary>
        /// Called when the selected job has been changed.
        /// </summary>
        protected virtual void OnSelectedJobChanged()
        {
            if (SelectedJob != null)
            {
                SelectedSegment = SelectedJob.Segments.FirstOrDefault();

                SelectedJob.LengthChanged -= SelectedJob_LengthChanged;
                SelectedJob.LengthChanged += SelectedJob_LengthChanged;

                UpdateEstimatedDuration();
            }
        }

        /// <summary>
        /// Called when the selected group history has been changed
        /// </summary>
        protected virtual void OnSelectedGroupHistoryChanged()
        {
            if (SelectedGroupHistory != null)
            {
                RmlProcessParametersTableGroup = SelectedGroupHistory.CloneGroup();
            }
        }

        /// <summary>
        /// Called when the machine has been changed
        /// </summary>
        protected virtual void OnMachineChanged()
        {
            InvalidateLiquidFactorsAndProcessTables();
        }

        #endregion

        #region Private Methods

        private void UpdateEstimatedDuration()
        {
            if (SelectedJob != null && SelectedProcessParametersTable != null)
            {
                EstimatedDuration = TimeSpan.FromSeconds(SelectedJob.Length / (SelectedProcessParametersTable.DyeingSpeed / 100d));
            }
        }

        private void SetSegmentBrushStopsLiquidVolumes(Segment segment)
        {
            if (!DesignMode)
            {
                foreach (var stop in segment.BrushStops)
                {
                    stop.SetLiquidVolumes(SelectedMachine.Configuration, SelectedRML);
                }
            }
        }

        /// <summary>
        /// Saves the liquid factors.
        /// </summary>
        private async void SaveLiquidFactors()
        {
            if (SelectedRML != null)
            {
                using (_notification.PushTaskItem("Saving Liquid Factors..."))
                {
                    await SelectedRML.SaveAsync();
                    InvalidateLiquidFactorsAndProcessTables();
                }
            }
        }

        /// <summary>
        /// Navigates to the DB Module in order to edit the selected RML.
        /// </summary>
        private void EditRML()
        {
            ApplicationManager.RequestModule("Data Base", SelectedRML);
        }

        /// <summary>
        /// Navigates to the Machine Designer Module in order to edit the selected machine.
        /// </summary>
        private void EditMachine()
        {
            ApplicationManager.RequestModule("Machine Designer", SelectedMachine);
        }

        /// <summary>
        /// Saves the process parameters group.
        /// </summary>
        private async void SaveProcessParameters()
        {
            var response = _notification.ShowTextInput("Enter Group Name", "Group Name");

            if (response == null) return;

            using (_notification.PushTaskItem("Saving Parameters Group..."))
            {
                ProcessParametersTablesGroup group = new ProcessParametersTablesGroup();

                List<ProcessParametersTable> tables = new List<ProcessParametersTable>();
                foreach (var table in RmlProcessParametersTableGroup.ProcessParametersTables)
                {
                    var newTable = table.CloneEntity();
                    newTable.ProcessParametersTablesGroup = group;
                    tables.Add(newTable);
                }

                group.Active = true;
                group.ProcessParametersTables = tables.ToObservableCollection();
                group.Rml = SelectedRML;
                group.Name = response;
                group.SaveDate = DateTime.UtcNow;

                foreach (var g in SelectedRML.ProcessParametersTablesGroups)
                {
                    g.Active = false;
                }

                //String machineGuid = SelectedMachine.Guid;
                //String rmlGuid = SelectedRML.Guid;

                SelectedRML.ProcessParametersTablesGroups.Add(group);
                await SelectedRML.SaveAsync();

                //SelectedMachine = Adapter.Machines.SingleOrDefault(x => x.Guid == machineGuid);
                //SelectedRML = Adapter.Rmls.SingleOrDefault(x => x.Guid == rmlGuid);

                InvalidateLiquidFactorsAndProcessTables();
            }
        }

        /// <summary>
        /// Invalidates the liquid factors and process parameters tables.
        /// </summary>
        private void InvalidateLiquidFactorsAndProcessTables()
        {
            if (SelectedRML != null && SelectedMachine != null)
            {
                LiquidTypesRmls = SelectedMachine.Configuration.IdsPacks.OrderBy(x => x.PackIndex).Select(x => x.LiquidType).SelectMany(x => x.LiquidTypesRmls).Where(x => x.Rml.Guid == SelectedRML.Guid).ToList();
                RmlProcessParametersTableGroup = SelectedRML.ProcessParametersTablesGroups.SingleOrDefault(x => x.Active);

                if (RmlProcessParametersTableGroup != null)
                {
                    RmlProcessParametersTableGroup = RmlProcessParametersTableGroup.CloneGroup();
                    RmlProcessParametersTableGroup.ProcessParametersTables = RmlProcessParametersTableGroup.ProcessParametersTables.OrderBy(x => x.TableIndex).ToObservableCollection();
                }

                GroupsHistory = SelectedRML.ProcessParametersTablesGroups.OrderByDescending(x => x.SaveDate).OrderBy(x => !x.Active).ToObservableCollection();
            }
        }

        /// <summary>
        /// Removes the selected segment.
        /// </summary>
        private void RemoveSegment()
        {
            if (SelectedJob != null && SelectedSegment != null)
            {
                SelectedSegment.DefferedDelete();
                SelectedJob.Segments.Remove(SelectedSegment);
            }
        }

        /// <summary>
        /// Adds a new segment.
        /// </summary>
        private void AddSegment()
        {
            if (SelectedJob != null)
            {
                Segment seg = new Segment();
                seg.Name = "Untitled Segment";
                seg.Length = 1;
                SelectedJob.Segments.Add(seg);
                SelectedSegment = seg;
                AddBrushStop();
            }
        }

        /// <summary>
        /// Removes the selected job.
        /// </summary>
        private void RemoveJob()
        {
            if (SelectedMachine != null && SelectedJob != null)
            {
                SelectedJob.Delete();
                SelectedMachine.Jobs.Remove(SelectedJob);
            }
        }

        /// <summary>
        /// Adds a new job to the selected machine.
        /// </summary>
        private void AddJob()
        {
            if (SelectedMachine != null)
            {
                SelectedMachine.Jobs.Add(new Job()
                {
                    Name = "Untitled Job",
                    CreationDate = DateTime.UtcNow,
                });
            }
        }

        /// <summary>
        /// Removes the selected brush stop.
        /// </summary>
        private void RemoveBrushStop()
        {
            if (SelectedBrushStop != null && SelectedSegment != null)
            {
                SelectedSegment.BrushStops.Remove(SelectedBrushStop);
            }
        }

        /// <summary>
        /// Adds a new brush stop to the selected segment.
        /// </summary>
        private void AddBrushStop()
        {
            if (SelectedSegment != null)
            {
                var stop = new BrushStop();
                stop.ColorSpace = Adapter.ColorSpaces.FirstOrDefault();
                stop.Color = Colors.Black;
                stop.SetLiquidVolumes(SelectedMachine.Configuration, SelectedRML);
                SelectedSegment.BrushStops.Add(stop);
            }
        }

        #endregion

        #region Public Events

        /// <summary>
        /// Add sensor graph from available sensors to displayed graphs.
        /// </summary>
        /// <param name="sensor">The sensor.</param>
        public void OnDropAvailableSensor(Sensor sensor)
        {
            if (Graphs.Count < 8)
            {
                IRealTimeGraph graphControl = null;

                if (!sensor.MultiChannel)
                {
                    graphControl = new RealTimeGraphControl();
                }
                else
                {
                    graphControl = new RealTimeGraphMultiControl();
                    GraphMultiController controller = new GraphMultiController();

                    for (int i = 0; i < sensor.ChannelCount; i++)
                    {
                        controller.AddSeries(new DataYSeries()
                        {
                            Name = sensor.Description.First().ToString() + (i + 1),
                            UseFillAndStroke = true,
                            Stroke = new SolidColorBrush(Core.Helpers.ColorHelper.GetRandomColor())
                        });
                    }

                    graphControl.Controller = controller;
                }

                graphControl.Tag = sensor;
                graphControl.SensorName = sensor.Description;
                graphControl.SensorUnits = sensor.Units;
                graphControl.InnerGraph.Minimum = sensor.Min;
                graphControl.InnerGraph.Maximum = sensor.Max;
                graphControl.InnerGraph.MaxPoints = Common.Helpers.GraphsHelper.GetMaxPoints(sensor.PointsPerFrame);
                graphControl.GraphRemoveButtonPressed += (sender, __) =>
                {
                    RemoveGraph(sender as IRealTimeGraph);
                };
                Graphs.Add(graphControl);
                AvailableSensors.Remove(sensor);
            }
            else
            {
                _notification.ShowInfo("The maximum number of real-time graphs is eight. Please remove a graph to add another.");
            }
        }

        /// <summary>
        /// Switch the brush stop position in the segment.
        /// </summary>
        /// <param name="draggedStop">The dragged stop.</param>
        /// <param name="droppedStop">The dropped stop.</param>
        public void OnDropBrushStop(BrushStop draggedStop, BrushStop droppedStop)
        {
            int tmpIndex = draggedStop.StopIndex;
            draggedStop.StopIndex = droppedStop.StopIndex;
            droppedStop.StopIndex = tmpIndex;

            SelectedSegment.BrushStops.Swap(draggedStop, droppedStop);
        }

        /// <summary>
        /// Removes the graph.
        /// </summary>
        /// <param name="graph">The graph.</param>
        public void RemoveGraph(IRealTimeGraph graph)
        {
            Graphs.Remove(graph);
            AvailableSensors.Insert(0, graph.Tag as Sensor);
        }

        #endregion
    }
}