using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading;
using System.Xml;

namespace Wayne.Lib.IO
{
    /// <summary>
    /// Support class for files.
    /// </summary>
    public class FileSupportNonStatic : IFileSupport
    {
        #region Properties

        /// <summary>
        /// Default encoding for reading and writing text files.
        /// </summary>
        public static readonly System.Text.Encoding DefaultEncoding = System.Text.Encoding.UTF8;



        /// <summary>
        /// The Paths implementation to be used.
        /// </summary>
        public IPaths Paths { get; private set; }
        #endregion

        /// <summary>
        /// Constructor. uses default paths implementation.
        /// </summary>
        public FileSupportNonStatic()
        {
            Paths = new PathsImplementation(this.UnresolvedDirectoryPathExists(@"c:\"));
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="paths"></param>
        public FileSupportNonStatic(IPaths paths)
        {
            Paths = paths;
        }

        #region Open

        /// <summary>
        /// Opens a file.
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="fileMode"></param>
        /// <param name="fileAccess"></param>
        /// <param name="fileShare"></param>
        /// <param name="retries"></param>
        /// <param name="delayBetweenRetries"></param>
        /// <returns></returns>
        [System.Diagnostics.DebuggerStepThrough]
        public virtual Stream Open(string fileName, FileMode fileMode, FileAccess fileAccess, FileShare fileShare, int retries, int delayBetweenRetries)
        {
            if (retries < 0)
                throw new ArgumentException("Number of retries must be positive non-zero", "retries");
            if (delayBetweenRetries < 0)
                throw new ArgumentException("Delay between retries must be equal to or greater than zero.");

            fileName = Paths.Parse(fileName);
            int retriesLeft = retries;
            do
            {
                try
                {
                    return FileOpen(fileName, fileMode, fileAccess, fileShare);
                }
                catch (IOException)
                {
                    retriesLeft--;
                    if (retriesLeft == 0)
                        throw;

                    ThreadSleep(delayBetweenRetries);
                }
                catch (UnauthorizedAccessException)
                {
                    retriesLeft--;
                    if (retriesLeft == 0)
                        throw;

                    ThreadSleep(delayBetweenRetries);
                }
            }
            while (true); //Exit either by returning, or by throwing the exception that occured.
        }

        /// <summary>
        /// Opens a file, using standard values for retries (100) and delayBetweenRetries(100)
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="fileMode"></param>
        /// <param name="fileAccess"></param>
        /// <param name="fileShare"></param>
        /// <returns></returns>
        public Stream Open(string fileName, FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
        {
            return Open(fileName, fileMode, fileAccess, fileShare, 100, 100);
        }

        #endregion

        #region Move

        /// <summary>
        /// Moves a file.
        /// </summary>
        /// <param name="sourceFileName"></param>
        /// <param name="destinationFileName"></param>
        /// <param name="retries"></param>
        /// <param name="delayBetweenRetries"></param>
        [System.Diagnostics.DebuggerStepThrough]
        public void Move(string sourceFileName, string destinationFileName, int retries, int delayBetweenRetries)
        {
            if (retries <= 0)
                throw new ArgumentException("Number of retries must be positive non-zero", "retries");
            if (delayBetweenRetries < 0)
                throw new ArgumentException("Delay between retries must be equal to or greater than zero.");

            sourceFileName = Paths.Parse(sourceFileName);
            destinationFileName = Paths.Parse(destinationFileName);

            int retriesLeft = retries;
            do
            {
                try
                {
                    if (FileExists(destinationFileName))
                        FileDelete(destinationFileName);

                    FileMove(sourceFileName, destinationFileName);
                    return;
                }
                catch (IOException)
                {
                    if (!FileExists(sourceFileName)) //If the source file does not even exist, then it is not worth looping.
                        throw;

                    retriesLeft--;

                    if (retriesLeft == 0)
                        throw;

                    ThreadSleep(delayBetweenRetries);
                }
                catch (UnauthorizedAccessException)
                {
                    if (!FileExists(sourceFileName)) //If the source file does not even exist, then it is not worth looping.
                        throw;

                    retriesLeft--;

                    if (retriesLeft == 0)
                        throw;

                    ThreadSleep(delayBetweenRetries);
                }
            }
            while (true); //Exit either by returning, or by throwing the exception that occured.
        }

        /// <summary>
        /// Moves a file, using standard values for retries (100) and delayBetweenRetries(100)
        /// </summary>
        /// <param name="sourceFileName"></param>
        /// <param name="destinationFileName"></param>
        [System.Diagnostics.DebuggerStepThrough]
        public void Move(string sourceFileName, string destinationFileName)
        {
            Move(sourceFileName, destinationFileName, 100, 100);
        }

        /// <summary>
        /// Moves an entire directory from one location to another
        /// </summary>
        /// <param name="sourceDirName"></param>
        /// <param name="destDirName"></param>
        public void MoveDirectory(string sourceDirName, string destDirName)
        {
            MoveDirectory(sourceDirName, destDirName, 100, 100);
        }

        /// <summary>
        /// Moves an entire directory from one location to another
        /// </summary>
        /// <param name="sourceDirName"></param>
        /// <param name="destDirName"></param>
        /// <param name="retries"></param>
        /// <param name="delayBetweenRetries"></param>
        public void MoveDirectory(string sourceDirName, string destDirName, int retries, int delayBetweenRetries)
        {
            if (retries <= 0)
                throw new ArgumentException("Number of retries must be positive non-zero", "retries");
            if (delayBetweenRetries < 0)
                throw new ArgumentException("Delay between retries must be equal to or greater than zero.");

            sourceDirName = Paths.Parse(sourceDirName);
            destDirName = Paths.Parse(destDirName);

            int retriesLeft = retries;
            do
            {
                try
                {
                    DirectoryMove(sourceDirName, destDirName);
                    return;
                }
                catch (IOException)
                {
                    if (DirectoryExists(destDirName) || !DirectoryExists(sourceDirName)) //If the dest dir already exist -or- the source dir does not even exist, then it is not worth looping.
                        throw;

                    retriesLeft--;

                    if (retriesLeft == 0)
                        throw;

                    ThreadSleep(delayBetweenRetries);
                }
                catch (UnauthorizedAccessException)
                {
                    if (DirectoryExists(destDirName) || !DirectoryExists(sourceDirName)) //If the dest dir already exist -or- the source dir does not even exist, then it is not worth looping.
                        throw;

                    retriesLeft--;

                    if (retriesLeft == 0)
                        throw;

                    ThreadSleep(delayBetweenRetries);
                }
            }
            while (true); //Exit either by returning, or by throwing the exception that occured.
        }

        #endregion

        #region Delete

        /// <summary>
        /// Deletes a file
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="retries"></param>
        /// <param name="delayBetweenRetries"></param>
        [System.Diagnostics.DebuggerStepThrough]
        public void Delete(string fileName, int retries, int delayBetweenRetries)
        {
            if (retries <= 0)
                throw new ArgumentException("Number of retries must be positive non-zero", "retries");
            if (delayBetweenRetries < 0)
                throw new ArgumentException("Delay between retries must be equal to or greater than zero.");

            fileName = Paths.Parse(fileName);
            int retriesLeft = retries;
            do
            {

                try
                {
                    if (FileExists(fileName))
                        FileDelete(fileName);
                    return;
                }
                catch (IOException)
                {
                    if (!FileExists(fileName)) //If the source file does not even exist, then it is not worth looping.
                        throw;

                    retriesLeft--;
                    if (retriesLeft == 0)
                        throw;

                    ThreadSleep(delayBetweenRetries);
                }
                catch (UnauthorizedAccessException)
                {
                    if (!FileExists(fileName)) //If the source file does not even exist, then it is not worth looping.
                        throw;

                    retriesLeft--;
                    if (retriesLeft == 0)
                        throw;

                    ThreadSleep(delayBetweenRetries);
                }
            }
            while (true); //Exit either by returning, or by throwing the exception that occured.
        }

        /// <summary>
        /// Deletes a file, using standard values for retries (100) and delayBetweenRetries(100)
        /// </summary>
        /// <param name="fileName"></param>
        [System.Diagnostics.DebuggerStepThrough]
        public void Delete(string fileName)
        {
            Delete(fileName, 100, 100);
        }

        #endregion

        #region SecureDelete

        private ISecureDeleteSupport secureDeleteSupport;
        private readonly object secureDeleteSupportSyncObj = new object();

        /// <summary>
        /// Get- and set property for the SecureDelete support object. Needed to create backend to the secure delete function.
        /// </summary>
        public ISecureDeleteSupport SecureDeleteSupport
        {
            get
            {
                lock (secureDeleteSupportSyncObj)
                {
                    return secureDeleteSupport;
                }
            }
            set
            {
                lock (secureDeleteSupportSyncObj)
                {
                    secureDeleteSupport = value;
                }
            }
        }

        /// <summary>
        /// Deletes a file securely.
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="sDeleteOK"></param>
        /// <param name="retries"></param>
        /// <param name="delayBetweenRetries"></param>
        public void SecureDelete(string fileName, out bool sDeleteOK, int retries, int delayBetweenRetries)
        {
            lock (secureDeleteSupportSyncObj)
            {
                if (secureDeleteSupport == null)
                    throw new NullReferenceException("The SecureDeleteSupport property is not assigned!");
                SecureDeleteSupport.SecureDelete(fileName, out sDeleteOK, retries, delayBetweenRetries);
            }
        }

        /// <summary>
        /// Deletes a file securely.
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="sDeleteOK"></param>
        public void SecureDelete(string fileName, out bool sDeleteOK)
        {
            SecureDelete(fileName, out sDeleteOK, 100, 100);
        }

        #endregion

        #region Copy

        /// <summary>
        /// Copy a file.
        /// </summary>
        /// <param name="sourceFileName"></param>
        /// <param name="destinationFileName"></param>
        /// <param name="overwrite"></param>
        public void Copy(string sourceFileName, string destinationFileName, bool overwrite)
        {
            Copy(sourceFileName, destinationFileName, overwrite, 100, 100);
        }

        /// <summary>
        /// Copies a file.
        /// </summary>
        /// <param name="sourceFileName"></param>
        /// <param name="destinationFileName"></param>
        /// <param name="overwrite"></param>
        /// <param name="retries"></param>
        /// <param name="delayBetweenRetries"></param>
        [System.Diagnostics.DebuggerStepThrough]
        public virtual void Copy(string sourceFileName, string destinationFileName, bool overwrite, int retries, int delayBetweenRetries)
        {
            if (retries <= 0)
                throw new ArgumentException("Number of retries must be positive non-zero", "retries");
            if (delayBetweenRetries < 0)
                throw new ArgumentException("Delay between retries must be equal to or greater than zero.");

            sourceFileName = Paths.Parse(sourceFileName);
            destinationFileName = Paths.Parse(destinationFileName);
            int retriesLeft = retries;
            do
            {
                try
                {
                    if (FileExists(destinationFileName))
                        FileDelete(destinationFileName);

                    FileCopy(sourceFileName, destinationFileName, overwrite);
                    return;
                }
                catch (IOException)
                {
                    if (!FileExists(sourceFileName)) //If the source file does not even exist, then it is not worth looping.
                        throw;

                    retriesLeft--;
                    if (retriesLeft == 0)
                        throw;

                    ThreadSleep(delayBetweenRetries);
                }
                catch (UnauthorizedAccessException)
                {
                    if (!FileExists(sourceFileName)) //If the source file does not even exist, then it is not worth looping.
                        throw;

                    retriesLeft--;
                    if (retriesLeft == 0)
                        throw;

                    ThreadSleep(delayBetweenRetries);
                }
            }
            while (true); //Exit either by returning, or by throwing the exception that occured.
        }

        #endregion

        #region LoadFromFile/SaveToFile

        /// <summary>
        /// Read the lines of a text file into a string.
        /// </summary>
        /// <param name="fileName">The path and file name.</param>
        public string LoadToString(string fileName)
        {
            return LoadToString(fileName, DefaultEncoding);
        }

        /// <summary>
        /// Read the lines of a text file into a string.
        /// </summary>
        /// <param name="fileName">The path and file name.</param>
        /// <param name="encoding">The encoding.</param>
        public virtual string LoadToString(string fileName, System.Text.Encoding encoding)
        {
            if (fileName == null)
                throw new ArgumentNullException("fileName");
            if (encoding == null)
                throw new ArgumentNullException("encoding");
            using (Stream stream = Open(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                using (StreamReader reader = new StreamReader(stream, encoding))
                {
                    return reader.ReadToEnd();
                }
            }
        }

        /// <summary>
        /// Read the lines of a text file into an array of strings.
        /// </summary>
        /// <param name="fileName">The path and file name.</param>
        public string[] LoadToStringArray(string fileName)
        {
            return LoadToStringArray(fileName, DefaultEncoding);
        }

        /// <summary>
        /// Read the lines of a text file into an array of strings.
        /// </summary>
        /// <param name="fileName">The path and file name.</param>
        /// <param name="encoding">The encoding.</param>
        public string[] LoadToStringArray(string fileName, System.Text.Encoding encoding)
        {
            return Regex.Split(LoadToString(fileName, encoding), "\r\n");
        }

        /// <summary>
        /// Saves a text string to a file.
        /// </summary>
        /// <param name="fileName">The path and file name.</param>
        /// <param name="text">The text to save.</param>
        public void SaveToFile(string fileName, string text)
        {
            SaveToFile(fileName, text, DefaultEncoding);
        }

        /// <summary>
        /// Saves a text string to a file.
        /// </summary>
        /// <param name="fileName">The path and file name.</param>
        /// <param name="lines">The lines to save.</param>
        public void SaveToFile(string fileName, string[] lines)
        {
            SaveToFile(fileName, lines, DefaultEncoding);
        }

        /// <summary>
        /// Saves a text string to a file.
        /// </summary>
        /// <param name="fileName">The path and file name.</param>
        /// <param name="text">The text to save.</param>
        /// <param name="encoding">The encoding.</param>
        public void SaveToFile(string fileName, string text, System.Text.Encoding encoding)
        {
            if (fileName == null)
                throw new ArgumentNullException("fileName");
            if (text == null)
                throw new ArgumentNullException("text");
            if (encoding == null)
                throw new ArgumentNullException("encoding");
            using (Stream stream = Open(fileName, FileMode.Create, FileAccess.Write, FileShare.None))
            {
                byte[] bytes = encoding.GetBytes(text);
                stream.Write(bytes, 0, bytes.Length);
            }
        }

        /// <summary>
        /// Saves a text string to a file.
        /// </summary>
        /// <param name="fileName">The path and file name.</param>
        /// <param name="lines">The lines to save.</param>
        /// <param name="encoding">The encoding.</param>
        public void SaveToFile(string fileName, string[] lines, System.Text.Encoding encoding)
        {
            SaveToFile(fileName, string.Join("\r\n", lines), encoding);
        }

        /// <summary>
        /// Loads the specified XML file into the XmlDocument.
        /// </summary>
        /// <param name="xmlDocument">The XmlDocument to load.</param>
        /// <param name="fileName">The path and file name.</param>
        public void LoadXml(XmlDocument xmlDocument, string fileName)
        {
            LoadXml(xmlDocument, fileName, DefaultEncoding);
        }

        /// <summary>
        /// Loads the specified XML file into the XmlDocument.
        /// </summary>
        /// <param name="xmlDocument">The XmlDocument to load.</param>
        /// <param name="fileName">The path and file name.</param>
        /// <param name="encoding">The encoding.</param>
        public void LoadXml(XmlDocument xmlDocument, string fileName, System.Text.Encoding encoding)
        {
            xmlDocument.LoadXml(LoadToString(fileName, encoding));
        }

        #endregion

        private IFileSupportExtension fileSupportExtension;
        private readonly object fileSupportExtensionSyncObj = new object();

        /// <summary>
        /// Gets or sets tha File support extension that can be different depending on the execution platform (WinCE or Win32)
        /// </summary>
        public IFileSupportExtension FileSupportExtension
        {
            get
            {
                lock (fileSupportExtensionSyncObj)
                {
                    return fileSupportExtension;
                }
            }
            set
            {
                lock (fileSupportExtensionSyncObj)
                {
                    fileSupportExtension = value;
                }
            }
        }

        /// <summary>
        /// Set creation time on a file.
        /// </summary>
        /// <param name="fileName"></param>
        public DateTime GetCreationTime(string fileName)
        {
            lock (fileSupportExtensionSyncObj)
            {
                if (fileSupportExtension == null)
                    throw new NullReferenceException("The FileSupportExtension property is not assigned!");
                return fileSupportExtension.GetCreationTime(fileName);
            }
        }

        /// <summary>
        /// Set creation time on a file.
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="dateTime"></param>
        public void SetCreationTime(string fileName, DateTime dateTime)
        {
            lock (fileSupportExtensionSyncObj)
            {
                if (fileSupportExtension == null)
                    throw new NullReferenceException("The FileSupportExtension property is not assigned!");
                fileSupportExtension.SetCreationTime(fileName, dateTime);
            }
        }

        /// <summary>
        /// Set last access time on a file.
        /// </summary>
        /// <param name="fileName"></param>
        public DateTime GetLastAccessTime(string fileName)
        {
            lock (fileSupportExtensionSyncObj)
            {
                if (fileSupportExtension == null)
                    throw new NullReferenceException("The FileSupportExtension property is not assigned!");
                return fileSupportExtension.GetLastAccessTime(fileName);
            }
        }

        /// <summary>
        /// Set last access time on a file.
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="dateTime"></param>
        public void SetLastAccessTime(string fileName, DateTime dateTime)
        {
            lock (fileSupportExtensionSyncObj)
            {
                if (fileSupportExtension == null)
                    throw new NullReferenceException("The FileSupportExtension property is not assigned!");
                fileSupportExtension.SetLastAccessTime(fileName, dateTime);
            }
        }

        /// <summary>
        /// Get last write time on the file.
        /// </summary>
        /// <param name="fileName"></param>
        public DateTime GetLastWriteTime(string fileName)
        {
            lock (fileSupportExtensionSyncObj)
            {
                if (fileSupportExtension == null)
                    throw new NullReferenceException("The FileSupportExtension property is not assigned!");
                return fileSupportExtension.GetLastWriteTime(fileName);
            }
        }

        /// <summary>
        /// Set last write time on the file.
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="dateTime"></param>
        public void SetLastWriteTime(string fileName, DateTime dateTime)
        {
            lock (fileSupportExtensionSyncObj)
            {
                if (fileSupportExtension == null)
                    throw new NullReferenceException("The FileSupportExtension property is not assigned!");
                fileSupportExtension.SetLastWriteTime(fileName, dateTime);
            }
        }

        /// <summary>
        /// Checks if the file exists
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        [System.Diagnostics.DebuggerStepThrough]
        public virtual bool FileExists(string fileName)
        {
            return File.Exists(Paths.Parse(fileName));
        }

        /// <summary>
        /// Deletes the file.
        /// </summary>
        /// <param name="fileName"></param>
        [System.Diagnostics.DebuggerStepThrough]
        protected virtual void FileDelete(string fileName)
        {
            File.Delete(fileName);
        }

        /// <summary>
        /// Opens a file.
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="fileMode"></param>
        /// <param name="fileAccess"></param>
        /// <param name="fileShare"></param>
        /// <returns></returns>
        [System.Diagnostics.DebuggerStepThrough]
        protected virtual Stream FileOpen(string fileName, FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
        {
            return File.Open(fileName, fileMode, fileAccess, fileShare);
        }

        /// <summary>
        /// Copies a file
        /// </summary>
        /// <param name="sourceFileName"></param>
        /// <param name="destinationFileName"></param>
        /// <param name="overwrite"></param>
        [System.Diagnostics.DebuggerStepThrough]
        protected virtual void FileCopy(string sourceFileName, string destinationFileName, bool overwrite)
        {
            File.Copy(sourceFileName, destinationFileName, overwrite);
        }

        /// <summary>
        /// Moves a file
        /// </summary>
        /// <param name="sourceFileName"></param>
        /// <param name="destinationFileName"></param>
        [System.Diagnostics.DebuggerStepThrough]
        protected virtual void FileMove(string sourceFileName, string destinationFileName)
        {
            File.Move(sourceFileName, destinationFileName);
        }

        /// <summary>
        /// Moves a directory
        /// </summary>
        /// <param name="sourceDirName"></param>
        /// <param name="destinationDirName"></param>
        [System.Diagnostics.DebuggerStepThrough]
        protected virtual void DirectoryMove(string sourceDirName, string destinationDirName)
        {
            Directory.Move(sourceDirName, destinationDirName);
        }

        /// <summary>
        /// Puts the thread in sleep mode.
        /// </summary>
        /// <param name="millisecondsTimeout"></param>
        [System.Diagnostics.DebuggerStepThrough]
        protected virtual void ThreadSleep(int millisecondsTimeout)
        {
            Thread.Sleep(millisecondsTimeout);
        }

        /// <summary>
        /// Copies the content of one directory into another.
        /// </summary>
        /// <param name="sourcePath"></param>
        /// <param name="destinationPath"></param>
        /// <param name="recurse"></param>
        public void CopyDirectory(string sourcePath, string destinationPath, bool recurse)
        {
            if (!DirectoryExists(sourcePath))
                throw new DirectoryNotFoundException(string.Format("Directory {0} does not exist", sourcePath));
            
            sourcePath = IO.Paths.Parse(sourcePath);
            destinationPath = IO.Paths.Parse(destinationPath);

            if (destinationPath[destinationPath.Length - 1] != Path.DirectorySeparatorChar)
                destinationPath += Path.DirectorySeparatorChar;

            if (sourcePath[sourcePath.Length - 1] != Path.DirectorySeparatorChar)
                sourcePath += Path.DirectorySeparatorChar;

            EnsureDirectoryExists(destinationPath);

            //Copy all the folders.
            string[] subDirectories = GetDirectories(sourcePath, true);

            foreach (var subDir in subDirectories)
            {
                string destinationFolder = SourceToDest(sourcePath, destinationPath, subDir);
                EnsureDirectoryExists(destinationFolder);
            }

            //Copy all the files.
            string[] files = GetFiles(sourcePath, "*.*", true);
            foreach (var file in files)
            {
                Copy(file, SourceToDest(sourcePath, destinationPath, file), true);
            }
        }

        private string SourceToDest(string sourcePath, string destinationPath, string sourceSubDir)
        {
            string replace = sourceSubDir.Replace(sourcePath, "");
            string result = Path.Combine(destinationPath, replace);
            return result;
        }


        /// <summary>
        /// Returns the names of files in the specified directory that match the specified search pattern.
        /// </summary>
        /// <param name="path">The directory to search.</param>
        /// <param name="searchPattern">The search string to match against the names of files in path. The parameter cannot end in two periods ("..") or contain two periods ("..") followed by System.IO.Path.DirectorySeparatorChar or System.IO.Path.AltDirectorySeparatorChar, nor can it contain any of the characters in System.IO.Path.InvalidPathChars.</param>
        /// <returns></returns>
        public string[] GetFiles(string path, string searchPattern)
        {
            return GetFiles(path, searchPattern, false);
        }

        /// <summary>
        /// Returns the names of files in the specified directory that match the specified search pattern.
        /// </summary>
        /// <param name="path">The directory to search.</param>
        /// <param name="searchPattern">The search string to match against the names of files in path. The parameter cannot end in two periods ("..") or contain two periods ("..") followed by System.IO.Path.DirectorySeparatorChar or System.IO.Path.AltDirectorySeparatorChar, nor can it contain any of the characters in System.IO.Path.InvalidPathChars.</param>
        /// <param name="recursive">Should the subdirectories be included in the search.</param>
        /// <returns></returns>
        public virtual string[] GetFiles(string path, string searchPattern, bool recursive)
        {
            List<string> files = new List<string>();
            files.AddRange(Directory.GetFiles(Paths.Parse(path), searchPattern));

            if (recursive)
            {
                foreach (string directory in GetDirectories(path))
                {
                    files.AddRange(GetFiles(directory, searchPattern, true));
                }
            }
            return files.ToArray();
        }

        /// <summary>
        /// Returns the names of subdirectories in the specified directory that match the specified search pattern.
        /// </summary>
        /// <param name="path">The directory to search.</param>
        /// <returns></returns>
        public virtual string[] GetDirectories(string path)
        {
            return Directory.GetDirectories(Paths.Parse(path));
        }

        /// <summary>
        /// Returns the subdirectories of the path
        /// </summary>
        /// <param name="path"></param>
        /// <param name="recursive">True if the method should get all subdirectories recursively.</param>
        /// <returns></returns>
        public string[] GetDirectories(string path, bool recursive)
        {
            if (!recursive) return GetDirectories(path);

            var stack = new Stack<string>();
            stack.Push(path);
            var dirsFound = new List<string>();

            while (stack.Any())
            {
                GetDirectories(stack.Pop()).ForEach(dir =>
                {
                    stack.Push(dir);
                    dirsFound.Add(dir);
                });
            }

            return dirsFound.ToArray();
        }

        /// <summary>
        /// Checks if directory exists
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public virtual bool DirectoryExists(string path)
        {
            return Directory.Exists(Paths.Parse(path));
        }

        /// <summary>
        /// Checks if the unresolved directory exits.
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        private bool UnresolvedDirectoryPathExists(string path)
        {
            return Directory.Exists(path);
        }

        /// <summary>
        /// Ensures the directory exists by trying to create it if it does not exist already.
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        [System.Diagnostics.DebuggerStepThrough]
        public virtual bool EnsureDirectoryExists(string path)
        {
            path = Paths.Parse(path);
            try
            {
                if (!Directory.Exists(path))
                    Directory.CreateDirectory(path);
            }
            catch { }
            return Directory.Exists(path);
        }

        /// <summary>
        /// OBSOLETE - Use EnsureDirectoryExists() instead.
        /// </summary>
        /// <param name="directoryName"></param>
        [System.Diagnostics.DebuggerStepThrough]
        [Obsolete("Use EnsureDirectoryExists() instead.")]
        public virtual void EnsureDirectoriesExists(string directoryName)
        {
            EnsureDirectoryExists(directoryName);
        }

        /// <summary>
        /// Removes a directory.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="onlyIfEmpty"></param>
        /// <returns></returns>
        public virtual bool RemoveDirectory(string path, bool onlyIfEmpty)
        {
            if (!Directory.Exists(path))
                return true;
            if (!onlyIfEmpty)
                Directory.Delete(path, true);
            else if ((GetFiles(path, "*.*").Length == 0) && (GetDirectories(path).Length == 0))
                Directory.Delete(path);
            return !Directory.Exists(path);
        }

        /// <summary>
        /// Checks if the filename is valid.
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns>True if the filename is valid otherwise false.</returns>
        public virtual bool IsValidFileName(string fileName)
        {
            return fileName != null && Regex.IsMatch(Paths.Parse(fileName), string.Format(@"^([^{0}]+[/\\])*[/\\]?[^{1}]+?$",
                Regex.Escape(new string(Path.GetInvalidPathChars())),
                Regex.Escape(new string(Path.GetInvalidPathChars()) + @":*?\/")));
        }

        /// <summary>
        /// Checks if the filepath is valid
        /// </summary>
        /// <param name="pathName"></param>
        /// <returns>True if the filepath is valid otherwise false.</returns>
        public virtual bool IsValidPathName(string pathName)
        {
            return pathName != null && Regex.IsMatch(Paths.Parse(pathName), string.Format(@"^[^{0}]*$",
                Regex.Escape(new string(Path.GetInvalidPathChars()))));
        }
    }
}