using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tango.BL.Entities;
using Tango.Core.Commands;
using Tango.FSE.BL;
using Tango.FSE.Common;
using Tango.FSE.Common.Navigation;
using Tango.FSE.Common.RemoteUpgrade;
using Tango.FSE.Upgrade.Views;

namespace Tango.FSE.Upgrade.ViewModels
{
    public class ApplicationUpgradeViewVM : RemoteUpgradeViewModel, INavigationObjectReceiver<ApplicationUpgradeViewVM.NavigationObject>
    {
        public enum ApplicationUpgradeMode
        {
            ConnectedMachine,
            OtherMachine
        }

        public class NavigationObject
        {
            public ApplicationUpgradeMode ApplicationUpgradeMode { get; set; }
            public Machine SelectedMachine { get; set; }
        }

        private ApplicationUpgradeMode _upgradeMode;
        public ApplicationUpgradeMode UpgradeMode
        {
            get { return _upgradeMode; }
            set { _upgradeMode = value; RaisePropertyChangedAuto(); }
        }

        private List<TangoVersion> _tangoVersions;
        public List<TangoVersion> TangoVersions
        {
            get { return _tangoVersions; }
            set { _tangoVersions = value; RaisePropertyChangedAuto(); }
        }

        private TangoVersion _selectedVersion;
        public TangoVersion SelectedVersion
        {
            get { return _selectedVersion; }
            set { _selectedVersion = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        private Machine _selectedMachine;
        public Machine SelectedMachine
        {
            get { return _selectedMachine; }
            set { _selectedMachine = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        private RemoteUpgradeHandler _handler;
        public RemoteUpgradeHandler Handler
        {
            get { return _handler; }
            set { _handler = value; RaisePropertyChangedAuto(); }
        }

        public RelayCommand GeneratePackageCommand { get; set; }

        public ApplicationUpgradeViewVM()
        {
            GeneratePackageCommand = new RelayCommand(GeneratePackage, () => SelectedVersion != null && SelectedMachine != null);
        }

        private async void GeneratePackage()
        {
            try
            {
                IsFree = false;

                if (MachineProvider.IsPPCAvailable)
                {
                    var machine = await Services.MachinesService.GetMachine(MachineProvider.Machine.SerialNumber);
                    if (machine.VersionTag != SelectedVersion.Tag)
                    {
                        IsFree = true;
                        await NotificationProvider.ShowError($"The selected machine cannot be updated to version '{SelectedVersion.VersionAndTag}'.\nPlease modify the machine version tag first.");
                        return;
                    }
                }

                var temporaryTupFile = TemporaryManager.CreateImaginaryFile(".tup");

                Handler = await RemoteUpgradeManager.CreateTupFile(SelectedVersion, SelectedMachine.SerialNumber, temporaryTupFile);
                await Handler.WaitForCompletion();

                await ModularNavigationManager.NavigateTo<ApplicationUpgradeGeneratedViewVM.NavigationObject>(Navigation.RemoteUpgradeView.ApplicationUpgradeGeneratedView, new ApplicationUpgradeGeneratedViewVM.NavigationObject()
                {
                    SelectedVersion = SelectedVersion,
                    UpgradeNow = UpgradeMode == ApplicationUpgradeMode.ConnectedMachine,
                    SelectedMachine = SelectedMachine,
                    TemporaryTupFile = temporaryTupFile
                }, false);
            }
            catch (OperationCanceledException)
            {
                //Aborted...
            }
            catch (AuthorizationException ex)
            {
                await NotificationProvider.ShowError(ex.Message);
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error generating remote upgrade package.");
            }
            finally
            {
                IsFree = true;
            }
        }

        public async override void OnNavigatedTo()
        {
            base.OnNavigatedTo();

            if (TangoVersions == null)
            {
                try
                {
                    TangoVersions = (await Services.TangoVersionsService.GetAllTangoVersions()).Take(10).ToList();
                    SelectedVersion = TangoVersions.FirstOrDefault();
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error retrieving tango versions.");
                    await NotificationProvider.ShowError($"Error retrieving Tango versions.\n{ex.FlattenMessage()}");
                }
            }
        }

        public async override Task<bool> OnNavigateBackRequest()
        {
            if (!IsFree)
            {
                var abort = await NotificationProvider.ShowWarningQuestion("Are you sure you want to abort the upgrade operation?");

                if (abort)
                {
                    if (Handler.CanAbort)
                    {
                        Handler.Abort();
                    }
                    else
                    {
                        await NotificationProvider.ShowError("Cannot abort the operation at the this stage.");
                        return false;
                    }
                }

                return abort;
            }

            return true;
        }

        public void OnNavigatedToWithObject(NavigationObject obj)
        {
            SelectedMachine = obj.SelectedMachine;
            UpgradeMode = obj.ApplicationUpgradeMode;
        }

        public override void OnBeforeNavigatedTo()
        {
            base.OnBeforeNavigatedTo();
            Handler = new RemoteUpgradeHandler("Ready");
            SelectedMachine = null;
            UpgradeMode = ApplicationUpgradeMode.OtherMachine;
            InvalidateRelayCommands();
        }
    }
}