using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using UnityEngine;
using UnityEngine.Networking;

public enum enFileOperation
{
    ReadFile,
    WriteFile,
    DeleteFile,
    CreateDirectory,
    DeleteDirectory
}

public class FileManager
{
    public delegate void DelegateOnOperateFileFail(string fullPath, enFileOperation fileOperation);

    private static string s_cachePath = null;

    public static string s_ifsExtractFolder = "AssetBundle";

    private static string s_ifsExtractPath = null;

    private static string ab_buildPath = null;

    private static MD5CryptoServiceProvider s_md5Provider = new MD5CryptoServiceProvider();

    public static FileManager.DelegateOnOperateFileFail s_delegateOnOperateFileFail = delegate
    {
   
    };

    public static bool ClearDirectory(string fullPath)
    {
        bool result;
        try
        {
            string[] files = Directory.GetFiles(fullPath);
            for (int i = 0; i < files.Length; i++)
            {
                File.Delete(files[i]);
            }
            string[] directories = Directory.GetDirectories(fullPath);
            for (int j = 0; j < directories.Length; j++)
            {
                //Directory.Delete(directories[j], true);
            }
            result = true;
        }
        catch (Exception)
        {
            result = false;
        }
        return result;
    }

    public static bool ClearDirectory(string fullPath, string[] fileExtensionFilter, string[] folderFilter)
    {
        bool result;
        try
        {
            if (fileExtensionFilter != null)
            {
                string[] files = Directory.GetFiles(fullPath);
                for (int i = 0; i < files.Length; i++)
                {
                    if (fileExtensionFilter != null && fileExtensionFilter.Length > 0)
                    {
                        for (int j = 0; j < fileExtensionFilter.Length; j++)
                        {
                            if (files[i].Contains(fileExtensionFilter[j]))
                            {
                                FileManager.DeleteFile(files[i]);
                                break;
                            }
                        }
                    }
                }
            }
            if (folderFilter != null)
            {
                string[] directories = Directory.GetDirectories(fullPath);
                for (int k = 0; k < directories.Length; k++)
                {
                    if (folderFilter != null && folderFilter.Length > 0)
                    {
                        for (int l = 0; l < folderFilter.Length; l++)
                        {
                            if (directories[k].Contains(folderFilter[l]))
                            {
                                FileManager.DeleteDirectory(directories[k]);
                                break;
                            }
                        }
                    }
                }
            }
            result = true;
        }
        catch (Exception)
        {
            result = false;
        }
        return result;
    }

    public static string CombinePath(string path1, string path2)
    {
        StringBuilder sb= new StringBuilder();
        sb.Append(path1);
        sb.Append("/");
        sb.Append(path2);
        return ReplacePathSymbol(sb.ToString());
    }

    public static string CombinePaths(params string[] values)
    {
        if (values.Length <= 0)
        {
            return string.Empty;
        }
        if (values.Length == 1)
        {
            return FileManager.CombinePath(values[0], string.Empty);
        }
        if (values.Length > 1)
        {
            string text = FileManager.CombinePath(values[0], values[1]);
            for (int i = 2; i < values.Length; i++)
            {
                text = FileManager.CombinePath(text, values[i]);
            }
            return text;
        }
        return string.Empty;
    }

    public static void CopyFile(string srcFile, string dstFile)
    {
        File.Copy(srcFile, dstFile, true);
    }

    public static bool CreateDirectory(string directory)
    {
        if (FileManager.IsDirectoryExist(directory))
        {
            return true;
        }
        int num = 0;
        bool result;
        while (true)
        {
            try
            {
                Directory.CreateDirectory(directory);
                result = true;
                break;
            }
            catch (Exception ex)
            {
                num++;
                if (num >= 3)
                {
                    Debug.Log("Create Directory " + directory + " Error! Exception = " + ex.ToString());
                    FileManager.s_delegateOnOperateFileFail(directory, enFileOperation.CreateDirectory);
                    result = false;
                    break;
                }
            }
        }
        return result;
    }

    public static bool DeleteDirectory(string directory)
    {
        if (!FileManager.IsDirectoryExist(directory))
        {
            return true;
        }
        int num = 0;
        bool result;
        while (true)
        {
            try
            {
                Directory.Delete(directory, true);
                result = true;
                break;
            }
            catch (Exception ex)
            {
                num++;
                if (num >= 3)
                {
                    Debug.Log("Delete Directory " + directory + " Error! Exception = " + ex.ToString());
                    FileManager.s_delegateOnOperateFileFail(directory, enFileOperation.DeleteDirectory);
                    result = false;
                    break;
                }
            }
        }
        return result;
    }

    public static bool DeleteFile(string filePath)
    {
        if (!FileManager.IsFileExist(filePath))
        {
            return true;
        }
        int num = 0;
        bool result;
        while (true)
        {
            try
            {
                File.Delete(filePath);
                result = true;
                break;
            }
            catch (Exception ex)
            {
                num++;
                if (num >= 3)
                {
                    Debug.Log("Delete File " + filePath + " Error! Exception = " + ex.ToString());
                    FileManager.s_delegateOnOperateFileFail(filePath, enFileOperation.DeleteFile);
                    result = false;
                    break;
                }
            }
        }
        return result;
    }

    public static string EraseExtension(string fullName)
    {
        if (fullName == null)
        {
            return null;
        }
        int num = fullName.LastIndexOf('.');
        if (num > 0)
        {
            return fullName.Substring(0, num);
        }
        return fullName;
    }

    public static string GetCachePath(string fileName)
    {
        return FileManager.CombinePath(FileManager.GetCachePath(), fileName);
    }

    public static string GetCachePath()
    {
        if (FileManager.s_cachePath == null)
        {
            //#if UNITY_STANDALONE_WIN
             //    FileManager.s_cachePath = CombinePath(Application.streamingAssetsPath, "AssetBundle/"); //特殊处理
            //#else
                FileManager.s_cachePath = PathDefine.AppPersistentDataPathPath();
            //#endif
        }
        return FileManager.s_cachePath;
    }

    public static string GetCachePathWithHeader(string fileName)
    {
        return FileManager.GetLocalPathHeader() + FileManager.GetCachePath(fileName);
    }

    public static string GetExtension(string fullName)
    {
        int num = fullName.LastIndexOf('.');
        if (num > 0 && num + 1 < fullName.Length)
        {
            return fullName.Substring(num);
        }
        return string.Empty;
    }

    public static long GetFileLength(string filePath)
    {
        if (!FileManager.IsFileExist(filePath))
        {
            return 0;
        }
        int num = 0;
        long result = 0;
        while (true)
        {
            try
            {
                FileInfo fileInfo = new FileInfo(filePath);
                result = fileInfo.Length;
                break;
            }
            catch (Exception ex)
            {
                num++;
                if (num >= 3)
                {
                    Debug.Log("Get FileLength of " + filePath + " Error! Exception = " + ex.ToString());
                    result = 0;
                    break;
                }
            }
        }
        return result;
    }

    public static string GetFullDirectory(string fullPath)
    {
        return Path.GetDirectoryName(fullPath);
    }

    public static string GetFullName(string fullPath)
    {
        if (fullPath == null)
        {
            return null;
        }
        int num = fullPath.LastIndexOf("/");
        if (num > 0)
        {
            return fullPath.Substring(num + 1, fullPath.Length - num - 1);
        }
        return fullPath;
    }

    /// <summary>
    /// 获取持久化路径persistentDataPath
    /// </summary>
    /// <returns></returns>
    public static string GetIFSExtractPath()
    {
        if (FileManager.s_ifsExtractPath == null)
        {
            FileManager.s_ifsExtractPath = Path.Combine(FileManager.GetCachePath(), PathDefine.GetPlatformName.ToLower()); //FileManager.CombinePath(FileManager.GetCachePath(), PathDefine.GetPlatformName.ToLower()); //FileManager.s_ifsExtractFolder);
        }
        return FileManager.s_ifsExtractPath;
    }

    /// <summary>
    /// 获取打包路径
    /// </summary>
    /// <returns></returns>
    public static string GetBuildABPath()
    {
        if (FileManager.ab_buildPath == null)
        {
            FileManager.ab_buildPath = FileManager.CombinePath(PathDefine.ABResPersistentDataPathPath(), PathDefine.GetPlatformName); //FileManager.s_ifsExtractFolder);
        }
        return FileManager.ab_buildPath;
    }


    private static string GetLocalPathHeader()
    {
        return "file://";
    }

    public static string GetFileMd5(string filePath)
    {
        if (!FileManager.IsFileExist(filePath))
        {
            return string.Empty;
        }
        return BitConverter.ToString(FileManager.s_md5Provider.ComputeHash(FileManager.ReadFile(filePath))).Replace("-", string.Empty).ToLower();
    }

    public static string GetMd5(byte[] data)
    {
        return BitConverter.ToString(FileManager.s_md5Provider.ComputeHash(data)).Replace("-", string.Empty).ToLower();
    }

    public static string GetMd5(string str)
    {
        return BitConverter.ToString(FileManager.s_md5Provider.ComputeHash(Encoding.UTF8.GetBytes(str))).Replace("-", string.Empty).ToLower();
    }

    public static string GetStreamingAssetsPathWithHeader(string fileName)
    {
        return Path.Combine(Application.streamingAssetsPath, fileName);
    }

    public static bool IsDirectoryExist(string directory)
    {
        return Directory.Exists(directory);
    }

    public static bool IsFileExist(string filePath)
    {
//#if UNITY_EDITOR
            return File.Exists(filePath);
//#endif

    //    return true;
    }

    public static byte[] ReadFile(string filePath)
    {
        if (!FileManager.IsFileExist(filePath))
        {
            Log.Error("file path is not exit :" + filePath);
            return null;
        }
        byte[] array = null;
        try
        {
            array = File.ReadAllBytes(filePath);
        }
        catch (Exception ex)
        {

            Log.Error(string.Concat(new object[] {
				"Read File ",
				filePath,
				" Error! Exception = ",
				ex.ToString (),
			}));
            array = null;
        }

        if (array != null && array.Length > 0)
        {
            return array;
        }
        return null;
    }

    public static bool WriteFile(string filePath, byte[] data, int offset, int length)
    {
        FileStream fileStream = null;
        int num = 0;
        bool result;
        while (true)
        {
            try
            {
                fileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);
                fileStream.Write(data, offset, length);
                fileStream.Close();
                result = true;
                break;
            }
            catch (Exception ex)
            {
                if (fileStream != null)
                {
                    fileStream.Close();
                }
                num++;
                if (num >= 3)
                {
                    Debug.Log("Write File " + filePath + " Error! Exception = " + ex.ToString());
                    FileManager.DeleteFile(filePath);
                    FileManager.s_delegateOnOperateFileFail(filePath, enFileOperation.WriteFile);
                    result = false;
                    break;
                }
            }
        }
        return result;
    }

    public static bool WriteFile(string filePath, byte[] data)
    {
        int num = 0;
        bool result;
        while (true)
        {
            try
            {
                File.WriteAllBytes(filePath, data);
                result = true;
                break;
            }
            catch (Exception ex)
            {
                num++;
                if (num >= 3)
                {
                    Debug.Log("Write File " + filePath + " Error! Exception = " + ex.ToString());
                    FileManager.DeleteFile(filePath);
                    FileManager.s_delegateOnOperateFileFail(filePath, enFileOperation.WriteFile);
                    result = false;
                    break;
                }
            }
        }
        return result;
    }

    /// <summary>
    /// 统一路径符号
    /// </summary>
    /// <param name="filePath"></param>
    /// <returns></returns>
    public static string ReplacePathSymbol(string filePath)
    {
        return new StringBuilder(filePath).Replace("//", "/").Replace('\\', '/').ToString();
    }

    /// <summary>
    /// 获取unity中指定路径中的所有文件，可选择忽略指定文件夹中文件
    /// </summary>
    /// <param name="dirctoryPath"></param>
    /// <param name="allFiles"></param>
    /// <param name="removePath"></param>
    public static void GetAllFile(string dirctoryPath, ref List<string> allFiles, string removePath = null)
    {
        if (Directory.Exists(dirctoryPath))
        {
            string[] allFiles1 = Directory.GetFiles(dirctoryPath);
            for (int i = 0; i < allFiles1.Length; i++)
            {
                if (!allFiles1[i].EndsWith(".meta"))
                {
                    string filePathName = allFiles1[i];
                    filePathName = ReplacePathSymbol(filePathName);
                    allFiles.Add(filePathName);
                }

            }
            string[] allDirctory = Directory.GetDirectories(dirctoryPath);
            if (allDirctory.Length > 0)
            {
                for (int j = 0; j < allDirctory.Length; j++)
                {
                    string filePathName = FileManager.EraseExtension(allDirctory[j]); 
                    filePathName = ReplacePathSymbol(filePathName);
                    if (removePath != null)
                    {
                        // Debug.LogError(fileName);
                        string fileName = filePathName.Substring(filePathName.LastIndexOf("/") + 1);

                        if (fileName == removePath)
                            continue;
                    }
                    GetAllFile(filePathName, ref allFiles, removePath);
                }
            }
        }

    }


    /// <summary>
    /// 获取路径中指定扩展名的所有文件
    /// </summary>
    /// <param name="dirctoryPath"></param>
    /// <param name="extensionName"></param>
    /// <param name="allFiles"></param>
    public static void GetAllocateFile(string dirctoryPath, string extensionName, ref List<string> allFiles)
    {
        if (Directory.Exists(dirctoryPath))
        {
            string[] allFiles1 = Directory.GetFiles(dirctoryPath);
            for (int i = 0; i < allFiles1.Length; i++)
            {
                if (allFiles1[i].EndsWith(extensionName))
                {
                    string filePathName = allFiles1[i];
                    filePathName = ReplacePathSymbol(filePathName);
                    allFiles.Add(filePathName);
                }

            }

            string[] allDirctory = Directory.GetDirectories(dirctoryPath);
            if (allDirctory.Length > 0)
            {
                for (int j = 0; j < allDirctory.Length; j++)
                {
                    string filePathName = FileManager.EraseExtension(allDirctory[j]);
                    filePathName = ReplacePathSymbol(filePathName);
                    GetAllocateFile(filePathName, extensionName, ref allFiles);
                }
            }

        }
    }



    /// <summary>
    /// 分割字符串
    /// </summary>
    /// <param name="str"></param>
    /// <param name="splitStr"></param>
    /// <param name="callBack"></param>
    public static void StringSplit(string str,string splitStr,Action<string[]> callBack)
    {
        string[] splitList= str.Trim().Split(splitStr.ToCharArray());
        if (callBack!=null)
            callBack(splitList);
    }


    /// <summary>
    /// 获取路径中的所有文件夹列表
    /// </summary>
    /// <param name="directoryPath"></param>
    /// <param name="directoryHierarchyList"></param>
    public static void GetAllDirectoryHierarchyByPath(string directoryPath,ref List<string> directoryHierarchyList)
    {
        int pos = directoryPath.IndexOf("/");
        if (pos>=0)
        {
            string tempDir = directoryPath.Substring(0, pos);
            directoryHierarchyList.Add(tempDir);
            tempDir = directoryPath.Substring(pos+1);
            GetAllDirectoryHierarchyByPath(tempDir,ref directoryHierarchyList);
        }
        else
        {
            directoryHierarchyList.Add(directoryPath);
            return;
        }
        
       
    }


    public static byte[] Encrypt(byte[] text, string key)
    {
        byte[] keyData = System.Text.UTF8Encoding.UTF8.GetBytes(key);
        for (int i = 0; i < text.Length; i++)
        {
            for (int j = 0; j < keyData.Length; j++)
            {
                text[i] = (byte)(text[i]^ keyData[j]);
            }

        }
        return text;
    }

    







}