using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.AccessControl;
using System.Text;
using System.Threading.Tasks;

namespace RandomFileRunner.IO
{
    public class SmartFileSystem
    {

        public static List<string> GetFiles(string path, string pattern)
        {
            List<string> fileList = new List<string>();
            List<string> directoryList = new List<string>();

            directoryList.Add(path);

            while (true)
            {
                if (directoryList.Count <= 0)
                {
                    break;
                }

                string directory = directoryList.First();
                directoryList.RemoveAt(0);

                if (IsDirectoryAccessible(directory))
                {
                    IEnumerable<string> searchDirList = new List<string>();

                    try
                    {
                        searchDirList = Directory.EnumerateDirectories(directory, "*", SearchOption.TopDirectoryOnly);
                    }
                    catch (Exception)
                    {
                        continue;
                    }

                    foreach (string item in searchDirList)
                    {
                        if (!IsDirectoryAccessible(item))
                        {
                            continue;
                        }

                        directoryList.Add(item);
                    }

                    foreach (string item in Directory.EnumerateFiles(directory, pattern, SearchOption.TopDirectoryOnly))
                    {
                        if (!IsFileAccessible(item))
                        {
                            continue;
                        }

                        fileList.Add(item);
                    }
                }
            }

            return fileList;
        }

        public static void GetFiles(string path, string pattern, Func<string, ulong, int, bool> callback)
        {
            List<string> directoryList = new List<string>();
            ulong searchCount = 0;

            if (string.IsNullOrWhiteSpace(pattern)) pattern = "*";

            directoryList.Add(path);
            searchCount++;

            while (true)
            {
                if (directoryList.Count <= 0)
                {
                    break;
                }

                string directory = directoryList.First();
                directoryList.RemoveAt(0);

                callback(null, searchCount, directoryList.Count);

                if (IsDirectoryAccessible(directory))
                {
                    IEnumerable<string> searchDirList = new List<string>();

                    try
                    {
                        searchDirList = Directory.EnumerateDirectories(directory, "*", SearchOption.TopDirectoryOnly);
                    }
                    catch (Exception)
                    {
                        continue;
                    }

                    foreach (string item in searchDirList)
                    {
                        if (!IsDirectoryAccessible(item))
                        {
                            continue;
                        }

                        directoryList.Add(item);
                        searchCount++;

                        callback(null, searchCount, directoryList.Count);
                    }

                    foreach (string item in Directory.EnumerateFiles(directory, "*", SearchOption.TopDirectoryOnly))
                    {
                        if (!MatchFileSearchPattern(pattern, Path.GetFileName(item)))
                        {
                            continue;
                        }

                        if (!IsFileAccessible(item))
                        {
                            continue;
                        }

                        callback(item, searchCount, directoryList.Count);
                    }
                }
            }
        }

        public static bool IsFileAccessible(string filename)
        {
            if (string.IsNullOrWhiteSpace(filename)) return false;
            if (!File.Exists(filename)) return false;

            try
            {
                FileInfo fi = new FileInfo(filename);
                fi.GetAccessControl();
            }
            catch
            {
                return false;
            }

            return true;
        }

        public static bool IsDirectoryAccessible(string path)
        {
            if (string.IsNullOrWhiteSpace(path)) return false;
            if (!Directory.Exists(path)) return false;

            try
            {
                DirectoryInfo di = new DirectoryInfo(path);
                di.GetAccessControl();
            }
            catch
            {
                return false;
            }

            return true;
        }

        public static bool MatchFileSearchPattern(string pattern, string subject)
        {
            if (pattern.Contains(';'))
            {
                string[] parts = pattern.Split(';');
                for (int i=0; i<parts.Length; i++)
                {
                    if (string.IsNullOrWhiteSpace(parts[i]))
                    {
                        continue;
                    }

                    if (MatchWildcard(parts[i].Trim(), subject))
                    {
                        return true;
                    }
                }

                return false;
            }
            else
            {
                return MatchWildcard(pattern, subject);
            }
        }

        public static bool MatchWildcard(string wildcardPattern, string subject)
        {
            if (string.IsNullOrWhiteSpace(wildcardPattern))
            {
                return false;
            }

            Func<string, string, bool> matchPattern = (pattern, subject) =>
            {
                string[] parts = pattern.Split('*');
                if (parts.Length <= 1)
                {
                    return subject.Equals(pattern, StringComparison.CurrentCultureIgnoreCase);
                }

                int pos = 0;

                for (int i = 0; i < parts.Length; i++)
                {
                    if (i <= 0)
                    {
                        // first
                        pos = subject.IndexOf(parts[i], pos, StringComparison.CurrentCultureIgnoreCase);
                        if (pos != 0)
                        {
                            return false;
                        }
                    }
                    else if (i >= (parts.Length - 1))
                    {
                        // last
                        if (!subject.EndsWith(parts[i], StringComparison.CurrentCultureIgnoreCase))
                        {
                            return false;
                        }
                    }
                    else
                    {
                        pos = subject.IndexOf(parts[i], pos, StringComparison.CurrentCultureIgnoreCase);
                        if (pos < 0)
                        {
                            return false;
                        }

                        pos += parts[i].Length;
                    }
                }

                return true;
            };

            int wildcardCount = wildcardPattern.Count(x => x.Equals('*'));
            if (wildcardCount <= 0)
            {
                return subject.Equals(wildcardPattern, StringComparison.CurrentCultureIgnoreCase);
            }
            else if (wildcardCount == 1)
            {
                string newWildcardPattern = wildcardPattern.Replace("*", "");

                if (wildcardPattern.StartsWith("*"))
                {
                    return subject.EndsWith(newWildcardPattern, StringComparison.CurrentCultureIgnoreCase);
                }
                else if (wildcardPattern.EndsWith("*"))
                {
                    return subject.StartsWith(newWildcardPattern, StringComparison.CurrentCultureIgnoreCase);
                }
                else
                {
                    return matchPattern(wildcardPattern, subject);
                }
            }
            else
            {
                return matchPattern(wildcardPattern, subject);
            }
        }

    }
}