using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core.Commands;
using Tango.Core.DI;
using Tango.Integration.Operation;
using Tango.PMR.Diagnostics;
using Tango.PMR.MachineStatus;
using Tango.PPC.Common;
using Tango.PPC.Common.Diagnostics;
using Tango.PPC.Jobs;
using Tango.PPC.Jobs.NavigationObjects;
using Tango.PPC.Jobs.Views;
using Tango.PPC.UI.Models;
using System.Timers;
using System.Windows.Threading;
using System.Diagnostics;
using Tango.PMR.Printing;

namespace Tango.PPC.UI.ViewModels
{
    public class MachineStatusViewVM : PPCViewModel
    {
        #region Properties

        [TangoInject]
        public IDiagnosticsFrameProvider DefaultDiagnosticsFrameProvider { get; set; }

        private JobHandler _handler;

        private Job _job;
        /// <summary>
        /// Gets or sets the job.
        /// </summary>
        public Job Job
        {
            get { return _job; }
            set
            {
                _job = value;
                if (_job == null)
                    IsDyeingProcess = false;
                RaisePropertyChangedAuto();
                InvalidateRelayCommands();
            }
        }

        private RunningJobStatus _runningJobStatus;
        /// <summary>
        /// Gets or sets the running job status.
        /// </summary>
        public RunningJobStatus RunningJobStatus
        {
            get { return _runningJobStatus; }
            set
            {
                _runningJobStatus = value;
                RaisePropertyChangedAuto();
            }
        }

        private bool _isJobStatusViewEnable;

        public bool IsJobStatusViewEnable
        {
            get { return _isJobStatusViewEnable; }
            set { _isJobStatusViewEnable = value; RaisePropertyChangedAuto(); }
        }

        private bool _isEnabledStopButton;
        /// <summary>
        /// Gets or sets a value indicating whether this instance is enabled stop button.
        /// </summary>
        public bool IsEnabledStopButton
        {
            get { return _isEnabledStopButton; }
            set { _isEnabledStopButton = value; RaisePropertyChangedAuto(); }
        }

        private bool _isSpoolView;
        /// <summary>
        /// Gets or sets a value indicating whether this instance is spool view.
        /// </summary>
        public bool IsSpoolView
        {
            get { return _isSpoolView; }
            set { _isSpoolView = value; RaisePropertyChangedAuto(); }
        }

        private bool _isWeightView;
        /// <summary>
        /// Gets or sets a value indicating whether this instance is length. Show indicator values in length or weight.
        /// </summary>
        public bool IsWeghtView
        {
            get { return _isWeightView; }
            set { _isWeightView = value; RaisePropertyChangedAuto(); }
        }


        private bool _isDyeingProcess;

        public bool IsDyeingProcess
        {
            get { return _isDyeingProcess; }
            set
            {
                if (_isDyeingProcess != value)
                {
                    _isDyeingProcess = value;
                    RaisePropertyChangedAuto();
                }
            }
        }

        private BrushStop _currentBrushStop;
        public BrushStop CurrentBrushStop
        {
            get { return _currentBrushStop; }
            set
            {
                // if (_currentBrushStop != value)
                {
                    _currentBrushStop = value;
                    OnUpdateCurrentBrush();
                    RaisePropertyChangedAuto();
                }
            }
        }

        public JobBrushStop JobBrushStop { get; set; }

        public double CyanOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.Cyan); }
        }

        public double MagentaOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.Magenta); }
        }

        public double YellowOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.Yellow); }
        }

        public double BlackOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.Black); }
        }

        public double LightCyanOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.LightCyan); }
        }

        public double LightMagentaOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.LightMagenta); }
        }

        public double LightYellowOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.LightYellow); }
        }

        //public double TransparentInkOutput
        //{
        //    get { return GetVolumeLiquidType(LiquidTypes.TransparentInk); }
        //}

        //public double LubricantOutput
        //{
        //    get { return GetVolumeLiquidType(LiquidTypes.Lubricant); }
        //}

        private List<JerricanLevelModel> _midTankLevels;
        public List<JerricanLevelModel> MidTankLevels
        {
            get { return _midTankLevels; }
            set { _midTankLevels = value; RaisePropertyChangedAuto(); }
        }

        private JerricanLevelModel _midTankLubLevel;
        public JerricanLevelModel MidTankLubLevel
        {
            get { return _midTankLubLevel; }
            set { _midTankLubLevel = value; RaisePropertyChangedAuto(); }
        }

        public MachineOverviewModel OverviewModel { get; set; }

        private bool _isDisplayJobOutline;
        /// <summary>
        /// Gets or sets a value indicating whether to display the job outline.
        /// </summary>
        public bool IsDisplayJobOutline
        {
            get { return _isDisplayJobOutline; }
            set { _isDisplayJobOutline = value; RaisePropertyChangedAuto(); }
        }

        private JobTicket _jobOutlineTicket;
        /// <summary>
        /// Gets or sets the job outline ticket.
        /// </summary>
        public JobTicket JobOutlineTicket
        {
            get { return _jobOutlineTicket; }
            set { _jobOutlineTicket = value; RaisePropertyChangedAuto(); }
        }

        public MachineOverviewErrorStates MachineErrorStates {  get; set; }

        #endregion

        #region Commands

        public RelayCommand StopCommand { get; set; }

        public RelayCommand AbortCommand { get; set; }

        public RelayCommand GoToJobCommand { get; set; }

        /// <summary>
        /// Gets or sets the job status view command.
        /// </summary>
        public RelayCommand JobStatusViewCommand { get; set; }

        /// <summary>
        /// Gets or sets the overview view command.
        /// </summary>
        public RelayCommand OverviewViewCommand { get; set; }

        public RelayCommand ClearAllNotificationsCommand { get; set; }

        public RelayCommand DisplayJobOutlineCommand { get; set; }

        public RelayCommand HideJobOutlineCommand { get; set; }

        #endregion

        public MachineStatusViewVM()
        {


            StopCommand = new RelayCommand(StopJob, () => CanStopped());
            AbortCommand = new RelayCommand(AbortJob, () => CanStopped());
            GoToJobCommand = new RelayCommand(GoToJob, () => IsEnableGoToJob());
            JobStatusViewCommand = new RelayCommand(JobStatusView);
            OverviewViewCommand = new RelayCommand(OverviewView);
            ClearAllNotificationsCommand = new RelayCommand(ClearAllNotifications);
            DisplayJobOutlineCommand = new RelayCommand(DisplayJobOutline);
            HideJobOutlineCommand = new RelayCommand(HideJobOutline);

            IsJobStatusViewEnable = true;
            IsEnabledStopButton = false;
            IsSpoolView = false;
            IsWeghtView = false;

            OverviewModel = new MachineOverviewModel();
            MachineErrorStates = new MachineOverviewErrorStates();
        }

        public override void OnApplicationReady()
        {
            base.OnApplicationReady();

            MidTankLevels = MachineProvider.Machine.Configuration.NoneEmptyIdsPacks.Where(x => x.MidTankType.HasLevelMeasure ).OrderBy(x => x.PackIndex).Select(x => new JerricanLevelModel()
            {
                Max = x.MidTankType.LiterCapacity,
                IDSPack = x,
            }).OrderBy(y => y.IDSPack.LiquidType.Type).ToList();
            var LubLevel = MachineProvider.Machine.Configuration.NoneEmptyIdsPacks.Where(x => x.MidTankType.Type == MidTankTypes.LubricantMidTank).FirstOrDefault();
           
            MidTankLubLevel = new JerricanLevelModel();
            if(LubLevel != null)
            {
                MidTankLubLevel.Max = LubLevel.MidTankType.LiterCapacity;
                MidTankLubLevel.IDSPack = LubLevel;
            };

            MachineProvider.MachineOperator.MachineStatusChanged += MachineOperator_MachineStatusChanged;

        }

        #region Events

        private void MachineOperator_MachineStatusChanged(object sender, MachineStatus status)
        {
            UpdateMidTankLevels(status);
            UpdateMachineStatusErrors(status);
        }
        private void UpdateMidTankLevels(MachineStatus status)
        {
            if (!IsJobStatusViewEnable)
            {
                foreach (var item in status.IDSPacksLevels)
                {
                    JerricanLevelModel model = null;
                    if (item.Index == 8)//lub
                    {
                        model = MidTankLubLevel;

                    }
                    else { 
                        model = MidTankLevels.SingleOrDefault(x => x.IDSPack.PackIndex == item.Index);
                    }

                    if (model != null)
                    {
                        model.Level = item.MidTankLevel;
                        model.JerricanPresent = item.JerricanPresent;
                        model.FillingTimeoutError = item.FillingTimeoutError;
                        model.MidTankEmpty = item.MidTankEmpty;
                        model.MidTankRefillPumpActive = item.MidTankRefillPumpActive;
                        model.RemainingTimeoutError = TimeSpan.FromSeconds(item.TimerRemainingSeconds);
                    }
                    //TEST
                    //if (model != null)
                    //{
                    //    var Li = model.IDSPack.LiquidType.Type;
                    //    var Mid = model.IDSPack.MidTankType.Type;
                    //    model.Level = 0.0;
                    //model.JerricanPresent = false;
                    //model.FillingTimeoutError = false;
                    //model.MidTankEmpty = true;
                    //model.MidTankRefillPumpActive = false;
                    //model.RemainingTimeoutError = TimeSpan.FromSeconds(300);

                    //if (item.Index == 1)
                    //{
                    //    model.Level = 1.0;
                    //}
                    //if (item.Index == 2)
                    //{
                    //    model.Level = 2.0;
                    //}
                    //if (item.Index == 3)
                    //{
                    //    model.Level = 3.0;
                    //}
                    //if (item.Index == 4)//TI
                    //{
                    //    model.Level = 7.0;
                    //}
                    //if (item.Index == 5)//LC
                    //{
                    //    model.Level = 7.0;
                    //}
                    //if (item.Index == 6)//LM
                    //{
                    //    model.Level = 3.5;
                    //}
                    //if (item.Index == 7)//LY
                    //{
                    //    model.Level = 2.5;
                    //}
                    //    if (item.Index == 8)//Lub
                    //    {
                    //        model.Level = 1.5;
                    //    }
                    //    if (item.Index ==9)
                    //    {
                    //        model.Level = 4.99;
                    //    }
                        
                    //}
                    //////////////////////////////
                }
            }
        }

        private void UpdateMachineStatusErrors(MachineStatus status)
        {
            var windersInError = status.WindersInError.ToList();// to test
            MachineErrorStates.UpdateWinders(windersInError);
            var dansersInError = status.DancersInError.ToList();
            MachineErrorStates.UpdateDancers(dansersInError);
            var btsrsInErrors = status.BtsrsInError.ToList();
            MachineErrorStates.UpdateBTSRs(btsrsInErrors);
        }

        private void MachineOperator_InkFillingStatusChanged(object sender, InkFillingStatusChangedEventArgs e)
        {
            //foreach (var cartridge in e.Status.CartridgesStatuses.Where(x => x.Cartridge.Slot != CartridgeSlot.Ink))
            //{
            //    var wasteState = WasteStates.SingleOrDefault(x => x.Slot == cartridge.Cartridge.Slot);

            //    if (wasteState != null)
            //    {
            //        wasteState.State = cartridge.State;
            //    }
            //}
        }

        #endregion

        #region printing

        public override void OnApplicationStarted()
        {
            MachineProvider.MachineOperator.PrintingStarted += MachineOperator_PrintingStarted;
            MachineProvider.MachineOperator.PrintingEnded += MachineOperator_PrintingEnded;

            DefaultDiagnosticsFrameProvider.FrameReceived += DefaultDiagnosticsFrameProvider_FrameReceived;
        }

        private void DefaultDiagnosticsFrameProvider_FrameReceived(object sender, PMR.Diagnostics.StartDiagnosticsResponse e)
        {
            OverviewModel.Update(e, this.Job != null ? Job.Rml : null, null);
        }

        private void MachineOperator_PrintingStarted(object sender, PrintingEventArgs e)
        {
            _handler = e.JobHandler;
            Job = e.Job;
            e.JobHandler.StatusChanged += JobHandler_StatusChanged;
            //e.JobHandler.SpoolChangeRequired += JobHandler_SpoolChangeRequired;
            e.JobHandler.Stopped += JobHandler_Stopped;
            e.JobHandler.CanCancelChanged += JobHandler_CanCancelChanged;
            InvokeUI(() =>
            {
                IsEnabledStopButton = true;
                StopCommand.RaiseCanExecuteChanged();
                AbortCommand.RaiseCanExecuteChanged();
            });


        }

        private void JobHandler_Stopped(object sender, EventArgs e)
        {
            if (_handler != null)
            {
                _handler.StatusChanged -= JobHandler_StatusChanged;
                //_handler.SpoolChangeRequired -= JobHandler_SpoolChangeRequired;
                _handler.Stopped -= JobHandler_Stopped;
                _handler.StatusChanged -= JobHandler_StatusChanged;
                _handler.CanCancelChanged -= JobHandler_CanCancelChanged;
            }
        }

        private void MachineOperator_PrintingEnded(object sender, PrintingEventArgs e)
        {
            LogManager.Log("Printing ended");
            InvokeUI(() =>
            {
                IsEnabledStopButton = false;
                StopCommand.RaiseCanExecuteChanged();
                AbortCommand.RaiseCanExecuteChanged();
            });
        }

        private void JobHandler_StatusChanged(object sender, RunningJobStatus e)
        {
            RunningJobStatus = e;
            IsDyeingProcess = (RunningJobStatus != null && RunningJobStatus.CurrentSegment != null);
            if (RunningJobStatus != null && RunningJobStatus.CurrentSegment != null)
            {
                var segment = Job.Segments.FirstOrDefault(x => x.SegmentIndex == _runningJobStatus.CurrentSegment.SegmentIndex);
                if (segment != null)
                {

                    if (_handler.JobTicket.Segments.Count > 0)
                    {
                        JobBrushStop = _handler.JobTicket.Segments[Job.OrderedSegments.IndexOf(segment)].BrushStops.First();
                    }

                    CurrentBrushStop = segment.FirstBrushStop;
                }
            }
        }

        private void JobHandler_CanCancelChanged(object sender, EventArgs e)
        {
            InvokeUI(() =>
           {
               IsEnabledStopButton = _handler.CanCancel;
               StopCommand.RaiseCanExecuteChanged();
               AbortCommand.RaiseCanExecuteChanged();
           });
        }

        #endregion

        #region Methods

        private bool IsEnableGoToJob()
        {
            return Job != null && _handler != null;
        }

        private void GoToJob()
        {

            NavigationManager.NavigateWithObject<JobsV2Module, JobEurekaView, JobNavigationObject>(new JobNavigationObject() { Job = _handler.Job });
            NavigationManager.ClearHistoryExcept<JobsView>();

        }
        /// <summary>
        /// Toggles the application technician mode.
        /// </summary>
        public void ToggleTechnicianMode()
        {
            if (!ApplicationManager.IsInTechnicianMode)
            {
                ApplicationManager.EnterTechnicianMode();
            }
            else
            {
                ApplicationManager.ExitTechnicianMode();
            }
        }

        protected void JobStatusView()
        {
            IsJobStatusViewEnable = true;
        }

        protected void OverviewView()
        {
            IsJobStatusViewEnable = false;
        }

        private double GetVolumeLiquidType(LiquidTypes liquidType)
        {
            if (JobBrushStop != null && JobBrushStop.Dispensers != null && JobBrushStop.Dispensers.Count > 0)
            {
                var lt = JobBrushStop.Dispensers.FirstOrDefault(x => x.DispenserLiquidType == (DispenserLiquidType)liquidType);

                if (lt != null)
                {
                    return Math.Round(lt.Volume, 2);
                }
            }
            return 0;
        }

        private bool CanStopped()
        {
            return IsEnabledStopButton;
        }

        private void StopJob()
        {
            _handler?.Cancel();
        }

        private void AbortJob()
        {
            _handler?.Cancel();
            Job = null;
        }

        protected void ClearAllNotifications()
        {
            NotificationProvider.NotificationItems.Where(x => x.CanClose).ToList().ForEach(y => NotificationProvider.PopNotification(y));
        }

        protected void OnUpdateCurrentBrush()
        {
            RaisePropertyChanged(nameof(CyanOutput));
            RaisePropertyChanged(nameof(LightCyanOutput));
            RaisePropertyChanged(nameof(MagentaOutput));
            RaisePropertyChanged(nameof(LightMagentaOutput));
            RaisePropertyChanged(nameof(YellowOutput));
            RaisePropertyChanged(nameof(LightYellowOutput));
            RaisePropertyChanged(nameof(BlackOutput));
        }

        private void HideJobOutline()
        {
            IsDisplayJobOutline = false;
        }

        private void DisplayJobOutline()
        {
            if(_handler != null && _handler.JobTicket != null)
            {
                JobOutlineTicket = _handler.JobTicket;
                IsDisplayJobOutline = true;
            }
        }

        #endregion
    }
}