using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media.Imaging;
using Tango.BL.Enumerations;
using Tango.MachineStudio.Common;
using Tango.MachineStudio.Sites.Views;
using Tango.SharedUI.Helpers;

namespace Tango.MachineStudio.Sites
{
    [StudioModule(20)]
    public class SitesModule : StudioModuleBase
    {
        public override string Name
        {
            get
            {
                return "Sites";
            }
        }

        public override string Description
        {
            get
            {
                return "Manage organizations sites and their common machine properties.";
            }
        }

        public override BitmapSource Image
        {
            get
            {
                return ResourceHelper.GetImageFromResources("Images/site.png");
            }
        }

        public override Type MainViewType
        {
            get
            {
                return typeof(MainView);
            }
        }

        public override Permissions Permission
        {
            get
            {
                return Permissions.RunRMLModule;
            }
        }

        public override void Dispose()
        {

        }
    }
}

using FluentFTP;
using Ionic.Zip;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.ServiceModel;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using Tango.Core.Commands;
using Tango.Core.Cryptography;
using Tango.Core.Helpers;
using Tango.Core.IO;
using Tango.MachineStudio.Common;
using Tango.MachineStudio.Common.Update;
using Tango.Settings;
using Tango.SharedUI;
using Tango.Transport.Web;
using Tango.Web;

namespace Tango.MachineStudio.Publisher
{
    public class MainWindowVM : ViewModel
    {
        private BasicHashGenerator _hashGenerator;
        private String _appPath = AppDomain.CurrentDomain.BaseDirectory + "..\\Release";
        private IMachineStudioUpdateService _client;

        private String _email;

        public String Email
        {
            get { return _email; }
            set { _email = value; RaisePropertyChangedAuto(); }
        }

        private String _password;

        public String Password
        {
            get { return _password; }
            set { _password = value; RaisePropertyChangedAuto(); }
        }

        private String _comments;

        public String Comments
        {
            get { return _comments; }
            set { _comments = value; RaisePropertyChangedAuto(); }
        }

        private bool _forcesUpdate;

        public bool ForcedUpdate
        {
            get { return _forcesUpdate; }
            set { _forcesUpdate = value; RaisePropertyChangedAuto(); }
        }

        private bool _isStable;

        public bool IsStable
        {
            get { return _isStable; }
            set { _isStable = value; RaisePropertyChangedAuto(); }
        }

        private DeploymentSlot _deploymentSlot;
        public DeploymentSlot DeploymentSlot
        {
            get { return _deploymentSlot; }
            set
            {
                _deploymentSlot = value; RaisePropertyChangedAuto();

                SettingsManager.Default.GetOrCreate<MachineStudioSettings>().DeploymentSlot = _deploymentSlot;
                UpdateVersions();
            }
        }

        private String _currentVersion;

        public String CurrentVersion
        {
            get { return _currentVersion; }
            set { _currentVersion = value; RaisePropertyChangedAuto(); }
        }

        private String _latestVersion;

        public String LatestVersion
        {
            get { return _latestVersion; }
            set { _latestVersion = value; RaisePropertyChangedAuto(); }
        }

        private double _maxProgress;

        public double MaxProgress
        {
            get { return _maxProgress; }
            set { _maxProgress = value; RaisePropertyChangedAuto(); }
        }

        private double _progress;

        public double Progress
        {
            get { return _progress; }
            set { _progress = value; RaisePropertyChangedAuto(); }
        }

        private bool _isUpdating;

        public bool IsUpdating
        {
            get { return _isUpdating; }
            set { _isUpdating = value; RaisePropertyChangedAuto(); }
        }

        public RelayCommand PublishCommand { get; set; }

        public MainWindowVM()
        {
            _client = new MachineStudioUpdateService();

            MaxProgress = 100;

            _hashGenerator = new BasicHashGenerator();

            PublishCommand = new RelayCommand(Publish, () => Email != null && Password != null && Comments != null && CurrentVersion != null && LatestVersion != null && !IsUpdating && Version.Parse(CurrentVersion) > Version.Parse(LatestVersion));

            var client = new MachineStudioUpdateService();

            UpdateVersions();

            var settings = SettingsManager.Default.GetOrCreate<MachineStudioSettings>();

            Email = settings.LastLoginEmail;

            var cryptographer = new Rfc2898Cryptographer();
            Password = cryptographer.Decrypt(settings.LastLoginPassword);
        }

        private void UpdateVersions()
        {
            CurrentVersion = FileVersionInfo.GetVersionInfo(_appPath + "\\Tango.MachineStudio.UI.exe").ProductVersion;
            LatestVersion = _client.GetLatestVersion(new LatestVersionRequest()).Result.Version;
        }

        private void Publish()
        {
            if (!ShowQuestion("Did you remember to synchronize production database ?"))
            {
                return;
            }

            MaxProgress = 100;
            Progress = 0;

            Task.Factory.StartNew(() =>
            {
                IsUpdating = true;
                String tempFile = TemporaryManager.CreateFile();

                try
                {
                    var response = _client.UploadVersion(new UploadVersionRequest()
                    {
                        Email = Email,
                        Password = _hashGenerator.Encrypt(Password),
                        Version = CurrentVersion.ToString(),
                        Comments = Comments,
                        ForcedUpdate = ForcedUpdate,
                        IsStable = IsStable,
                    }).Result;

                    using (ZipFile zip = new ZipFile())
                    {
                        zip.AddDirectory(Path.Combine(_appPath, "x86"), "/x86");
                        zip.AddDirectory(Path.Combine(_appPath, "x64"), "/x64");

                        foreach (var file in Directory.GetFiles(_appPath, "*.*", SearchOption.TopDirectoryOnly))
                        {
                            zip.AddFile(file, "/");
                        }

                        zip.SaveProgress += (x, e) =>
                        {
                            MaxProgress = e.TotalBytesToTransfer;
                            Progress = e.BytesTransferred;
                        };

                        zip.Save(tempFile);
                    }

                    Progress = 0;
                    MaxProgress = 100;

                    using (StorageBlobUploader uploader = new StorageBlobUploader(response.BlobAddress,tempFile))
                    {
                        uploader.Progress += (x, e) => 
                        {
                            InvokeUINow(() =>
                            {
                                Progress = ((double)e.Current / (double)e.Total) * 100d;
                            });
                        };

                        uploader.Upload().Wait();
                    }

                    _client.NotifyUploadCompleted(new UploadCompletedRequest()
                    {
                        AccessToken = response.Token,
                    }).Wait();

                    Progress = 0;
                    UpdateVersions();
                    ShowInfo("Version published successfully!");
                }
                catch (Exception ex)
                {
                    ShowError(ex.FlattenMessage());
                }
                finally
                {
                    IsUpdating = false;
                    PathHelper.TryDeleteFile(tempFile);
                }
            });
        }

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

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

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

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