using FluentFTP;
using Ionic.Zip;
using Microsoft.Win32;
using Microsoft.WindowsAzure.Storage.Blob;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Configuration;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Data;
using Tango.BL;
using Tango.BL.DTO;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core;
using Tango.Core.Commands;
using Tango.Core.Components;
using Tango.Core.Cryptography;
using Tango.Core.Helpers;
using Tango.Core.IO;
using Tango.PPC.Common;
using Tango.PPC.Common.Publish;
using Tango.PPC.Common.Web;
using Tango.Settings;
using Tango.SharedUI;
using Tango.SQLExaminer;
using Tango.Transport.Web;
using Tango.Web;

namespace Tango.PPC.Publisher.UI
{
    public class MainWindowVM : ViewModel
    {
        private PPCWebClient _client;
        private PPCPublisher _publisher;

        private PublishOptions _options;
        public PublishOptions Options
        {
            get { return _options; }
            set { _options = value; RaisePropertyChangedAuto(); }
        }

        private List<MachineVersionDTO> _machineVersions;
        public List<MachineVersionDTO> MachineVersions
        {
            get { return _machineVersions; }
            set { _machineVersions = value; RaisePropertyChangedAuto(); }
        }

        private MachineVersionDTO _selectedMachineVersion;
        public MachineVersionDTO SelectedMachineVersion
        {
            get { return _selectedMachineVersion; }
            set
            {
                _selectedMachineVersion = value;
                MachineType = _selectedMachineVersion.ToObservable().MachineType;
                RaisePropertyChangedAuto();
                OnSelectedMachineVersionChanged(); }
        }

        public MachineTypes MachineType { get; set; }

        private String _localVersion;
        public String LocalVersion
        {
            get { return _localVersion; }
            set { _localVersion = value; RaisePropertyChangedAuto(); }
        }

        private String _localFirmwareVersion;
        public String LocalFirmwareVersion
        {
            get { return _localFirmwareVersion; }
            set { _localFirmwareVersion = value; RaisePropertyChangedAuto(); }
        }

        private String _remoteVersion;
        public String RemoteVersion
        {
            get { return _remoteVersion; }
            set { _remoteVersion = value; RaisePropertyChangedAuto(); }
        }

        private String _remoteFirmwareVersion;
        public String RemoteFirmwareVersion
        {
            get { return _remoteFirmwareVersion; }
            set { _remoteFirmwareVersion = value; RaisePropertyChangedAuto(); }
        }

        private ICollectionView _provisionSequenceItemsView;
        public ICollectionView ProvisionSequenceItemsView
        {
            get { return _provisionSequenceItemsView; }
            set { _provisionSequenceItemsView = value; RaisePropertyChangedAuto(); }
        }

        private ICollectionView _updateSequenceItemsView;
        public ICollectionView UpdateSequenceItemsView
        {
            get { return _updateSequenceItemsView; }
            set { _updateSequenceItemsView = value; RaisePropertyChangedAuto(); }
        }

        private PublishProgressEventArgs _publishArgs;
        public PublishProgressEventArgs PublishArgs
        {
            get { return _publishArgs; }
            set { _publishArgs = value; RaisePropertyChangedAuto(); }
        }

        private String _packageSize;
        public String PackageSize
        {
            get { return _packageSize; }
            set { _packageSize = value; RaisePropertyChangedAuto(); }
        }

        private List<String> _tags;
        public List<String> Tags
        {
            get { return _tags; }
            set { _tags = value; RaisePropertyChangedAuto(); }
        }

        public RelayCommand PublishCommand { get; set; }

        public RelayCommand CreateTupCommand { get; set; }

        public RelayCommand FirmwareUpgradePackageBrowseCommand { get; set; }

        public bool IsEureka { get; set; }

        public MainWindowVM()
        {
            MachineType = MachineTypes.TS1800;

#if Eureka
            IsEureka = true;
            MachineType = MachineTypes.Eureka;
#endif

#if X1
            MachineType = MachineTypes.X1;
#endif

            _client = new PPCWebClient();

            var settings = SettingsManager.Default.GetOrCreate<PublisherSettings>();
            var options = settings.Options;

            String vsPath = Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory + "..\\..\\..\\");

            options.InstallerProject = $@"{vsPath}Advanced Installer Projects\{MachineType.ToInstallerBuildFolder()} Installer.aip";
            options.InstallerOutputFolder = $@"{vsPath}Build\Installers\{MachineType.ToInstallerBuildFolder()}";

            Options = options;

            _publisher = new PPCPublisher(Options);
            _publisher.MachineType = MachineType;

            _publisher.PublishProgress += _publisher_PublishProgress;

            ProvisionSequenceItemsView = CollectionViewSource.GetDefaultView(Options.Synchronization.ProvisionSequenceItems);
            ProvisionSequenceItemsView.SortDescriptions.Add(new SortDescription(nameof(SequenceItem.Index), ListSortDirection.Ascending));

            UpdateSequenceItemsView = CollectionViewSource.GetDefaultView(Options.Synchronization.UpdateSequenceItems);
            UpdateSequenceItemsView.SortDescriptions.Add(new SortDescription(nameof(SequenceItem.Index), ListSortDirection.Ascending));

            SettingsManager.Default.GetOrCreate<CoreSettings>();
            SettingsManager.Default.Save();

            PublishCommand = new RelayCommand(Publish, () => Options.Email != null && Options.Password != null && Options.Comments != null && LocalVersion != null && RemoteVersion != null && IsFree);
            CreateTupCommand = new RelayCommand(PublishTupFile);
            FirmwareUpgradePackageBrowseCommand = new RelayCommand(BrowseFirmwareUpgradePackage);

            Options.BasicInfoChanged += (_, __) => InvalidateRelayCommands();
            Options.EnvironmentChanged += async (_, __) => await OnEnvironmentChanged();
            Options.BuidConfigChanged += async (_, __) => await UpdateVersions();
            Options.TfpPathChanged += async (_, __) => await UpdateVersions();
            Options.TagChanged += async (_, __) => await UpdateVersions();

            Init();
        }

        private void _publisher_PublishProgress(object sender, PublishProgressEventArgs e)
        {
            PublishArgs = e;
        }

        private async void Init()
        {
            await UpdateAvailableMachineVersions();
        }

        private async Task OnEnvironmentChanged()
        {
            IsFree = false;
            _client.Environment = Options.Environment;
            await UpdateAvailableMachineVersions();
            await UpdateVersions();
            IsFree = true;
        }

        private async Task UpdateAvailableMachineVersions()
        {
            IsFree = false;
            _machineVersions = (await _client.GetMachineVersions(new MachineVersionsRequest())).MachineVersions;
            _selectedMachineVersion = MachineVersions.OrderBy(x => x.Version).LastOrDefault();
            RaisePropertyChanged(nameof(MachineVersions));
            RaisePropertyChanged(nameof(SelectedMachineVersion));
            await OnSelectedMachineVersionChanged();
            IsFree = true;
        }

        private async Task UpdateVersions()
        {
            IsFree = false;
            LocalVersion = _publisher.GetLocalVersion();

            DirectoryInfo di = new DirectoryInfo(Options.GetApplicationPath());
            long totalSize = di.GetFiles("*", SearchOption.AllDirectories).Sum(x => x.Length);
            PackageSize = totalSize.FileSizeToString();

            try
            {
                LocalFirmwareVersion = _publisher.GetLocalFirmwareVersion(Options.TfpPath);
            }
            catch { }

            if (SelectedMachineVersion != null)
            {
                var latestVersion = await _publisher.GetRemoteVersion(SelectedMachineVersion.Guid);
                RemoteVersion = latestVersion.Version;
                RemoteFirmwareVersion = latestVersion.FirmwareVersion;
            }
            InvalidateRelayCommands();
            IsFree = true;
        }

        private async Task OnSelectedMachineVersionChanged()
        {
            if (SelectedMachineVersion != null)
            {
                Options.MachineVersionGuid = SelectedMachineVersion.Guid;
                Tags = (await _client.GetTags(new GetTagsRequest() { MachineVersionGuid = SelectedMachineVersion.Guid })).Tags;
            }

            await UpdateVersions();
        }

        private async void Publish()
        {
            try
            {
                IsFree = false;
                SettingsManager.Default.Save();

                if (String.IsNullOrWhiteSpace(Options.Tag) && Options.Tag != null)
                {
                    Options.Tag = null;
                }

                CmdCommand cmdCommand = new CmdCommand("rc.exe", $"\"{_publisher.GetPPCExecutablePath()}\" --set-version-string \"Comments\" \"{Options.Tag}\"");
                var result = await cmdCommand.Run();

                if (result.ExitCode != 0)
                {
                    throw new Exception("Error modifying version tag on output.");
                }

                await _publisher.Publish();
                ShowInfo("Version published successfully.");
                await UpdateVersions();
            }
            catch (Exception ex)
            {
                ShowError(ex.FlattenMessage());
            }
            finally
            {
                IsFree = true;
            }
        }

        private async void PublishTupFile()
        {
            SaveFileDialog dlg = new SaveFileDialog();
            dlg.Filter = "Tango Update Package|*.tup";
            dlg.DefaultExt = ".tup";
            if (dlg.ShowDialog().Value)
            {
                try
                {
                    IsFree = false;
                    await _publisher.CreateTupPackage(dlg.FileName);
                    ShowInfo("Package file created successfully!");
                }
                catch (Exception ex)
                {
                    ShowError(ex.Message);
                }
                finally
                {
                    IsFree = true;
                }
            }
        }

        private void BrowseFirmwareUpgradePackage()
        {
            OpenFileDialog dlg = new OpenFileDialog();
            dlg.Title = $"Select {MachineType.ToDescription()} Firmware Package";
            dlg.Filter = $"{MachineType.ToDescription()} Firmware Package Files|*.tfp";
            if (dlg.ShowDialog().Value)
            {
                Options.TfpPath = dlg.FileName;
            }
        }

        private void ShowError(String error)
        {
            MessageBox.Show(error, $"{MachineType.ToDescription()} Publisher", MessageBoxButton.OK, MessageBoxImage.Error);
        }

        private void ShowInfo(String message)
        {
            MessageBox.Show(message, $"{MachineType.ToDescription()} Publisher", MessageBoxButton.OK, MessageBoxImage.Information);
        }

        private bool ShowQuestion(String message)
        {
            return MessageBox.Show(message, $"{MachineType.ToDescription()} Publisher", MessageBoxButton.YesNo, MessageBoxImage.Information) == MessageBoxResult.Yes;
        }

        protected override void RaisePropertyChangedAuto([CallerMemberName] string caller = null)
        {
            base.RaisePropertyChangedAuto(caller);
            InvalidateRelayCommands();
        }
    }
}