using System;
using System.IO;
using UnifiedIO.SystemIO.Internal;

namespace UnifiedIO
{
    public static class Directory
    {
        public static bool Exists(string path)
        {
            path = UnifiedIO.SystemIO.Internal.Path.GetFullPath(path);
            return System.IO.Directory.Exists(path);
        }

        public static void Create(string path)
        {
            path = UnifiedIO.SystemIO.Internal.Path.GetFullPath(path);
            if (!System.IO.Directory.Exists(path))
            {
                System.IO.Directory.CreateDirectory(path);
            }
        }

        public static void Rename(string path, string newName)
        {
            path = UnifiedIO.SystemIO.Internal.Path.GetFullPath(path);
            if (newName.Contains("/") || newName.Contains("\\"))
            {
                throw new FileNotFoundException();
            }
            string directoryName = System.IO.Path.GetDirectoryName(path);
            try
            {
                System.IO.Directory.Move(path, System.IO.Path.Combine(directoryName, newName));
            }
            catch (DirectoryNotFoundException)
            {
                throw new FileNotFoundException();
            }
        }

        public static void Move(string sourcePath, string destinationPath)
        {
            sourcePath = UnifiedIO.SystemIO.Internal.Path.GetFullPath(sourcePath);
            destinationPath = UnifiedIO.SystemIO.Internal.Path.GetFullPath(destinationPath);
            if (!areSameDirectory(sourcePath, destinationPath) && !isSubdirectory(destinationPath, sourcePath))
            {
                if (!System.IO.Directory.Exists(destinationPath))
                {
                    System.IO.Directory.CreateDirectory(destinationPath);
                }
                move(sourcePath, destinationPath);
                return;
            }
            throw new IOException();
        }

        public static void Copy(string sourcePath, string destinationPath)
        {
            sourcePath = UnifiedIO.SystemIO.Internal.Path.GetFullPath(sourcePath);
            destinationPath = UnifiedIO.SystemIO.Internal.Path.GetFullPath(destinationPath);
            if (!areSameDirectory(sourcePath, destinationPath) && !isSubdirectory(destinationPath, sourcePath))
            {
                if (!System.IO.Directory.Exists(destinationPath))
                {
                    System.IO.Directory.CreateDirectory(destinationPath);
                }
                copy(sourcePath, destinationPath);
                return;
            }
            throw new IOException();
        }

        public static void MoveInside(string sourcePath, string destinationPath)
        {
            sourcePath = UnifiedIO.SystemIO.Internal.Path.GetFullPath(sourcePath);
            destinationPath = UnifiedIO.SystemIO.Internal.Path.GetFullPath(destinationPath);
            string fileName = System.IO.Path.GetFileName(sourcePath);
            string text = System.IO.Path.Combine(destinationPath, fileName);
            if (!areSameDirectory(sourcePath, text) && !isSubdirectory(text, sourcePath))
            {
                if (!System.IO.Directory.Exists(text))
                {
                    System.IO.Directory.CreateDirectory(text);
                }
                move(sourcePath, text);
                return;
            }
            throw new IOException();
        }

        public static void CopyInside(string sourcePath, string destinationPath)
        {
            sourcePath = UnifiedIO.SystemIO.Internal.Path.GetFullPath(sourcePath);
            destinationPath = UnifiedIO.SystemIO.Internal.Path.GetFullPath(destinationPath);
            string fileName = System.IO.Path.GetFileName(sourcePath);
            string text = System.IO.Path.Combine(destinationPath, fileName);
            if (!areSameDirectory(sourcePath, text) && !isSubdirectory(text, sourcePath))
            {
                if (!System.IO.Directory.Exists(text))
                {
                    System.IO.Directory.CreateDirectory(text);
                }
                copy(sourcePath, text);
                return;
            }
            throw new IOException();
        }

        public static void Delete(string path)
        {
            path = UnifiedIO.SystemIO.Internal.Path.GetFullPath(path);
            if (System.IO.Directory.Exists(path))
            {
                System.IO.Directory.Delete(path, recursive: true);
                return;
            }
            FileNotFoundException ex = new FileNotFoundException("Unable to find the specified directory: " + path);
            throw ex;
        }

        public static void DeleteContents(string path)
        {
            path = UnifiedIO.SystemIO.Internal.Path.GetFullPath(path);
            string[] directories = System.IO.Directory.GetDirectories(path);
            foreach (string path2 in directories)
            {
                System.IO.Directory.Delete(path2, recursive: true);
            }
            string[] files = System.IO.Directory.GetFiles(path);
            foreach (string path3 in files)
            {
                System.IO.File.Delete(path3);
            }
        }

        public static string[] GetFiles(string path, string searchPattern = null, SearchOption searchOption = SearchOption.TopDirectoryOnly)
        {
            path = UnifiedIO.SystemIO.Internal.Path.GetFullPath(path);
            string[] array = (searchPattern == null) ? System.IO.Directory.GetFiles(path, "*", searchOption) : System.IO.Directory.GetFiles(path, searchPattern, searchOption);
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = array[i].Substring(path.Length + 1, array[i].Length - path.Length - 1);
            }
            return array;
        }

        [Obsolete("Deprecated because it never actually returned an \"enumeration\". Please use GetFiles instead.")]
        public static string[] EnumerateFiles(string path, string searchPattern = null, SearchOption searchOption = SearchOption.TopDirectoryOnly)
        {
            return GetFiles(path, searchPattern, searchOption);
        }

        public static string[] GetDirectories(string path, string searchPattern = null, SearchOption searchOption = SearchOption.TopDirectoryOnly)
        {
            path = UnifiedIO.SystemIO.Internal.Path.GetFullPath(path);
            string[] array = (searchPattern == null) ? System.IO.Directory.GetDirectories(path, "*", searchOption) : System.IO.Directory.GetDirectories(path, searchPattern, searchOption);
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = array[i].Substring(path.Length + 1, array[i].Length - path.Length - 1);
            }
            return array;
        }

        [Obsolete("Deprecated because it never actually returned an \"enumeration\". Please use GetDirectories instead.")]
        public static string[] EnumerateDirectories(string path, string searchPattern = null, SearchOption searchOption = SearchOption.TopDirectoryOnly)
        {
            return GetDirectories(path, searchPattern, searchOption);
        }

        private static void move(string sourcePath, string destinationPath)
        {
            string[] files = System.IO.Directory.GetFiles(sourcePath);
            string[] array = files;
            foreach (string text in array)
            {
                string fileName = System.IO.Path.GetFileName(text);
                string text2 = System.IO.Path.Combine(destinationPath, fileName);
                if (System.IO.File.Exists(text2))
                {
                    System.IO.File.Delete(text2);
                }
                System.IO.File.Move(text, text2);
            }
            string[] directories = System.IO.Directory.GetDirectories(sourcePath);
            string[] array2 = directories;
            foreach (string text3 in array2)
            {
                string fileName2 = System.IO.Path.GetFileName(text3);
                string text4 = System.IO.Path.Combine(destinationPath, fileName2);
                if (!System.IO.Directory.Exists(text4))
                {
                    System.IO.Directory.CreateDirectory(text4);
                }
                move(text3, text4);
            }
            if (isEmpty(sourcePath))
            {
                System.IO.Directory.Delete(sourcePath, recursive: true);
            }
        }

        private static void copy(string sourcePath, string destinationPath)
        {
            string[] files = System.IO.Directory.GetFiles(sourcePath);
            string[] array = files;
            foreach (string text in array)
            {
                string fileName = System.IO.Path.GetFileName(text);
                string text2 = System.IO.Path.Combine(destinationPath, fileName);
                if (System.IO.File.Exists(text2))
                {
                    System.IO.File.Delete(text2);
                }
                System.IO.File.Copy(text, text2);
            }
            string[] directories = System.IO.Directory.GetDirectories(sourcePath);
            string[] array2 = directories;
            foreach (string text3 in array2)
            {
                string fileName2 = System.IO.Path.GetFileName(text3);
                string text4 = System.IO.Path.Combine(destinationPath, fileName2);
                if (!System.IO.Directory.Exists(text4))
                {
                    System.IO.Directory.CreateDirectory(text4);
                }
                copy(text3, text4);
            }
        }

        private static bool areSameDirectory(string dir1, string dir2)
        {
            DirectoryInfo directoryInfo = new DirectoryInfo(dir1);
            DirectoryInfo directoryInfo2 = new DirectoryInfo(dir2);
            return directoryInfo2.Parent.FullName == directoryInfo.FullName;
        }

        private static bool isSubdirectory(string childCandidate, string parentCandidate)
        {
            DirectoryInfo directoryInfo = new DirectoryInfo(parentCandidate);
            DirectoryInfo directoryInfo2 = new DirectoryInfo(childCandidate);
            while (directoryInfo2.Parent != null)
            {
                if (directoryInfo2.Parent.FullName == directoryInfo.FullName)
                {
                    return true;
                }
                directoryInfo2 = directoryInfo2.Parent;
            }
            return false;
        }

        private static bool isEmpty(string path)
        {
            return System.IO.Directory.GetFileSystemEntries(path).Length == 0;
        }
    }
}