//------------------------------------------------------------------
//本文件中的工具提供在编辑器环境下，快速整理特效相关的资源
//-------------------------------------------------------------------

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using UnityEngine.UI;
using System.IO;
using System;
using System.Threading;
using System.Text.RegularExpressions;

public class RemoveUnUsedEffect
{
    static string uiroot1 = "Assets/ResourcesOut/UI/Window";
    static string uiroot2 = "Assets/ResourcesOut/UI/PriorityWindow";
    static string uiroot3 = "Assets/ResourcesOut/UI/Prefab";
    static string mobroot = "Assets/ResourcesOut/UI/Prefab";
    static string builtinroot = "Assets/ResourcesOut/BuiltIn/Prefabs";

    static string effectroot = "Assets/ResourcesOut/Effect";

    static List<string> prefabTexts = new List<string>();

    static Dictionary<string, GameObject> processObjects = new Dictionary<string, GameObject>();
    static List<AnalyzeTask> tasks = new List<AnalyzeTask>();

    static int taskCount = 1;
    static int completedTaskCount = 0;
    static List<EffectConfig> configs;

    [MenuItem("程序/Effect Assets/移除无用的特效")]
    public static void RemoveUnUsedEffects()
    {
        try
        {
            EditorApplication.update += OnUpdate;
            EffectConfig.Init(true);
            configs = EffectConfig.GetValues();

            LoadPrefabTexts();
            FindEffects();

            taskCount = 0;
            completedTaskCount = 0;
            foreach (var task in tasks)
            {
                task.total = task.effects.Count;
                taskCount += task.total;
            }

            Analyze();
        }
        catch (Exception e)
        {
            EditorApplication.update -= OnUpdate;
            EditorUtility.ClearProgressBar();
        }
    }

    static void LoadPrefabTexts()
    {
        var guids = new List<string>();
        guids.AddRange(AssetDatabase.FindAssets("t:prefab", new string[] { uiroot1 }));
        guids.AddRange(AssetDatabase.FindAssets("t:prefab", new string[] { uiroot2 }));
        guids.AddRange(AssetDatabase.FindAssets("t:prefab", new string[] { uiroot3 }));
        guids.AddRange(AssetDatabase.FindAssets("t:prefab", new string[] { mobroot }));
        guids.AddRange(AssetDatabase.FindAssets("t:prefab", new string[] { builtinroot }));

        var assetPaths = new List<string>();
        foreach (var item in guids)
        {
            assetPaths.Add(AssetDatabase.GUIDToAssetPath(item));
        }

        var count = 0;
        prefabTexts.Clear();
        foreach (var path in assetPaths)
        {
            count++;
            EditorUtility.DisplayProgressBar("读取预置体", "正在读取预置体文本", (float)count / assetPaths.Count);
            prefabTexts.Add(File.ReadAllText(Application.dataPath + path.Substring(6, path.Length - 6)));
        }

        EditorUtility.ClearProgressBar();
    }

    static void FindEffects()
    {
        processObjects.Clear();
        tasks.Clear();

        var effects = new List<GameObject>();
        var guids = new List<string>();
        var subFolders = AssetDatabase.GetSubFolders(effectroot);
        foreach (var folder in subFolders)
        {
            guids.AddRange(AssetDatabase.FindAssets("t:prefab", new string[] { folder }));
        }

        foreach (var guid in guids)
        {
            effects.Add(AssetDatabase.LoadAssetAtPath<GameObject>(AssetDatabase.GUIDToAssetPath(guid)));
        }

        var count = 0;
        var task = new AnalyzeTask();
        tasks.Add(task);
        foreach (var asset in effects)
        {
            var path = AssetDatabase.GetAssetPath(asset);
            var guid = AssetDatabase.AssetPathToGUID(path);
            processObjects[guid] = asset;

            var folderName = Path.GetDirectoryName(path).Split('/').GetLast();
            task.Add(new EffectInfo()
            {
                name = asset.name,
                guid = guid,
                folder = folderName
            });

            count++;
            EditorUtility.DisplayProgressBar("获取特效", "正在获取特效预置体", (float)count / effects.Count);
            if (count >= 20)
            {
                count = 0;
                task = new AnalyzeTask();
                tasks.Add(task);
            }
        }

        EditorUtility.ClearProgressBar();

    }

    static void Analyze()
    {
        foreach (var task in tasks)
        {
            ThreadPool.QueueUserWorkItem(x =>
            {
                for (int i = 0; i < task.effects.Count; i++)
                {
                    task.completed++;
                    var info = task.effects[i];
                    if (ContainByIconTable(info))
                    {
                        continue;
                    }

                    if (RefrenceByPrefab(info))
                    {
                        continue;
                    }

                    info.unUsed = true;
                    task.effects[i] = info;
                }

                task.done = true;
            });
        }
    }

    static void ProcessUnUsedEffects()
    {
        var total = 0;
        foreach (var task in tasks)
        {
            foreach (var effect in task.effects)
            {
                if (effect.unUsed)
                {
                    Debug.LogFormat("找到一个无用的Effect：文件夹->{0};特效名称->{1}", effect.folder, effect.name);
                    total++;
                }
            }
        }

        var count = 0;
        foreach (var task in tasks)
        {
            foreach (var sprite in task.effects)
            {
                if (sprite.unUsed)
                {
                    EditorUtility.DisplayProgressBar("删除Effect", string.Format("正在删除第{0}个特效，共{1}个", count + 1, total), (float)count / total);
                    count++;
                    AssetDatabase.DeleteAsset(AssetDatabase.GUIDToAssetPath(sprite.guid));
                }
            }
        }

        EditorUtility.ClearProgressBar();
    }

    static bool ContainByIconTable(EffectInfo info)
    {
        return configs.FindIndex(x => { return x.packageName.ToLower() == info.folder.ToLower() && x.fxName == info.name; }) != -1;
    }

    static bool RefrenceByPrefab(EffectInfo info)
    {
        foreach (var content in prefabTexts)
        {
            if (Regex.IsMatch(content, info.guid))
            {
                return true;
            }
        }

        return false;
    }

    static void OnUpdate()
    {
        var done = true;
        completedTaskCount = 0;
        foreach (var task in tasks)
        {
            completedTaskCount += task.completed;
            if (!task.done)
            {
                done = false;
            }
        }

        EditorUtility.DisplayProgressBar("分析无用Effect",
            string.Format("正在分析第{0}个Effect,共计{1}个", completedTaskCount + 1, taskCount),
            (float)completedTaskCount / taskCount);

        if (done)
        {
            EditorUtility.ClearProgressBar();
            ProcessUnUsedEffects();
            EditorApplication.update -= OnUpdate;
        }
    }

    struct EffectInfo
    {
        public string guid;
        public string name;
        public string folder;
        public bool unUsed;
    }

    class AnalyzeTask
    {
        public int total;
        public int completed;
        public bool done;
        public List<EffectInfo> effects;

        public AnalyzeTask()
        {
            effects = new List<EffectInfo>();
        }

        public void Add(EffectInfo info)
        {
            effects.Add(info);
        }
    }

}

public class RemoveUnUsedEffectKey
{
    static string uiroot1 = "Assets/ResourcesOut/UI/Window";
    static string uiroot2 = "Assets/ResourcesOut/UI/PriorityWindow";
    static string uiroot3 = "Assets/ResourcesOut/UI/Prefab";

    static string soskillroot = "Assets/ResourcesOut/Refdata/ScriptableObject/SoSkill";
    static string newbieguideroot = "Assets/ResourcesOut/Refdata/ScriptableObject/SoNewBieGuide";

    static int taskCount = 1;
    static int completedTaskCount = 0;
    static Dictionary<string, List<string>> iconKeyMap = new Dictionary<string, List<string>>();

    static List<UIEffect> uieffects = new List<UIEffect>();
    static List<Column> iconKeyRefrences = new List<Column>();
    static List<string> csharpFileContents = new List<string>();
    static List<NewBieGuideScriptableObject> newbieGuides = new List<NewBieGuideScriptableObject>();
    static List<SoSkill> soSkills = new List<SoSkill>();
    static List<AnalyzeTask> tasks = new List<AnalyzeTask>();
    static string ignorekeys = string.Empty;

    [MenuItem("程序/Effect Assets/移除无用的EffectKey")]
    public static void Remove()
    {
        tasks.Clear();
        var effectKeys = GetOriginalEffectKeys();

        taskCount = effectKeys.Count;
        completedTaskCount = 0;

        var count = 0;
        var task = new AnalyzeTask();
        tasks.Add(task);
        foreach (var keyInfo in effectKeys)
        {
            task.Add(keyInfo);
            if (count >= 100)
            {
                count = 0;
                task = new AnalyzeTask();
                tasks.Add(task);
            }
            count++;
        }

        iconKeyMap = GetEffectKeyMap();
        iconKeyRefrences = GetAllEffectKeyRefrences();
        csharpFileContents = GetAllCSharpFileContents();
        uieffects = GetEffectComponents();
        soSkills = GetSoSkills();
        newbieGuides = GetNewbieGuides();
        ignorekeys = GetIngoreKeys();

        try
        {
            EditorApplication.update += OnUpdate;
            Analyze();
        }
        catch (Exception e)
        {
            EditorUtility.ClearProgressBar();
            EditorApplication.update -= OnUpdate;
            Debug.Log(e);
        }

    }

    static void Analyze()
    {
        foreach (var task in tasks)
        {
            ThreadPool.QueueUserWorkItem(x =>
            {
                for (int i = 0; i < task.effectKeys.Count; i++)
                {
                    task.completed++;
                    var info = task.effectKeys[i];
                    if (info.folder.ToLower() == "cj")
                    {
                        continue;
                    }

                    if (IsIgnoreKey(info.key, ref ignorekeys))
                    {
                        Debug.LogFormat("找到一个不要删除的 effect key：{0}", info.key);
                        continue;
                    }

                    if (ContainBySoSkills(info.key, ref soSkills))
                    {
                        Debug.LogFormat("找到一个被soskill依赖的 effect key：{0}", info.key);
                        continue;
                    }

                    if (ContainByNewbieGuides(info.key, ref newbieGuides))
                    {
                        Debug.LogFormat("找到一个被新手引导依赖的 effect key：{0}", info.key);
                        continue;
                    }

                    if (ContainByPrefab(info.key, ref uieffects))
                    {
                        Debug.LogFormat("找到一个被prefab依赖的 effect key：{0}", info.key);
                        continue;
                    }

                    if (ContainByTables(info.key, ref iconKeyRefrences))
                    {
                        Debug.LogFormat("找到一个被其他配置配件引用的 effect key：{0}", info.key);
                        continue;
                    }

                    if (ContainByCSharpFile(info.key, ref csharpFileContents))
                    {
                        Debug.LogFormat("找到一个写在C#文件中的 effect key：{0}", info.key);
                        continue;
                    }

                    info.unused = true;
                    task.effectKeys[i] = info;
                }

                task.done = true;
            });
        }
    }

    static void ProcessUnUsedEffectKeys()
    {
        var lines = new List<string>(File.ReadAllLines(Application.dataPath + "/ResourcesOut/Refdata/Config/Effect.txt"));
        var deleteLines = new List<string>();
        var unUsedEffectKeys = new List<string>();
        foreach (var task in tasks)
        {
            foreach (var iconkey in task.effectKeys)
            {
                if (iconkey.unused)
                {
                    unUsedEffectKeys.Add(iconkey.key);
                }
            }
        }

        for (int i = lines.Count - 1; i >= 3; i--)
        {
            var contents = lines[i].Split('\t');
            if (!contents.IsNullOrEmpty())
            {
                if (unUsedEffectKeys.Contains(contents[0]))
                {
                    deleteLines.Add(lines[i]);
                    lines.RemoveAt(i);
                }
            }
        }

        File.WriteAllLines(Application.dataPath + "/删除的Effect表配置.txt", deleteLines.ToArray());
        File.WriteAllLines(Application.dataPath + "/ResourcesOut/Refdata/Config/Effect.txt", lines.ToArray());
    }

    static Dictionary<string, List<string>> GetEffectKeyMap()
    {
        var lines = File.ReadAllLines(Application.dataPath + "/Editor/Config/TxtEffectKey.txt");
        var map = new Dictionary<string, List<string>>();

        for (int i = 1; i < lines.Length; i++)
        {
            var line = lines[i];
            var contents = new List<string>(line.Split('\t'));
            if (!contents.IsNullOrEmpty() && contents.Count >= 2)
            {
                var fields = map[contents[0]] = new List<string>();
                fields.AddRange(contents.GetRange(1, contents.Count - 1));
            }
        }

        return map;
    }

    static List<EffectKeyInfo> GetOriginalEffectKeys()
    {
        var lines = File.ReadAllLines(Application.dataPath + "/ResourcesOut/Refdata/Config/Effect.txt");
        var effectKeys = new List<EffectKeyInfo>();
        for (int i = 3; i < lines.Length; i++)
        {
            var contents = lines[i].Split('\t');
            if (!contents.IsNullOrEmpty())
            {
                effectKeys.Add(new EffectKeyInfo() { key = contents[0], folder = contents[1] });
            }
        }

        return effectKeys;
    }

    static List<Column> GetAllEffectKeyRefrences()
    {
        var files = FileExtersion.GetFileInfos(Application.dataPath + "/ResourcesOut/Refdata/Config", new string[] { "*.txt", "*.TXT" });

        var columns = new List<Column>();
        foreach (var file in files)
        {
            var nameWithoutExtension = Path.GetFileNameWithoutExtension(file.FullName);
            if (!iconKeyMap.ContainsKey(nameWithoutExtension))
            {
                continue;
            }

            var lines = File.ReadAllLines(file.FullName);
            var fields0 = new List<string>(lines[0].Split('\t'));
            var fields1 = new List<string>(lines[1].Split('\t'));
            var refrences = iconKeyMap[nameWithoutExtension];
            foreach (var refrence in refrences)
            {
                var name = string.Empty;
                var index = fields0.IndexOf(refrence);
                if (index != -1)
                {
                    name = fields0[index];
                }
                else
                {
                    index = fields1.IndexOf(refrence);
                    if (index != -1)
                    {
                        name = fields1[index];
                    }
                }

                if (index == -1)
                {
                    continue;
                }

                var column = new Column()
                {
                    name = name,
                    values = new List<string>()
                };

                columns.Add(column);
                for (int i = 1; i < lines.Length; i++)
                {
                    var line = lines[i];
                    var contents = line.Split('\t');
                    column.values.Add(contents[index]);
                }
            }

        }

        return columns;
    }

    static List<string> GetAllCSharpFileContents()
    {
        var files = FileExtersion.GetFileInfos(Application.dataPath + "/Scripts", new string[] { "*.cs" });
        var contents = new List<string>();

        var count = 0;
        foreach (var file in files)
        {
            count++;
            EditorUtility.DisplayProgressBar("读取代码文件", "正在读取代码文件", (float)count / files.Count);
            contents.Add(File.ReadAllText(file.FullName));
        }

        EditorUtility.ClearProgressBar();
        return contents;
    }

    static List<UIEffect> GetEffectComponents()
    {
        var guids = new List<string>();
        guids.AddRange(AssetDatabase.FindAssets("t:prefab", new string[] { uiroot1 }));
        guids.AddRange(AssetDatabase.FindAssets("t:prefab", new string[] { uiroot2 }));
        guids.AddRange(AssetDatabase.FindAssets("t:prefab", new string[] { uiroot3 }));

        var assetPaths = new List<string>();
        foreach (var item in guids)
        {
            assetPaths.Add(AssetDatabase.GUIDToAssetPath(item));
        }

        var count = 0;
        var uieffects = new List<UIEffect>();
        foreach (var path in assetPaths)
        {
            count++;
            EditorUtility.DisplayProgressBar("收集UIEffect", "正在搜索Prefab上的UIEffect", (float)count / assetPaths.Count);
            var gameObject = AssetDatabase.LoadAssetAtPath<GameObject>(path);
            if (gameObject == null)
            {
                continue;
            }

            var components = gameObject.GetComponentsInChildren<UIEffect>(true);
            if (!components.IsNullOrEmpty())
            {
                uieffects.AddRange(components);
            }
        }

        EditorUtility.ClearProgressBar();
        return uieffects;
    }

    static List<SoSkill> GetSoSkills()
    {
        var guids = new List<string>();
        guids.AddRange(AssetDatabase.FindAssets("t:ScriptableObject", new string[] { soskillroot }));

        var assetPaths = new List<string>();
        foreach (var item in guids)
        {
            assetPaths.Add(AssetDatabase.GUIDToAssetPath(item));
        }

        var soskills = new List<SoSkill>();
        foreach (var path in assetPaths)
        {
            var soskill = AssetDatabase.LoadAssetAtPath<SoSkill>(path);
            if (soskill != null)
            {
                soskills.Add(soskill);
            }
        }

        return soskills;
    }

    static List<NewBieGuideScriptableObject> GetNewbieGuides()
    {
        var guids = new List<string>();
        guids.AddRange(AssetDatabase.FindAssets("t:ScriptableObject", new string[] { newbieguideroot }));

        var assetPaths = new List<string>();
        foreach (var item in guids)
        {
            assetPaths.Add(AssetDatabase.GUIDToAssetPath(item));
        }

        var newbieguides = new List<NewBieGuideScriptableObject>();
        foreach (var path in assetPaths)
        {
            var so = AssetDatabase.LoadAssetAtPath<NewBieGuideScriptableObject>(path);
            if (newbieguides != null)
            {
                newbieguides.Add(so);
            }
        }

        return newbieguides;
    }

    static string GetIngoreKeys()
    {
        return File.ReadAllText(Application.dataPath + "/Editor/Config/DeleteEffectExcludeKey.txt");
    }

    static bool ContainByTables(string key, ref List<Column> columns)
    {
        foreach (var column in columns)
        {
            foreach (var value in column.values)
            {
                if (Regex.IsMatch(value, key))
                {
                    return true;
                }
            }
        }

        return false;
    }

    static bool ContainByCSharpFile(string key, ref List<string> csharpContents)
    {
        var pattern1 = string.Format(@"SFXPlayUtility.Instance.PlayBattleEffect.*{0}", key);
        var pattern2 = string.Format(@"SFXPlayUtility.Instance.PlayEffectAsync.*{0}", key);
        var pattern3 = string.Format(@"SFXPlayUtility.Instance.PlayWithEulerAngle.*{0}", key);
        var pattern4 = string.Format(@"SFXPlayUtility.Instance.Play.*{0}", key);

        foreach (var content in csharpContents)
        {
            if (Regex.IsMatch(content, pattern1))
            {
                return true;
            }

            if (Regex.IsMatch(content, pattern2))
            {
                return true;
            }

            if (Regex.IsMatch(content, pattern3))
            {
                return true;
            }

            if (Regex.IsMatch(content, pattern4))
            {
                return true;
            }
        }

        return false;
    }

    static bool ContainByPrefab(string key, ref List<UIEffect> uieffects)
    {
        foreach (var uieffect in uieffects)
        {
            if (uieffect.effect.ToString() == key)
            {
                return true;
            }
        }

        return false;
    }

    static bool ContainBySoSkills(string key, ref List<SoSkill> soSkills)
    {
        foreach (var soskill in soSkills)
        {
            foreach (var frameEvent in soskill.animationEventList)
            {
                if (frameEvent.frameEventType == E_FrameEventType.OnPlayEffect)
                {
                    if (frameEvent.intParam.ToString() == key)
                    {
                        return true;
                    }
                }
            }
        }

        return false;
    }

    static bool ContainByNewbieGuides(string key, ref List<NewBieGuideScriptableObject> newbieGuides)
    {
        foreach (var newbieGuide in newbieGuides)
        {
            if (newbieGuide.effect2.ToString() == key)
            {
                return true;
            }
        }

        return false;
    }

    static bool IsIgnoreKey(string key, ref string ignores)
    {
        return Regex.IsMatch(ignores, key);
    }

    static void OnUpdate()
    {
        var done = true;
        completedTaskCount = 0;
        foreach (var task in tasks)
        {
            completedTaskCount += task.completed;
            if (!task.done)
            {
                done = false;
            }
        }

        EditorUtility.DisplayProgressBar("分析无用EffectKey",
            string.Format("正在分析第{0}个EffectKey,共计{1}个", completedTaskCount + 1, taskCount),
            (float)completedTaskCount / taskCount);

        if (done)
        {
            EditorUtility.ClearProgressBar();
            ProcessUnUsedEffectKeys();
            EditorApplication.update -= OnUpdate;
        }
    }

    struct Column
    {
        public string name;
        public List<string> values;
    }

    struct EffectKeyInfo
    {
        public string key;
        public string folder;
        public bool unused;
    }

    class AnalyzeTask
    {
        public int total;
        public int completed;
        public bool done;
        public List<EffectKeyInfo> effectKeys;

        public AnalyzeTask()
        {
            effectKeys = new List<EffectKeyInfo>();
        }

        public void Add(EffectKeyInfo key)
        {
            effectKeys.Add(key);
        }
    }

}