/* 
 * $Id$
 * Copyright 2008-2009 The Eraser Project
 * Original Author: Joel Low <lowjoel@users.sourceforge.net>
 * Modified By:
 * 
 * This file is part of Eraser.
 * 
 * Eraser is free software: you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 * 
 * Eraser is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 * 
 * A copy of the GNU General Public License can be found at
 * <http://www.gnu.org/licenses/>.
 */

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Reflection;
using System.IO;
using System.Xml;
using Eraser.Util;
using System.Net.Cache;
using System.Net.Mime;
using System.Globalization;

namespace Eraser
{
	public partial class UpdateForm : Form
	{
		/// <summary>
		/// Constructor.
		/// </summary>
		public UpdateForm()
		{
			InitializeComponent();
			UXThemeApi.UpdateControlTheme(this);
			updateListDownloader.RunWorkerAsync();
		}

		/// <summary>
		/// Called when the form is about to be closed.
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void UpdateForm_FormClosing(object sender, FormClosingEventArgs e)
		{
			//Cancel all running background tasks
			if (updateListDownloader.IsBusy || downloader.IsBusy || installer.IsBusy)
			{
				updateListDownloader.CancelAsync();
				downloader.CancelAsync();
				installer.CancelAsync();
				e.Cancel = true;
			}
		}

		/// <summary>
		/// Called when any of the Cancel buttons are clicked.
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void cancelBtn_Click(object sender, EventArgs e)
		{
			Close();
		}

		#region Update List retrieval
		/// <summary>
		/// Downloads and parses the list of updates available for this client.
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void updateListDownloader_DoWork(object sender, DoWorkEventArgs e)
		{
			try
			{
				updates.OnProgressEvent += updateListDownloader_ProgressChanged;
				updates.DownloadUpdateList();
			}
			finally
			{
				updates.OnProgressEvent -= updateListDownloader_ProgressChanged;
			}
		}

		/// <summary>
		/// Called when progress has been made in the update list download.
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void updateListDownloader_ProgressChanged(object sender, ProgressEventArgs e)
		{
			if (InvokeRequired)
			{
				if (updateListDownloader.CancellationPending)
					throw new OperationCanceledException();

				Invoke((EventHandler<ProgressEventArgs>)updateListDownloader_ProgressChanged,
					sender, e);
				return;
			}

			progressPb.Style = ProgressBarStyle.Continuous;
			progressPb.Value = (int)(e.OverallProgressPercentage * 100);
			progressProgressLbl.Text = e.Message;

			if (progressPb.Value == 100)
				progressProgressLbl.Text = S._("Processing update list...");
		}

		/// <summary>
		/// Displays the parsed updates on the updates list view, filtering and displaying
		/// only those relevant to the current system's architecture.
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void updateListDownloader_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
		{
			//The Error property will normally be null unless there are errors during the download.
			if (e.Error != null)
			{
				if (!(e.Error is OperationCanceledException))
					MessageBox.Show(this, e.Error.Message, S._("Eraser"), MessageBoxButtons.OK,
						MessageBoxIcon.Error, MessageBoxDefaultButton.Button1,
						S.IsRightToLeft(this) ? MessageBoxOptions.RtlReading : 0);

				Close();
				return;
			}

			progressPanel.Visible = false;
			updatesPanel.Visible = true;

			//First list all available mirrors
			Dictionary<string, Mirror>.Enumerator iter = updates.Mirrors.GetEnumerator();
			while (iter.MoveNext())
				updatesMirrorCmb.Items.Add(iter.Current.Value);
			updatesMirrorCmb.SelectedIndex = 0;

			//Get a list of translatable categories (this will change as more categories
			//are added)
			Dictionary<string, string> updateCategories = new Dictionary<string, string>();
			updateCategories.Add("update", S._("Updates"));
			updateCategories.Add("plugin", S._("Plugins"));

			//Only include those whose architecture is compatible with ours.
			List<string> compatibleArchs = new List<string>();
			{
				//any is always compatible.
				compatibleArchs.Add("any");

				switch (KernelApi.ProcessorArchitecture)
				{
					case ProcessorArchitecture.Amd64:
						compatibleArchs.Add("x64");
						break;
					case ProcessorArchitecture.IA64:
						compatibleArchs.Add("ia64");
						break;
					case ProcessorArchitecture.X86:
						compatibleArchs.Add("x86");
						break;
				}
			}

			foreach (string key in updates.Categories)
			{
				ListViewGroup group = new ListViewGroup(updateCategories.ContainsKey(key) ?
					updateCategories[key] : key);
				updatesLv.Groups.Add(group);

				foreach (UpdateInfo update in updates.Updates[key])
				{
					//Skip if this update won't work on our current architecture.
					if (compatibleArchs.IndexOf(update.Architecture) == -1)
						continue;

					ListViewItem item = new ListViewItem(update.Name);
					item.SubItems.Add(update.Version.ToString());
					item.SubItems.Add(update.Publisher);
					item.SubItems.Add(Util.File.GetHumanReadableFilesize(update.FileSize));

					item.Tag = update;
					item.Group = group;
					item.Checked = true;

					updatesLv.Items.Add(item);
					uiUpdates.Add(update, new UpdateData(update, item));
				}
			}

			updatesBtn.Enabled = updatesLv.Items.Count > 0;

			//Check if there are any updates at all.
			if (updatesLv.Items.Count == 0)
			{
				MessageBox.Show(this, S._("There are no new updates or plugins available for " +
					"Eraser."), S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Information,
					MessageBoxDefaultButton.Button1,
					S.IsRightToLeft(this) ? MessageBoxOptions.RtlReading : 0);
				Close();
			}
		}
		#endregion

		#region Update downloader
		/// <summary>
		/// Handles the update checked event.
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void updatesLv_ItemChecked(object sender, ItemCheckedEventArgs e)
		{
			if (selectedUpdates == -1 || updatesCount != updatesLv.Items.Count)
			{
				updatesCount = updatesLv.Items.Count;
				selectedUpdates = 0;
				foreach (ListViewItem item in updatesLv.Items)
					if (item.Checked)
						++selectedUpdates;
			}
			else
				selectedUpdates += e.Item.Checked ? 1 : -1;
			updatesBtn.Text = selectedUpdates == 0 ? S._("Close") : S._("Install");
		}

		/// <summary>
		/// Handles the Install button click; fetches and installs the updates selected.
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void updatesBtn_Click(object sender, EventArgs e)
		{
			updatesPanel.Visible = false;
			downloadingPnl.Visible = true;
			List<UpdateInfo> updatesToInstall = new List<UpdateInfo>();

			//Set the mirror
			updates.SelectedMirror = (Mirror)updatesMirrorCmb.SelectedItem;

			//Collect the items that need to be installed
			foreach (ListViewItem item in updatesLv.Items)
				if (item.Checked)
				{
					item.Remove();
					item.SubItems.RemoveAt(1);
					item.SubItems.RemoveAt(1);
					downloadingLv.Items.Add(item);

					updatesToInstall.Add((UpdateInfo)item.Tag);
				}
				else
					uiUpdates.Remove((UpdateInfo)item.Tag);

			//Then run the thread if there are updates.
			if (updatesToInstall.Count > 0)
				downloader.RunWorkerAsync(updatesToInstall);
			else
				Close();
		}

		/// <summary>
		/// Background thread to do the downloading and installing of updates.
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void downloader_DoWork(object sender, DoWorkEventArgs e)
		{
			try
			{
				updates.OnProgressEvent += downloader_ProgressChanged;
				object downloadedUpdates = updates.DownloadUpdates((List<UpdateInfo>)e.Argument);
				e.Result = downloadedUpdates;
			}
			finally
			{
				updates.OnProgressEvent -= downloader_ProgressChanged;
			}
		}

		/// <summary>
		/// Handles the download progress changed event.
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void downloader_ProgressChanged(object sender, ProgressEventArgs e)
		{
			if (InvokeRequired)
			{
				if (updateListDownloader.CancellationPending)
					throw new OperationCanceledException();

				Invoke((EventHandler<ProgressEventArgs>)downloader_ProgressChanged,
					sender, e);
				return;
			}

			UpdateData update = uiUpdates[(UpdateInfo)e.UserState];

			if (e is ProgressErrorEventArgs)
			{
				update.Error = ((ProgressErrorEventArgs)e).Exception;
				update.LVItem.ImageIndex = 3;
				update.LVItem.SubItems[1].Text = S._("Error");
				update.LVItem.ToolTipText = update.Error.Message;
			}
			else
			{
				if (e.ProgressPercentage >= 1.0f)
				{
					update.LVItem.ImageIndex = -1;
					update.LVItem.SubItems[1].Text = S._("Downloaded");
				}
				else
				{
					update.amountDownloaded = (long)(e.ProgressPercentage * update.Update.FileSize);
					update.LVItem.ImageIndex = 0;
					update.LVItem.SubItems[1].Text = Util.File.GetHumanReadableFilesize(
						update.Update.FileSize - update.amountDownloaded);
				}
			}

			downloadingItemLbl.Text = e.Message;
			downloadingItemPb.Value = (int)(e.ProgressPercentage * 100);
			downloadingOverallPb.Value = (int)(e.OverallProgressPercentage * 100);

			long amountToDownload = 0;
			foreach (UpdateData upd in uiUpdates.Values)
				amountToDownload += upd.Update.FileSize - upd.amountDownloaded;
			downloadingOverallLbl.Text = S._("Overall progress: {0} left",
				Util.File.GetHumanReadableFilesize(amountToDownload));
		}

		/// <summary>
		/// Handles the completion of updating event
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void downloader_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
		{
			if (e.Error != null)
			{
				if (!(e.Error is OperationCanceledException))
					MessageBox.Show(this, e.Error.Message, S._("Eraser"),
						MessageBoxButtons.OK, MessageBoxIcon.Error,
						MessageBoxDefaultButton.Button1,
						S.IsRightToLeft(this) ? MessageBoxOptions.RtlReading : 0);

				Close();
				return;
			}

			downloadingPnl.Visible = false;
			installingPnl.Visible = true;

			foreach (ListViewItem item in downloadingLv.Items)
			{
				item.Remove();
				installingLv.Items.Add(item);

				UpdateData update = uiUpdates[(UpdateInfo)item.Tag];
				if (update.Error == null)
					item.SubItems[1].Text = string.Empty;
				else
					item.SubItems[1].Text = S._("Error: {0}", update.Error.Message);
			}

			installer.RunWorkerAsync(e.Result);
		}
		#endregion

		#region Update installer
		/// <summary>
		/// Background thread to install downloaded updates
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void installer_DoWork(object sender, DoWorkEventArgs e)
		{
			try
			{
				updates.OnProgressEvent += installer_ProgressChanged;
				updates.InstallUpdates(e.Argument);
			}
			finally
			{
				updates.OnProgressEvent -= installer_ProgressChanged;
			}
		}

		/// <summary>
		/// Handles the progress events generated during update installation.
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void installer_ProgressChanged(object sender, ProgressChangedEventArgs e)
		{
			if (InvokeRequired)
			{
				if (updateListDownloader.CancellationPending)
					throw new OperationCanceledException();

				Invoke((EventHandler<ProgressEventArgs>)installer_ProgressChanged,
					sender, e);
				return;
			}

			UpdateData update = uiUpdates[(UpdateInfo)e.UserState];
			if (e is ProgressErrorEventArgs)
			{
				update.Error = ((ProgressErrorEventArgs)e).Exception;
				update.LVItem.ImageIndex = 3;
				update.LVItem.SubItems[1].Text = S._("Error: {0}", update.Error.Message);
			}
			else
				switch (update.LVItem.ImageIndex)
				{
					case -1:
						update.LVItem.ImageIndex = 1;
						break;
					case 1:
						update.LVItem.ImageIndex = 2;
						break;
				}
		}

		/// <summary>
		/// Re-enables the close dialog button.
		/// </summary>
		/// <param name="sender">The object triggering this event/</param>
		/// <param name="e">Event argument.</param>
		private void installer_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
		{
			if (e.Error is OperationCanceledException)
				Close();

			installingPnl.UseWaitCursor = false;
		}
		#endregion

		/// <summary>
		/// The Update manager instance used by this form.
		/// </summary>
		UpdateManager updates = new UpdateManager();

		/// <summary>
		/// Maps listview items to the UpdateManager.Update object.
		/// </summary>
		Dictionary<UpdateInfo, UpdateData> uiUpdates = new Dictionary<UpdateInfo, UpdateData>();

		/// <summary>
		/// Manages information associated with the update.
		/// </summary>
		private class UpdateData
		{
			/// <summary>
			/// Constructor.
			/// </summary>
			/// <param name="update">The UpdateManager.Update object containing the
			/// internal representation of the update.</param>
			/// <param name="item">The ListViewItem used for the display of the
			/// update.</param>
			public UpdateData(UpdateInfo update, ListViewItem item)
			{
				Update = update;
				LVItem = item;
			}

			/// <summary>
			/// The UpdateManager.Update object containing the internal representation
			/// of the update.
			/// </summary>
			public UpdateInfo Update;

			/// <summary>
			/// The ListViewItem used for the display of the update.
			/// </summary>
			public ListViewItem LVItem;

			/// <summary>
			/// The amount of the download already completed.
			/// </summary>
			public long amountDownloaded;

			/// <summary>
			/// The error raised when downloading/installing the update, if any. Null
			/// otherwise.
			/// </summary>
			public Exception Error;
		}

		/// <summary>
		/// The number of updates selected for download.
		/// </summary>
		private int selectedUpdates = -1;

		/// <summary>
		/// The number of updates present in the previous count, so the Selected
		/// Updates number can be deemed invalid.
		/// </summary>
		private int updatesCount = -1;
	}

	public class UpdateManager
	{
		/// <summary>
		/// Constructor.
		/// </summary>
		public UpdateManager()
		{
			Updates = new UpdateCategoriesDictionary();
		}

		/// <summary>
		/// Retrieves the update list from the server.
		/// </summary>
		public void DownloadUpdateList()
		{
			WebRequest.DefaultCachePolicy = new HttpRequestCachePolicy(
				HttpRequestCacheLevel.Refresh);
			HttpWebRequest req = (HttpWebRequest)
				WebRequest.Create(new Uri("http://eraser.heidi.ie/scripts/updates?" +
					"action=listupdates&version=" +
					Assembly.GetExecutingAssembly().GetName().Version.ToString()));
			
			using (WebResponse response = req.GetResponse())
			using (Stream responseStream = response.GetResponseStream())
			using (MemoryStream memoryStream = new MemoryStream())
			{
				Manager.ProgressManager progress = new Manager.ProgressManager();
				progress.Total = response.ContentLength;

				//Download the response
				int lastRead = 0;
				byte[] buffer = new byte[16384];
				while ((lastRead = responseStream.Read(buffer, 0, buffer.Length)) != 0)
				{
					memoryStream.Write(buffer, 0, lastRead);
					progress.Completed = memoryStream.Position;
					OnProgress(new ProgressEventArgs(progress.Progress, progress.Progress, null,
						S._("{0} of {1} downloaded",
							Util.File.GetHumanReadableFilesize(progress.Completed),
							Util.File.GetHumanReadableFilesize(progress.Total))));
				}

				//Parse it.
				memoryStream.Position = 0;
				ParseUpdateList(memoryStream);
			}
		}

		/// <summary>
		/// Parses the list of updates provided by the server
		/// </summary>
		/// <param name="strm">The stream containing the XML data.</param>
		private void ParseUpdateList(Stream strm)
		{
			//Move the XmlReader to the root node
			Updates.Clear();
			mirrors.Clear();
			XmlReader rdr = XmlReader.Create(strm);
			rdr.ReadToFollowing("updateList");

			//Read the descendants of the updateList node (which are categories,
			//except for the <mirrors> element)
			XmlReader categories = rdr.ReadSubtree();
			bool cont = categories.ReadToDescendant("mirrors");
			while (cont)
			{
				if (categories.NodeType == XmlNodeType.Element)
				{
					if (categories.Name == "mirrors")
					{
						Dictionary<string, string> mirrorsList =
							ParseMirror(categories.ReadSubtree());
						Dictionary<string, string>.Enumerator e = mirrorsList.GetEnumerator();
						while (e.MoveNext())
							this.mirrors.Add(e.Current.Key,
								new Mirror(e.Current.Value, e.Current.Key));
					}
					else
						Updates.Add(categories.Name, ParseUpdateCategory(categories.ReadSubtree()));
				}

				cont = categories.Read();
			}
		}

		/// <summary>
		/// Parses a list of mirrors.
		/// </summary>
		/// <param name="rdr">The XML reader object representing the &lt;mirrors&gt; node</param>
		/// <returns>The list of mirrors defined by the element.</returns>
		private static Dictionary<string, string> ParseMirror(XmlReader rdr)
		{
			Dictionary<string, string> result = new Dictionary<string,string>();
			if (!rdr.ReadToDescendant("mirror"))
				return result;

			//Load every element.
			do
			{
				if (rdr.NodeType != XmlNodeType.Element || rdr.Name != "mirror")
					continue;

				string location = rdr.GetAttribute("location");
				result.Add(rdr.ReadElementContentAsString(), location);
			}
			while (rdr.ReadToNextSibling("mirror"));

			return result;
		}

		/// <summary>
		/// Parses a specific category and its assocaited updates.
		/// </summary>
		/// <param name="rdr">The XML reader object representing the element and its children.</param>
		/// <returns>A list of updates in the category.</returns>
		private static UpdateCollection ParseUpdateCategory(XmlReader rdr)
		{
			UpdateCollection result = new UpdateCollection();
			if (!rdr.ReadToDescendant("item"))
				return result;

			//Load every element.
			do
			{
				if (rdr.Name != "item")
					continue;

				UpdateInfo update = new UpdateInfo();
				update.Name = rdr.GetAttribute("name");
				update.Version = new Version(rdr.GetAttribute("version"));
				update.Publisher = rdr.GetAttribute("publisher");
				update.Architecture = rdr.GetAttribute("architecture");
				update.FileSize = Convert.ToInt64(rdr.GetAttribute("filesize"),
					CultureInfo.InvariantCulture);
				update.Link = rdr.ReadElementContentAsString();

				result.Add(update);
			}
			while (rdr.ReadToNextSibling("item"));

			return result;
		}

		/// <summary>
		/// Downloads the list of updates.
		/// </summary>
		/// <param name="updates">The updates to retrieve and install.</param>
		/// <returns>An opaque object for use with InstallUpdates.</returns>
		public object DownloadUpdates(ICollection<UpdateInfo> downloadQueue)
		{
			//Create a folder to hold all our updates.
			DirectoryInfo tempDir = new DirectoryInfo(Path.GetTempPath());
			tempDir = tempDir.CreateSubdirectory("eraser" + Environment.TickCount.ToString(
				CultureInfo.InvariantCulture));

			int currUpdate = 0;
			Dictionary<string, UpdateInfo> tempFilesMap = new Dictionary<string, UpdateInfo>();
			Manager.SteppedProgressManager progress = new Manager.SteppedProgressManager();
			foreach (UpdateInfo update in downloadQueue)
			{
				try
				{
					//Add the update to the overall progress.
					Manager.ProgressManager step = new Eraser.Manager.ProgressManager();
					progress.Steps.Add(new Manager.SteppedProgressManager.Step(
						step, 1.0f / downloadQueue.Count));

					//Decide on the URL to connect to. The Link of the update may
					//be a relative path (relative to the selected mirror) or an
					//absolute path (which we have no choice)
					Uri reqUri = null;
					if (Uri.IsWellFormedUriString(update.Link, UriKind.Absolute))
						reqUri = new Uri(update.Link);
					else
						reqUri = new Uri(new Uri(SelectedMirror.Link), new Uri(update.Link));
					
					//Then grab the download.
					HttpWebRequest req = (HttpWebRequest)WebRequest.Create(reqUri);
					using (WebResponse resp = req.GetResponse())
					{
						//Check for a suggested filename.
						ContentDisposition contentDisposition = null;
						foreach (string header in resp.Headers.AllKeys)
							if (header.ToLowerInvariant() == "content-disposition")
								contentDisposition = new ContentDisposition(resp.Headers[header]);

						string tempFilePath = Path.Combine(
							tempDir.FullName, string.Format(CultureInfo.InvariantCulture, "{0}-{1}",
							++currUpdate,
							contentDisposition == null ?
								Path.GetFileName(reqUri.GetComponents(UriComponents.Path,
								UriFormat.Unescaped)) : contentDisposition.FileName));

						using (Stream responseStream = resp.GetResponseStream())
						using (FileStream fileStream = new FileStream(tempFilePath, FileMode.CreateNew))
						{
							//Update the progress of this step
							step.Total = resp.ContentLength;

							//Copy the information into the file stream
							int lastRead = 0;
							byte[] buffer = new byte[16384];
							while ((lastRead = responseStream.Read(buffer, 0, buffer.Length)) != 0)
							{
								fileStream.Write(buffer, 0, lastRead);

								//Compute progress
								step.Completed = fileStream.Position;
								OnProgress(new ProgressEventArgs(step.Progress, progress.Progress,
									update, S._("Downloading: {0}", update.Name)));
							}
						}

						//Store the filename-to-update mapping
						tempFilesMap.Add(tempFilePath, update);

						//Let the event handler know the download is complete.
						step.Completed = step.Total;
						OnProgress(new ProgressEventArgs(step.Progress, progress.Progress,
							update, S._("Downloaded: {0}", update.Name)));
					}
				}
				catch (Exception e)
				{
					OnProgress(new ProgressErrorEventArgs(new ProgressEventArgs(1.0f,
						(float)currUpdate / downloadQueue.Count, update,
							S._("Error downloading {0}: {1}", update.Name, e.Message)),
						e));
				}
			}

			return tempFilesMap;
		}

		/// <summary>
		/// Installs all updates downloaded.
		/// </summary>
		/// <param name="value">The value returned from a call to
		/// <see cref="DownloadUpdates"/>.</param>
		public void InstallUpdates(object value)
		{
			Manager.ProgressManager progress = new Manager.ProgressManager();
			Dictionary<string, UpdateInfo> tempFiles = (Dictionary<string, UpdateInfo>)value;
			Dictionary<string, UpdateInfo>.KeyCollection files = tempFiles.Keys;

			try
			{
				progress.Total = files.Count;
				foreach (string path in files)
				{
					UpdateInfo item = tempFiles[path];
					++progress.Completed;
					OnProgress(new ProgressEventArgs(0.0f, progress.Progress,
						item, S._("Installing {0}", item.Name)));

					System.Diagnostics.ProcessStartInfo info = new System.Diagnostics.ProcessStartInfo();
					info.FileName = path;
					info.UseShellExecute = true;

					System.Diagnostics.Process process = System.Diagnostics.Process.Start(info);
					process.WaitForExit(Int32.MaxValue);
					if (process.ExitCode == 0)
						OnProgress(new ProgressEventArgs(1.0f, progress.Progress,
							item, S._("Installed {0}", item.Name)));
					else
						OnProgress(new ProgressErrorEventArgs(new ProgressEventArgs(1.0f,
							progress.Progress, item, S._("Error installing {0}", item.Name)),
							new ApplicationException(S._("The installer exited with an error code {0}",
								process.ExitCode))));
				}
			}
			finally
			{
				//Clean up after ourselves
				foreach (string file in files)
				{
					DirectoryInfo tempDir = null;
					{
						FileInfo info = new FileInfo(file);
						tempDir = info.Directory;
					}

					tempDir.Delete(true);
					break;
				}
			}
		}

		/// <summary>
		/// Called when the progress of the operation changes.
		/// </summary>
		public EventHandler<ProgressEventArgs> OnProgressEvent { get; set; }

		/// <summary>
		/// Helper function: invokes the OnProgressEvent delegate.
		/// </summary>
		/// <param name="arg">The ProgressEventArgs object holding information
		/// about the progress of the current operation.</param>
		private void OnProgress(ProgressEventArgs arg)
		{
			if (OnProgressEvent != null)
				OnProgressEvent(this, arg);
		}

		/// <summary>
		/// Retrieves the list of mirrors which the server has indicated to exist.
		/// </summary>
		public Dictionary<string, Mirror> Mirrors
		{
			get
			{
				return mirrors;
			}
		}

		/// <summary>
		/// Gets or sets the active mirror to use to download mirrored updates.
		/// </summary>
		public Mirror SelectedMirror
		{
			get
			{
				if (selectedMirror.Link.Length == 0)
				{
					Dictionary<string, Mirror>.Enumerator iter = mirrors.GetEnumerator();
					if (iter.MoveNext())
						return iter.Current.Value;
				}
				return selectedMirror;
			}
			set
			{
				foreach (Mirror mirror in Mirrors.Values)
					if (mirror.Equals(value))
					{
						selectedMirror = value;
						return;
					}

				throw new ArgumentException(S._("Unknown mirror selected."));
			}
		}

		/// <summary>
		/// Retrieves the categories available.
		/// </summary>
		public ICollection<string> Categories
		{
			get
			{
				return Updates.Keys;
			}
		}

		/// <summary>
		/// Retrieves all updates available.
		/// </summary>
		public UpdateCategoriesDictionary Updates { get; private set; }

		/// <summary>
		/// The list of mirrors to download updates from.
		/// </summary>
		private Dictionary<string, Mirror> mirrors =
			new Dictionary<string, Mirror>();

		/// <summary>
		/// The currently selected mirror.
		/// </summary>
		private Mirror selectedMirror;
	}

	/// <summary>
	/// Manages a list of categories, mapping categories to a list of updates.
	/// </summary>
	public class UpdateCategoriesDictionary : IDictionary<string, UpdateCollection>,
		ICollection<KeyValuePair<string, UpdateCollection>>,
		IEnumerable<KeyValuePair<string, UpdateCollection>>
	{
		#region IDictionary<string,UpdateList> Members
		public void Add(string key, UpdateCollection value)
		{
			dictionary.Add(key, value);
		}

		public bool ContainsKey(string key)
		{
			return dictionary.ContainsKey(key);
		}

		public ICollection<string> Keys
		{
			get { return dictionary.Keys; }
		}

		public bool Remove(string key)
		{
			return dictionary.Remove(key);
		}

		public bool TryGetValue(string key, out UpdateCollection value)
		{
			return dictionary.TryGetValue(key, out value);
		}

		public ICollection<UpdateCollection> Values
		{
			get { return dictionary.Values; }
		}

		public UpdateCollection this[string key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				dictionary[key] = value;
			}
		}
		#endregion

		#region ICollection<KeyValuePair<string,UpdateList>> Members
		public void Add(KeyValuePair<string, UpdateCollection> item)
		{
			dictionary.Add(item.Key, item.Value);
		}

		public void Clear()
		{
			dictionary.Clear();
		}

		public bool Contains(KeyValuePair<string, UpdateCollection> item)
		{
			return dictionary.ContainsKey(item.Key) && dictionary[item.Key] == item.Value;
		}

		public void CopyTo(KeyValuePair<string, UpdateCollection>[] array, int arrayIndex)
		{
			throw new NotImplementedException();
		}

		public int Count
		{
			get { return dictionary.Count; }
		}

		public bool IsReadOnly
		{
			get { return true; }
		}

		public bool Remove(KeyValuePair<string, UpdateCollection> item)
		{
			return dictionary.Remove(item.Key);
		}
		#endregion

		#region IEnumerable<KeyValuePair<string,UpdateList>> Members
		public IEnumerator<KeyValuePair<string, UpdateCollection>> GetEnumerator()
		{
			return dictionary.GetEnumerator();
		}
		#endregion

		#region IEnumerable Members
		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
		#endregion

		/// <summary>
		/// The store for the current object.
		/// </summary>
		private Dictionary<string, UpdateCollection> dictionary =
			new Dictionary<string, UpdateCollection>();
	}

	/// <summary>
	/// Manages a category, containing a list of updates.
	/// </summary>
	public class UpdateCollection : IList<UpdateInfo>, ICollection<UpdateInfo>,
		IEnumerable<UpdateInfo>
	{
		#region IList<UpdateInfo> Members
		public int IndexOf(UpdateInfo item)
		{
			return list.IndexOf(item);
		}

		public void Insert(int index, UpdateInfo item)
		{
			list.Insert(index, item);
		}

		public void RemoveAt(int index)
		{
			list.RemoveAt(index);
		}

		public UpdateInfo this[int index]
		{
			get
			{
				return list[index];
			}
			set
			{
				list[index] = value;
			}
		}
		#endregion

		#region ICollection<UpdateInfo> Members
		public void Add(UpdateInfo item)
		{
			list.Add(item);
		}

		public void Clear()
		{
			list.Clear();
		}

		public bool Contains(UpdateInfo item)
		{
			return list.Contains(item);
		}

		public void CopyTo(UpdateInfo[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		public int Count
		{
			get { return list.Count; }
		}

		public bool IsReadOnly
		{
			get { return true; }
		}

		public bool Remove(UpdateInfo item)
		{
			return list.Remove(item);
		}
		#endregion

		#region IEnumerable<UpdateInfo> Members
		public IEnumerator<UpdateInfo> GetEnumerator()
		{
			return list.GetEnumerator();
		}
		#endregion

		#region IEnumerable Members
		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return list.GetEnumerator();
		}
		#endregion

		/// <summary>
		/// The store for this object.
		/// </summary>
		private List<UpdateInfo> list = new List<UpdateInfo>();
	}

	/// <summary>
	/// Represents a download mirror.
	/// </summary>
	public struct Mirror
	{
		public Mirror(string location, string link)
			: this()
		{
			Location = location;
			Link = link;
		}

		/// <summary>
		/// The location where the mirror is at.
		/// </summary>
		public string Location { get; set; }

		/// <summary>
		/// The URL prefix to utilise the mirror.
		/// </summary>
		public string Link { get; set; }

		public override string ToString()
		{
			return Location;
		}

		public override bool Equals(object obj)
		{
			if (!(obj is Mirror))
				return false;
			return Equals((Mirror)obj);
		}

		public bool Equals(Mirror other)
		{
			return Link == other.Link;
		}

		public static bool operator ==(Mirror mirror1, Mirror mirror2)
		{
			return mirror1.Equals(mirror2);
		}

		public static bool operator !=(Mirror mirror1, Mirror mirror2)
		{
			return !mirror1.Equals(mirror2);
		}

		public override int GetHashCode()
		{
			return Link.GetHashCode();
		}
	}

	/// <summary>
	/// Represents an update available on the server.
	/// </summary>
	public struct UpdateInfo
	{
		public string Name { get; set; }
		public Version Version { get; set; }
		public string Publisher { get; set; }
		public string Architecture { get; set; }
		public long FileSize { get; set; }
		public string Link { get; set; }

		public override bool Equals(object obj)
		{
			if (!(obj is UpdateInfo))
				return false;
			return Equals((UpdateInfo)obj);
		}

		public bool Equals(UpdateInfo other)
		{
			return Link == other.Link;
		}

		public static bool operator ==(UpdateInfo update1, UpdateInfo update2)
		{
			return update1.Equals(update2);
		}

		public static bool operator !=(UpdateInfo update1, UpdateInfo update2)
		{
			return !update1.Equals(update2);
		}

		public override int GetHashCode()
		{
			return Link.GetHashCode();
		}
	}

	/// <summary>
	/// Specialised progress event argument, containing message describing
	/// current action, and overall progress percentage.
	/// </summary>
	public class ProgressEventArgs : ProgressChangedEventArgs
	{
		public ProgressEventArgs(float progressPercentage, float overallPercentage,
			object userState, string message)
			: base((int)(progressPercentage * 100), userState)
		{
			ProgressPercentage = progressPercentage;
			OverallProgressPercentage = overallPercentage;
			Message = message;
		}

		/// <summary>
		/// Gets the asynchronous task progress percentage.
		/// </summary>
		public new float ProgressPercentage { get; private set; }

		/// <summary>
		/// Gets the asynchronous task overall progress percentage.
		/// </summary>
		public float OverallProgressPercentage { get; private set; }

		/// <summary>
		/// Gets the message associated with the current task.
		/// </summary>
		public string Message { get; private set; }
	}

	/// <summary>
	/// Extends the ProgressEventArgs further by allowing for the inclusion of
	/// an exception.
	/// </summary>
	public class ProgressErrorEventArgs : ProgressEventArgs
	{
		/// <summary>
		/// Constructor.
		/// </summary>
		/// <param name="e">The base ProgressEventArgs object.</param>
		/// <param name="ex">The exception</param>
		public ProgressErrorEventArgs(ProgressEventArgs e, Exception ex)
			: base(e.ProgressPercentage, e.OverallProgressPercentage, e.UserState, e.Message)
		{
			Exception = ex;
		}

		/// <summary>
		/// The exception associated with the progress event.
		/// </summary>
		public Exception Exception { get; private set; }
	}
}