using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.PMR.Diagnostics;
using Tango.PMR.Hardware;

namespace Tango.PPC.Maintenance.Commands
{
    public abstract class OpenCloseMotorCommand : MaintenanceCommand<OpenCloseMotorCommand.MotorState>
    {
        public enum MotorState
        {
            Closed,
            Opened,
        }

        public HardwareMotorType Motor { get; set; }

        public MotorDirection OpenDirection { get; set; }

        public MotorDirection CloseDirection
        {
            get
            {
                return OpenDirection == MotorDirection.Forward ? MotorDirection.Backward : MotorDirection.Forward;
            }
        }

        public double OpeningSpeed { get; set; }

        public double ClosingSpeed { get; set; }

        public String OpeningMessage { get; set; }

        public String ClosingMessage { get; set; }

        public String OpeningErrorMessage { get; set; }

        public String ClosingErrorMessage { get; set; }

        public String OpeningSuccessMessage { get; set; }

        public String ClosingSuccessMessage { get; set; }

        public OpenCloseMotorCommand(
            HardwareMotorType motor,
            MotorDirection openDirection,
            double openingSpeed,
            double closingSpeed,
            MotorState defaultState,
            String openingMessage,
            String closingMessage,
            String openingErrorMessage,
            String closingErrorMessage,
            String openingSuccessMessage,
            String closingSuccessMessage)
        {

            Motor = motor;
            OpenDirection = openDirection;
            OpeningSpeed = openingSpeed;
            ClosingSpeed = closingSpeed;
            State = defaultState;
            OpeningMessage = openingMessage;
            ClosingMessage = closingMessage;
            OpeningErrorMessage = openingErrorMessage;
            ClosingErrorMessage = closingErrorMessage;
            OpeningSuccessMessage = openingSuccessMessage;
            ClosingSuccessMessage = closingSuccessMessage;
        }

        protected override void OnExecute()
        {
            if (State == MotorState.Closed)
            {
                IsEnabled = false;

                try
                {
                    NotificationProvider.SetGlobalBusyMessage(OpeningMessage);

                    MachineProvider.MachineOperator.StartMotorHoming(new PMR.Diagnostics.MotorHomingRequest()
                    {
                        Direction = OpenDirection,
                        MotorType = Motor,
                        Speed = OpeningSpeed,
                    }).Subscribe((response) =>
                    {
                        //Next
                    }, (ex) =>
                    {
                        //Error
                        IsEnabled = true;
                        NotificationProvider.ReleaseGlobalBusyMessage();
                        LogManager.Log(ex, OpeningErrorMessage);
                        NotificationProvider.ShowError(ex.FlattenMessage());
                    }, () =>
                    {
                        //Complete
                        IsEnabled = true;
                        State = MotorState.Opened;
                        NotificationProvider.ReleaseGlobalBusyMessage();
                        NotificationProvider.ShowSuccess(OpeningSuccessMessage);
                    });
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, OpeningErrorMessage);
                    NotificationProvider.ReleaseGlobalBusyMessage();
                    NotificationProvider.ShowError(ex.FlattenMessage());
                    IsEnabled = true;
                }
            }
            else
            {
                IsEnabled = false;

                try
                {
                    NotificationProvider.SetGlobalBusyMessage(ClosingMessage);

                    MachineProvider.MachineOperator.StartMotorHoming(new PMR.Diagnostics.MotorHomingRequest()
                    {
                        Direction = CloseDirection,
                        MotorType = Motor,
                        Speed = ClosingSpeed,
                    }).Subscribe((response) =>
                    {
                        //Next
                    }, (ex) =>
                    {
                        //Error
                        IsEnabled = true;
                        NotificationProvider.ReleaseGlobalBusyMessage();
                        LogManager.Log(ex, ClosingErrorMessage);
                        NotificationProvider.ShowError(ex.FlattenMessage());
                    }, () =>
                    {
                        //Complete
                        IsEnabled = true;
                        State = MotorState.Closed;
                        NotificationProvider.ReleaseGlobalBusyMessage();
                        NotificationProvider.ShowSuccess(ClosingSuccessMessage);
                    });
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, ClosingErrorMessage);
                    NotificationProvider.ReleaseGlobalBusyMessage();
                    NotificationProvider.ShowError(ex.FlattenMessage());
                    IsEnabled = true;
                }
            }
        }
    }
}