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

namespace Ubisoft
{
    /// <summary>
    /// Class responsible for implementing System.IO related extensions
    /// </summary>
    public class HtSystemIO
    {
        public static string NormalizePath(string path)
        {
            return path.Replace('\\', '/');
        }

        public static bool File_Exists(string path)
        {
            return !string.IsNullOrEmpty(path) && File.Exists(path);
        }

        public static bool Directory_Exists(string path)
        {
            return !string.IsNullOrEmpty(path) && Directory.Exists(path);
        }

        public static int Directory_FileCount(string path)
        {
            string[] paths = Directory.GetFiles(path);
            return paths.Length;
        }

        /// <summary>
        /// Create the directory passed in, if it doesn't exist, along with all intermediate directories.
        /// </summary>
        /// <param name="path">Path to a directory to create if it doesn't already exist.</param>
        public static void CreateDirectory(string path)
        {
            if (!Directory_Exists(path))
            {
                path = NormalizePath(path);
                string[] tokens = path.Split('/');

                string partialPath = "";
                int count = tokens.Length;
                for (int i = 0; i < count; ++i)
                {
                    if (i > 0)
                    {
                        partialPath = Path.Combine(partialPath, tokens[i]);
                    }
                    else
                    {
                        partialPath = tokens[i];
                    }

                    if (!Directory_Exists(partialPath))
                    {
                        Directory.CreateDirectory(partialPath);
                    }
                }
            }
        }

        /// <summary>
        /// Copies the directory at <c>fullSrcPath</c> to <c>fullDstPath</c>. fullDstPath directory is created
        /// </summary>
        /// <param name="fullSrcPath">Full source path of the directory to copy</param>
        /// <param name="fullDstPath">Full destination path where the <c>fullSrcPath</c> will be copied to</param>
        public static void CopyDirectory(string fullSrcPath, string fullDstPath)
        {
            CopyDirectory(new DirectoryInfo(fullSrcPath), new DirectoryInfo(fullDstPath));
        }

        /// <summary>
        /// Copies the directory <c>sr</c> to <c>dst</c>. dst directory is created
        /// </summary>
        /// <param name="src"><c>DirectoryInfo</c> the directory to copy</param>
        /// <param name="dst"><c>DirectoryInfo</c> where the <c>src</c> will be copied to</param>
        public static void CopyDirectory(DirectoryInfo src, DirectoryInfo dst)
        {
            _ = Directory.CreateDirectory(dst.FullName);

            // Copy each file into the new directory.
            foreach (FileInfo fi in src.GetFiles())
            {
                _ = fi.CopyTo(Path.Combine(dst.FullName, fi.Name), true);
            }

            // Copy each subdirectory using recursion.
            foreach (DirectoryInfo diSourceSubDir in src.GetDirectories())
            {
                DirectoryInfo nextTargetSubDir = dst.CreateSubdirectory(diSourceSubDir.Name);
                CopyDirectory(diSourceSubDir, nextTargetSubDir);
            }
        }

        /// <summary>
        /// Copies a file at <c>fullSrcPath</c> to <c>fullDstPath</c> creating all inexistent folders in <c>fullDstPath</c>.
        /// </summary>
        /// <param name="fullSrcPath">Full source path of the file to copy</param>
        /// <param name="fullDstPath">Full destination path where the  file at <c>fullSrcPath</c> will be copied to</param>
        public static void CopyFile(string fullSrcPath, string fullDstPath)
        {
            if (File_Exists(fullSrcPath))
            {
                // Create dst folder if it doesn't exist
                FileInfo fileInfo = new FileInfo(fullDstPath);
                fileInfo.Directory.Create();

                File.Copy((fullSrcPath), fullDstPath);
            }
        }

        // <summary>
        /// Recursive find all files starting at root directory at path <paramref name="fullPath"/>
        /// and return a list of full paths to those files.
        /// </summary>
        /// <param name="fullPath">Full path to the root directory< which files are requested/param>
        /// <param name="includeDirectories">Whether or not directories should be included in the returned value </param>
        /// <returns>A list of full paths to the files found</returns>
        public static IEnumerable<string> GetAllFiles(string fullPath, bool includeDirectories = true)
        {
            List<string> filePaths = new List<string>();
            if (Directory.Exists(fullPath))
            {
                filePaths.AddRange(Directory.GetFiles(
                    fullPath,
                    "*",
                    SearchOption.AllDirectories));

                if (includeDirectories)
                {
                    filePaths.AddRange(Directory.GetDirectories(
                        fullPath,
                        "*",
                        SearchOption.AllDirectories));
                }
            }

            return filePaths.Distinct().OrderBy(x =>
            {
                return x;
            });
        }

        /// <summary>
        /// Returns the part of <c>path</c> that goes after <c>directory</c>.
        /// Example:
        /// GetPathFromDirectory("dir_01/dir_02/dir_03/filename, "dir_02", true) returns dir_02/dir_03/filename
        /// GetPathFromDirectory("dir_01/dir_02/dir_03/filename, "dir_02", false) returns dir_03/filename
        /// GetPathFromDirectory("dir_01/dir_02/dir_03/filename, "dir_xx", false) returns null
        /// </summary>
        /// <param name="path">Source path</param>
        /// <param name="directory">Directory to search for</param>
        /// <param name="includeDirectory">Whether or not <c>directory</c> should be part of the returned value</param>
        /// <returns>Returns the part of <c>path</c> that goes after <c>directory</c>. It returns null if path doesn't contain <c>directory</c></returns>
        public static string GetPathFromDirectory(string path, string directory, bool includeDirectory)
        {
            string returnValue = null;

            if (!string.IsNullOrEmpty(path) && !string.IsNullOrEmpty(directory))
            {
                returnValue = "";

                bool addDirectory = false;
                string[] tokens = path.Split(Path.DirectorySeparatorChar);
                int count = tokens.Length;
                for (int i = 0; i < count; i++)
                {
                    if (includeDirectory && tokens[i] == directory)
                    {
                        addDirectory = true;
                    }

                    if (addDirectory)
                    {
                        returnValue = Path.Combine(returnValue, tokens[i]);
                    }

                    if (tokens[i] == directory)
                    {
                        addDirectory = true;
                    }
                }
            }

            return returnValue;
        }

        /// <summary>
        /// Returns the last entry of a path
        /// Example:
        /// GetPathLastEntry("dir_01/dir_02/filename") returns "fileName"
        /// GetPathLastEntry("dir_01/dir_02") returns "dir_02"
        /// GetPathLastEntry("") returns ""
        /// </summary>
        /// <param name="path">Source path</param>
        /// <returns>Returns the last entry of a path</returns>
        public static string GetPathLastEntry(string path)
        {
            string originalPath = path;
            path = NormalizePath(path);
            return string.IsNullOrEmpty(path) ? path : path.Split('/').Last();
        }
    }
}