using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core.Commands;
using Tango.Core.DI;
using Tango.Logging;
using Tango.PPC.Common.Connection;
using Tango.PPC.Common.Notifications;
using Tango.SharedUI;

namespace Tango.PPC.UI.Dialogs
{
    public class ThreadBreakViewVM : DialogViewVM
    {
        public enum ThreadBreakWizardResult
        {
            None,
            StartThreadLoading
        }

        public enum WizardStage
        {
            Welcome,
            GuidingUnits,
            FeedingUnits,
            Jogging,
            TheDryer,
            DryerClose,
            Fixed,
            ContactSupport,
        }

        [TangoInject]
        private IMachineProvider MachineProvider { get; set; }

        [TangoInject]
        private INotificationProvider NotificationProvider { get; set; }

        public ThreadBreakWizardResult Result { get; set; }

        private WizardStage _stage;
        public WizardStage Stage
        {
            get { return _stage; }
            set { _stage = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        private bool _isArcHead;
        public bool IsArcHead
        {
            get { return _isArcHead; }
            set { _isArcHead = value; RaisePropertyChangedAuto(); }
        }

        public RelayCommand BackCommand { get; set; }

        //Guiding Units
        public RelayCommand GuidingUnitsFoundCantFixCommand { get; set; }
        public RelayCommand GuidingUnitsCantFindItCommand { get; set; }
        public RelayCommand GuidingUnitsFoundAndFixedCommand { get; set; }

        //Feeding Units
        public RelayCommand FeedingUnitsCantFixCommand { get; set; }
        public RelayCommand FeedingUnitsFoundAndFixedCommand { get; set; }

        //The Dryer
        public RelayCommand TheDryerCantRemoveCommand { get; set; }
        public RelayCommand TheDryerRemovedSuccessfullyCommand { get; set; }

        //Dryer Close
        public RelayCommand OpenThreadLoadingWizardCommand { get; set; }

        public ThreadBreakViewVM()
        {
            CanClose = true;
            TangoIOC.Default.Inject(this);

            MachineProvider.MachineOperator.MachineEventsStateProvider.EventsChanged += MachineEventsStateProvider_EventsChanged;
            MachineProvider.MachineDisconnected += MachineProvider_MachineDisconnected;

            IsArcHead = MachineProvider.Machine.MachineHeadType == BL.Enumerations.HeadTypes.Arc;

            BackCommand = new RelayCommand(GoBack, CanGoBack);

            //Guiding Units Commands
            GuidingUnitsFoundCantFixCommand = new RelayCommand(GuidingUnitsFoundCantFix);
            GuidingUnitsCantFindItCommand = new RelayCommand(GuidingUnitsCantFindIt);
            GuidingUnitsFoundAndFixedCommand = new RelayCommand(GuidingUnitsFoundAndFixed);

            //Feeding Units Commands
            FeedingUnitsCantFixCommand = new RelayCommand(FeedingUnitsCantFix);
            FeedingUnitsFoundAndFixedCommand = new RelayCommand(FeedingUnitsFoundAndFixed);

            //The Dryer Commands
            TheDryerRemovedSuccessfullyCommand = new RelayCommand(TheDryerRemovedSuccessfully);
            TheDryerCantRemoveCommand = new RelayCommand(TheDryerCantRemove);

            OpenThreadLoadingWizardCommand = new RelayCommand(OpenThreadLoadingWizard, () => !MachineProvider.MachineOperator.MachineEventsStateProvider.Events.Any(x => x.Type == BL.Enumerations.EventTypes.DRYER_DOOR_OPEN));
        }

        private void MachineProvider_MachineDisconnected(object sender, EventArgs e)
        {
            InvokeUI(() =>
            {
                Cancel();
            });
        }

        private void MachineEventsStateProvider_EventsChanged(object sender, IEnumerable<BL.Entities.MachinesEvent> e)
        {
            InvalidateRelayCommands();
        }

        #region Back

        private bool CanGoBack()
        {
            return Stage != WizardStage.GuidingUnits &&
                   Stage != WizardStage.Jogging &&
                   Stage != WizardStage.Fixed;
        }

        private void GoBack()
        {
            switch (Stage)
            {
                case WizardStage.FeedingUnits:
                    Stage = WizardStage.GuidingUnits;
                    break;
                case WizardStage.TheDryer:
                    Stage = WizardStage.GuidingUnits;
                    break;
                case WizardStage.ContactSupport:
                    Stage = WizardStage.TheDryer;
                    break;
                case WizardStage.DryerClose:
                    Stage = WizardStage.TheDryer;
                    break;
            }
        }

        #endregion

        #region Guiding Units Commands

        private async void GuidingUnitsFoundAndFixed()
        {
            Stage = WizardStage.Jogging;

            try
            {
                await MachineProvider.MachineOperator.AttemptThreadJogging();
                Stage = WizardStage.Fixed;
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, LogCategory.Warning, "Error occurred while attempting to perform thread jogging.");
                await NotificationProvider.ShowError($"Thread movement verification failed.\n{ex.FlattenMessage()}");
                Stage = WizardStage.FeedingUnits;
            }
        }

        private void GuidingUnitsCantFindIt()
        {
            Stage = WizardStage.FeedingUnits;
        }

        private void GuidingUnitsFoundCantFix()
        {
            Stage = WizardStage.TheDryer;
        }

        #endregion

        #region Feeding Units Commands

        private void FeedingUnitsCantFix()
        {
            Stage = WizardStage.TheDryer;
        }

        private async void FeedingUnitsFoundAndFixed()
        {
            Stage = WizardStage.Jogging;

            try
            {
                await MachineProvider.MachineOperator.AttemptThreadJogging();
                Stage = WizardStage.Fixed;
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, LogCategory.Warning, "Error occurred while attempting to perform thread jogging.");
                await NotificationProvider.ShowError($"Thread movement verification failed.\n{ex.FlattenMessage()}");
                Stage = WizardStage.TheDryer;
            }
        }

        #endregion

        #region The Dryer Commands

        private void TheDryerCantRemove()
        {
            Stage = WizardStage.ContactSupport;
        }

        private void TheDryerRemovedSuccessfully()
        {
            Stage = WizardStage.DryerClose;
        }

        #endregion

        #region Dryer Close Commands

        private void OpenThreadLoadingWizard()
        {
            Result = ThreadBreakWizardResult.StartThreadLoading;
            Accept();
        }

        #endregion

        protected override void Accept()
        {
            base.Accept();
            CleanUp();
        }

        protected override void Cancel()
        {
            base.Cancel();
            CleanUp();
        }

        private void CleanUp()
        {
            MachineProvider.MachineOperator.MachineEventsStateProvider.EventsChanged -= MachineEventsStateProvider_EventsChanged;
            MachineProvider.MachineDisconnected -= MachineProvider_MachineDisconnected;
        }
    }
}