namespace ZTUpdater
{
    class Program
    {
        [STAThread]
        static int Main(string[] args)
        {
            var MinimumLevel = TraceLevel.Info;
            try
            {
                // Read the command-line options

                string OptName = null;
                var Options = new Dictionary<string, string>();
                var Arguments = new List<string>();
                foreach (var arg in args)
                {
                    if (OptName != null)
                    {

                    var Dialog = new System.Windows.Forms.FolderBrowserDialog
                    {
                        SelectedPath = @"C:\ZTree",
                        ShowNewFolderButton = false,
                        Description = "Please select the folder where ZTreeWin is installed"
                    };
                    if (Dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                        Updater.ZTreeHome = Dialog.SelectedPath;
                }
                if (Options.TryGetValue("archive", out var Value))
                    Updater.ArchiveDir = new DirectoryInfo(Value);
                else if (Options.TryGetValue("backup", out Value))
                    Updater.BackupDir = new DirectoryInfo(Value);

                // Perform the actual update
                int FilesUpdated;
                if (Arguments.Count > 0)
                {
                    FilesUpdated = Updater.UpdateFromFile(Arguments[0]);
                }
                else
                {
                    var UpdateTask = Updater.UpdateAsync();
                    UpdateTask.Wait();
                    FilesUpdated = UpdateTask.Result;
                }
                WriteLog($"{FilesUpdated} files updated.", TraceLevel.Info);
                return FilesUpdated > 0 ? 0 : 1;
            }
            catch (Exception ex)
            {
                Func<Exception,bool> WriteException = (iex) =>
                {
                    if (MinimumLevel >= TraceLevel.Verbose)
                        Console.Error.WriteLine(iex.ToString());
                    else
                        Console.Error.WriteLine(iex.Message);
                    return true;
                };
                var BackupColor = Console.ForegroundColor;
                Console.ForegroundColor = ConsoleColor.Magenta;
                if (ex is AggregateException)
                    ((AggregateException)ex).Handle(WriteException);




                else
                    WriteException(ex);
                Console.ForegroundColor = BackupColor;
                return 255;
            }
        }

        private static void ShowHelp()
        {
            string Name = Path.GetFileNameWithoutExtension(System.Reflection.Assembly.GetEntryAssembly().Location);
            var Lines = new List<string>
            {
                $@"{Name} [/v | /verbose] [/home ZTHOMEDIR] [/backup BACKUPDIR] [/archive ARCHIVEDIR] [UPDATEZIPFILE]",
                "",
                $@"/verbose             Display more messages.",
                $@"/home ZTHOMEDIR      ZTreeWin's installation directory. If not specified, {Name} attempts to determine it automatically. Failing that, it must be browsed interactively.",
                $@"/backup BACKUPDIR    Where to save backups of files replaced during an update. Default is %#ZTHome%\Backup.",

                    }
                    else
                    {
                        // TODO: break on word boundaries, and omit spaces at the start of a new line?
                        Console.Write(Description.Extract(0, Console.BufferWidth - TabPos));
                        while (Description.Length > 0)
                        {
                            Console.WriteLine();
                            Console.Write(Prefix);
                            Console.Write(Description.Extract(0, Console.BufferWidth - TabPos));
                        }
                        Console.WriteLine();
                    }
                }
            }

        {
            if (_levelColors.Count == 0)
            {
                _levelColors.Add(TraceLevel.Verbose, ConsoleColor.DarkGray);
                _levelColors.Add(TraceLevel.Warning, ConsoleColor.Yellow);
                _levelColors.Add(TraceLevel.Error, ConsoleColor.Red);
            }
            var Output = level >= TraceLevel.Warning ? Console.Out : Console.Error;
            var BackupColor = Console.ForegroundColor;
            if (_levelColors.TryGetValue(level, out var Color))
                Console.ForegroundColor = Color;
            Output.WriteLine(message);
            Console.ForegroundColor = BackupColor;
        }

        {
            get => _ZTreeHome;
            set
            {
                _ZTreeHome = value;
                if (_ZTreeHome != null)
                {
                    string[] Executables = Directory.GetFiles(ZTreeHome, Executable);
                    if (Executables.Length > 0)
                        Executable = Executables[0];
                    else
                        Executable = Path.Combine(ZTreeHome, Executable);

                    // determine version of local executable
                    CurrentVersion = FileVersionInfo.GetVersionInfo(Executable).FileVersion;

            // from the environment
            string ZTHome = Environment.GetEnvironmentVariable("#ZTHome");
            if (Directory.Exists(ZTHome))
                return ZTHome;

            // from registry (both Win32 and Win64)
            object InstallDir = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\ZTreeWin", "Install_Dir", null);
            if (InstallDir is string && Directory.Exists(ZTHome = (string)InstallDir))
                return ZTHome;
            InstallDir = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\ZTreeWin", "Install_Dir", null);
            if (InstallDir is string && Directory.Exists(ZTHome = (string)InstallDir))
                return ZTHome;

            return null;
        }

        private Regex _rexZetaAvailable = new Regex(@"forum_entry.php\?id=(\d+)""[^\<]*?v(\d+\.\S+) Now Available", RegexOptions.Compiled | RegexOptions.IgnoreCase);
        private Regex _rexWhatsNew = new Regex(@"<div class=""posting"">(.*?)</div><p class=""signature"">", RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.Singleline);
        private Regex _rexLink = new Regex(@"""(https?://(www.)?z(edtek|tree).com\/[^""]*\.(zip|exe))""", RegexOptions.Compiled | RegexOptions.IgnoreCase);

        public async Task<Uri> GetUriLatestVersion()
        {
            using (var Client = new HttpClient())
            {
                // get the forum home page
                Log("Looking for announcement on ZTreeWin Forum...");

        /// <summary>
        /// Checks for an updated version of ZTreeWin; and if found, download and install it.
        /// </summary>
        /// <returns>The number of files that were updated.</returns>
        public async Task<int> UpdateAsync()
        {
            Log($@"ZTreeWin version {CurrentVersion} located in ""{ZTreeHome}"".", TraceLevel.Info);
            if (!Directory.Exists(ZTreeHome))
                throw new DirectoryNotFoundException($@"Directory ""{ZTreeHome}"" not found");

            Uri DownloadUri = await GetUriLatestVersion();
            if (DownloadUri == null)
                return 0;

            // Prepare to save the file in the user’s Downloads folder
            string Folder = (ArchiveDir ?? BackupDir)?.FullName ?? KnownFolders.Downloads.Path;
            string OrgZipFile = DownloadUri.AbsolutePath;
            int Pos = OrgZipFile.LastIndexOf("/");

                Counter++;
                ZipFile = Base + $" ({Counter})" + Extension;
            }

            Log($@"Downloading update file to ""{OrgZipFile}""...");
            using (var Client = new HttpClient())
            {
                Stream ZipStream = await Client.GetStreamAsync(DownloadUri);
                using (var FileStream = new FileStream(ZipFile, FileMode.CreateNew, FileAccess.Write, FileShare.Read))
                {
                    await ZipStream.CopyToAsync(FileStream);
                }
            }

            // If the newly downloaded file is identical to the existing one, delete the new one and just reuse the old one.

                        }

                        // Try moving to version-based folder first; only if that doesn't work, try to rename
                        //  to a version-based file name in the same folder.
                        Log($"\t{Entry.FullName}\tbacking up existing file.");
                        try
                        {
                            string BackupName = VersionBasedFolder(TargetFile);
                            try
                            {
                                File.Move(TargetFile.FullName, BackupName);
                                TargetFile.Refresh();
                                if (TargetFile.Exists)
                                    // Then, the move was NOT successful
                                    throw new Exception("Unable to move the file.");

            }
            return NumFiles;
        }

        private string VersionBasedFolder(FileInfo File)
        {
            var SourceDir = new DirectoryInfo(ZTreeHome);
            var TargetDir = BackupDir ?? SourceDir.CreateSubdirectory("Backup");
            TargetDir = TargetDir.CreateSubdirectory(CurrentVersion);
            return Path.Combine(TargetDir.FullName, File.FullName.Substring(SourceDir.FullName.Length + 1));
        }

        private string VersionBasedFilename(FileInfo File)
        {
            var Extension = File.Extension;

            // decode all HTML entities
            var rexEntity = new Regex(@"&(#x?[0-9a-f]{1,4}|\w{2,8});", RegexOptions.Compiled | RegexOptions.IgnoreCase);
            Match Match;
            int StartAt = 0;
            while ((Match = rexEntity.Match(Text, StartAt)).Success)
            {
                string Entity = Match.Groups[1].Value;
                string Replacement = "?";
                if (Entity.StartsWith("#"))
                {
                    int CharCode = 0;
                    if (Entity.Substring(1, 1) == "x")
                        // hexadecimal char code
                        CharCode = int.Parse(Entity.Substring(2), System.Globalization.NumberStyles.HexNumber);
                    else