// Copyright (c) 2011, Outercurve Foundation.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// - Redistributions of source code must  retain  the  above copyright notice, this
//   list of conditions and the following disclaimer.
//
// - Redistributions in binary form  must  reproduce the  above  copyright  notice,
//   this list of conditions  and  the  following  disclaimer in  the documentation
//   and/or other materials provided with the distribution.
//
// - Neither  the  name  of  the  Outercurve Foundation  nor   the   names  of  its
//   contributors may be used to endorse or  promote  products  derived  from  this
//   software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT  NOT  LIMITED TO, THE IMPLIED
// WARRANTIES  OF  MERCHANTABILITY   AND  FITNESS  FOR  A  PARTICULAR  PURPOSE  ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL,  SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT  OF  SUBSTITUTE  GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)  HOWEVER  CAUSED AND ON
// ANY  THEORY  OF  LIABILITY,  WHETHER  IN  CONTRACT,  STRICT  LIABILITY,  OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING  IN  ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using System;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using Ionic.Zip;
using WebsitePanel.Providers.OS;


namespace WebsitePanel.Providers.Utils
{
    /// <summary>
    /// Summary description for FileUtils.
    /// </summary>
    public class FileUtils
    {
		public static string EvaluateSystemVariables(string str)
        {
            if (String.IsNullOrEmpty(str))
                return str;

            Regex re = new Regex("%(.+)%", RegexOptions.IgnoreCase);
            return re.Replace(str, new MatchEvaluator(EvaluateSystemVariable));
        }

        public static string GetExecutablePathWithoutParameters(string path)
        {
            if (String.IsNullOrEmpty(path))
                return path;

            int idx = -1;
            int exeIdx = path.ToLower().IndexOf(".exe");
            int dllIdx = path.ToLower().IndexOf(".dll");

            if (exeIdx != -1)
                idx = exeIdx;

            if (dllIdx != -1)
                idx = dllIdx;

            if (exeIdx != -1 && dllIdx != -1)
            {
                idx = exeIdx;
                if (dllIdx < exeIdx)
                    idx = dllIdx;
            }

            string execPath = path;
            if (idx != -1)
            {
                execPath = path.Substring(0, idx + 4);
                if (execPath.StartsWith("\""))
                    execPath = execPath.Substring(1);
            }

            return execPath;
        }

        public static string CorrectRelativePath(string relativePath)
        {
            // clean path
            string correctedPath = Regex.Replace(relativePath.Replace("/", "\\"),
                    @"\.\\|\.\.|\\\\|\?|\:|\""|\<|\>|\||%|\$", "");
            if (correctedPath.StartsWith("\\"))
                correctedPath = correctedPath.Substring(1);
            return correctedPath;
        }

        private static string EvaluateSystemVariable(Match match)
        {
            return Environment.GetEnvironmentVariable(match.Groups[1].Value);
        }

        public static bool FileExists(string path)
        {
            return File.Exists(path);
        }

        public static bool DirectoryExists(string path)
        {
            return Directory.Exists(path);
        }

        public static string CreatePackageFolder(string initialPath)
        {
            // substitute vars
            initialPath = FileUtils.EvaluateSystemVariables(initialPath);

            int i = 0;
            string path = null;
            while (true)
            {
                path = initialPath + ((i == 0) ? "" : i.ToString());
                if (!FileUtils.DirectoryExists(path))
                {
                    // create directory
                    FileUtils.CreateDirectory(path);
                    break;
                }

                i++;
            }

			// Set permissions
			// We decided to inherit NTFS permissions from the parent folder to comply with with the native security schema in Windows,
			// when a user decides on his own how to implement security practices for NTFS permissions schema and harden the server.
			SecurityUtils.GrantNtfsPermissionsBySid(path, SystemSID.ADMINISTRATORS, NTFSPermission.FullControl, true, true);
			SecurityUtils.GrantNtfsPermissionsBySid(path, SystemSID.SYSTEM, NTFSPermission.FullControl, true, true);
			//
            return path;
        }

        public static SystemFile GetFile(string path)
        {
            if (!File.Exists(path))
                return null;

            FileInfo file = new FileInfo(path);
            return new SystemFile(file.Name, file.FullName, false, file.Length,
                file.CreationTime, file.LastWriteTime);
        }

        public static SystemFile[] GetFiles(string path)
        {
            ArrayList items = new ArrayList();
            DirectoryInfo root = new DirectoryInfo(path);

            // get directories
            DirectoryInfo[] dirs = root.GetDirectories();
            foreach (DirectoryInfo dir in dirs)
            {
                string fullName = System.IO.Path.Combine(path, dir.Name);
                SystemFile fi = new SystemFile(dir.Name, fullName, true, 0, dir.CreationTime, dir.LastWriteTime);
                items.Add(fi);

                // check if the directory is empty
                fi.IsEmpty = (Directory.GetFileSystemEntries(fullName).Length == 0);
            }

            // get files
            FileInfo[] files = root.GetFiles();
            foreach (FileInfo file in files)
            {
                string fullName = System.IO.Path.Combine(path, file.Name);
                SystemFile fi = new SystemFile(file.Name, fullName, false, file.Length, file.CreationTime, file.LastWriteTime);
                items.Add(fi);
            }

            return (SystemFile[])items.ToArray(typeof(SystemFile));
        }

        public static SystemFile[] GetFilesRecursive(string rootFolder, string path)
        {
            return GetFilesRecursiveByPattern(rootFolder, path, "*.*");
        }

        public static SystemFile[] GetFilesRecursiveByPattern(string rootFolder, string path, string pattern)
        {
            // parse pattern
            string[] patterns = new string[] { pattern };
            if (pattern.IndexOf("|") != -1 || pattern.IndexOf(";") != -1)
                patterns = pattern.Split(new char[] { '|', ';' });

            // get files
            ArrayList files = new ArrayList();
            foreach (string ptrn in patterns)
                GetFilesList(files, rootFolder, path, ptrn);
            return (SystemFile[])files.ToArray(typeof(SystemFile));
        }

        private static void GetFilesList(ArrayList files, string rootFolder, string folder, string pattern)
        {
            string fullPath = System.IO.Path.Combine(rootFolder, folder);

            // add files in the current folder
            FileInfo[] dirFiles = new DirectoryInfo(fullPath).GetFiles(pattern);
            foreach (FileInfo file in dirFiles)
            {
                SystemFile fi = new SystemFile(folder + "\\" + file.Name, file.Name, false, file.Length,
                    file.CreationTime, file.LastWriteTime);
                files.Add(fi);
            }

            // add children folders

            DirectoryInfo[] dirs = new DirectoryInfo(fullPath).GetDirectories();
            foreach (DirectoryInfo dir in dirs)
            {
                GetFilesList(files, rootFolder, System.IO.Path.Combine(folder, dir.Name), pattern);
            }
        }

        public static SystemFile[] GetDirectoriesRecursive(string rootFolder, string path)
        {
            ArrayList folders = new ArrayList();
            GetDirectoriesRecursive(folders, rootFolder, path);
            return (SystemFile[])folders.ToArray(typeof(SystemFile));
        }

        private static void GetDirectoriesRecursive(ArrayList folders, string rootFolder, string folder)
        {
            // add the current folder
            SystemFile fi = new SystemFile("\\" + folder, folder, true, 0, DateTime.Now, DateTime.Now);
            folders.Add(fi);

            // add children folders
            string fullPath = System.IO.Path.Combine(rootFolder, folder);
            DirectoryInfo dir = new DirectoryInfo(fullPath);
            fi.Created = dir.CreationTime;
            fi.Changed = dir.LastWriteTime;
            DirectoryInfo[] subDirs = dir.GetDirectories();
            foreach (DirectoryInfo subDir in subDirs)
            {
                GetDirectoriesRecursive(folders, rootFolder, System.IO.Path.Combine(folder, subDir.Name));
            }
        }

        public static byte[] GetFileBinaryContent(string path)
        {
            if (!File.Exists(path))
                return null;

            FileStream stream = new FileStream(path, FileMode.Open);
            if (stream == null)
                return null;

            long length = stream.Length;
            byte[] content = new byte[length];
            stream.Read(content, 0, (int)length);
            stream.Close();
            return content;
        }

		/// <summary>
		/// Returns file contents trying to read according to file contents
		/// </summary>
		/// <param name="path">Path to the file.</param>
		/// <param name="encoding">Current file encoding.</param>
		/// <returns>Array of bytes.</returns>
		/// <remarks>
		/// It uses UTF8 by default, so in case incorrect or not supported encoding name
		/// UTF8 will be used to read file contents and convert it to the byte array.
		/// </remarks>
		public static byte[] GetFileBinaryContent(string path, string encoding)
		{
			if (!File.Exists(path))
				return null;

			Encoding fileEncoding = GetEncodingByNameOrDefault(encoding, Encoding.UTF8);

			string fileContent = String.Empty;
			using (StreamReader sr = new StreamReader(path, fileEncoding))
			{
				fileContent = sr.ReadToEnd();
			}

			return fileEncoding.GetBytes(fileContent).Clone() as byte[];
		}

		/// <summary>
		/// Returns <see cref="Encoding"/> from <paramref name="encoding"/> name specified.
		/// If cannot find <see cref="Encoding"/>, returns <paramref name="defaultEncoding"/>.
		/// </summary>
		/// <param name="encoding">The name of the encoding to return.</param>
		/// <param name="defaultEncoding"><see cref="Encoding"/> that will be returned if no <paramref name="encoding"/> will be found.</param>
		/// <returns>
		/// <see cref="Encoding"/> from the <paramref name="encoding"/> name specified, 
		/// otherwise <paramref name="defaultEncoding"/>.
		/// </returns>
		private static Encoding GetEncodingByNameOrDefault(string encoding, Encoding defaultEncoding)
		{
			Encoding currentEncoding = defaultEncoding;

			try
			{
				currentEncoding = Encoding.GetEncoding(encoding);
			}
			catch(ArgumentException)
			{
				// this encoding is either no supported or incorrect
				// set to default encoding
				currentEncoding = defaultEncoding;
			}

			return currentEncoding;
		}

        public static Stream GetFileBinaryContentStream(string path)
        {
            if (!File.Exists(path))
                return null;

            return new FileStream(path, FileMode.Open);
        }

        public static byte[] GetFileBinaryChunk(string path, int offset, int length)
        {
            if (!File.Exists(path))
                return null;

            FileStream stream = new FileStream(path, FileMode.Open);
            if (stream == null)
                return null;

            if (offset > 0)
                stream.Seek(offset, SeekOrigin.Begin);

            byte[] content = new byte[length];
            int readBytes = stream.Read(content, 0, length);
            stream.Close();

            if (readBytes < length)
            {
                byte[] lastContent = new byte[readBytes];
                if (readBytes > 0)
                {
                    Array.Copy(content, 0, lastContent, 0, readBytes);
                }
                // avoiding of getting empty content
                if (lastContent.Length == 0)
                {
                    lastContent = new byte[] { 1 };
                }
                return lastContent;
            }
            else
            {
                return content;
            }
        }

        public static string GetFileTextContent(string path)
        {
            StreamReader reader = new StreamReader(path);
            string content = reader.ReadToEnd();
            reader.Close();
            return content;
        }

        public static void UpdateFileBinaryContent(string path, byte[] content)
        {
            FileStream stream = new FileStream(path, FileMode.Create);
            stream.Write(content, 0, content.Length);
            stream.Close();
        }

		/// <summary>
		/// Updates file contents using encoding.
		/// </summary>
		/// <param name="path">Path to the file.</param>
		/// <param name="content">File contents.</param>
		/// <param name="encoding">Current file encoding.</param>
		/// <remarks>
		/// It uses UTF8 by default, so in case incorrect or not supported encoding name is submitted, 
		/// then UTF8 will be used to convert bytes to file contents.
		/// </remarks>
		public static void UpdateFileBinaryContent(string path, byte[] content, string encoding)
		{
			Encoding fileEncoding = GetEncodingByNameOrDefault(encoding, Encoding.UTF8);

			using (StreamWriter sw = new StreamWriter(File.Create(path), fileEncoding))
			{
				sw.Write(
					fileEncoding.GetString(content)
					);
			}
		}

        public static void AppendFileBinaryContent(string path, byte[] chunk)
        {
            FileStream stream = new FileStream(path, FileMode.Append, FileAccess.Write);
            stream.Write(chunk, 0, chunk.Length);
            stream.Close();
        }

        public static void UpdateFileTextContent(string path, string content)
        {
            StreamWriter stream = new StreamWriter(path);
            stream.Write(content);
            stream.Close();
        }

        public static void CreateFile(string path)
        {
            FileStream stream = File.Create(path);
            stream.Close();
        }

        public static void ChangeFileAttributes(string path, DateTime createdTime, DateTime changedTime)
        {
            if (Directory.Exists(path))
            {
                Directory.SetCreationTime(path, createdTime);
                Directory.SetLastWriteTime(path, changedTime);
            }
            else if (File.Exists(path))
            {
                File.SetCreationTime(path, createdTime);
                File.SetLastWriteTime(path, changedTime);
            }
        }

        public static void DeleteFile(string path)
        {
            if (File.Exists(path))
                  File.Delete(path);
            else
                if (Directory.Exists(path))
                Directory.Delete(path, true);
            
        }

        public static void DeleteFiles(string[] files)
        {
            foreach (string file in files)
                DeleteFile(file);
        }

        public static void DeleteEmptyDirectories(string[] directories)
        {
            foreach (string directory in directories)
                DeleteEmptyDirectoryRecursive(directory);
        }

        private static bool DeleteEmptyDirectoryRecursive(string directory)
        {
            if (!Directory.Exists(directory))
                return true;

            // iterate through child folders
            bool empty = true;
            string[] dirs = Directory.GetDirectories(directory);
            foreach (string dir in dirs)
            {
                if (!DeleteEmptyDirectoryRecursive(dir))
                    empty = false;
            }

            string[] files = Directory.GetFiles(directory);
            empty = empty && (files.Length == 0);

            // try to delete directory
            if (empty)
                Directory.Delete(directory);

            return empty;
        }

        public static void MoveFile(string sourcePath, string destinationPath)
        {
            if (File.Exists(sourcePath))
            {
                File.Move(sourcePath, destinationPath);
            }
            else if (Directory.Exists(sourcePath))
            {
                Directory.Move(sourcePath, destinationPath);
            }
            else
            {
                throw new Exception("Specified file is not found!");
            }

            // reset NTFS permissions on destination file/folder
            SecurityUtils.ResetNtfsPermissions(destinationPath);
        }

        public static void CopyFile(string sourcePath, string destinationPath)
        {
            if (File.Exists(sourcePath))
            {
                File.Copy(sourcePath, destinationPath, true);
            }
            else if (Directory.Exists(sourcePath))
            {
                CopyDirectory(sourcePath, destinationPath);
            }
            else
            {
                throw new Exception("Specified file is not found!");
            }

            // reset NTFS permissions on destination file/folder
            SecurityUtils.ResetNtfsPermissions(destinationPath);
        }

        private static void CopyDirectory(string sourceDir, string destinationDir)
        {
            // create directory
            DirectoryInfo srcDir = new DirectoryInfo(sourceDir);
            if(!Directory.Exists(destinationDir))
                Directory.CreateDirectory(destinationDir);

            // create subdirectories
            DirectoryInfo[] dirs = srcDir.GetDirectories();
            foreach (DirectoryInfo dir in dirs)
            {
                CopyDirectory(System.IO.Path.Combine(sourceDir, dir.Name),
                    System.IO.Path.Combine(destinationDir, dir.Name));
            }

            // copy files
            FileInfo[] files = srcDir.GetFiles();
            foreach (FileInfo file in files)
            {
                // copy file
                file.CopyTo(System.IO.Path.Combine(destinationDir, file.Name), true);
            }
        }

        public static void CreateDirectory(string path)
        {
            if (!Directory.Exists(path))
            {
                // create directory structure
                Directory.CreateDirectory(path);
            }
        }
		

		public static void ZipFiles(string zipFile, string rootPath, string[] files)
		{
			using (ZipFile zip = new ZipFile())
			{
				//use unicode if necessary
				zip.UseUnicodeAsNecessary = true;
                zip.UseZip64WhenSaving = Zip64Option.AsNecessary;

				//skip locked files
				zip.ZipErrorAction = ZipErrorAction.Skip;
				foreach (string file in files)
				{
					string fullPath = Path.Combine(rootPath, file);
					if (Directory.Exists(fullPath))
					{
						//add directory with the same directory name
						zip.AddDirectory(fullPath, file);
					}
					else if (File.Exists(fullPath))
					{
						//add file to the root folder
						zip.AddFile(fullPath, "");
					}
				}
				zip.Save(zipFile);
			}
		}

        public static string[] UnzipFiles(string zipFile, string destFolder)
        {
			using (ZipFile zip = ZipFile.Read(zipFile))
			{
				foreach (ZipEntry e in zip)
				{
					// Remove Read-Only attribute from a zip entry
					if ((e.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
						e.Attributes ^= FileAttributes.ReadOnly;
					//
					e.Extract(destFolder, ExtractExistingFileAction.OverwriteSilently);
				}
			}
			
			List<string> files = new List<string>();
			foreach(SystemFile systemFile in GetFiles(destFolder))
			{
				files.Add(systemFile.FullName);
			}			

			return files.ToArray();
        }

        private static void CreateDirectoriesStructure(string path)
        {
            string dir = System.IO.Path.GetDirectoryName(path);
            if (!Directory.Exists(dir))
            {
                // create directory structure
                Directory.CreateDirectory(dir);
            }
        }

        public static string ExecuteSystemCommand(string cmd, string args)
        {
            return ExecuteSystemCommand(cmd, args, null);
        }

        public static string ExecuteSystemCommand(string cmd, string args, string outputFile)
        {
            // launch system process
            ProcessStartInfo startInfo = new ProcessStartInfo(cmd, args);
            startInfo.WindowStyle = ProcessWindowStyle.Hidden;
            startInfo.RedirectStandardOutput = true;
            startInfo.StandardOutputEncoding = Encoding.UTF8;
            startInfo.UseShellExecute = false;
            startInfo.CreateNoWindow = true;

            // get working directory from executable path
			startInfo.WorkingDirectory = Path.GetDirectoryName(cmd);
            Process proc = Process.Start(startInfo);


            // analyze results
            StreamReader reader = proc.StandardOutput;
            string results = "";
            if (!String.IsNullOrEmpty(outputFile))
            {
                // stream to writer
                StreamWriter writer = new StreamWriter(outputFile);
                int BUFFER_LENGTH = 2048;
                int readBytes = 0;
                char[] buffer = new char[BUFFER_LENGTH];
                while ((readBytes = reader.Read(buffer, 0, BUFFER_LENGTH)) > 0)
                {
                    writer.Write(buffer, 0, readBytes);
                }
                writer.Close();
            }
            else
            {
                // return as string
                results = reader.ReadToEnd();
            }
            reader.Close();

            return results;
        }

        public static void ExecuteCmdCommand(string command)
        {
            ProcessStartInfo ProcessInfo;
            Process process;

            ProcessInfo = new ProcessStartInfo("cmd.exe", "/C " + command);
            ProcessInfo.CreateNoWindow = true;
            ProcessInfo.UseShellExecute = false;
            process = Process.Start(ProcessInfo);
            if (process != null)
            {
                process.WaitForExit(500);
                process.Close();
            }
        }

        public static void SaveStreamToFile(Stream stream, string path)
        {
            try
            {
                //Create a file to save to
                Stream toStream = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);

                //use the binary reader & writer because
                //they can work with all formats
                //i.e images, text files ,avi,mp3..
                BinaryReader br = new BinaryReader(stream);
                BinaryWriter bw = new BinaryWriter(toStream);

                //copy data from the FromStream to the outStream
                //convert from long to int 
                bw.Write(br.ReadBytes((int)stream.Length));

                //save
                bw.Flush();

                //clean up 
                bw.Close();
                br.Close();
            }
            //use Exception e as it can handle any exception 
            catch
            {
                //code if u like 
            }
        }

        public static long CalculateFolderSize(string path)
        {
            int files = 0;
            int folders = 0;
			// check directory exists
			if (!Directory.Exists(path))
				return 0;
			// normalize path
			path = path.Replace("/", "\\");
			// remove trailing slash
			if (path.EndsWith(@"\"))
				path = path.Substring(0, path.Length - 1);
			// calculate folder size
			return CalculateFolderSize(path, out files, out folders);
        }

        private static long CalculateFolderSize(string path, out int files, out int folders)
        {
            files = 0;
            folders = 0;

            IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);
            long size = 0;
            FindData findData = new FindData();

            IntPtr findHandle;

            findHandle = path.StartsWith("\\\\")
                             ? Kernel32.FindFirstFile(path + @"\*", findData)
                             : Kernel32.FindFirstFile(@"\\?\" + path + @"\*", findData);
            if (findHandle != INVALID_HANDLE_VALUE)
            {

                do
                {
                    if ((findData.fileAttributes & (int)FileAttributes.Directory) != 0)
                    {

                        if (findData.fileName != "." && findData.fileName != "..")
                        {
                            folders++;

                            int subfiles, subfolders;
                            string subdirectory = path + (path.EndsWith(@"\") ? "" : @"\") +
                                findData.fileName;
                            size += CalculateFolderSize(subdirectory, out subfiles, out subfolders);
                            folders += subfolders;
                            files += subfiles;
                        }
                    }
                    else
                    {
                        // File
                        files++;

                        size += (long)findData.nFileSizeLow + (long)findData.nFileSizeHigh * 4294967296;
                    }
                }
                while (Kernel32.FindNextFile(findHandle, findData));
                Kernel32.FindClose(findHandle);

            }

            return size;
        }

        public static void CreateAccessDatabase(string databasePath)
        {
            if (String.IsNullOrEmpty(databasePath))
                throw new ArgumentException("databasePath");

            string connectionString = String.Format("Provider=Microsoft.Jet.OLEDB.4.0;Data Source={0};Jet OLEDB:Engine Type=5;Mode=Share Deny None;Jet OLEDB:Database Locking Mode=0",
                databasePath);

            Type adoxType = Type.GetTypeFromProgID("ADOX.Catalog");
            object cat = Activator.CreateInstance(adoxType);
            adoxType.InvokeMember("Create", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod,
                null, cat, new object[] { connectionString });
            object conn = adoxType.InvokeMember("ActiveConnection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty,
                null, cat, null);
            adoxType.InvokeMember("Close", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod, null,
                conn, null);
            cat = null;
        }
		#region Advanced Delete
		/// <summary>
		/// Deletes the specified file.
		/// </summary>
		/// <param name="fileName">The name of the file to be deleted.</param>
		public static void DeleteFileAdvanced(string fileName)
		{
			int attempts = 0;
			while (true)
			{
				try
				{
					DeleteFileInternal(fileName);
					break;
				}
				catch (Exception)
				{
					if (attempts > 2)
						throw;

					attempts++;
					System.Threading.Thread.Sleep(1000);
				}
			}
		}

		/// <summary>
		/// Deletes the specified file.
		/// </summary>
		/// <param name="fileName">The name of the file to be deleted.</param>
		private static void DeleteReadOnlyFile(string fileName)
		{
			FileInfo info = new FileInfo(fileName);
			info.Attributes = FileAttributes.Normal;
			info.Delete();
		}

		/// <summary>
		/// Deletes the specified file.
		/// </summary>
		/// <param name="fileName">The name of the file to be deleted.</param>
		private static void DeleteFileInternal(string fileName)
		{
			try
			{
				File.Delete(fileName);
			}
			catch (UnauthorizedAccessException)
			{
				DeleteReadOnlyFile(fileName);
			}
		}

		/// <summary>
		/// Deletes the specified directory.
		/// </summary>
		/// <param name="directory">The name of the directory to be deleted.</param>
		public static void DeleteDirectoryAdvanced(string directory)
		{
			if (!Directory.Exists(directory))
				return;

			// iterate through child folders
			string[] dirs = Directory.GetDirectories(directory);
			foreach (string dir in dirs)
			{
				DeleteDirectoryAdvanced(dir);
			}

			// iterate through child files
			string[] files = Directory.GetFiles(directory);
			foreach (string file in files)
			{
				DeleteFileAdvanced(file);
			}

			//try to delete dir for 3 times
			int attempts = 0;
			while (true)
			{
				try
				{
					DeleteDirectoryInternal(directory);
					break;
				}
				catch (Exception)
				{
					if (attempts > 2)
						throw;

					attempts++;
					System.Threading.Thread.Sleep(1000);
				}
			}
		}

		/// <summary>
		/// Deletes the specified directory.
		/// </summary>
		/// <param name="directory">The name of the directory to be deleted.</param>
		public static void DeleteDirectoryInternal(string directory)
		{
			try
			{
				Directory.Delete(directory);
			}
			catch (IOException)
			{
				DeleteReadOnlyDirectory(directory);
			}
		}

		/// <summary>
		/// Deletes the specified directory.
		/// </summary>
		/// <param name="directory">The name of the directory to be deleted.</param>
		private static void DeleteReadOnlyDirectory(string directory)
		{
			DirectoryInfo info = new DirectoryInfo(directory);
			info.Attributes = FileAttributes.Normal;
			info.Delete();
		}
		#endregion

    }

    #region File Size Calculation helper classes
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
    class FindData
    {
        public int fileAttributes;
        public int creationTime_lowDateTime;
        public int creationTime_highDateTime;
        public int lastAccessTime_lowDateTime;
        public int lastAccessTime_highDateTime;
        public int lastWriteTime_lowDateTime;
        public int lastWriteTime_highDateTime;
        public uint nFileSizeHigh;
        public uint nFileSizeLow;
        public int dwReserved0;
        public int dwReserved1;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
        public String fileName;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)]
        public String alternateFileName;
    }

    class Kernel32
    {
        [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr FindFirstFile(String fileName, [In, Out] FindData findFileData);

        [DllImport("kernel32", CharSet = CharSet.Auto)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool FindNextFile(IntPtr hFindFile, [In, Out] FindData lpFindFileData);

        [DllImport("kernel32", CharSet = CharSet.Auto)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool FindClose(IntPtr hFindFile);
    }
    #endregion
}