MARKUS

using NetSparkle.TestAppWPF.Common;

using NetSparkleUpdater.Events;

using NetSparkleUpdater.SignatureVerifiers;

using System;

using System.Diagnostics;

using System.Drawing;

using System.IO;

using System.IO.Compression;

using System.Linq;

using System.Security;

using System.Threading.Tasks;

using System.Windows;

namespace NetSparkleUpdater.Samples.NetFramework.WPF

{

    /// <summary>

    /// Interaction logic for MainWindow.xaml

    /// </summary>

    public partial class MainWindow : Window

    {

        private SparkleUpdater _sparkle;

        private const string InstallPath = @"C:\Program Files\Doftech\MARKUS";

        private string KcomPath = @"C:\Program Files\Doftech\MARKUS\KCOM.exe";

        private string downloadFile;

        private string tempStoragePath;

        private NetSparkle.TestAppWPF.ViewModels.MainViewModel viewModel;

        public MainWindow()

        {

            InitializeComponent();

            viewModel = new NetSparkle.TestAppWPF.ViewModels.MainViewModel();

            this.DataContext = viewModel;

            //remove the netsparkle key from registry z

            //try

            //{

            //    Microsoft.Win32.Registry.CurrentUser.DeleteSubKeyTree("Software\\Microsoft\\NetSparkle.TestAppNetCoreWPF");

            //}

            //catch (Exception ex)

            //{

            //    System.Diagnostics.Debug.WriteLine(ex);

            //}

            // set icon in project properties!

            try

            {

                string manifestModuleName = System.Reflection.Assembly.GetEntryAssembly().ManifestModule.FullyQualifiedName;

                var icon = System.Drawing.Icon.ExtractAssociatedIcon(manifestModuleName);

                tempStoragePath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "MARKUS", System.IO.Path.GetRandomFileName());

                App.logger.Info($"Temp Strorage Create : {tempStoragePath}");

                if (!Directory.Exists(tempStoragePath))

                {

                    Directory.CreateDirectory(tempStoragePath);

                }

                //File.Copy(KcomPath, System.IO.Path.Combine(tempStoragePath, "Kcom.exe"));

                //KcomPath = System.IO.Path.Combine(tempStoragePath, "Kcom.exe");

                if (!File.Exists(KcomPath))

                {

                    File.Copy(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "kcom.exe"), KcomPath);

                }

                _sparkle = new SparkleUpdater(App.AppCastUri, new Ed25519Checker(Enums.SecurityMode.Unsafe, null, "NetSparkle_Ed25519.pub"), KcomPath)

                {

                    UIFactory = new NetSparkleUpdater.UI.WPF.UIFactory(NetSparkleUpdater.UI.WPF.IconUtilities.ToImageSource(icon)),

                    ShowsUIOnMainThread = true,

                    TmpDownloadFilePath = tempStoragePath,

                    UserInteractionMode = Enums.UserInteractionMode.DownloadNoInstall,

                    //UseNotificationToast = true

                    RelaunchAfterUpdate = true,

                    SecurityProtocolType = System.Net.SecurityProtocolType.Tls12

            };

                // TLS 1.2 required by GitHub (https://developer.github.com/changes/2018-02-01-weak-crypto-removal-notice/)

                _sparkle.DownloadFinished += FullUpdate_DownloadFileIsReady;

                _sparkle.UpdateCheckFinished += _sparkle_UpdateCheckFinished;

                _sparkle.DownloadHadError += _sparkle_DownloadError;

                _sparkle.DownloadMadeProgress += _sparkle_DownloadMadeProgress;

                //_sparkle.StartLoop(true, true);

                Updater();

                App.logger.Info("main Initialize");

                this.Loaded += MainWindow_Loaded;

            }

            catch (Exception ex)

            {

                App.logger.Error("main Initialize", ex);

            }

        }

        private void _sparkle_DownloadMadeProgress(object sender, AppCastItem item, ItemDownloadProgressEventArgs args)

        {

            viewModel.DownloadProgress = args.ProgressPercentage;

        }

        private void _sparkle_DownloadError(AppCastItem item, string path, Exception exception)

        {

            App.logger.Error($"Download Error", exception);

        }

        private async void Updater()

        {

            App.logger.Info("main Load");

            try

            {

                var _updateInfo = await _sparkle.CheckForUpdatesQuietly();

                if (_updateInfo != null)

                {

                    App.logger.Info("Update Status : " + _updateInfo.Status);

                    switch (_updateInfo.Status)

                    {

                        case Enums.UpdateStatus.UpdateAvailable:

                            this.Visibility = Visibility.Visible;

                            //string a = "There's an update available!";

                            var castitem = _updateInfo.Updates.First();

                            viewModel.UpdateVersion = castitem.Version;

                            System.Threading.Thread.Sleep(1000);

                            if (App.IsExternal)

                            {

                                if (!string.IsNullOrWhiteSpace(castitem.DownloadLink))

                                {

                                    var uri = UriHelper.ChangeAddress(new Uri(castitem.DownloadLink), App.ExternalAddress);

                                    castitem.DownloadLink = uri.ToString();

                                }

                                if (!string.IsNullOrWhiteSpace(castitem.ReleaseNotesLink))

                                {

                                    var uri2 = UriHelper.ChangeAddress(new Uri(castitem.ReleaseNotesLink), App.ExternalAddress);

                                    castitem.ReleaseNotesLink = uri2.ToString();

                                }

                            }

                            await _sparkle.InitAndBeginDownload(castitem);

                            App.logger.Info($"Update available Version : {castitem.Version} Link : {castitem.DownloadLink}");

                            break;

                        case Enums.UpdateStatus.UpdateNotAvailable:

                        case Enums.UpdateStatus.CouldNotDetermine:

                            _sparkle.CloseApplication += () =>

                            {

                                App.logger.Info($"Start Markus : {App.KcomParam}");

                                Process.Start(KcomPath, App.KcomParam);

                                Application.Current.Shutdown();

                            };

                            App.logger.Info($"Update Not available. Application Exit.");

                            await _sparkle.QuitApplication();

                            break;

                    }

                }

                else

                {

                    if (_updateInfo != null)

                    {

                        App.logger.Error("Update Is Null");

                        Process.Start(KcomPath, App.KcomParam);

                    }

                }

            }

            catch (Exception ex)

            {

                App.logger.Error($"main Load", ex);

            }

        }

        private async void MainWindow_Loaded(object sender, RoutedEventArgs e)

        {

        }

        private void _sparkle_UpdateCheckFinished(object sender, Enums.UpdateStatus status)

        {

        }

        //[PermissionSet(SecurityAction.Demand, Name = "FullTrust")]

        private void FullUpdate_DownloadFileIsReady(AppCastItem item, string downloadPath)

        {

            viewModel.IsWait = true;

            ExtractFiles(InstallPath,tempStoragePath,downloadPath,KcomPath, App.KcomParam);

            //ExtractProcess(item, downloadPath);

        }

        [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")]

        private void ExtractFiles(string InstallPath, string tempStoragePath, string downloadFile, string KcomPath, string Param)

        {

            viewModel.IsWait = true;

            try

            {

                var extractFolder = Path.Combine(tempStoragePath, "Extract");

                ZipFile.ExtractToDirectory(downloadFile, extractFolder);

                foreach (var file in Directory.EnumerateFiles(extractFolder, "*.*", SearchOption.AllDirectories))

                {

                    var target = System.IO.Path.Combine(InstallPath, file.Replace(extractFolder, "").Substring(1));

                    var dir = Path.GetDirectoryName(target);

                    if (!Directory.Exists(dir))

                    {

                        Directory.CreateDirectory(dir);

                    }

                    File.Copy(file, target, FileExits(target));

                    App.logger.Info($"Copy - {target}");

                }

                Process.Start(KcomPath, Param);

            }

            catch (Exception ex)

            {

                App.logger.Error($"ExtractFile Error", ex);

                if (ex.InnerException != null)

                {

                    App.logger.Error($"ExtractFile Error InnerException", ex.InnerException);

                }

            }

            finally

            {

                Application.Current.Shutdown();

            }

        }

        private static bool FileExits(string fileName)

        {

            try

            {

                return File.Exists(fileName);

            }

            catch (Exception)

            {

                return false;

            }

        }

        private void ExtractProcess(AppCastItem item, string downloadPath)

        { 

            try

            {

                downloadFile = downloadPath;

                //var args = $"{InstallPath} {tempStoragePath} {downloadFile} {KcomPath} {App.KcomParam}";

                string endpoint = IIpc.Commons.shortGuid();

                var wcfServer = new IIpc.WcfServer(endpoint + "M");

                wcfServer.Start();

                wcfServer.ProcessStart += (snd, ect) =>

                {

                    var ipcClient = new IIpc.WcfClient(endpoint + "E");

                    try

                    {

                        ipcClient.ParamReceived(InstallPath, tempStoragePath, downloadFile, KcomPath, App.KcomParam);

                        //Application.Current.Shutdown();

                    }

                    catch (Exception ex)

                    {

                        App.logger.Error($"ParamReceived ", ex);

                    }

                };

                //MarkusExtract.GetFile();

                var exrtractFile = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "MarkusExtractUpdate", @"MarkusUpdateExtract.exe");

                Process DownloadProcess = new Process();

                ProcessStartInfo startInfo = new ProcessStartInfo

                {

                    UseShellExecute = false,

                    FileName = exrtractFile,

                    WindowStyle = ProcessWindowStyle.Hidden,

                    CreateNoWindow = true,

                    ErrorDialog = false,

                    Verb = "runas",

                    RedirectStandardInput = false,

                    RedirectStandardError = false,

                    Arguments = endpoint

                };

                //$"{ InstallPath} {tempStoragePath} {downloadFile} {KcomPath} {param}"

                DownloadProcess.StartInfo = startInfo;

                DownloadProcess.EnableRaisingEvents = false;

                DownloadProcess.Start();

            }

            catch (Exception ex)

            {

                App.logger.Error($"DownloadFileIsReady ", ex);

            }

        }

    }

}