/// <summary>
        /// Get the files in the given Directory entry
        /// </summary>
        /// <param name="aDir">Must be a Directory</param>
        /// <returns></returns>
        public static FilesystemEntry[] GetFiles(FilesystemEntry aDir)
        {
            // Cosmos.Debug.Debugger.SendMessage("GetFiles(FileystemEntry)", aDir.Name);

            if (aDir == null)
            {
                throw new ArgumentNullException("aDir in GetFiles(FilesystemEntry)");
            }

            if (!aDir.IsDirectory)
            {
                throw new Exception("Must be a directory");
            }

            List <FilesystemEntry> xFiles = new List <FilesystemEntry>();

            foreach (FilesystemEntry xEntry in VFSManager.GetDirectoryListing(aDir))
            {
                // Cosmos.Debug.Debugger.SendMessage("GetFiles(FileystemEntry)", "Found " + xEntry.Name);
                if (!xEntry.IsDirectory)
                {
                    xFiles.Add(xEntry);
                }
            }

            return(xFiles.ToArray());
        }
        /// Retrieve multiple directories from the given directory.
        //public static FilesystemEntry[] GetDirectories(string aDir)
        //{
        //    // Cosmos.Debug.Debugger.SendMessage("GetDirectories", "Checking for nullreference");
        //    if (aDir == null)
        //    {
        //        throw new ArgumentNullException("aDir is null");
        //    }

        //    // Cosmos.Debug.Debugger.SendMessage("GetDirectories", "Checking if " + aDir + " exists");
        //    //if (!Directory.Exists(aDir))
        //    //{
        //    //    throw new DirectoryNotFoundException("Unable to find directory " + aDir);
        //    //}

        //    // Cosmos.Debug.Debugger.SendMessage("GetDirectories", "About to GetDirectoryListing");

        //    var xDir = VFSManager.GetDirectoryEntry(Path.GetDirectoryName(aDir));
        //    ///// Cosmos.Debug.Debugger.SendMessage("GetDirectories", xDir.Name + " with ID " + xDir.Id.ToString());
        //    var xEntries = VFSManager.GetDirectoryListing(xDir);
        //    //var xEntries = VFSManager.GetDirectoryListing(Path.GetDirectoryName(aDir));
        //    //List<FilesystemEntry> xDirectories = new List<FilesystemEntry>();
        //    //for (int i = 0; i < xEntries.Length; i++)
        //    //{
        //    //    if (xEntries[i].IsDirectory)
        //    //    {
        //    //        xDirectories.Add(xEntries[0]);
        //    //    }
        //    //}

        //    ////foreach (FilesystemEntry entry in xEntries)
        //    ////    if (entry.IsDirectory)
        //    ////        xDirectories.Add(entry);


        //    ////return (from xEntry in GetDirectoryListing(aDir) where xEntry.IsDirectory select xEntry).ToArray();
        //    //// Cosmos.Debug.Debugger.SendMessage("GetDirectories", "Returning");
        //    //return xDirectories.ToArray();
        //    return new FilesystemEntry[0];
        //}


        /// <summary>
        /// Retrieve a specific file with the given path.
        /// </summary>
        /// <param name="aFile"></param>
        /// <returns></returns>
        public static FilesystemEntry GetFileEntry(String aFile)
        {
            // Cosmos.Debug.Debugger.SendMessage("GetFileEntry", "Searching for file " + aFile);
            string xFileName = Path.GetFileName(aFile);
            // Cosmos.Debug.Debugger.SendMessage("GetFileEntry", "Filename is " + xFileName);

            //Find the directory first.
            var xDirectory = VFSManager.GetDirectoryEntry(Path.GetDirectoryName(aFile) + Path.DirectorySeparatorChar);

            // Cosmos.Debug.Debugger.SendMessage("GetFileEntry", "Directory is " + xDirectory.Name);

            //Then find file in that directory
            //var xFS = GetFileSystemFromPath(aFile, 1);
            //// Cosmos.Debug.Debugger.SendMessage("GetFileEntry", "Got filesystem");

            //FilesystemEntry[] xEntries = xFS.GetDirectoryListing(xDirectory.Id);
            //// Cosmos.Debug.Debugger.SendMessage("GetFileEntry", "Got Directory Listing");

            FilesystemEntry[] xEntries = VFSManager.GetDirectoryListing(xDirectory);
            // Cosmos.Debug.Debugger.SendMessage("GetFileEntry", "Found " + xEntries.Length + " entries");

            foreach (FilesystemEntry xEntry in xEntries)
            {
                // Cosmos.Debug.Debugger.SendMessage("GetFileEntry", "Matching " + xEntry.Name + " with " + xFileName);
                if (xEntry.Name.Equals(xFileName))
                {
                    return(xEntry);
                }
            }

            //throw new FileNotFoundException();
            // Cosmos.Debug.Debugger.SendMessage("GetFileEntry", "File not found: " + aFile);
            return(null);
        }
        /// <summary>
        /// Get all the files in the given directory.
        /// </summary>
        /// <param name="aDir"></param>
        /// <returns></returns>
        public static FilesystemEntry[] GetFiles(string aDir)
        {
            if (aDir == null)
            {
                throw new ArgumentNullException("aDir is null");
            }

            //var xDirectory = VFSManager.GetDirectoryEntry(Path.GetDirectoryName(aDir));
            //// Cosmos.Debug.Debugger.SendMessage("GetFiles", "Directory found");
            ////var xFS = xDirectory.Filesystem;
            //var xFS = GetFileSystemFromPath(Path.GetDirectoryName(aDir), 1);
            //// Cosmos.Debug.Debugger.SendMessage("GetFiles", "Filesystem set");

            //List<FilesystemEntry> xFiles = new List<FilesystemEntry>();
            //// Cosmos.Debug.Debugger.SendMessage("GetFiles", "Going to search directory with ID " + xDirectory.Id);
            //var xEntries = xFS.GetDirectoryListing(xDirectory.Id);
            //foreach (FilesystemEntry xEntry in xEntries)
            //{
            //    // Cosmos.Debug.Debugger.SendMessage("GetFiles", "Foreach");
            //    if (!xEntry.IsDirectory)
            //        xFiles.Add(xEntry);
            //}

            //// Cosmos.Debug.Debugger.SendMessage("GetFiles", "Converting to array");
            //return xFiles.ToArray();


            //if (!Directory.Exists(aDir))
            //    throw new DirectoryNotFoundException("Unable to find directory " + aDir);

            List <FilesystemEntry> xFiles = new List <FilesystemEntry>();
            var xDirName = Path.GetDirectoryName(aDir);
            var xEntries = VFSManager.GetDirectoryListing(xDirName);

            for (int i = 0; i < xEntries.Length; i++)
            {
                var entry = xEntries[i];
                if (!entry.IsDirectory)
                {
                    xFiles.Add(entry);
                }
            }

            return(xFiles.ToArray());

            //return (from xEntry in GetDirectoryListing(aDir) where !xEntry.IsDirectory select xEntry).ToArray();
        }
        //Mimics the behaviour of System.IO.Directory.InternalGetFileDirectoryNames
        public static string[] InternalGetFileDirectoryNames(string path, string userPathOriginal, string searchPattern, bool includeFiles, bool includeDirs, SearchOption searchOption)
        {
            //TODO: Add SearchOption functionality
            //TODO: What is userPathOriginal?
            //TODO: Add SearchPattern functionality

            List <string> xFileAndDirectoryNames = new List <string>();

            //Validate input arguments
            if ((searchOption != SearchOption.TopDirectoryOnly) && (searchOption != SearchOption.AllDirectories))
            {
                throw new ArgumentOutOfRangeException("searchOption");
            }

            searchPattern = searchPattern.TrimEnd(new char[0]);
            if (searchPattern.Length == 0)
            {
                return(new string[0]);
            }

            //Perform search in filesystem
            FilesystemEntry[] xEntries = VFSManager.GetDirectoryListing(path);

            foreach (FilesystemEntry xEntry in xEntries)
            {
                if (xEntry.IsDirectory && includeDirs)
                {
                    xFileAndDirectoryNames.Add(xEntry.Name);
                }
                else if (!xEntry.IsDirectory && includeFiles)
                {
                    xFileAndDirectoryNames.Add(xEntry.Name);
                }
            }

            return(xFileAndDirectoryNames.ToArray());
        }