using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core.DI;
using Tango.Integration.Operation;
using Tango.Logging;
using Tango.PPC.Common.Build;
using Tango.PPC.Common.Connection;
using Tango.PPC.Common.Notifications;
using Tango.PPC.Common.Threading;
using Tango.PPC.Common.ThreadLoading;
using Tango.PPC.UI.Dialogs;

namespace Tango.PPC.UI.ThreadLoading
{
    public class DefaultThreadLoadingService : IThreadLoadingService
    {
        private INotificationProvider _notificationsProvider;
        private IMachineProvider _machineProvider;
        private IDispatcherProvider _dispatcher;
        private bool _dialogShown;

        public DefaultThreadLoadingService(INotificationProvider notificationsProvider, IMachineProvider machineProvider, IDispatcherProvider dispatcher)
        {
            _notificationsProvider = notificationsProvider;
            _machineProvider = machineProvider;
            _dispatcher = dispatcher;
            if (false == TangoIOC.Default.GetInstance<IBuildProvider>().IsEureka)
                _machineProvider.MachineOperator.ThreadLoadingStatusChanged += MachineOperator_ThreadLoadingStatusChanged;
        }

        private void MachineOperator_ThreadLoadingStatusChanged(object sender, PMR.ThreadLoading.StartThreadLoadingResponse e)
        {
            if (!_dialogShown && e.State != PMR.ThreadLoading.ThreadLoadingState.None)
            {
                _dialogShown = true;
                _dispatcher.Invoke(async () =>
                {
                    var vm = await _notificationsProvider.ShowDialog<ThreadLoadingViewVM>(new ThreadLoadingViewVM());
                    _dialogShown = false;
                    if (!vm.DialogResult && vm.Stage != ThreadLoadingViewVM.ThreadLoadingStage.Completed)
                    {
                        if (_machineProvider.IsConnected)
                        {
                            try
                            {
                                await _machineProvider.MachineOperator.AbortThreadLoading();
                            }
                            catch (Exception ex)
                            {
                                LogManager.Default.Log(ex, "Error aborting thread loading.");
                            }

                            await _notificationsProvider.ShowInfo("Thread loading aborted.");
                        }
                    }
                });
            }
        }

        public async void StartThreadLoadingWizard()
        {
            _dialogShown = true;
            var vm = await _notificationsProvider.ShowDialog<ThreadLoadingViewVM>(new ThreadLoadingViewVM(true));
            _dialogShown = false;
            if (!vm.DialogResult && vm.Stage != ThreadLoadingViewVM.ThreadLoadingStage.Completed)
            {
                if (_machineProvider.IsConnected)
                {
                    try
                    {
                        await _machineProvider.MachineOperator.AbortThreadLoading();
                    }
                    catch (Exception ex)
                    {
                        LogManager.Default.Log(ex, "Error aborting thread loading.");
                    }

                    await _notificationsProvider.ShowInfo("Thread loading aborted.");
                }
            }
        }

        public async void StartThreadBreakWizard()
        {
            if (!_dialogShown)
            {
                _dialogShown = true;
                var vm = await _notificationsProvider.ShowDialog<ThreadBreakViewVM>();
                _dialogShown = false;

                if (vm.Result == ThreadBreakViewVM.ThreadBreakWizardResult.StartThreadLoading)
                {
                    StartThreadLoadingWizard();
                }
            }
        }
    }
}