public ModDetails(BundleMod mod)
     : this()
 {
     this._mod = mod;
 }
        /// <summary>
        ///     The update local mods.
        /// </summary>
        private void updateModsListView()
        {
            //Regen the missingfile list
            Dictionary<string, BundleMod> modsList = this.mods_db.modsList;
            List<BackupEntry> missingfile_list = this.mods_db.installedModsList_missing;

            this.allowCheck = false;
            //Clear items
            //this.availiableMods_listView.Items.Clear();
            List<ListViewItem> new_availiableMods = new List<ListViewItem>();

            //Populate with local mods
            foreach (BundleMod localMod in modsList.Values.ToList())
            {
                ListViewItem lvdi = new ListViewItem();

                if (this.mods_db.InstalledModsListContains(localMod) >= 0 || localMod.status == BundleMod.ModStatus.Installed)
                {
                    localMod.status = BundleMod.ModStatus.Installed;
                    lvdi.Checked = true;
                }
                else
                    lvdi.Checked = false;

                if (localMod.IncludesPatchScriptWithinOverride)
                {
                    lvdi.Text = "[*]" + localMod.Name;
                    lvdi.ToolTipText = "This mod uses the override folder with scripts, which may need to be reinstalled with game updates.";
                }
                else if (localMod.UtilizesBundles)
                {
                    lvdi.Text = "[#]" + localMod.Name;
                    lvdi.ToolTipText = "This mod will need to be reinstalled with each game update.";
                }
                else
                {
                    lvdi.Text = localMod.Name;
                }

                lvdi.Tag = localMod;
                lvdi.Group = this.availiableMods_listView.Groups[0];
                if(localMod.type == BundleMod.ModType.mod_override)
                    lvdi.Group = this.availiableMods_listView.Groups[1];
                else if (localMod.type == BundleMod.ModType.lua)
                {
                    lvdi.Group = this.availiableMods_listView.Groups[2];
                    lvdi.Checked = localMod.enabled;
                }

                if (localMod.actionStatus == BundleMod.ModActionStatus.Install)
                {
                    lvdi.BackColor = Color.LimeGreen;
                    lvdi.ForeColor = Color.Black;
                    lvdi.Checked = true;
                }
                else if (localMod.actionStatus == BundleMod.ModActionStatus.Remove)
                {
                    lvdi.BackColor = Color.Red;
                    lvdi.ForeColor = Color.White;
                    lvdi.Checked = false;
                }
                else if (localMod.actionStatus == BundleMod.ModActionStatus.Reinstall)
                {
                    lvdi.BackColor = Color.Yellow;
                    lvdi.ForeColor = Color.Black;
                    lvdi.Checked = true;
                }
                else if (localMod.actionStatus == BundleMod.ModActionStatus.ForcedReinstall)
                {
                    lvdi.BackColor = Color.Orange;
                    lvdi.ForeColor = Color.Black;
                    lvdi.Checked = true;
                }
                else if (localMod.actionStatus == BundleMod.ModActionStatus.Missing)
                {
                    localMod.canInstall = false;
                    localMod.canUninstall = true;
                    lvdi.BackColor = Color.LightBlue;
                    lvdi.ForeColor = Color.Black;
                    lvdi.Checked = true;
                }
                else
                {
                    lvdi.BackColor = Color.White;
                    lvdi.ForeColor = Color.Black;
                }

                if (searchMod(localMod, this.availiableModsSearch_textbox.Text) && (!(localMod.type == BundleMod.ModType.mod_override && !StaticStorage.settings.ShowOverrideMods)))
                    new_availiableMods.Add(lvdi);
                //this.availiableMods_listView.Items.Add( lvdi );
            }

            //Populate with other mods
            //population here

            if (missingfile_list.Count > 0)
            {
                foreach (var missing in missingfile_list)
                {
                    ListViewItem lvdi = new ListViewItem();
                    BundleMod missingMod = new BundleMod();
                    missingMod.Name = missing.Name;
                    missingMod.Author = missing.Author;
                    missingMod.Description = missing.Description;
                    missingMod.ItemQueue = missing.ItemQueue;

                    missingMod.canInstall = false;
                    missingMod.canUninstall = true;
                    missingMod.actionStatus = BundleMod.ModActionStatus.Missing;
                    lvdi.BackColor = Color.LightBlue;
                    lvdi.ForeColor = Color.Black;
                    lvdi.Checked = true;

                    lvdi.Text = missingMod.Name;
                    lvdi.Tag = missingMod;
                    lvdi.Group = this.availiableMods_listView.Groups[0];

                    if (searchMod(missingMod, this.availiableModsSearch_textbox.Text))
                        new_availiableMods.Add(lvdi);
                    //this.availiableMods_listView.Items.Add(lvdi);
                }
            }

            //this.availiableMods_listView.Items = (this.availiableMods_listView.Items.).OrderByDescending(o => o.Checked).ToList();

            this.availiableMods_listView.Items.Clear();
            this.availiableMods_listView.Items.AddRange(new_availiableMods.ToArray());

            this.availiableMods_listView.Update();
            this.refreshModsListView();
            this.allowCheck = true;
        }
        /// <summary>
        ///     The apply button_ click.
        /// </summary>
        /// <param name="sender">
        ///     The sender.
        /// </param>
        /// <param name="e">
        ///     The e.
        /// </param>
        private void ApplyButtonClick(object sender, EventArgs e)
        {
            if (!String.IsNullOrEmpty(StaticStorage.settings.GameProcess))
            {
                Process[] pname = Process.GetProcessesByName(StaticStorage.settings.GameProcess);
                if (pname.Length != 0)
                {
                    MessageBox.Show(StaticStorage.settings.Game + " is currently running, cannot patch.\nPlease close the game before applying mods.");
                    return;
                }
            }

            if (!this.TestAssetsFolder())
            {
                MessageBox.Show("Your assets folder appears to be invalid. Please select a valid assets folder in Options.", "Invalid assets folder.");
                return;
            }
            if (this.rewriter != null)
                return;
            if (this.ExtractTimer != null)
            {
                if (this.ExtractTimer.Enabled)
                {
                    MessageBox.Show("Cannot perform 2 actions at once");
                    return;
                }
            }
            this.TotalProgressLabel.Text = "Preparing to Apply Changes";

            this.savedStateApplyMod = this.ApplyButton.Enabled;
            this.savedStateOpenMod = this.OpenModButton.Enabled;
            this.savedStateRefreshButton = this.refreshButton.Enabled;
            this.savedStateFileControlButton = this.filecontrol_button.Enabled;

            this.availiableMods_listView.Enabled = false;
            this.availiableModsSearch_textbox.Enabled = false;
            this.ApplyButton.Enabled = false;
            this.OpenModButton.Enabled = false;
            this.refreshButton.Enabled = false;
            this.filecontrol_button.Enabled = false;
            this.ExtraOptions1.Enabled = false;

            List<BundleMod> uninstall = new List<BundleMod>();
            List<BundleMod> reinstall = new List<BundleMod>();
            List<BundleMod> install = new List<BundleMod>();
            List<BundleMod> install_combo = new List<BundleMod>();
            Queue<BundleRewriteItem> mix_bri = new Queue<BundleRewriteItem>();
            BundleMod mix = new BundleMod();

            // 0 = Nothing, 1 = Marked for install (limegreen), 2 = Marked for removal (red), 3 = Marked for reinstallation (yellow), 4 =
            Dictionary<string, BundleMod> modsList = this.mods_db.modsList;

            install = modsList.Values.Where(mod => mod.actionStatus == BundleMod.ModActionStatus.Install).ToList();
            reinstall = modsList.Values.Where(mod => mod.actionStatus == BundleMod.ModActionStatus.Reinstall || mod.actionStatus == BundleMod.ModActionStatus.ForcedReinstall).ToList();
            uninstall = modsList.Values.Where(mod => mod.actionStatus == BundleMod.ModActionStatus.Remove).ToList();

            //Perform other actions

            //Generate install/reinstall/uninstall mods
            if (uninstall.Count > 0)
            {
                //Generate Bundle Mod
                foreach (BundleMod uninstMod in uninstall)
                {
                    if (uninstMod.type == BundleMod.ModType.lua)
                    {
                        Directory.Delete(uninstMod.file, true);
                    }
                    else
                    {
                        foreach (BundleRewriteItem bri in uninstMod.ItemQueue)
                        {
                            if (uninstMod.type == BundleMod.ModType.mod_override)
                            {
                                if (bri.isOverrideable()
                                    //&& !bri.ReplacementFile.EndsWith(".script")
                                )
                                {

                                    if (!string.IsNullOrEmpty(StaticStorage.Known_Index.GetPath(bri.BundlePath)) && !string.IsNullOrEmpty(StaticStorage.Known_Index.GetExtension(bri.BundleExtension)))
                                    {
                                        string extrname = "";
                                        extrname += StaticStorage.Known_Index.GetPath(bri.BundlePath);
                                        extrname += "." + StaticStorage.Known_Index.GetExtension(bri.BundleExtension);

                                        string modName = bri.ModName;
                                        modName = Path.GetInvalidFileNameChars().Aggregate(modName, (current, c) => current.Replace(c.ToString(), "_"));

                                        if (File.Exists(Path.Combine(StaticStorage.settings.AssetsFolder, "mod_overrides", modName)))
                                        {
                                            if (File.Exists(Path.Combine(StaticStorage.settings.AssetsFolder, "mod_overrides", modName, extrname)))
                                            {
                                                File.Delete(Path.Combine(StaticStorage.settings.AssetsFolder, "mod_overrides", modName, extrname));

                                                DeleteEmptyDirs(Path.Combine(StaticStorage.settings.AssetsFolder, "mod_overrides", modName));
                                            }
                                        }
                                    }
                                }
                            }
                            else
                            {
                                if (!mix_bri.Contains(bri))
                                {
                                    BundleRewriteItem newBri = bri;
                                    newBri.toRemove = true;
                                    mix_bri.Enqueue(newBri);
                                }
                            }
                        }
                        if (File.Exists(Path.Combine(StaticStorage.settings.AssetsFolder, "mod_overrides", uninstMod.getEscapedName(), "mod.txt")))
                        {
                             File.Delete(Path.Combine(StaticStorage.settings.AssetsFolder, "mod_overrides", uninstMod.getEscapedName(), "mod.txt"));
                        }
                    }
                }
            }
            if (reinstall.Count > 0)
            {
                //Generate Bundle Mod
                foreach (BundleMod bm in reinstall)
                {
                    foreach (BundleRewriteItem bri in bm.ItemQueue)
                    {
                        if (!bri.ReplacementFile.EndsWith(".script") && filecontrolSelectedDictionary.ContainsKey(bri.getBundleEntryPath()))
                        {
                            if (filecontrolSelectedDictionary[bri.getBundleEntryPath()] != bm.Name)
                            {
                                BundleRewriteItem newBri = bri;
                                newBri.toRemove = true;
                                mix_bri.Enqueue(newBri);
                                continue;
                            }
                        }

                        if (bri.toReinstall && !mix_bri.Contains(bri))
                        {
                            BundleRewriteItem newBri = bri;
                            newBri.toRemove = false;
                            mix_bri.Enqueue(newBri);
                        }
                    }

                    if (bm.UtilizesOverride)
                    {
                        if (File.Exists(Path.Combine(StaticStorage.settings.AssetsFolder, "mod_overrides", bm.getEscapedName())) && File.Exists(Path.Combine(StaticStorage.settings.AssetsFolder, "mod_overrides", bm.getEscapedName(), "mod.txt")))
                        {
                            using (StreamWriter modsw = File.CreateText(Path.Combine(StaticStorage.settings.AssetsFolder, "mod_overrides", bm.getEscapedName(), "mod.txt")))
                            {
                                modsw.Write(OverrideMod.Serialize(new OverrideMod(bm.Name, bm.Author, bm.Description)));
                            }
                        }
                    }
                }
            }
            if (install.Count > 0)
            {
                //Generate Bundle Mod
                foreach (BundleMod bm in install)
                {
                    foreach (BundleRewriteItem bri in bm.ItemQueue)
                    {

                        if (!bri.ReplacementFile.EndsWith(".script") && filecontrolSelectedDictionary.ContainsKey(bri.getBundleEntryPath()))
                        {
                            if (filecontrolSelectedDictionary[bri.getBundleEntryPath()] != bm.Name)
                                continue;
                        }

                        if (!mix_bri.Contains(bri))
                        {
                            BundleRewriteItem newBri = bri;
                            newBri.toRemove = false;
                            mix_bri.Enqueue(newBri);
                        }
                    }

                    if (bm.UtilizesOverride)
                    {
                        if (!Directory.Exists(Path.Combine(StaticStorage.settings.AssetsFolder, "mod_overrides", bm.getEscapedName())))
                            Directory.CreateDirectory(Path.Combine(StaticStorage.settings.AssetsFolder, "mod_overrides", bm.getEscapedName()));

                        using (StreamWriter modsw = File.CreateText(Path.Combine(StaticStorage.settings.AssetsFolder, "mod_overrides", bm.getEscapedName(), "mod.txt")))
                        {
                            modsw.Write(OverrideMod.Serialize(new OverrideMod(bm.Name, bm.Author, bm.Description)));
                        }
                    }
                }
            }
            install_combo.AddRange(install);
            install_combo.AddRange(reinstall);

            mix.ItemQueue = new HashSet<BundleRewriteItem>(mix_bri.ToList());

            int BufferSize;
            if (!Int32.TryParse(this.patchingBufferSize.Text, out BufferSize))
            {
                BufferSize = 4096;
            }

            this.rewriter = new BundleRewriter(
                "",
                mix,
                BufferSize,
                StaticStorage.settings.AssetsFolder,
                StaticStorage.settings.BackupType,
                StaticStorage.settings.OverrideFolder,
                StaticStorage.settings.OverrideFolderDummies,
                StaticStorage.settings.OverrideFolderShared,
                true,
                false);

            this.progressTimer = new Timer();
            this.progressTimer.Interval = 500;
            this.progressTimer.Tick += this.MultiProgressTimerElapsed;
            this.progressTimer.Enabled = true;
            this.progressTimer.Start();
            rewriterThread = new Thread(() => this.rewriter.ApplyChanges(install_combo.ToArray(), false));
            rewriterThread.IsBackground = true;
            rewriterThread.Start();
        }
        /// <summary>
        ///     The markup mods for reinstall
        /// </summary>
        private Dictionary<string, List<BundleMod>> markupModCollision(BundleMod newMod, bool reverse = false)
        {
            Dictionary<string, BundleMod> modsList = this.mods_db.modsList;
            Dictionary<string, List<BundleMod>> return_list = new Dictionary<string, List<BundleMod>>();
            BundleMod return_item;

            foreach (BundleMod localmod in modsList.Values)
            {
                if (newMod == localmod)
                    continue;

                if (this.mods_db.InstalledModsListContains(localmod) != -1 && (localmod.actionStatus != BundleMod.ModActionStatus.Remove && localmod.actionStatus != BundleMod.ModActionStatus.ForcedReinstall))
                {
                    return_item = new BundleMod();

                    foreach (BundleRewriteItem bri in newMod.ItemQueue)
                    {
                        foreach (BundleRewriteItem briLocal in localmod.ItemQueue)
                        {
                            if (bri == briLocal)
                            {
                                if (reverse)
                                {
                                    bri.toReinstall = false;
                                    briLocal.toReinstall = false;
                                    bri.toShared = false;
                                    briLocal.toShared = false;
                                }
                                else
                                {
                                    bri.toReinstall = true;
                                    briLocal.toReinstall = true;
                                    bri.toShared = true;
                                    briLocal.toShared = true;
                                }
                                return_item.ItemQueue.Add(bri);
                            }
                        }
                    }

                    if (localmod.ItemQueue.Any(items => items.toReinstall == true))
                        localmod.actionStatus = BundleMod.ModActionStatus.Reinstall;
                    else
                        localmod.actionStatus = BundleMod.ModActionStatus.None;

                    if (localmod.actionStatus == BundleMod.ModActionStatus.Reinstall)
                    {
                        return_item.Author = localmod.Author;
                        return_item.Description = localmod.Description;
                        return_item.Name = localmod.Name;

                        foreach (var item in return_item.ItemQueue)
                        {
                            string file_name = "";
                            file_name += StaticStorage.Known_Index.GetPath(item.BundlePath);
                            if (item.IsLanguageSpecific)
                                file_name += "." + item.BundleLanguage;
                            file_name += "." + StaticStorage.Known_Index.GetExtension(item.BundleExtension);

                            if (return_list.ContainsKey(file_name))
                                return_list[file_name].Add(return_item);
                            else
                            {
                                List<BundleMod> newModList = new List<BundleMod>();
                                newModList.Add(newMod);
                                newModList.Add(return_item);
                                return_list.Add(file_name, newModList);
                            }
                        }
                    }
                }
            }

            return return_list;
        }
        private bool searchMod(BundleMod mod, String text)
        {
            if (String.IsNullOrWhiteSpace(this.availiableModsSearch_textbox.Text) || this.searchWatermark)
                return true;

            text = text.ToLower(CultureInfo.InvariantCulture);

            //special logic
            if (text.StartsWith("status:"))
            {
                if (text.TrimStart("status:".ToCharArray()).Equals("installed") &&
                    mod.status == BundleMod.ModStatus.Installed)
                    return true;
                else if ((text.TrimStart("status:".ToCharArray()).Equals("not installed") ||
                    text.TrimStart("status:".ToCharArray()).Equals("!installed")) &&
                    mod.status == BundleMod.ModStatus.NotInstalled)
                    return true;
                else if ((text.TrimStart("status:".ToCharArray()).Equals("partially installed") ||
                    text.TrimStart("status:".ToCharArray()).Equals("partly installed") ||
                    text.TrimStart("status:".ToCharArray()).Equals("part installed")) &&
                    mod.status == BundleMod.ModStatus.ParticallyInstalled)
                    return true;
                else if ((text.TrimStart("status:".ToCharArray()).Equals("unknown") ||
                    text.TrimStart("status:".ToCharArray()).Equals("?")) &&
                    mod.status == BundleMod.ModStatus.Unrecognized)
                    return true;
            }
            else if (text.StartsWith("type:"))
            {
                if (text.TrimStart("type:".ToCharArray()).Equals("pdmod") &&
                    mod.type == BundleMod.ModType.PDMod)
                    return true;
                else if (text.TrimStart("type:".ToCharArray()).Equals("override") &&
                    mod.type == BundleMod.ModType.mod_override)
                    return true;
                else if (text.TrimStart("type:".ToCharArray()).Equals("lua") &&
                    mod.type == BundleMod.ModType.lua)
                    return true;
            }
            else if (text.StartsWith("marked:"))
            {
                if ((text.TrimStart("marked:".ToCharArray()).Equals("install") ||
                    text.TrimStart("marked:".ToCharArray()).Equals("installation")) &&
                    mod.actionStatus == BundleMod.ModActionStatus.Install)
                    return true;
                else if ((text.TrimStart("marked:".ToCharArray()).Equals("remove") ||
                    text.TrimStart("marked:".ToCharArray()).Equals("removal") ||
                    text.TrimStart("marked:".ToCharArray()).Equals("uninstall") ||
                    text.TrimStart("marked:".ToCharArray()).Equals("delete")) &&
                    mod.actionStatus == BundleMod.ModActionStatus.Remove)
                    return true;
                else if ((text.TrimStart("marked:".ToCharArray()).Equals("reinstall") ||
                    text.TrimStart("marked:".ToCharArray()).Equals("reinstallation")) &&
                    mod.actionStatus == BundleMod.ModActionStatus.Reinstall)
                    return true;
                else if ((text.TrimStart("marked:".ToCharArray()).Equals("force reinstall") ||
                    text.TrimStart("marked:".ToCharArray()).Equals("force reinstallation") ||
                    text.TrimStart("marked:".ToCharArray()).Equals("freinstall")) &&
                    mod.actionStatus == BundleMod.ModActionStatus.ForcedReinstall)
                    return true;
                else if ((text.TrimStart("marked:".ToCharArray()).Equals("missing")) &&
                    mod.actionStatus == BundleMod.ModActionStatus.Missing)
                    return true;
            }

            if (mod.Name.ToLower(CultureInfo.InvariantCulture).Contains(this.availiableModsSearch_textbox.Text.ToLower(CultureInfo.InvariantCulture)) ||
                    mod.Author.ToLower(CultureInfo.InvariantCulture).Contains(this.availiableModsSearch_textbox.Text.ToLower(CultureInfo.InvariantCulture)) ||
                    mod.Description.ToLower(CultureInfo.InvariantCulture).Contains(this.availiableModsSearch_textbox.Text.ToLower(CultureInfo.InvariantCulture))
                    )
                return true;

            return false;
        }
        private void createModLoad_Click(object sender, EventArgs e)
        {
            var openDialog = new OpenFileDialog();
            openDialog.Filter = "PAYDAY Mod Project|*.*";
            openDialog.CheckFileExists = true;
            if (openDialog.ShowDialog() != DialogResult.OK)
            {
                return;
            }
            this.newMod = new BundleMod();
            this.modScriptPath = Path.GetDirectoryName(openDialog.FileName);
            try
            {
                ParseModScript(openDialog.FileName);
            }
            catch (Exception exc)
            {
                System.Windows.Forms.MessageBox.Show(exc.Message, "Mod Script Error", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
            }

            this.AddedFilesView.DataSource = this.newMod.ItemQueue.ToList();
            this.AddedFilesView.Refresh();
        }
        /// <summary>
        ///     The load mod.
        /// </summary>
        private void LoadMod()
        {
            try
            {
                using (var zip = new ZipFile(this.modZipFile))
                {
                    foreach (ZipEntry entry in zip.Entries)
                    {
                        if (entry.UsesEncryption)
                        {
                            entry.Password = "******";
                            //entry.Encryption = EncryptionAlgorithm.WinZipAes256;
                        }

                        if (entry.FileName == "pdmod.json")
                        {
                            var ms = new MemoryStream();
                            entry.Extract(ms);
                            ms.Seek(0, SeekOrigin.Begin);
                            this.currentMod = BundleMod.Deserialize(ms);

                            if (this.currentMod.Version > Version)
                                throw new Exception("This mod is not compatible with your Bundle Modder. Please update your Bundle Modder to the latest version. (" + this.currentMod.Version + ")");
                            this.ModNameText.Text = this.currentMod.Name;
                            this.AuthorText.Text = this.currentMod.Author;
                            this.DescriptionText.Text = this.currentMod.Description;
                            this.ApplyButton.Enabled = true;
                        }
                    }
                }
            }
            catch (Exception e)
            {
                this.ModNameText.Text = "Failed to load mod.";
                this.DescriptionText.Text = e.Message;
            }
        }
 private void availableMods_listView_SelectedIndexChanged(object sender, EventArgs e)
 {
     if (availiableMods_listView.SelectedItems.Count == 1)
     {
         this._selectedMod = (BundleMod)availiableMods_listView.SelectedItems[0].Tag;
         this.ModNameText.Text = this._selectedMod.Name;
         this.AuthorText.Text = this._selectedMod.Author;
         this.DescriptionText.Text = this._selectedMod.Description;
         this.moreModDetails_button.Enabled = true;
         this.availiableMods_listView.SelectedItems[0].Focused = false;
         this.availiableMods_listView.SelectedItems[0].Selected = false;
         this.availiableMods_listView.Update();
     }
 }
 private void availiableMods_listView_MouseClick(object sender, MouseEventArgs e)
 {
     ListView listView = sender as ListView;
     if (e.Button == System.Windows.Forms.MouseButtons.Right)
     {
         ListViewItem item = listView.GetItemAt(e.X, e.Y);
         if (item != null)
         {
             this._rightclickedMod = (BundleMod)item.Tag;
             item.Selected = true;
             modContextMenuStrip.Show(listView, e.Location);
         }
     }
 }
 /// <summary>
 /// The serialize.
 /// </summary>
 /// <param name="mod">
 /// The mod.
 /// </param>
 /// <returns>
 /// The <see cref="string"/>.
 /// </returns>
 public static string Serialize(BundleMod mod)
 {
     return JsonConvert.SerializeObject(mod, Formatting.Indented);
 }
        public bool Equals(BundleMod guest)
        {
            if (ReferenceEquals(guest, null))
                return false;

            if (ReferenceEquals(this, guest))
                return true;

            return this == guest;
        }
        /// <summary>
        /// The apply changes.
        /// </summary>
        public void ApplyChanges(BundleMod[] toAddModsList, bool method)
        {
            this.Done = false;
            using (this.Zip = new ZipFile(this._zipPath))
            {
                bool wasSuccessful = false;
                this._mod.ItemQueue.RemoveWhere(i => i.BundleExtension == 0xAB2664BF82E646UL);
                this._mod.ItemQueue.RemoveWhere(i => i.BundleExtension == 0xAB2664BF82E6460C);
                this._mod.ItemQueue.RemoveWhere(i => i.BundleExtension == 0x29104BC4AC649965);

                if (!this.LocateChangeIds())
                    return;

                var toRemove = this._mod.ItemQueue.Where(p => p.toRemove);
                //var toReinstall = this._mod.ItemQueue.Where(p => p.toReinstall);
                var toInstall = this._mod.ItemQueue.Where(p => !p.toRemove);

                if (this._overrideFolder)
                {
                    this.SetTotalProgress("Utilizing Override Folder", -1);

                    HashSet<BundleEntryPath> toSharedFolder = new HashSet<BundleEntryPath>();
                    HashSet<BundleEntryPath> overrideApplied = new HashSet<BundleEntryPath>();
                    Dictionary<BundleEntryPath, HashSet<BundleRewriteItem>> bep_sorted = new Dictionary<BundleEntryPath, HashSet<BundleRewriteItem>>();

                    foreach (BundleRewriteItem bri in this._mod.ItemQueue)
                    {
                        if (bri.toRemove)
                            continue;

                        if (bep_sorted.ContainsKey(bri.getBundleEntryPath()))
                        {
                            if (this._overrideFolderShared && !toSharedFolder.Contains(bri.getBundleEntryPath()))
                                toSharedFolder.Add(bri.getBundleEntryPath());
                            bep_sorted[bri.getBundleEntryPath()].Add(bri);
                        }
                        else
                        {
                            HashSet<BundleRewriteItem> newbrihs = new HashSet<BundleRewriteItem>();
                            newbrihs.Add(bri);
                            bep_sorted.Add(bri.getBundleEntryPath(), newbrihs);
                        }
                    }

                    HashSet<BundleRewriteItem> reducedItemQueue = new HashSet<BundleRewriteItem>();
                    int override_count = 1;
                    foreach (BundleRewriteItem bri in this._mod.ItemQueue)
                    {
                        this.SetBundleProgress(
                            string.Format("Processing {0}/{1}", override_count, this._mod.ItemQueue.Count),
                            (int)((override_count / (float)this._mod.ItemQueue.Count) * 100.0f));

                        if (bri.isOverrideable()
                            //&& !bri.ReplacementFile.EndsWith(".script")
                            )
                        {

                            if (!string.IsNullOrEmpty(StaticStorage.Known_Index.GetPath(bri.BundlePath)) &&
                                !string.IsNullOrEmpty(StaticStorage.Known_Index.GetExtension(bri.BundleExtension))
                                )
                            {
                                string extrname = "";
                                extrname += StaticStorage.Known_Index.GetPath(bri.BundlePath);
                                extrname += "." + StaticStorage.Known_Index.GetExtension(bri.BundleExtension);

                                string modName = bri.getEscapedName();

                                if (bri.toRemove)
                                {
                                    if (!toSharedFolder.Contains(bri.getBundleEntryPath()) && File.Exists(Path.Combine(this._assetFolder, "mod_overrides", "Bundle_Modder_Shared", extrname)))
                                        File.Delete(Path.Combine(this._assetFolder, "mod_overrides", "Bundle_Modder_Shared", extrname));
                                    else if (File.Exists(Path.Combine(this._assetFolder, "mod_overrides", modName, extrname)))
                                        File.Delete(Path.Combine(this._assetFolder, "mod_overrides", modName, extrname));

                                    DeleteEmptyDirs(Path.Combine(this._assetFolder, "mod_overrides", modName));
                                }
                                else
                                {
                                    if (bri.toReinstall)
                                    {
                                        if (File.Exists(Path.Combine(this._assetFolder, "mod_overrides", modName, extrname)))
                                            File.Delete(Path.Combine(this._assetFolder, "mod_overrides", modName, extrname));
                                    }

                                    String path;
                                    if (this._overrideFolderShared && toSharedFolder.Contains(bri.getBundleEntryPath()))
                                        path = Path.Combine(this._assetFolder, "mod_overrides", "Bundle_Modder_Shared", extrname);
                                    else
                                        path = Path.Combine(this._assetFolder, "mod_overrides", modName, extrname);

                                    if (!Directory.Exists(Path.GetDirectoryName(path)))
                                        Directory.CreateDirectory(Path.GetDirectoryName(path));

                                    HashSet<BundleRewriteItem> bep_items = new HashSet<BundleRewriteItem>();
                                    if (bep_sorted.ContainsKey(bri.getBundleEntryPath()))
                                        bep_items = bep_sorted[bri.getBundleEntryPath()];

                                    var outOverride = new FileStream(
                                                    path,
                                                    FileMode.Create,
                                                    FileAccess.ReadWrite);

                                    int runningcount = 0;
                                    foreach (var item in bep_items)
                                    {
                                        if (item.SourceFile != null)
                                        {
                                            if(this.Zip == null)
                                                this.Zip = new ZipFile(item.SourceFile);

                                            if (!this.Zip.Name.Equals(item.SourceFile))
                                            {
                                                this.Zip.Dispose();
                                                this.Zip = new ZipFile(item.SourceFile);
                                            }
                                        }
                                        else
                                            continue;

                                        ZipEntry zip_entry = this.Zip[item.ReplacementFile];
                                        if (zip_entry != null)
                                        {
                                            if (zip_entry.UsesEncryption)
                                            {
                                                zip_entry.Password = "******";
                                                //zip_entry.Encryption = EncryptionAlgorithm.WinZipAes256;
                                            }

                                            MemoryStream zipEntryData = new MemoryStream();

                                            if (item.ReplacementFile.EndsWith(".script"))
                                            {
                                                MemoryStream scriptData = new MemoryStream();
                                                zip_entry.Extract(scriptData);
                                                scriptData.Seek(0, SeekOrigin.Begin);
                                                MemoryStream bundleData = new MemoryStream();

                                                if (RetrieveFile(item, out bundleData))
                                                {
                                                    if (runningcount > 0)
                                                    {
                                                        bundleData.SetLength(0);
                                                        outOverride.Seek(0, SeekOrigin.Begin);
                                                        outOverride.CopyTo(bundleData);
                                                    }

                                                    StreamReader scriptStream = new StreamReader(scriptData);

                                                    List<BundleRewriteScriptAction> scriptActions = ParseScriptActions(ref scriptStream, zip_entry.FileName);
                                                    scriptData.Close();
                                                    scriptStream.Close();

                                                    //apply script functions here
                                                    bundleData.Seek(0, SeekOrigin.Begin);

                                                    List<byte> entryBytes = bundleData.ToArray().ToList();

                                                    outOverride.Seek(0, SeekOrigin.Begin);
                                                    ApplyScriptActions(ref entryBytes, ref scriptActions);

                                                    foreach (byte b in entryBytes)
                                                        outOverride.WriteByte(b);

                                                }
                                                else
                                                {
                                                    reducedItemQueue.Add(item);
                                                }
                                            }
                                            else
                                            {
                                                outOverride.Position = 0L;
                                                zipEntryData.Position = 0L;
                                                zip_entry.Extract(zipEntryData);
                                                zipEntryData.Position = 0L;
                                                zipEntryData.CopyTo(outOverride, this.bufferSize);
                                                //foreach (byte b in zipEntryData.ToArray().ToList())
                                                //    outOverride.WriteByte(b);
                                            }

                                            outOverride.Flush();

                                        }
                                        runningcount++;
                                    }

                                    outOverride.Close();
                                }
                            }
                            else
                            {
                                reducedItemQueue.Add(bri);
                            }

                        }
                        else
                        {
                            if (this._overrideFolderDummies)
                            {
                                string modName = bri.ModName;
                                modName = Path.GetInvalidFileNameChars().Aggregate(modName, (current, c) => current.Replace(c.ToString(), "_"));

                                if (bri.toRemove)
                                {
                                    if (Directory.Exists(Path.Combine(this._assetFolder, "mod_overrides", modName)))
                                    {
                                        //Directory.Delete(Path.Combine(this._assetFolder, "mod_overrides", modName), true);
                                        DeleteDirectory(Path.Combine(this._assetFolder, "mod_overrides", modName));
                                    }
                                }
                                else
                                {
                                    if (!Directory.Exists(Path.Combine(this._assetFolder, "mod_overrides", modName)))
                                        Directory.CreateDirectory(Path.Combine(this._assetFolder, "mod_overrides", modName));
                                }
                            }

                            reducedItemQueue.Add(bri);
                        }
                        override_count++;
                    }

                    this.SetBundleProgress("Done", 100);
                    this._mod.ItemQueue = reducedItemQueue;
                }

                HashSet<string> bundles = this.LocateBundlesToRewrite(out wasSuccessful);
                if (!wasSuccessful)
                    return;

                if (!this._patchAllBundles)
                    bundles.RemoveWhere(i => i.StartsWith("all_"));

                if (bundles.Count <= 0 && !this._overrideFolder)
                {
                    this.Error = "Unable to locate any bundles with the requested items in them.\n"
                                 + "If the changed file(s) only exists within an all_x.bundle file you will need to enable the option to patch all_x.bundle files.\n"
                                 + "Refer to the patch description for if this is required.";
                    return;
                }

                this.SetTotalProgress("Backing up Bundles", -1);
                this.CurrentBundlesCount = 1;
                this.TotalBundlesCount = bundles.Count;
                foreach (var bundle in bundles)
                {

                    this.SetBundleProgress(
                        string.Format("Backing up Bundle {0}/{1}", this.CurrentBundlesCount, this.TotalBundlesCount),
                        (int)((this.CurrentBundlesCount / (float)this.TotalBundlesCount) * 100.0f));

                    if (this._backupType == 1)
                    {
                        this.BackupEntries(this._mod, Path.Combine(this._assetFolder, bundle));
                    }
                    else
                    {
                        this.BackupFile(Path.Combine(this._assetFolder, bundle + "_h.bundle"));
                        this.BackupFile(Path.Combine(this._assetFolder, bundle + ".bundle"));
                    }
                    this.CurrentBundlesCount += 1;

                }

                foreach (BundleMod bm in toAddModsList)
                {
                    BackupEntry multibackupEntry = new BackupEntry();
                    multibackupEntry.Name = bm.Name;
                    multibackupEntry.Author = bm.Author;
                    multibackupEntry.Description = bm.Description;
                    multibackupEntry.BackupType = (this._backupType == 0) ? "Bundles" : "Bundle Entries";
                    multibackupEntry.InstallDate = DateTime.Now;
                    multibackupEntry.RewriteAll = this._patchAllBundles;
                    HashSet<BundleRewriteItem> backupQueue = new HashSet<BundleRewriteItem>();

                    foreach (BundleRewriteItem bri in bm.ItemQueue)
                    {
                        BundleRewriteItem newbri = new BundleRewriteItem();
                        newbri.BundleExtension = bri.BundleExtension;
                        newbri.BundleLanguage = bri.BundleLanguage;
                        newbri.BundlePath = bri.BundlePath;
                        newbri.Ids = bri.Ids;
                        newbri.IsLanguageSpecific = bri.IsLanguageSpecific;
                        if (this._backupType == 0)
                            newbri.ReplacementFile = bri.ReplacementFile;
                        else
                            newbri.ReplacementFile = bri.BundlePath.ToString("x") + '.' + bri.BundleLanguage.ToString("x") + '.' + bri.BundleExtension.ToString("x");
                        newbri.SourceFile = bri.SourceFile;

                        backupQueue.Add(newbri);
                    }
                    multibackupEntry.ItemQueue = backupQueue;
                    backupEntries.Add(multibackupEntry);
                }
                allowBackup = true;

                foreach (var rewriteItem in this._mod.ItemQueue)
                {
                    foreach (var id in rewriteItem.Ids)
                    {
                        if (this._rewriteItems.ContainsKey(id))
                        {
                            if (rewriteItem.toRemove)
                                this._rewriteItems[id].toRestore = true;

                            if (rewriteItem.ReplacementFile.EndsWith(".script"))
                            {
                                this._rewriteItems[id].BundleRewriteItem_queue.Add(rewriteItem);
                            }
                            else
                            {
                                if (rewriteItem.priority)
                                {
                                    this._rewriteItems[id].priorityBundleRewriteItem = rewriteItem;
                                }
                                else
                                {
                                    //Don't add... it's not part of priority
                                    this._rewriteItems[id].BundleRewriteItem_queue.Add(rewriteItem);
                                }
                            }
                        }
                        else
                        {
                            BundleRewriteEntryID breid = new BundleRewriteEntryID();

                            if (rewriteItem.toRemove)
                                breid.toRestore = true;

                            if (rewriteItem.ReplacementFile.EndsWith(".script"))
                            {
                                breid.BundleRewriteItem_queue.Add(rewriteItem);
                            }
                            else
                            {
                                if (rewriteItem.priority)
                                {
                                    breid.priorityBundleRewriteItem = rewriteItem;
                                }
                                else
                                {
                                    //Don't add, it's not part of priority
                                    breid.BundleRewriteItem_queue.Add(rewriteItem);
                                }
                            }

                            this._rewriteItems.Add(id, breid);
                        }
                    }
                }

                this.CurrentBundlesCount = 1;
                TotalElapsedTime.Start();
                SpeedElapsedTime.Start();

                foreach (var bundle in bundles)
                {
                    CurrentBundle = bundle;
                    this.SetTotalProgress(
                        string.Format("Patching Bundle {0}/{1}", this.CurrentBundlesCount, this.TotalBundlesCount),
                        (int)((this.CurrentBundlesCount / (float)this.TotalBundlesCount) * 100.0f));
                    if (!this.PatchBundle(bundle))
                        return;

                    this.CurrentBundlesCount += 1;
                }
                TotalElapsedTime.Stop();
                SpeedElapsedTime.Stop();
            }
            this.Zip.Dispose();
            this.SetTotalProgress("Done", 100);
            this.Done = true;
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="BundleRewriter"/> class.
 /// </summary>
 /// <param name="zipPath">
 /// The zip path.
 /// </param>
 /// <param name="mod">
 /// The mod.
 /// </param>
 /// <param name="assetsPath">
 /// The assets path.
 /// </param>
 /// <param name="includeAllBundles">
 /// The include all bundles.
 /// </param>
 /// </param>
 /// <param name="multiMods">
 /// The multiple mod involvement.
 /// </param>
 public BundleRewriter(string zipPath, BundleMod mod, int bufferSize, string assetsPath, int backupType, bool overridefolder, bool overridefolderdummies, bool overridefoldershared, bool includeAllBundles, bool multiMods)
 {
     this._zipPath = zipPath;
     this._mod = mod;
     this.bufferSize = bufferSize;
     this._assetFolder = assetsPath;
     this._backupType = backupType;
     this._overrideFolder = overridefolder;
     this._overrideFolderDummies = overridefolderdummies;
     this._overrideFolderShared = overridefolderdummies;
     this._patchAllBundles = includeAllBundles;
     this._multiMods = multiMods;
 }
        /// <summary>
        /// The patch bundle restore.
        /// </summary>
        /// <param name="bundleId">
        /// The bundle id.
        /// </param>
        /// <returns>
        /// The <see cref="bool"/>.
        /// </returns>
        private bool PatchBundleRestore(BundleMod mod, string bundleId, bool method)
        {
            if (method)
            {
                if (!File.Exists(Path.Combine(this._assetFolder, bundleId + ".bundle")) || !File.Exists(Path.Combine(this._assetFolder, bundleId + "_h.bundle")) || !File.Exists(Path.Combine(this._assetFolder, "asset_backups", bundleId + ".bundle")) || !File.Exists(Path.Combine(this._assetFolder, "asset_backups", bundleId + "_h.bundle")))
                    return false;

                File.Delete(Path.Combine(this._assetFolder, bundleId + ".bundle"));
                File.Delete(Path.Combine(this._assetFolder, bundleId + "_h.bundle"));
                File.Copy(Path.Combine(this._assetFolder, "asset_backups", bundleId + ".bundle"), Path.Combine(this._assetFolder, bundleId + ".bundle"), true);
                File.Copy(Path.Combine(this._assetFolder, "asset_backups", bundleId + "_h.bundle"), Path.Combine(this._assetFolder, bundleId + "_h.bundle"), true);
                this.SetBundleProgress("Done", 100);
                return true;
            }

            var inHeader = new BundleHeader();
            var inRestoreHeader = new BundleHeader();
            Dictionary<uint, BundleEntry> inRestoreDictionary = new Dictionary<uint, BundleEntry>();
            if (!inHeader.Load(Path.Combine(this._assetFolder, bundleId)))
            {
                return false;
            }

            if (!inRestoreHeader.Load(Path.Combine(this._assetFolder, "asset_backups", bundleId)))
                return false;

            foreach (BundleEntry entry in inRestoreHeader.Entries)
            {
                if (!inRestoreDictionary.ContainsKey(entry.Id))
                    inRestoreDictionary.Add(entry.Id, entry);
            }

            var outHeader = new BundleHeader();
            outHeader.Footer = inHeader.Footer;
            outHeader.Header = inHeader.Header;
            outHeader.HasLengthField = inHeader.HasLengthField;
            var inRestoreBundle = new FileStream(Path.Combine(this._assetFolder, "asset_backups", bundleId + ".bundle"), FileMode.Open, FileAccess.Read);
            var inBundle = new FileStream(Path.Combine(this._assetFolder, bundleId + ".bundle"), FileMode.Open, FileAccess.Read);
            var outBundle = new FileStream(
                Path.Combine(this._assetFolder, bundleId + ".bundle.new"),
                FileMode.OpenOrCreate,
                FileAccess.ReadWrite);
            int currentAddress = 0;
            int currentEntry = 1;
            int entryCount = inHeader.Entries.Count;
            foreach (BundleEntry entry in inHeader.Entries)
            {
                if (currentEntry % 100 == 0)
                {
                    this.SetBundleProgress(
                        string.Format("Writing entry {0}/{1}", currentEntry, entryCount),
                        (int)((currentEntry / (float)entryCount) * 100.0f));
                }

                var newEntry = new BundleEntry();
                newEntry.Id = entry.Id;
                newEntry.Length = entry.Length;
                newEntry.Address = (uint)currentAddress;
                bool replaced = false;

                foreach (int length in from rewriteItem in mod.ItemQueue
                                       where rewriteItem.Ids.Contains(entry.Id)
                                       select this.RestoreEntry(inRestoreDictionary[entry.Id], (uint)currentAddress, inRestoreBundle, outBundle))
                {
                    currentAddress += length;
                    newEntry.Length = length;
                    replaced = true;
                    break;
                }

                outHeader.Entries.Add(newEntry);

                if (!replaced)
                {
                    inBundle.Seek(entry.Address, SeekOrigin.Begin);
                    long entryLength = entry.Length == -1 ? inBundle.Length - inBundle.Position : entry.Length;
                    var br = new BinaryReader(inBundle);
                    var bw = new BinaryWriter(outBundle);
                    bw.Write(br.ReadBytes((int)entryLength));
                    currentAddress += (int)entryLength;
                }

                currentEntry += 1;
            }

            inBundle.Close();
            inRestoreBundle.Close();
            outBundle.Close();
            var outHeaderStream = new FileStream(
                Path.Combine(this._assetFolder, bundleId + "_h.bundle"),
                FileMode.OpenOrCreate,
                FileAccess.Write);
            var outHeaderBr = new BinaryWriter(outHeaderStream);
            outHeader.WriteHeader(outHeaderBr);
            foreach (BundleEntry entry in outHeader.Entries)
            {
                entry.WriteEntry(outHeaderBr, outHeader.HasLengthField);
            }

            outHeader.WriteFooter(outHeaderBr);
            outHeaderBr.Close();
            outHeaderStream.Close();
            File.Delete(Path.Combine(this._assetFolder, bundleId + ".bundle"));
            File.Move(Path.Combine(this._assetFolder, bundleId + ".bundle.new"), Path.Combine(this._assetFolder, bundleId + ".bundle"));
            this.SetBundleProgress("Done", 100);
            return true;
        }
        /// <summary>
        /// The backup bundle entry.
        /// </summary>
        /// <param name="bundlePath">
        /// The bundle path.
        /// </param>
        private void BackupEntries(BundleMod mod, string bundlePath)
        {
            string backupFolder = Path.Combine(this._assetFolder, "asset_backups") + "\\";
            Directory.CreateDirectory(backupFolder);

            var header = new BundleHeader();
            if (!header.Load(bundlePath))
            {
                this.Error = "Failed to parse bundle header: " + bundlePath;
            }

            var bundleFS = new FileStream(bundlePath + ".bundle", FileMode.Open, FileAccess.Read);
            var bundleBR = new BinaryReader(bundleFS);

            foreach (BundleEntry entry in header.Entries)
            {
                BundleRewriteItem rewriteEntryItem;
                BundleRewriteItem backupRewriteItem = new BundleRewriteItem();
                if (mod.ItemQueue.Any(rewriteItem => rewriteItem.Ids.Contains(entry.Id)))
                {
                    NameEntry ne = StaticStorage.Index.Id2Name(entry.Id);
                    rewriteEntryItem = mod.ItemQueue.First(rewriteItem => rewriteItem.Ids.Contains(entry.Id));

                    if (!File.Exists(backupFolder + ne.ToString()))
                    {
                        using (FileStream exportFS = new FileStream(backupFolder + ne.ToString(), FileMode.CreateNew, FileAccess.Write))
                        {
                            using (BinaryWriter exportBW = new BinaryWriter(exportFS))
                            {
                                long entryLength = entry.Length == -1 ? bundleFS.Length - bundleFS.Position : entry.Length;
                                bundleFS.Seek(entry.Address, SeekOrigin.Begin);
                                exportBW.Write(bundleBR.ReadBytes((int)entryLength));
                            }
                        }
                    }
                }
            }

            bundleBR.Close();
            bundleFS.Close();
        }
        /// <summary>
        /// The apply mods.
        /// </summary>
        public void ApplyMods(BundleMod[] toAddModsList)
        {
            this.Done = false;
            using (this.Zip = new ZipFile(this._zipPath))
            {
                bool wasSuccessful = false;
                this._mod.ItemQueue.RemoveWhere(i => i.BundleExtension == 0xAB2664BF82E646UL);
                this._mod.ItemQueue.RemoveWhere(i => i.BundleExtension == 0xAB2664BF82E6460C);
                this._mod.ItemQueue.RemoveWhere(i => i.BundleExtension == 0x29104BC4AC649965);

                if (!this.LocateChangeIds())
                    return;

                HashSet<string> bundles = this.LocateBundlesToRewrite(out wasSuccessful);
                if (!wasSuccessful)
                    return;

                if (!this._patchAllBundles)
                    bundles.RemoveWhere(i => i.StartsWith("all_"));

                if (bundles.Count <= 0)
                {
                    this.Error = "Unable to locate any bundles with the requested items in them.\n"
                                 + "If the changed file(s) only exists within an all_x.bundle file you will need to enable the option to patch all_x.bundle files.\n"
                                 + "Refer to the patch description for if this is required.";
                    return;
                }

                this.SetTotalProgress("Backing up Bundles", -1);
                this.CurrentBundlesCount = 1;
                this.TotalBundlesCount = bundles.Count;
                foreach (var bundle in bundles)
                {

                    this.SetBundleProgress(
                        string.Format("Backing up Bundle {0}/{1}", CurrentBundlesCount, TotalBundlesCount),
                        (int)((CurrentBundlesCount / (float)TotalBundlesCount) * 100.0f));

                    if (this._backupType == 1)
                    {
                        this.BackupEntries(this._mod, Path.Combine(this._assetFolder, bundle));
                    }
                    else
                    {
                        this.BackupFile(Path.Combine(this._assetFolder, bundle + "_h.bundle"));
                        this.BackupFile(Path.Combine(this._assetFolder, bundle + ".bundle"));
                    }
                    CurrentBundlesCount += 1;

                }

                foreach (BundleMod bm in toAddModsList)
                {
                    BackupEntry multibackupEntry = new BackupEntry();
                    multibackupEntry.Name = bm.Name;
                    multibackupEntry.Author = bm.Author;
                    multibackupEntry.Description = bm.Description;
                    multibackupEntry.BackupType = (this._backupType == 0) ? "Bundles" : "Bundle Entries";
                    multibackupEntry.InstallDate = DateTime.Now;
                    multibackupEntry.RewriteAll = this._patchAllBundles;
                    HashSet<BundleRewriteItem> backupQueue = new HashSet<BundleRewriteItem>();

                    foreach (BundleRewriteItem bri in bm.ItemQueue)
                    {
                        BundleRewriteItem newbri = new BundleRewriteItem();
                        newbri.BundleExtension = bri.BundleExtension;
                        newbri.BundleLanguage = bri.BundleLanguage;
                        newbri.BundlePath = bri.BundlePath;
                        newbri.Ids = bri.Ids;
                        newbri.IsLanguageSpecific = bri.IsLanguageSpecific;
                        if (this._backupType == 0)
                            newbri.ReplacementFile = bri.ReplacementFile;
                        else
                            newbri.ReplacementFile = bri.BundlePath.ToString("x") + '.' + bri.BundleLanguage.ToString("x") + '.' + bri.BundleExtension.ToString("x");
                        newbri.SourceFile = bri.SourceFile;

                        backupQueue.Add(newbri);
                    }
                    multibackupEntry.ItemQueue = backupQueue;
                    backupEntries.Add(multibackupEntry);
                }
                allowBackup = true;

                CurrentBundlesCount = 1;
                TotalElapsedTime.Start();
                foreach (var bundle in bundles)
                {
                    this.SetTotalProgress(
                        string.Format("Patching Bundle {0}/{1}", CurrentBundlesCount, TotalBundlesCount),
                        (int)((CurrentBundlesCount / (float)TotalBundlesCount) * 100.0f));
                    if (!this.PatchBundle(bundle))
                        return;

                    CurrentBundlesCount += 1;
                }
                TotalElapsedTime.Stop();
            }
            this.SetTotalProgress("Done", 100);
            this.Done = true;
        }