/* 
 * $Id$
 * Copyright 2008-2010 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.Linq;
using System.Text;

using System.Runtime.Serialization;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.IO;

using Eraser.Util;
using Eraser.Util.ExtensionMethods;
using Eraser.Plugins;
using Eraser.Plugins.ExtensionPoints;
using Eraser.Plugins.Registrars;

namespace Eraser.DefaultPlugins
{
	/// <summary>
	/// Class representing a unused space erase.
	/// </summary>
	[Serializable]
	[Guid("A627BEC4-CAFC-46ce-92AD-209157C3177A")]
	class UnusedSpaceErasureTarget : ErasureTargetBase
	{
		#region Serialization code
		protected UnusedSpaceErasureTarget(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			Drive = (string)info.GetValue("Drive", typeof(string));
			EraseClusterTips = (bool)info.GetValue("EraseClusterTips", typeof(bool));
		}

		[SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("Drive", Drive);
			info.AddValue("EraseClusterTips", EraseClusterTips);
		}
		#endregion

		/// <summary>
		/// Constructor.
		/// </summary>
		public UnusedSpaceErasureTarget()
			: base()
		{
		}

		public override Guid Guid
		{
			get { return GetType().GUID; }
		}

		public override string ToString()
		{
			return S._("Unused disk space ({0})", Drive);
		}

		public override string Name
		{
			get { return S._("Unused disk space"); }
		}

		public sealed override IErasureMethod EffectiveMethod
		{
			get
			{
				if (Method != ErasureMethodRegistrar.Default)
					return base.EffectiveMethod;

				return Host.Instance.ErasureMethods[
					Host.Instance.Settings.DefaultUnusedSpaceErasureMethod];
			}
		}

		public override bool SupportsMethod(IErasureMethod method)
		{
			return method == ErasureMethodRegistrar.Default ||
				method is IUnusedSpaceErasureMethod;
		}

		/// <summary>
		/// Override the base class property so that we won't need to keep casting
		/// </summary>
		protected new SteppedProgressManager Progress
		{
			get
			{
				return (SteppedProgressManager)base.Progress;
			}
			set
			{
				base.Progress = value;
			}
		}

		public override IErasureTargetConfigurer Configurer
		{
			get { return new UnusedSpaceErasureTargetConfigurer(); }
		}

		/// <summary>
		/// The drive to erase
		/// </summary>
		public string Drive { get; set; }

		/// <summary>
		/// Whether cluster tips should be erased.
		/// </summary>
		public bool EraseClusterTips { get; set; }

		public override void Execute()
		{
			//Check for sufficient privileges to run the unused space erasure.
			if (!Security.IsAdministrator())
			{
				if (Environment.OSVersion.Platform == PlatformID.Win32NT &&
					Environment.OSVersion.Version >= new Version(6, 0))
				{
					Logger.Log(S._("The program does not have the required permissions to erase " +
						"the unused space on disk. Run the program as an administrator and retry " +
						"the operation."), LogLevel.Error);
				}
				else
				{
					Logger.Log(S._("The program does not have the required permissions to erase " +
						"the unused space on disk."), LogLevel.Error);
				}

				return;
			}

			//Check whether System Restore has any available checkpoints.
			if (SystemRestore.GetInstances().Count != 0)
			{
				Logger.Log(S._("This computer has had System Restore or Volume Shadow Copies " +
					"enabled. This may allow copies of files stored on the disk to be recovered " +
					"and pose a security concern.", Drive), LogLevel.Warning);
			}

			//If the user is under disk quotas, log a warning message
			if (VolumeInfo.FromMountPoint(Drive).HasQuota)
			{
				Logger.Log(S._("The drive {0} has disk quotas active. This will prevent the " +
					"complete erasure of unused space and may pose a security concern.",
					Drive), LogLevel.Warning);
			}

			//Get the erasure method if the user specified he wants the default.
			IErasureMethod method = EffectiveMethod;

			//Make a folder to dump our temporary files in
			DirectoryInfo info = new DirectoryInfo(Drive);
			VolumeInfo volInfo = VolumeInfo.FromMountPoint(Drive);
			IFileSystem fsManager = Host.Instance.FileSystems[volInfo];

			//Start sampling the speed of the task.
			Progress = new SteppedProgressManager();

			//Erase the cluster tips of every file on the drive.
			if (EraseClusterTips)
			{
				//Define the callback handlers
				ProgressManager tipSearch = new ProgressManager();
				tipSearch.MarkIndeterminate();
				Progress.Steps.Add(new SteppedProgressManagerStep(tipSearch,
					0.0f, S._("Searching for files' cluster tips...")));
				ClusterTipsSearchProgress searchProgress = delegate(string path)
				{
					if (Task.Canceled)
						throw new OperationCanceledException(S._("The task was cancelled."));

					tipSearch.Tag = path;
				};

				ProgressManager tipProgress = new ProgressManager();
				Progress.Steps.Add(new SteppedProgressManagerStep(tipProgress, 0.1f,
					S._("Erasing cluster tips...")));
				ClusterTipsEraseProgress eraseProgress =
					delegate(int currentFile, int totalFiles, string currentFilePath)
					{
						tipSearch.MarkComplete();
						tipProgress.Total = totalFiles;
						tipProgress.Completed = currentFile;
						tipProgress.Tag = currentFilePath;

						if (Task.Canceled)
							throw new OperationCanceledException(S._("The task was cancelled."));
					};

				//Start counting statistics
				fsManager.EraseClusterTips(VolumeInfo.FromMountPoint(Drive),
					method, searchProgress, eraseProgress);
				tipProgress.MarkComplete();
			}

			bool lowDiskSpaceNotifications = Shell.LowDiskSpaceNotificationsEnabled;
			info = info.CreateSubdirectory(Path.GetFileName(
				FileSystemBase.GenerateRandomFileName(info, 18)));
			try
			{
				//Set the folder's compression flag off since we want to use as much
				//space as possible
				if (info.IsCompressed())
					info.Uncompress();

				//Disable the low disk space notifications
				Shell.LowDiskSpaceNotificationsEnabled = false;

				//Fill the disk
				EraseUnusedSpace(volInfo, info, fsManager, method);

				//Erase old resident file system table files
				ProgressManager residentProgress = new ProgressManager();
				Progress.Steps.Add(new SteppedProgressManagerStep(residentProgress,
					0.05f, S._("Old resident file system table files")));
				fsManager.EraseOldFileSystemResidentFiles(volInfo, info, method,
					delegate(int currentFile, int totalFiles)
					{
						residentProgress.Completed = currentFile;
						residentProgress.Total = totalFiles;

						if (Task.Canceled)
							throw new OperationCanceledException(S._("The task was cancelled."));
					}
				);

				residentProgress.MarkComplete();
			}
			finally
			{
				//Remove the folder holding all our temporary files.
				ProgressManager tempFiles = new ProgressManager();
				Progress.Steps.Add(new SteppedProgressManagerStep(tempFiles,
					0.0f, S._("Removing temporary files...")));
				info.Delete(true);
				tempFiles.MarkComplete();

				//Reset the low disk space notifications
				Shell.LowDiskSpaceNotificationsEnabled = lowDiskSpaceNotifications;
			}

			//Then clean the old file system entries
			ProgressManager structureProgress = new ProgressManager();
			Progress.Steps.Add(new SteppedProgressManagerStep(structureProgress,
				0.05f, S._("Erasing unused directory structures...")));
			fsManager.EraseDirectoryStructures(volInfo,
				delegate(int currentFile, int totalFiles)
				{
					if (Task.Canceled)
						throw new OperationCanceledException(S._("The task was cancelled."));

					//Compute the progress
					structureProgress.Total = totalFiles;
					structureProgress.Completed = currentFile;
				}
			);

			structureProgress.MarkComplete();
			Progress = null;
		}

		private void EraseUnusedSpace(VolumeInfo volInfo, DirectoryInfo info, IFileSystem fsInfo,
			IErasureMethod method)
		{
			ProgressManager mainProgress = new ProgressManager();
			Progress.Steps.Add(new SteppedProgressManagerStep(mainProgress,
				EraseClusterTips ? 0.8f : 0.9f, S._("Erasing unused space...")));

			//Continue creating files while there is free space.
			while (volInfo.AvailableFreeSpace > 0)
			{
				//Generate a non-existant file name
				string currFile = FileSystemBase.GenerateRandomFileName(info, 18);

				//Create the stream
				FileStream stream = new FileStream(currFile, FileMode.CreateNew,
					FileAccess.Write, FileShare.None, 8, FileOptions.WriteThrough);
				try
				{
					//Set the length of the file to be the amount of free space left
					//or the maximum size of one of these dumps.
					mainProgress.Total = mainProgress.Completed +
						method.CalculateEraseDataSize(null, volInfo.AvailableFreeSpace);
					long streamLength = Math.Min(PassBasedErasureMethod.FreeSpaceFileUnit,
						volInfo.AvailableFreeSpace);

					//Handle IO exceptions gracefully, because the filesystem
					//may require more space than demanded by us for file allocation.
					while (true)
						try
						{
							stream.SetLength(streamLength);
							break;
						}
						catch (IOException)
						{
							if (streamLength > volInfo.ClusterSize)
								streamLength -= volInfo.ClusterSize;
							else
								throw;
						}

					//Then run the erase task
					method.Erase(stream, long.MaxValue, Host.Instance.Prngs.ActivePrng,
						delegate(long lastWritten, long totalData, int currentPass)
						{
							mainProgress.Completed += lastWritten;
							mainProgress.Tag = new int[] { currentPass, method.Passes };

							if (Task.Canceled)
								throw new OperationCanceledException(S._("The task was cancelled."));
						}
					);
				}
				finally
				{
					stream.Close();
					fsInfo.ResetFileTimes(new FileInfo(currFile));
				}
			}

			//Mark the main bulk of the progress as complete
			mainProgress.MarkComplete();
		}
	}
}