using System;
using System.Collections.Generic;
using System.Text;

namespace UniversalEditor.ObjectModels.FileSystem
{
	public class FileSystemObjectModel : ObjectModel
	{
		private ObjectModelReference _omr = null;
		public override ObjectModelReference MakeReference()
		{
			if (_omr == null)
			{
				_omr = new ObjectModelReference(GetType(), new Guid("{A23026E9-DFE1-4090-AF35-8B916D3F1FCD}"));
				_omr.Title = "File system/archive";
				_omr.Path = new string[] { "General", "File system/archive" };
			}
			return _omr;
		}
		public override void Clear()
		{
            mvarFiles.Clear();
            mvarFolders.Clear();
            mvarID = Guid.Empty;
            mvarTitle = String.Empty;
            mvarPathSeparators = new string[] { System.IO.Path.DirectorySeparatorChar.ToString(), System.IO.Path.AltDirectorySeparatorChar.ToString() };
		}
		public override void CopyTo(ObjectModel where)
		{
			FileSystemObjectModel clone = (where as FileSystemObjectModel);
			clone.ID = mvarID;
			for (int i = 0; i < mvarFiles.Count; i++)
			{
                File file = mvarFiles[i];
				clone.Files.Add(file.Clone() as File);
			}
			for (int i = 0; i < mvarFolders.Count; i++)
			{
                Folder folder = mvarFolders[i];
				clone.Folders.Add(folder.Clone() as Folder);
			}
		}

		public static FileSystemObjectModel FromFiles(string[] fileNames)
		{
			FileSystemObjectModel fsom = new FileSystemObjectModel();

			foreach (string fileName in fileNames)
			{
				FileSystemObjectModel fsom1 = UniversalEditor.Common.Reflection.GetAvailableObjectModel<FileSystemObjectModel>(fileName);
				if (fsom1 == null) continue;

				fsom1.CopyTo(fsom);
			}
			return fsom;
		}
		public static FileSystemObjectModel FromDirectory(string path, string searchPattern = "*.*", System.IO.SearchOption searchOption = System.IO.SearchOption.TopDirectoryOnly)
		{
			string[] files = System.IO.Directory.GetFiles(path, searchPattern, searchOption);
			return FromFiles(files);
		}

		private File.FileCollection mvarFiles = new File.FileCollection();
		public File.FileCollection Files { get { return mvarFiles; } }
		private Folder.FolderCollection mvarFolders = new Folder.FolderCollection();
		public Folder.FolderCollection Folders { get { return mvarFolders; } }

		private Guid mvarID = Guid.Empty;
		/// <summary>
		/// The unique ID associated with this file system. Not supported by all data formats.
		/// </summary>
		public Guid ID { get { return mvarID; } set { mvarID = value; } }

		private string mvarTitle = String.Empty;
		/// <summary>
		/// The title associated with this file system.  Not supported by all data formats.
		/// </summary>
		public string Title { get { return mvarTitle; } set { mvarTitle = value; } }

        private string[] mvarPathSeparators = new string[] { System.IO.Path.DirectorySeparatorChar.ToString(), System.IO.Path.AltDirectorySeparatorChar.ToString() };
        public string[] PathSeparators { get { return mvarPathSeparators; } set { mvarPathSeparators = value; } }

		public bool ContainsFile(string path)
		{
			return (FindFile(path) != null);
		}

		public File FindFile(string path)
		{
			string[] pathParts = path.Split(new char[] { System.IO.Path.DirectorySeparatorChar, System.IO.Path.AltDirectorySeparatorChar });
			if (pathParts.Length == 1)
			{
				File file = mvarFiles[pathParts[0]];
				if (file != null) return file;
			}
			else
			{
				Folder parentFolder = mvarFolders[pathParts[0]];
				if (parentFolder == null) return null;

				for (int i = 1; i < pathParts.Length; i++)
				{
					if (i < pathParts.Length - 1)
					{
						parentFolder = parentFolder.Folders[pathParts[i]];
						if (parentFolder == null) return null;
					}
					else
					{
						return parentFolder.Files[pathParts[i]];
					}
				}
			}
			return null;
		}

        public Folder FindFolder(string name)
        {
            string[] path = name.Split(new char[] { '/' });
            Folder parent = null;
            for (int i = 0; i < path.Length - 1; i++)
            {
                if (parent == null)
                {
                    parent = mvarFolders[path[i]];
                }
                else
                {
                    parent = parent.Folders[path[i]];
                }
            }

            if (parent == null)
            {
                return mvarFolders[path[path.Length - 1]];
            }
            else
            {
                return parent.Folders[path[path.Length - 1]];
            }
        }

        public object FindObject(string name)
        {
            string[] path = name.Split(new char[] { '/' });
            Folder parent = null;
            for (int i = 0; i < path.Length - 1; i++)
            {
                if (parent == null)
                {
                    parent = mvarFolders[path[i]];
                }
                else
                {
                    parent = parent.Folders[path[i]];
                }
            }

            if (parent == null)
            {
                File file = mvarFiles[path[path.Length - 1]];
                Folder folder = mvarFolders[path[path.Length - 1]];
                if (folder == null) return file;
                return folder;
            }
            else
            {
                File file = parent.Files[path[path.Length - 1]];
                Folder folder = parent.Folders[path[path.Length - 1]];
                if (folder == null) return file;
                return folder;
            }
        }

        public Folder AddFolder(string name)
        {
            string[] path = name.Split(mvarPathSeparators, StringSplitOptions.None);
            Folder parent = null;
            for (int i = 0; i < path.Length - 1; i++)
            {
                if (parent == null)
                {
                    parent = mvarFolders[path[i]];
                }
                else
                {
                    parent = parent.Folders[path[i]];
                }
                if (parent == null) throw new System.IO.DirectoryNotFoundException();
            }
            if (parent == null)
            {
                return mvarFolders.Add(path[path.Length - 1]);
            }
            return parent.Folders.Add(path[path.Length - 1]);
        }

        public File AddFile(string name)
        {
            string[] path = name.Split(mvarPathSeparators, StringSplitOptions.None);
            Folder parent = null;
            for (int i = 0; i < path.Length - 1; i++)
            {
                if (parent == null)
                {
                    if (mvarFolders.Contains(path[i]))
                    {
                        parent = mvarFolders[path[i]];
                    }
                    else
                    {
                        parent = mvarFolders.Add(path[i]);
                    }
                }
                else
                {
                    if (parent.Folders.Contains(path[i]))
                    {
                        parent = parent.Folders[path[i]];
                    }
                    else
                    {
                        parent = parent.Folders.Add(path[i]);
                    }
                }

                if (parent == null)
                {
                    throw new System.IO.DirectoryNotFoundException();
                }
            }

            if (parent == null)
            {
                File file = new File();
                file.Name = path[path.Length - 1];
                mvarFiles.Add(file);
                return file;
            }
            else
            {
                File file = new File();
                file.Name = path[path.Length - 1];
                parent.Files.Add(file);
                return file;
            }
        }

		/// <summary>
		/// Gets all files in all folders of the <see cref="FileSystemObjectModel" /> with file names that
		/// match the <see cref="searchPattern"/>, and assigns the file names separated by the
		/// <see cref="pathSeparator"/>.
		/// </summary>
		/// <param name="searchPattern">The string by which to filter the retrieved file names.</param>
		/// <param name="pathSeparator">The string by which to separate directory and file names.</param>
		/// <returns></returns>
		public File[] GetFiles(string searchPattern = null, string pathSeparator = null)
		{
			if (pathSeparator == null) pathSeparator = "/";

			List<File> files = new List<File>();
			for (int i = 0; i < mvarFiles.Count; i++)
			{
				File file = mvarFiles[i];
				if (searchPattern != null && !file.Name.Match(searchPattern)) continue;

				files.Add(file);
			}
			for (int i = 0; i < mvarFolders.Count; i++)
			{
				Folder folder = mvarFolders[i];
				GetAllFilesRecursively(folder, ref files, folder.Name, pathSeparator, searchPattern);
			}
			return files.ToArray();
		}

        /// <summary>
        /// Gets all files in all folders of the <see cref="FileSystemObjectModel" />, and assigns the file names
        /// separated by the default path separator.
        /// </summary>
        /// <returns></returns>
        public File[] GetAllFiles(string pathSeparator = null)
        {
            if (pathSeparator == null) pathSeparator = "/";

            List<File> files = new List<File>();
            for (int i = 0; i < mvarFiles.Count; i++)
            {
                File file = mvarFiles[i];
                files.Add(file);
            }
            for (int i = 0; i < mvarFolders.Count; i++ )
            {
                Folder folder = mvarFolders[i];
                GetAllFilesRecursively(folder, ref files, folder.Name, pathSeparator);
            }
            return files.ToArray();
        }

        private void GetAllFilesRecursively(Folder folder, ref List<File> files, string parentPath, string pathSeparator, string searchPattern = null)
        {
            for (int i = 0; i < folder.Files.Count; i++)
            {
                File file = folder.Files[i];
				if (searchPattern != null && !file.Name.Match(searchPattern)) continue;

                File file2 = (file.Clone() as File);
                file2.Name = parentPath + pathSeparator + file.Name;
                files.Add(file2);
            }
            for (int i = 0; i < folder.Folders.Count; i++)
            {
                Folder folder1 = folder.Folders[i];
                GetAllFilesRecursively(folder1, ref files, parentPath + pathSeparator + folder1.Name, pathSeparator, searchPattern);
            }
        }
	}
}