using AppUpdater.UI.Helpers;

using Downloader;

using Ionic.Zip;

using MahApps.Metro.Controls;

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.Linq;

using System.Net;

using System.Text;

using System.Text.RegularExpressions;

using System.Threading;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Shapes;

​

namespace AppUpdater.UI.Views

{

    /// <summary>

    /// Interaction logic for DownloadWindow.xaml

    /// </summary>

    public partial class DownloadWindow : MetroWindow

    {

        public DownloadWindow()

        {

            InitializeComponent();

            StartDownloading();

        }

​

​

        Task _downloadTask;

        async Task RunDownloading(string fileStandard, string fileStudio, bool downloadStudioToo)

        {

​

            Random random = new Random(Guid.NewGuid().GetHashCode());

​

​

            var downloadOpt = new DownloadConfiguration()

            {

                BufferBlockSize = 10240, // usually, hosts support max to 8000 bytes, default values is 8000

                ChunkCount = 1, // file parts to download, default value is 1

                MaximumBytesPerSecond = 0, // download speed limited to 1MB/s, default values is zero or unlimited

                MaxTryAgainOnFailover = 5, // the maximum number of times to fail

                OnTheFlyDownload = false, // caching in-memory or not? default values is true

                ParallelDownload = false, // download parts of file as parallel or not. Default value is false

​

            };

​

            var downloader = new DownloadService(downloadOpt);

            downloader.DownloadProgressChanged += OnDownloadProgressChanged;

​

​

            await downloader.DownloadFileTaskAsync(DARTUpdate.urlStandard + "?random=" + random.Next().ToString(), fileStandard);

​

            if (downloadStudioToo)

                await downloader.DownloadFileTaskAsync(DARTUpdate.urlStudio + "?random=" + random.Next().ToString(), fileStudio);

        }

​

​

​

        private async void StartDownloading()

        {

            string desktopPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);

            //List<string> downloadURLs = new List<string> { DARTUpdate.urlStandard };

​

            bool downloadStudioToo = Directory.EnumerateDirectories(desktopPath + "\\", "DART *")

                                    .SelectMany(parent => Directory.EnumerateDirectories(parent, "DART Studio")).ToArray().Length > 0;

            //if (downloadStudioToo)

            //    downloadURLs.Add(DARTUpdate.urlStudio);

​

            //HttpClientDownloadWithProgress downloader = new HttpClientDownloadWithProgress(downloadURLs, desktopPath);

            //downloader.ProgressChanged +=Downloader_ProgressChanged;

​

            Random random = new Random(Guid.NewGuid().GetHashCode());

​

​

​

​

            string fileStandard = System.IO.Path.Combine(desktopPath, System.IO.Path.GetFileName(DARTUpdate.urlStandard));

            string fileStudio = System.IO.Path.Combine(desktopPath, System.IO.Path.GetFileName(DARTUpdate.urlStudio));

​

            File.Delete(fileStandard);

            File.Delete(fileStudio);

​

​

​

​

​

            try

            {

                //await downloader.StartDownload();

                //await downloader.DownloadFileTaskAsync(DARTUpdate.urlStandard + "?random=" + random.Next().ToString(), fileStandard);

​

                //if (downloadStudioToo)

                //   await downloader.DownloadFileTaskAsync(DARTUpdate.urlStudio + "?random=" + random.Next().ToString(), fileStudio);

​

​

                _downloadTask = Task.Run(() => RunDownloading(fileStandard, fileStudio, downloadStudioToo));

​

                //await _downloadTask;

​

                /*

                IDownload download1 = DownloadBuilder.New()

                    .WithUrl(DARTUpdate.urlStandard + "?random=" + random.Next().ToString())

                    .WithDirectory(desktopPath)

                    .WithFileName(System.IO.Path.GetFileName(DARTUpdate.urlStandard))

                    .WithConfiguration(downloadOpt)

                    .Build();

                download1.DownloadProgressChanged += OnDownloadProgressChanged;

​

                await download1.StartAsync();

                download1.Clear();

                download1 = null;

​

​

                if (downloadStudioToo)

                {

                    IDownload download2 = DownloadBuilder.New()

                        .WithUrl(DARTUpdate.urlStudio + "?random=" + random.Next().ToString())

                        .WithDirectory(desktopPath)

                        .WithFileName(System.IO.Path.GetFileName(DARTUpdate.urlStudio))

                        .WithConfiguration(downloadOpt)

                        .Build();

                    download2.DownloadProgressChanged += OnDownloadProgressChanged;

                    //MessageBox.Show("111", "111");

                    await download2.StartAsync();

                    download2.Clear();

                }

                */

​

​

            }

            catch

            {

                DownloaderShowError("Download Error!", "DART update failed!");

                return;

            }

​

            // Deal with DART process running!

            if (ProcessHelper.ProcessExists("DART "))

            {

                // Change the GUI text

                UpdateStatusTitle.Text = "DART is running!";

                UpdateStatusText.Text = "Please close it!";

​

                // Bring GUI to front

                this.Activate();

                this.WindowState = System.Windows.WindowState.Normal;

                //this.Topmost = true;

                this.Focus();

​

                // Wait for the user to exit DART

                await Task.Factory.StartNew(() =>

                {

                    do

                    {

                        Thread.Sleep(300);

                    } while (ProcessHelper.ProcessExists("DART "));

                });

            }

​

            UpdateStatusTitle.Text = "DART is getting better!";

            UpdateStatusText.Text = "New DART update is installing.";

​

            string desktopDir = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + @"\";

            string ZipFileStandard = System.IO.Path.Combine(desktopDir, System.IO.Path.GetFileName(DARTUpdate.urlStandard));

            string ZipFileStudio = System.IO.Path.Combine(desktopDir, System.IO.Path.GetFileName(DARTUpdate.urlStudio));

​

            try

            {

​

                if (File.Exists(ZipFileStandard))

                {

                    Unzip_Files(ZipFileStandard, desktopDir);

                    //MessageBox.Show(ZipFileStandard);

                }

​

                if (File.Exists(ZipFileStudio))

                {

                    Unzip_Files(ZipFileStudio, desktopDir);

                    //MessageBox.Show(ZipFileStudio);

                }

            }

            catch

            {

                DownloaderShowError("Install Error!", "DART installation failed!");

                return;

            }

​

            Properties.Settings.Default.LastVersion = DARTUpdate.newVersion;

            Properties.Settings.Default.Save();

​

            try

            {

                File.Copy(@"DART Creator 4.lnk", desktopPath + @"\DART Creator 4.lnk",true);

                File.Copy(@"DART Experience 4.lnk", desktopPath + @"\DART Experience 4.lnk", true);

                File.Copy(@"DART Range 4.lnk", desktopPath + @"\DART Range 4.lnk", true);

​

                if (File.Exists(ZipFileStudio))

                    File.Copy(@"DART Studio 4.lnk", desktopPath + @"\DART Studio 4.lnk", true);

            }

            catch{}

​

​

​

​

            new ReleaseNotesWindow().Show();

            this.Close();

​

​

        }

        void DownloaderShowError(string errorTitle, string errorText)

        {

            UpdateStatusTitle.Text = errorTitle;

            UpdateStatusText.Text = errorText;

            downloadProgressBar.Value = 100;

            downloadProgressBar.Foreground = Brushes.Tomato;

            downloadCancelButton.Content = "Exit";

        }

​

​

​

​

        private void Unzip_Files(string zipFilePath, string targetDir)

        {

​

            using (ZipFile zip = ZipFile.Read(zipFilePath))

            {

​

                zip.ExtractProgress +=

                   new EventHandler<ExtractProgressEventArgs>(Zip_ExtractProgress);

                zip.ExtractAll(targetDir, ExtractExistingFileAction.OverwriteSilently);

​

            }

​

        }

​

​

        void Zip_ExtractProgress(object sender, ExtractProgressEventArgs e)

        {

            if (e.TotalBytesToTransfer > 0)

            {

                downloadProgressBar.Value = Convert.ToInt32(100 * e.BytesTransferred / e.TotalBytesToTransfer);

            }

        }

​

​

        private void OnDownloadProgressChanged(object sender, Downloader.DownloadProgressChangedEventArgs e)

        {

            //ConsoleProgress.Tick((int)(e.ProgressPercentage * 100));

            //e.UpdateTitleInfo();

            try

            {

                 this.Dispatcher.BeginInvoke(new Action(() =>

                {

​

                 downloadProgressBar.Value = e.ProgressPercentage;

                }));

            }

            catch { }

        }

​

​

        private void Downloader_ProgressChanged(long? totalFileSize, long totalBytesDownloaded, double? progressPercentage)

        {

​

            this.Dispatcher.Invoke(new Action(() =>

            {

                downloadProgressBar.Value = progressPercentage ?? 0;

            }));

        }

​

        private void Button_Click(object sender, RoutedEventArgs e)

        {

            // Here we Delete incomplete file(s)!

            Application.Current.Shutdown();

        }

    }

}

​