using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows;
using vCloud.GeneratePackages.Entitys;
using vCloud.GeneratePackages.Utilities;
using Vinno.IUS.Common;
using Vinno.IUS.Common.Log;
using Vinno.vCloud.Common.Storage.ObjectStorageInfo;

namespace vCloud.GeneratePackages.Tool.ViewModels
{
    class MainWindowViewModel : ViewModel
    {
        private DeployToolGenerator _deployToolGenerator = new DeployToolGenerator();
        private string _outputDir;
        private string _ftpUrl;
        private string _windowSonoPostVersion;

        /// <summary>
        /// Request window close
        /// </summary>
        public event EventHandler RequestClosed;

        /// <summary>
        /// Cancel Command
        /// </summary>
        public Command CancelCommand { get; }

        /// <summary>
        /// Finish command
        /// </summary>
        public Command CloseCommand { get; }

        /// <summary>
        /// Refresh ftp items with specified url
        /// </summary>
        public Command RefreshCommand { get; }

        /// <summary>
        /// generage package Command
        /// </summary>
        public Command GenerateCommand { get; }

        /// <summary>
        /// Open Output Dir Command
        /// </summary>
        public Command OpenOutputDirCommand { get; }

        /// <summary>
        /// 
        /// </summary>
        public ObservableCollection<FtpItem> Files { get; }

        public FtpItem SelectedFile { get; set; }

        public  string WindowSonoPostVersion
        {
            get { return _windowSonoPostVersion; }
            set
            {
                if (_windowSonoPostVersion != value)
                {
                    _windowSonoPostVersion = value;
                    OnPropertyChanged(() => WindowSonoPostVersion);
                    DeployToolGenerator._windowSonoPostVersion = _windowSonoPostVersion;
                }
            }
        }

        public int FailedNum => _deployToolGenerator.FailedFileNumber;

        /// <summary>
        /// 打包客户端文件数据
        /// </summary>
        public bool PackageClientData 
        {
            get
            {
               return AppManager.Instance.PackageClientData;
            }
            set
            {
                AppManager.Instance.PackageClientData = value;
                OnPropertyChanged(() => PackageClientData);
            }
        }

        public bool IsNeedRemoteDeployment 
        {
            get
            {
                return AppManager.Instance.IsNeedRemoteDeployment;
            }
            set
            {
                AppManager.Instance.IsNeedRemoteDeployment = value;
                OnPropertyChanged(() => IsNeedRemoteDeployment);
            }
        }

        /// <summary>
        /// Ftp url
        /// </summary>
        public string FtpUrl
        {
            get => _ftpUrl;
            set
            {
                if (_ftpUrl != value)
                {
                    _ftpUrl = value;
                    AppManager.Instance.SaveFtpUrl(_ftpUrl);
                    OnPropertyChanged(() => FtpUrl);
                }
            }
        }


        /// <summary>
        /// Output directory
        /// </summary>
        public string OutputDir
        {
            get { return _outputDir; }
            set
            {
                if (_outputDir != value)
                {
                    _outputDir = value;
                    OnPropertyChanged(() => OutputDir);
                }
            }
        }

        /// <summary>
        /// Log infoes
        /// </summary>
        public ObservableCollection<LogItem> LogItems { get; }

        /// <summary>
        /// Update package window view model
        /// </summary>
        public UpdatePackageInfoWindowViewModel UpdatePackageInfo { get; }

        public Command ClearLogCommand { get; }

        public Command OpenFilesCommand { get; }

        /// <summary>
        /// retry upload command
        /// </summary>
        public Command RetryUploadCommand { get; }

        public MainWindowViewModel()
        {
            UpdatePackageInfo = new UpdatePackageInfoWindowViewModel();
            LogItems = new ObservableCollection<LogItem>();
            Description = "AppName";
            CancelCommand = new Command("Cancel", OnCancelCommand);
            CloseCommand = new Command("Finish", OnCloseCommand);
            RefreshCommand = new Command("Refresh", OnRefreshCommand);
            GenerateCommand = new Command("Generate", OnGenerateCommand);
            OpenOutputDirCommand = new Command("OpenFolder", OnOpenOutputDirCommand);
            ClearLogCommand = new Command("ClearLog", OnClearLogCommand);
            RetryUploadCommand = new Command("ClearLog", OnRetryUploadCommand);
            Files = new ObservableCollection<FtpItem>();
            _ftpUrl = AppManager.Instance.AppSettings.FtpUrl;
            OpenFilesCommand = new Command("OpenFiles", OnOpenFilesCommand);
        }

        private void OnOpenFilesCommand(object obj)
        {
            var uploadFilesPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UploadFailedFiles");
            if (Directory.Exists(uploadFilesPath))
            {
                Process.Start("explorer.exe", uploadFilesPath);
            }
        }

        private void OnRetryUploadCommand(object obj)
        {
            try
            {
                AppManager.DoModalAction(() =>
                {
                    var cosConfig = _deployToolGenerator.StorageUploadConfig;
                    var cOSUploadHelpler = _deployToolGenerator.COSUploadHelpler;
                    var uploadFilesPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UploadFailedFiles");
                    if (!Directory.Exists(uploadFilesPath))
                    {
                        Logger.WriteLineWarn($"Directory is not exist:{uploadFilesPath}");
                    }

                    if (!string.IsNullOrEmpty(cosConfig.DefaultStroageNode))
                    {
                        var res = false;
                        var storageNode = cosConfig.StorageNodes.Find(c => c.Name == cosConfig.DefaultStroageNode);
                        if (storageNode != null && !string.IsNullOrEmpty(storageNode.Bucket))
                        {
                            var nodeFilePath = Path.Combine(uploadFilesPath, storageNode.Bucket);
                            if (!Directory.Exists(nodeFilePath))
                            {
                                return;
                            }
                            var files = Directory.GetFiles(nodeFilePath);
                            if (files.Count() == 0)
                            {
                                return;
                            }
                            var result = cOSUploadHelpler.UploadFilesWithoutMove(storageNode.Bucket, files.ToList());
                            if (!result)
                            {
                                Logger.WriteLineError($"retry upload file to {storageNode.Name} failed");
                            }
                            else
                            {
                                Logger.WriteLineInfo($"end retry upload files to:{storageNode.Name}");
                                foreach (var file in files)
                                {
                                    List<StorageNode> destStorageNodesList = new List<StorageNode>();
                                    foreach (var item in cosConfig.StorageNodes)
                                    {
                                        if (item.Name == storageNode.Name)
                                        {
                                            continue;
                                        }
                                        destStorageNodesList.Add(item);
                                    }
                                    string fileName = "";
                                    var fileArray = file.Split('\\');
                                    if (fileArray?.Length > 0)
                                    {
                                        fileName = fileArray[(fileArray.Length - 1)];
                                    }
                                    res = cOSUploadHelpler.CopyFile(destStorageNodesList, storageNode, fileName);
                                    if (!res)
                                    {
                                        break;
                                    }
                                }
                            }
                        }
                        if (res)
                        {
                            Logger.WriteLineInfo($"end retry copy files to otherNode success");
                            return;
                        }
                        else
                        {
                            Logger.WriteLineInfo($"end retry copy files to otherNode fail");
                            Logger.WriteLineInfo($"begin retry upload files to otherNode");
                        }
                    }
                    foreach (var node in cosConfig.StorageNodes)
                    {
                        var nodeFilePath = Path.Combine(uploadFilesPath, node.Bucket);
                        if (!Directory.Exists(nodeFilePath))
                        {
                            continue;
                        }
                        var files = Directory.GetFiles(nodeFilePath);
                        if (files.Count() == 0)
                        {
                            continue;
                        }
                        var result = cOSUploadHelpler.UploadFilesWithoutMove(node.Bucket, files.ToList());
                        if (!result)
                        {
                            Logger.WriteLineError($"retry upload file to {node.Name} failed");
                        }
                        else
                        {
                            Logger.WriteLineInfo($"end retry upload files to:{node.Name}");
                        }
                    }
                });
            }
            catch (Exception ex) 
            {
                Logger.WriteLineError($"OnRetryUploadCommand exceptin:{ex}");
            }
        }

        private void OnClearLogCommand(object obj)
        {
            LogItems.Clear();
        }

        private void OnOpenOutputDirCommand(object obj)
        {
            if (Directory.Exists(OutputDir))
            {
                Process.Start("explorer.exe", OutputDir);
            }
        }

        private void OnGenerateCommand(object obj)
        {
            try
            {
                AppManager.DoModalAction(() =>
                {
                    if (SelectedFile == null)
                    {
                        MessageBox.Show("请选择一个压缩包！");
                        return;
                    }

                    if (SelectedFile.FtpItemType == FtpItemType.Dir)
                    {
                        MessageBox.Show("请选择一个zip包而不是文件夹！");
                        return;
                    }
                    OutputDir = string.Empty;
                    var packages = new List<UpgradePackage>();

                    foreach (var packageInfo in UpdatePackageInfo.PackageInfos)
                    {
                        if (!packageInfo.IsPublic)
                        {
                            continue;
                        }

                        var packageType = packageInfo.PackageType;
                        switch (packageType)
                        {
                            case GeneratePackagePlatform.PC:
                                var item = new UpgradePackage(packageType, GeneratePackageType.Client);
                                packages.Add(item);
                                break;
                            case GeneratePackagePlatform.Android:
                                var adroid = new UpgradePackage(packageType, GeneratePackageType.Client);
                                packages.Add(adroid);
                                break;
                            //case PackagePlatform.Mac:
                            //    var mac = new UpgradePackage(packageType, PackageType.Client);
                            //    packages.Add(mac);
                            //    break;
                            case GeneratePackagePlatform.Sonopost:
                                var sonopost = new UpgradePackage(packageType, GeneratePackageType.Sonopost);
                                packages.Add(sonopost);
                                break;
                            case GeneratePackagePlatform.Server:
                                var server = new UpgradePackage(packageType, GeneratePackageType.Server);
                                packages.Add(server);
                                break;
                            case GeneratePackagePlatform.WindowsSonopost:
                                var winSonopost = new UpgradePackage(packageType,GeneratePackageType.Sonopost);
                                packages.Add(winSonopost);
                                break;
                        }
                    }
                    if (packages.Count == 0)
                    {
                        MessageBox.Show($"请至少选择一个发布内容！");
                        return;
                    }
                    var packageClientData = AppManager.Instance.PackageClientData;
                    var outputdir = _deployToolGenerator.GenerateInstallPackage(SelectedFile, FtpUrl, packages, packageClientData, AppManager.Instance.IsNeedRemoteDeployment).Result;
                    if (!string.IsNullOrWhiteSpace(outputdir))
                    {
                        OutputDir = outputdir;
                        Process.Start("explorer.exe", OutputDir);
                    }
                    if (!AppManager.Instance.PackageClientData)
                    {
                        var result = _deployToolGenerator.UploadClientPackage(packages);
                    }
                });

            }
            catch (Exception e)
            {
                Logger.WriteLineError($"OnGenerateCommand ex:{e}");
            }
        }

        private void OnRefreshCommand(object obj)
        {
            try
            {

                Files.Clear();
                AppManager.DoModalAction(() =>
                {
                    Logger.WriteLineInfo($"Start to load file list from {FtpUrl}");
                    var list = FtpHelper.GetFileList(FtpUrl);
                    foreach (var item in list)
                    {
                        if (item.StartsWith("drw"))
                        {
                            continue;
                        }
                        AppManager.MainDispatcher.Invoke(() => Files.Insert(0, new FtpItem(item)));
                    }

                    Logger.WriteLineInfo($"Load file list from {FtpUrl} done");
                }, "正在加载...", "刷新文件列表");


            }
            catch (Exception e)
            {
                Logger.WriteLineError($"OnRefreshCommand ex:{e}");
            }
        }

        private void OnCancelCommand(object obj)
        {
            OnRequestClosed();
        }


        private void OnCloseCommand(object obj)
        {
            AppManager.DoModalAction(() =>
            {
                //AppManager.Instance.Finish();

            }, "Deploying");

            OnRequestClosed();
        }


        void OnRequestClosed()
        {
            RequestClosed?.Invoke(this, EventArgs.Empty);
        }
    }

    
}