using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace Chernobyl
{
    /// <summary>
    /// The default implementation of the ISearchPaths interface. Used to hold
    /// several file/folder paths for so that other systems can search these
    /// paths for files, folders, etc. This class will automatically convert all
    /// '\' to '/' for cross platform purposes.
    /// </summary>
    public class SearchPaths : ISearchPaths
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        public SearchPaths() : this(false)
        {
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="addWorkingDirectory">True if the current working
        /// directory should be added to the search path list.</param>
        public SearchPaths(bool addWorkingDirectory)
        {
            Paths = new List<string>();

            if(addWorkingDirectory == true)
                Add(Directory.GetCurrentDirectory());
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="paths">The paths to add to the internal
        /// list of search paths.</param>
        public SearchPaths(params string[] paths)
        {
            Paths = new List<string>();
            foreach (string str in paths)
                Add(str);
        }

        /// <summary>
        /// Adds a search path to the search path list.
        /// </summary>
        /// <param name="searchPath">The search path to add to the
        /// list of search paths.</param>
        public void Add(string searchPath)
        {
            searchPath.Replace('\\', '/');
            Paths.Add(searchPath);
        }

        /// <summary>
        /// Clears out the collection of search paths.
        /// </summary>
        public void Clear()
        {
            Paths.Clear();
        }

        /// <summary>
        /// Checks if a search path is contained within
        /// this collection
        /// </summary>
        /// <param name="item">The search path to check for.</param>
        /// <returns>True if the search path is contained within
        /// this collection.</returns>
        public bool Contains(string item)
        {
            return Paths.Contains(item);
        }

        /// <summary>
        /// Copies the array of search paths to this collection
        /// starting at <paramref name="arrayIndex"/>.
        /// </summary>
        /// <param name="array">The array to copy over.</param>
        /// <param name="arrayIndex">The index to start at</param>
        public void CopyTo(string[] array, int arrayIndex)
        {
            Paths.CopyTo(array, arrayIndex);
        }

        /// <summary>
        /// The number of search paths contained within this collection.
        /// </summary>
        public int Count
        {
            get { return Paths.Count; }
        }

        /// <summary>
        /// True if this collection is read only, false if otherwise.
        /// </summary>
        public bool IsReadOnly
        {
            get { return false; }
        }

        /// <summary>
        /// Removes a search path from this collection.
        /// </summary>
        /// <param name="item">The search path to remove.</param>
        /// <returns>True if the search path was removed, false
        /// if otherwise.</returns>
        public bool Remove(string item)
        {
            return Paths.Remove(item);
        }

        /// <summary>
        /// Returns an enumerator to the paths.
        /// </summary>
        /// <returns>The enumerator to the paths.</returns>
        public IEnumerator<string> GetEnumerator()
        {
            return Paths.GetEnumerator();
        }

        /// <summary>
        /// Returns an enumerator to the paths.
        /// </summary>
        /// <returns>The enumerator to the paths.</returns>
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return Paths.GetEnumerator();
        }

        /// <summary>
        /// Searches the search paths for a file that matches the search pattern
        /// and returns a FileStream (for reading only) to that file or null if
        /// no file could be found. Only the first file found is returned. This
        /// method does not search subdirectories.
        /// </summary>
        /// <param name="searchPattern">The pattern to look for when searching
        /// for the file. See the search pattern parameter on
        /// <see cref="Directory.GetFiles(string)"/> for more information on
        /// this parameter</param>
        /// <param name="fileMode">Specifies how the file should be opened.</param>
        /// <returns>The FileStream to the found file or null if no file could
        /// be found.</returns>
        public FileStream Find(string searchPattern, FileMode fileMode)
        {
            return Find(searchPattern, SearchOption.TopDirectoryOnly, fileMode);
        }

        /// <summary>
        /// Searches the search paths for a file that matches the search pattern
        /// and returns a FileStream (for reading only) to that file or null if
        /// no file could be found.
        /// </summary>
        /// <param name="searchPattern">The pattern to look for when searching
        /// for the file. See the search pattern parameter on
        /// <see cref="Directory.GetFiles(string)"/> for more information on
        /// this parameter</param>
        /// <param name="searchOptions">Specifies how each of the search paths
        /// should be searched. See the searchOptions parameter on
        /// <see cref="Directory.GetFiles(string)"/> for more information.</param>
        /// <param name="fileMode">Specifies how the file should be opened.</param>
        /// <returns>The FileStream to the found file or null if no file could
        /// be found.</returns>
        public FileStream Find(string searchPattern, SearchOption searchOptions, FileMode fileMode)
        {
            return Find(searchPattern, searchOptions, fileMode, FileAccess.Read);
        }

        /// <summary>
        /// Searches the search paths for a file that matches the search pattern
        /// and returns a FileStream to that file or null if no file could be
        /// found.
        /// </summary>
        /// <param name="searchPattern">The pattern to look for when searching
        /// for the file. See the search pattern parameter on
        /// <see cref="Directory.GetFiles(string)"/> for more information on
        /// this parameter</param>
        /// <param name="searchOptions">Specifies how each of the search paths
        /// should be searched. See the searchOptions parameter on
        /// <see cref="Directory.GetFiles(string)"/> for more information.</param>
        /// <param name="fileMode">Specifies how the file should be opened.</param>
        /// <param name="fileAccess">Specifies what operations you want to do on
        /// the file.</param>
        /// <returns>The FileStream to the found file or null if no file could
        /// be found.</returns>
        public FileStream Find(string searchPattern, SearchOption searchOptions, FileMode fileMode, FileAccess fileAccess)
        {
            FileStream foundFile = null;

            List<string>.Enumerator enumer = Paths.GetEnumerator();
            while (enumer.MoveNext() && foundFile == null)
            {
                string[] files = Directory.GetFiles(enumer.Current, searchPattern, searchOptions);

                if (files.Length != 0)
                    foundFile = new FileStream(files[0], fileMode, fileAccess);
            }

            return foundFile;
        }

        /// <summary>
        /// Returns the first path to the file specified.
        /// </summary>
        /// <param name="file">The name of the file to look for.</param>
        /// <returns>The path to the file specified.</returns>
        public string FindFilePath(string file)
        {
            return FilePaths(file).First();
        }

        /// <summary>
        /// Returns an enumerator of file paths that are contained
        /// in this SearchPath. Only paths to files that actually
        /// exist are returned.
        /// </summary>
        /// <param name="filepathAppendage">A string that should be
        /// appended to the end of the contained file paths before they
        /// are searched for existence.</param>
        /// <returns>An enumerator of paths to files that exist.</returns>
        public IEnumerable<string> FilePaths(string filepathAppendage)
        {
            string fullpath = "";
            foreach (string path in Paths)
            {
                fullpath = Path.Combine(path, filepathAppendage);
                if (File.Exists(fullpath) == true)
                    yield return fullpath;
            }
        }

        /// <summary>
        /// Returns an enumerator of file paths that are contained
        /// in this SearchPath. Only paths to files that actually
        /// exist are returned.
        /// </summary>
        /// <returns>An enumerator of paths to files that exist.</returns>
        public IEnumerable<string> FilePaths()
        {
            return FilePaths("");
        }

        /// <summary>
        /// Returns an enumerator of folder paths that are contained
        /// in this SearchPath. Only paths to folders that actually
        /// exist are returned.
        /// </summary>
        /// <param name="directorypathAppendage">A string that should be
        /// appended to the end of the contained folder paths before they
        /// are searched for existence.</param>
        /// <returns>An enumerator of paths to folders that exist.</returns>
        public IEnumerable<string> DirectoryPaths(string directorypathAppendage)
        {
            string fullpath = "";
            foreach (string path in Paths)
            {
                fullpath = Path.Combine(path, directorypathAppendage);
                if (Directory.Exists(fullpath) == true)
                    yield return fullpath;
            }
        }

        /// <summary>
        /// Returns an enumerator of folder paths that are contained
        /// in this SearchPath. Only paths to folders that actually
        /// exist are returned.
        /// </summary>
        /// <returns>An enumerator of paths to folders that exist.</returns>
        public IEnumerable<string> DirectoryPaths()
        {
            return DirectoryPaths("");
        }

        /// <summary>
        /// Returns an enumeration of FileStreams created
        /// from search paths in this class. Any FileStreams
        /// to files which do not exist will not be returned.
        /// </summary>
        /// <param name="filepathAppendage">A string that should be appended
        /// to the front of each of the SearchPaths before they are checked for
        /// existence or created.</param>
        /// <param name="fileMode">The FileMode to open the files with.</param>
        /// <returns>An enumeration of FileStreams which point to the files
        /// pointed to by the search paths.</returns>
        public IEnumerable<FileStream> Files(FileMode fileMode, string filepathAppendage)
        {
            string fullPath = "";
            foreach (string path in Paths)
            {
                fullPath = Path.Combine(path, filepathAppendage);
                if (File.Exists(fullPath))
                    yield return new FileStream(fullPath, fileMode);
            }
        }

        /// <summary>
        /// Returns an enumeration of FileStreams created
        /// from search paths in this class. Any FileStreams
        /// to files which do not exist will not be returned.
        /// </summary>
        /// <param name="fileMode">The FileMode to open the files with.</param>
        /// <returns>An enumeration of FileStreams which point to the files
        /// pointed to by the search paths.</returns>
        public IEnumerable<FileStream> Files(FileMode fileMode)
        {
            return Files(fileMode, "");
        }

        /// <summary>
        /// The collection of search paths.
        /// </summary>
        protected List<string> Paths { get; set; }
    }
}