public IncrementalPatchApplier(PatchIntercomms comms, PatchInfo patchInfo)
        {
            this.comms     = comms;
            this.patchInfo = patchInfo;

            string patchVersion = patchInfo.PatchVersion();

            patchDownloadPath   = comms.GetDownloadPathForPatch(patchVersion);
            patchDecompressPath = comms.GetDecompressPathForPatch(patchVersion);
        }
        private PatchResult Patch()
        {
            PatchStage = PatchStage.CheckingUpdates;

            Stopwatch timer = Stopwatch.StartNew();

            comms.Log(Localization.Get(StringId.RetrievingVersionInfo));

            if (!FetchVersionInfo())
            {
                return(PatchResult.Failed);
            }

            if (comms.IsUnderMaintenance())
            {
                return(PatchResult.Failed);
            }

            if (!currentVersion.IsValid)
            {
                currentVersion = new VersionCode(0);
            }

            VersionCode rootVersion = currentVersion;

            if (comms.SelfPatching)
            {
                VersionCode patchedVersion = PatchUtils.GetVersion(comms.DecompressedFilesPath, comms.VersionInfo.Name);
                if (patchedVersion > currentVersion)
                {
                    currentVersion = patchedVersion;
                }
            }

            PatchStage = PatchStage.CheckingFileIntegrity;

            if (CheckLocalFilesUpToDate(true, false))
            {
                return(PatchResult.AlreadyUpToDate);
            }

            if (!PatchUtils.CheckWriteAccessToFolder(comms.RootPath))
            {
                FailReason  = PatchFailReason.RequiresAdminPriviledges;
                FailDetails = Localization.Get(StringId.E_AccessToXIsForbiddenRunInAdminMode, comms.RootPath);

                return(PatchResult.Failed);
            }

            if (!PatchUtils.CheckWriteAccessToFolder(comms.CachePath))
            {
                FailReason  = PatchFailReason.RequiresAdminPriviledges;
                FailDetails = Localization.Get(StringId.E_AccessToXIsForbiddenRunInAdminMode, comms.CachePath);

                return(PatchResult.Failed);
            }

            if (checkForMultipleRunningInstances)
            {
                string currentExecutablePath = PatchUtils.GetCurrentExecutablePath();
                if (PatchUtils.GetNumberOfRunningProcesses(currentExecutablePath) > 1)
                {
                    FailReason  = PatchFailReason.MultipleRunningInstances;
                    FailDetails = Localization.Get(StringId.E_AnotherInstanceOfXIsRunning, Path.GetFileName(currentExecutablePath));

                    return(PatchResult.Failed);
                }
            }

            if (comms.Cancel)
            {
                return(PatchResult.Failed);
            }

            // Add a date holder file to the cache to save the last access time reliably
            DateTime dateTimeNow = DateTime.UtcNow;

            File.WriteAllText(comms.CachePath + PatchParameters.CACHE_DATE_HOLDER_FILENAME, dateTimeNow.ToString("O"));

            // Check if there are any leftover files from other SimplePatchTool integrated apps in cache
            DirectoryInfo[] patcherCaches = new DirectoryInfo(comms.CachePath).Parent.GetDirectories();
            for (int i = 0; i < patcherCaches.Length; i++)
            {
                DirectoryInfo cacheDir = patcherCaches[i];
                if (cacheDir.Name.Equals(comms.VersionInfo.Name, StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                FileInfo dateHolder = new FileInfo(PatchUtils.GetPathWithTrailingSeparatorChar(cacheDir.FullName) + PatchParameters.CACHE_DATE_HOLDER_FILENAME);
                if (dateHolder.Exists && dateHolder.Length > 0L)
                {
                    DateTime lastAccessTime;
                    if (DateTime.TryParseExact(File.ReadAllText(dateHolder.FullName), "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out lastAccessTime))
                    {
                        if ((dateTimeNow - lastAccessTime).TotalDays <= PatchParameters.CACHE_DATE_EXPIRE_DAYS)
                        {
                            continue;
                        }
                    }
                }

                // This cache directory doesn't have a date holder file or is older than CACHE_DATE_EXPIRE_DAYS, delete it
                cacheDir.Delete(true);
            }

            bool canRepairPatch      = this.canRepairPatch;
            bool canIncrementalPatch = this.canIncrementalPatch;
            bool canInstallerPatch   = this.canInstallerPatch;

            List <PatchMethodHolder> preferredPatchMethods = new List <PatchMethodHolder>(3);
            List <VersionItem>       versionInfoFiles      = comms.VersionInfo.Files;

            if (canRepairPatch)
            {
                for (int i = 0; i < versionInfoFiles.Count; i++)
                {
                    VersionItem item = versionInfoFiles[i];
                    if (item.CompressedFileSize == 0L && string.IsNullOrEmpty(item.CompressedMd5Hash))
                    {
                        canRepairPatch = false;
                        break;
                    }
                }

                if (canRepairPatch)
                {
                    long repairPatchSize = 0L;
                    for (int i = 0; i < versionInfoFiles.Count; i++)
                    {
                        VersionItem item      = versionInfoFiles[i];
                        FileInfo    localFile = new FileInfo(comms.RootPath + item.Path);
                        if (localFile.Exists && localFile.MatchesSignature(item.FileSize, item.Md5Hash))
                        {
                            continue;
                        }

                        FileInfo downloadedFile = new FileInfo(comms.DownloadsPath + item.Path);
                        if (downloadedFile.Exists && downloadedFile.MatchesSignature(item.CompressedFileSize, item.CompressedMd5Hash))
                        {
                            continue;
                        }

                        if (comms.SelfPatching)
                        {
                            FileInfo decompressedFile = new FileInfo(comms.DecompressedFilesPath + item.Path);
                            if (decompressedFile.Exists && decompressedFile.MatchesSignature(item.FileSize, item.Md5Hash))
                            {
                                continue;
                            }
                        }

                        repairPatchSize += item.CompressedFileSize;
                    }

                    preferredPatchMethods.Add(new PatchMethodHolder(PatchMethod.RepairPatch, repairPatchSize));
                }
            }

            if (canIncrementalPatch)
            {
                // Find incremental patches to apply
                VersionCode             thisVersion        = rootVersion;
                List <IncrementalPatch> versionInfoPatches = comms.VersionInfo.IncrementalPatches;
                for (int i = 0; i < versionInfoPatches.Count; i++)
                {
                    if (thisVersion == comms.VersionInfo.Version)
                    {
                        break;
                    }

                    IncrementalPatch patch = versionInfoPatches[i];
                    if (thisVersion == patch.FromVersion)
                    {
                        thisVersion = patch.ToVersion;
                        incrementalPatches.Add(patch);
                    }
                }

                if (thisVersion != comms.VersionInfo.Version)
                {
                    incrementalPatches.Clear();
                }

                if (incrementalPatches.Count == 0)
                {
                    canIncrementalPatch = false;
                }
                else
                {
                    long incrementalPatchSize = 0L;
                    for (int i = 0; i < incrementalPatches.Count; i++)
                    {
                        IncrementalPatch incrementalPatch = incrementalPatches[i];
                        if (currentVersion > incrementalPatch.FromVersion)
                        {
                            continue;
                        }

                        FileInfo patchFile = new FileInfo(comms.GetDownloadPathForPatch(incrementalPatch.PatchVersion()));
                        if (patchFile.Exists && patchFile.MatchesSignature(incrementalPatch.PatchSize, incrementalPatch.PatchMd5Hash))
                        {
                            continue;
                        }

                        incrementalPatchSize += incrementalPatch.PatchSize;
                    }

                    preferredPatchMethods.Add(new PatchMethodHolder(PatchMethod.IncrementalPatch, incrementalPatchSize));
                }
            }

            if (canInstallerPatch)
            {
                InstallerPatch installerPatch = comms.VersionInfo.InstallerPatch;
                if (installerPatch.PatchSize == 0L && string.IsNullOrEmpty(installerPatch.PatchMd5Hash))
                {
                    canInstallerPatch = false;
                }
                else
                {
                    preferredPatchMethods.Add(new PatchMethodHolder(PatchMethod.InstallerPatch, installerPatch.PatchSize));
                }
            }

            preferredPatchMethods.Sort((p1, p2) => p1.size.CompareTo(p2.size));

            if (preferredPatchMethods.Count == 0)
            {
                FailReason  = PatchFailReason.NoSuitablePatchMethodFound;
                FailDetails = Localization.Get(StringId.E_NoSuitablePatchMethodFound);

                return(PatchResult.Failed);
            }

            // Check if there is enough free disk space
            long requiredFreeSpaceInCache = preferredPatchMethods[0].size, requiredFreeSpaceInRoot = 0L;

            for (int i = 0; i < versionInfoFiles.Count; i++)
            {
                VersionItem item      = versionInfoFiles[i];
                FileInfo    localFile = new FileInfo(comms.RootPath + item.Path);
                if (!localFile.Exists)
                {
                    requiredFreeSpaceInCache += item.FileSize;
                    requiredFreeSpaceInRoot  += item.FileSize;
                }
                else if (!localFile.MatchesSignature(item.FileSize, item.Md5Hash))
                {
                    requiredFreeSpaceInCache += item.FileSize;

                    long deltaSize = item.FileSize - localFile.Length;
                    if (deltaSize > 0L)
                    {
                        requiredFreeSpaceInRoot += deltaSize;
                    }
                }
            }

            requiredFreeSpaceInCache += requiredFreeSpaceInCache / 3;    // Require additional 33% free space (might be needed by compressed files and/or incremental patches)
            requiredFreeSpaceInCache += 1024 * 1024 * 1024L;             // Require additional 1 GB of free space, just in case

            string rootDrive = new DirectoryInfo(comms.RootPath).Root.FullName;
            string cacheDrive = new DirectoryInfo(comms.CachePath).Root.FullName;

            if (rootDrive.Equals(cacheDrive, StringComparison.OrdinalIgnoreCase))
            {
                if (!CheckFreeSpace(rootDrive, requiredFreeSpaceInCache + requiredFreeSpaceInRoot))
                {
                    return(PatchResult.Failed);
                }
            }
            else
            {
                if (!CheckFreeSpace(rootDrive, requiredFreeSpaceInRoot))
                {
                    return(PatchResult.Failed);
                }

                if (!CheckFreeSpace(cacheDrive, requiredFreeSpaceInCache))
                {
                    return(PatchResult.Failed);
                }
            }

            for (int i = 0; i < preferredPatchMethods.Count; i++)
            {
                comms.LogToFile(Localization.Get(StringId.PatchMethodXSizeY, preferredPatchMethods[i].method, preferredPatchMethods[i].size.ToMegabytes() + "MB"));
            }

            // Start patching
            for (int i = 0; i < preferredPatchMethods.Count; i++)
            {
                PatchMethod patchMethod = preferredPatchMethods[i].method;

                bool success;
                if (patchMethod == PatchMethod.RepairPatch)
                {
                    PatchMethod = PatchMethod.RepairPatch;
                    comms.ListenerCallPatchMethodChanged(PatchMethod);

                    success = PatchUsingRepairPatch();
                }
                else if (patchMethod == PatchMethod.IncrementalPatch)
                {
                    PatchMethod = PatchMethod.IncrementalPatch;
                    comms.ListenerCallPatchMethodChanged(PatchMethod);

                    success = PatchUsingIncrementalPatches();
                }
                else
                {
                    PatchMethod = PatchMethod.InstallerPatch;
                    comms.ListenerCallPatchMethodChanged(PatchMethod);

                    success = PatchUsingInstallerPatch();
                }

                if (comms.Cancel)
                {
                    return(PatchResult.Failed);
                }

                if (success)
                {
                    break;
                }
                else
                {
                    comms.LogToFile(string.Concat(comms.FailReason, ": ", comms.FailDetails));

                    if (i == preferredPatchMethods.Count - 1)
                    {
                        return(PatchResult.Failed);
                    }
                }
            }

            PatchStage = PatchStage.CheckingFileIntegrity;

            if (!CheckLocalFilesUpToDate(false, comms.SelfPatching))
            {
                comms.Log(Localization.Get(StringId.SomeFilesAreStillNotUpToDate));

                if (canRepairPatch)
                {
                    if (!PatchUsingRepairPatch())
                    {
                        return(PatchResult.Failed);
                    }
                }
                else
                {
                    FailReason  = PatchFailReason.FilesAreNotUpToDateAfterPatch;
                    FailDetails = Localization.Get(StringId.E_FilesAreNotUpToDateAfterPatch);

                    return(PatchResult.Failed);
                }
            }

            comms.UpdateVersion(comms.VersionInfo.Version);

            PatchStage = PatchStage.DeletingObsoleteFiles;
            comms.Log(Localization.Get(StringId.CalculatingObsoleteFiles));

            List <string> obsoleteFiles = FindFilesToDelete(comms.RootPath);

            if (!comms.SelfPatching)
            {
                if (obsoleteFiles.Count > 0)
                {
                    comms.Log(Localization.Get(StringId.DeletingXObsoleteFiles, obsoleteFiles.Count));
                    for (int i = 0; i < obsoleteFiles.Count; i++)
                    {
                        comms.Log(Localization.Get(StringId.DeletingX, obsoleteFiles[i]));
                        File.Delete(comms.RootPath + obsoleteFiles[i]);
                    }
                }
                else
                {
                    comms.Log(Localization.Get(StringId.NoObsoleteFiles));
                }

                PatchUtils.DeleteDirectory(comms.CachePath);
            }
            else
            {
                // Delete obsolete self patching files
                List <string> obsoleteSelfPatchingFiles = FindFilesToDelete(comms.DecompressedFilesPath);
                if (obsoleteSelfPatchingFiles.Count > 0)
                {
                    comms.Log(Localization.Get(StringId.DeletingXObsoleteFiles, obsoleteSelfPatchingFiles.Count));
                    for (int i = 0; i < obsoleteSelfPatchingFiles.Count; i++)
                    {
                        comms.Log(Localization.Get(StringId.DeletingX, obsoleteSelfPatchingFiles[i]));
                        File.Delete(comms.DecompressedFilesPath + obsoleteSelfPatchingFiles[i]);
                    }
                }
                else
                {
                    comms.Log(Localization.Get(StringId.NoObsoleteFiles));
                }

                // Self patcher executable, if exists, can't self patch itself, so patch it manually here
                // This assumes that self patcher and any related files are located at SELF_PATCHER_DIRECTORY
                string selfPatcherFiles = comms.DecompressedFilesPath + PatchParameters.SELF_PATCHER_DIRECTORY;
                if (Directory.Exists(selfPatcherFiles))
                {
                    PatchUtils.MoveDirectory(selfPatcherFiles, comms.RootPath + PatchParameters.SELF_PATCHER_DIRECTORY);
                }

                string        separator = PatchParameters.SELF_PATCH_OP_SEPARATOR;
                StringBuilder sb        = new StringBuilder(500);

                // Append current version to the beginning of the file
                sb.Append(rootVersion);

                // 1. Rename files
                if (incrementalPatchesInfo.Count > 0)
                {
                    sb.Append(separator).Append(PatchParameters.SELF_PATCH_MOVE_OP);
                    for (int i = 0; i < incrementalPatchesInfo.Count; i++)
                    {
                        IncrementalPatchInfo incrementalPatch = incrementalPatchesInfo[i];
                        for (int j = 0; j < incrementalPatch.RenamedFiles.Count; j++)
                        {
                            PatchRenamedItem renamedItem = incrementalPatch.RenamedFiles[j];
                            sb.Append(separator).Append(comms.RootPath + renamedItem.BeforePath).Append(separator).Append(comms.RootPath + renamedItem.AfterPath);
                        }
                    }
                }

                // 2. Update files
                sb.Append(separator).Append(PatchParameters.SELF_PATCH_MOVE_OP);

                DirectoryInfo   updatedFilesDir       = new DirectoryInfo(comms.DecompressedFilesPath);
                DirectoryInfo[] updatedSubDirectories = updatedFilesDir.GetDirectories();
                for (int i = 0; i < updatedSubDirectories.Length; i++)
                {
                    sb.Append(separator).Append(comms.DecompressedFilesPath).Append(updatedSubDirectories[i].Name).Append(Path.DirectorySeparatorChar).Append(separator).Append(comms.RootPath).Append(updatedSubDirectories[i].Name).Append(Path.DirectorySeparatorChar);
                }

                string     versionHolderFilename = comms.VersionInfo.Name + PatchParameters.VERSION_HOLDER_FILENAME_POSTFIX;
                FileInfo[] updatedFiles          = updatedFilesDir.GetFiles();
                for (int i = 0; i < updatedFiles.Length; i++)
                {
                    // Don't update the version holder file until everything else is updated properly
                    if (updatedFiles[i].Name != versionHolderFilename)
                    {
                        sb.Append(separator).Append(comms.DecompressedFilesPath).Append(updatedFiles[i].Name).Append(separator).Append(comms.RootPath).Append(updatedFiles[i].Name);
                    }
                }

                // Update the version holder now
                sb.Append(separator).Append(comms.DecompressedFilesPath).Append(versionHolderFilename).Append(separator).Append(comms.RootPath).Append(versionHolderFilename);

                // 3. Delete obsolete files
                if (obsoleteFiles.Count > 0)
                {
                    string selfPatcherDirectory = PatchParameters.SELF_PATCHER_DIRECTORY + Path.DirectorySeparatorChar;
                    sb.Append(separator).Append(PatchParameters.SELF_PATCH_DELETE_OP);

                    comms.Log(Localization.Get(StringId.DeletingXObsoleteFiles, obsoleteFiles.Count));
                    for (int i = 0; i < obsoleteFiles.Count; i++)
                    {
                        // Delete the obsolete files inside SELF_PATCHER_DIRECTORY manually
                        string absolutePath = comms.RootPath + obsoleteFiles[i];
                        if (obsoleteFiles[i].StartsWith(selfPatcherDirectory, StringComparison.OrdinalIgnoreCase))
                        {
                            comms.Log(Localization.Get(StringId.DeletingX, obsoleteFiles[i]));

                            if (File.Exists(absolutePath))
                            {
                                File.Delete(absolutePath);
                            }
                            else if (Directory.Exists(absolutePath))
                            {
                                PatchUtils.DeleteDirectory(absolutePath);
                            }
                        }
                        else
                        {
                            // '-->' indicates that the file will be deleted by the self patcher executable
                            comms.LogToFile(Localization.Get(StringId.DeletingX, "--> " + obsoleteFiles[i]));
                            sb.Append(separator).Append(absolutePath);
                        }
                    }
                }
                else
                {
                    comms.Log(Localization.Get(StringId.NoObsoleteFiles));
                }

                sb.Append(separator).Append(comms.CachePath);

                File.Delete(comms.CachePath + PatchParameters.SELF_PATCH_COMPLETED_INSTRUCTIONS_FILENAME);
                File.WriteAllText(comms.CachePath + PatchParameters.SELF_PATCH_INSTRUCTIONS_FILENAME, sb.Append(separator).ToString());
            }

            comms.Log(Localization.Get(StringId.PatchCompletedInXSeconds, timer.ElapsedSeconds()));
            return(PatchResult.Success);
        }