using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using Convention;
using Convention.WindowsUI.Variant;
using Demo.Game;
using Flee.PublicTypes;
using Sirenix.OdinInspector;
using Unity.Profiling;
using UnityEngine;

namespace Demo
{
    public enum ProjectDefaultFileStyle
    {
        CPP,
        PY
    }

    [System.AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class ScriptableCallAttribute : Attribute
    {
        public string Description;
        public ScriptableCallAttribute(string description)
        {
            this.Description = description;
        }
    }

    [System.AttributeUsage(AttributeTargets.Enum, Inherited = true, AllowMultiple = false)]
    public sealed class ScriptableEnumAttribute : Attribute
    {
        public string Description;
        public ScriptableEnumAttribute(string description)
        {
            this.Description = description;
        }
    }

    public static class ScriptCallUtility
    {
        // 解析函数调用的方法，支持 with 子句
        public static (string functionName, string[] arguments, Dictionary<string, string> withVariables) ParseFunctionCall(string input)
        {
            // 匹配函数名和参数部分，以及可选的 with 子句
            Match match = Regex.Match(input, @"^(\w+)\s*\(\s*(.*?)\s*\)\s*(?:\s+with\s*\(\s*(.*?)\s*\))?\s*;?$");

            if (!match.Success)
                return (null, new string[0], new Dictionary<string, string>());

            string functionName = match.Groups[1].Value;
            string argumentsString = match.Groups[2].Value;
            string withString = match.Groups[3].Value;

            // 解析参数数组
            string[] arguments = ParseArguments(argumentsString);

            // 解析 with 子句的变量
            Dictionary<string, string> withVariables = new Dictionary<string, string>();
            if (!string.IsNullOrWhiteSpace(withString))
            {
                withVariables = ParseWithClause(withString);
            }

            return (functionName, arguments, withVariables);
        }

        // 解析 with 子句的方法
        private static Dictionary<string, string> ParseWithClause(string withString)
        {
            var variables = new Dictionary<string, string>();
            
            if (string.IsNullOrWhiteSpace(withString))
                return variables;

            int i = 0;
            while (i < withString.Length)
            {
                // 跳过空白字符
                while (i < withString.Length && char.IsWhiteSpace(withString[i]))
                    i++;
                
                if (i >= withString.Length)
                    break;

                // 解析变量名
                int nameStart = i;
                while (i < withString.Length && (char.IsLetterOrDigit(withString[i]) || withString[i] == '_'))
                    i++;
                
                if (i == nameStart)
                    break; // 没有找到有效的变量名

                string varName = withString.Substring(nameStart, i - nameStart);

                // 跳过空白字符
                while (i < withString.Length && char.IsWhiteSpace(withString[i]))
                    i++;

                // 检查等号
                if (i >= withString.Length || withString[i] != '=')
                    break; // 没有找到等号
                i++; // 跳过等号

                // 跳过空白字符
                while (i < withString.Length && char.IsWhiteSpace(withString[i]))
                    i++;

                // 解析变量值
                string varValue = ExtractArgument(withString, ref i);
                variables[varName] = varValue.Trim();

                // 跳过空白字符
                while (i < withString.Length && char.IsWhiteSpace(withString[i]))
                    i++;

                // 检查逗号
                if (i < withString.Length && withString[i] == ',')
                {
                    i++; // 跳过逗号
                }
                else if (i < withString.Length)
                {
                    break; // 期望逗号但找到了其他字符
                }
            }

            return variables;
        }

        // 解析参数的方法
        private static string[] ParseArguments(string argumentsString)
        {
            if (string.IsNullOrWhiteSpace(argumentsString))
                return new string[0];

            var arguments = new List<string>();
            int i = 0;
            
            while (i < argumentsString.Length)
            {
                // 跳过空白字符
                while (i < argumentsString.Length && char.IsWhiteSpace(argumentsString[i]))
                    i++;
                
                // 越界检查
                if (i >= argumentsString.Length)
                    break;
                
                string argument = ExtractArgument(argumentsString, ref i);
                if (!string.IsNullOrEmpty(argument))
                    arguments.Add(argument.Trim());

                // 跳过空白字符
                while (i < argumentsString.Length && char.IsWhiteSpace(argumentsString[i]))
                    i++;

                // 越界检查
                if (i >= argumentsString.Length)
                    break;

                // 必定是逗号, 否则异常情况
                if (argumentsString[i] != ',')
                    throw new InvalidOperationException("Parser is invalid logic");
                i++;
            }
            
            return arguments.ToArray();
        }
        
        // 提取单个参数的方法，支持花括号和字符串字面量
        private static string ExtractArgument(string input, ref int index)
        {
            int start = index;
            
            if (input[index] == '"')
            {
                // 处理字符串字面量
                index++; // 跳过开始的引号
                while (index < input.Length)
                {
                    if (input[index] == '"' && (index == 0 || input[index - 1] != '\\'))
                    {
                        index++; // 跳过结束的引号
                        break;
                    }
                    index++;
                }
            }
            else if (input[index] == '{')
            {
                // 处理花括号内的内容
                int braceCount = 0;
                while (index < input.Length)
                {
                    if (input[index] == '{')
                        braceCount++;
                    else if (input[index] == '}')
                        braceCount--;
                    
                    index++;
                    
                    if (braceCount == 0)
                        break;
                }
            }
            else
            {
                // 处理普通参数（直到遇到逗号）
                while (index < input.Length && input[index] != ',')
                    index++;
            }
            
            return input[start..index];
        }
    }

    [System.AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
    public sealed class DefaultScriptAttribute : Attribute
    {
        public string DefaultScript;
        public DefaultScriptAttribute(string script)
        {
            this.DefaultScript = script;
        }
    }

    public static class DefaultScriptUtility
    {
        public static void WriteStyleMethodHelper(StreamWriter stream,MethodInfo methodInfo)
        {

        }

        public static void WriteDefaultScript(StreamWriter fs, Type type)
        {
            if (typeof(ScriptableObject).IsAssignableFrom(type) == false)
                throw new InvalidOperationException($"{type.FullName} is not inherited from {typeof(ScriptableObject).FullName}");
            var attr = type.GetCustomAttribute<DefaultScriptAttribute>();
            var typeName = type.Name;
            if (typeName.Contains('`'))
            {
                typeName = typeName[..typeName.LastIndexOf('`')];
            }
            switch (Editor.EditorController.instance.MainGameController.CurrentProjectDefaultFileStyle)
            {
                case ProjectDefaultFileStyle.CPP:
                    {
                        fs.WriteLine($"#include \"{typeName}.helper.h\"");
                        if (attr == null)
                        {
                            var scriptCalls = (from info in type.GetMembers(BindingFlags.Public | BindingFlags.Instance)
                                               where info is MethodInfo
                                               where info.GetCustomAttribute<ScriptableCallAttribute>(false) != null
                                               select info as MethodInfo).ToList();
                            if (scriptCalls.Count > 0)
                            {
                                foreach (var scriptCall in scriptCalls)
                                {
                                    fs.WriteLine($"#ifndef {scriptCall.Name}");
                                    fs.WriteLine($"#define {scriptCall.Name}({string.Join(',', (from param in scriptCall.GetParameters() select param.Name))})");
                                    fs.WriteLine($"#endif");
                                }
                            }
                        }
                        else
                        {
                            var text = attr.DefaultScript;
                            fs.Write(text);
                        }
                    }
                    break;
                case ProjectDefaultFileStyle.PY:
                    {

                    }
                    break;
            }
        }

        public static void OpenScriptFile(ScriptableObject so)
        {
            string path = so.ScriptPath;
            var ScriptEditor = so.GetRoot().RootGameController.WhichOpenScript;
            try
            {
                System.Diagnostics.Process.Start(string.Format($"{ScriptEditor}", $"\"{path}\""));
            }
            catch (Exception ex)
            {
                Debug.LogError($"Cannt open {path}: {string.Format($"{ScriptEditor}", $"\"{path}\"")}", so);
                Debug.LogException(ex, so);
            }
        }
    }

    public interface IScriptableObject
    {
        ScriptableObject SharedInterfaceScriptObject { get; }
    }

    #region ScriptableObject Inside

    public partial class ScriptableObject : IScriptableObject
    {
        /// <summary>
        /// 用于开放给倒置接口
        /// </summary>
        public ScriptableObject SharedInterfaceScriptObject => this;
    }

    public partial class ScriptableObject
    {
        // 时间点系统

        public static Dictionary<string, float> TimePointDelta = new();
        public static Dictionary<string, float> TimePoints = new();

        /// <summary>
        /// 重设指定时间线
        /// </summary>
        /// <param name="id">时间线ID，若不存在则创建</param>
        /// <param name="delta">当每次调用NextTimePoint函数时使用的单位值</param>
        /// <param name="value">初始化时间</param>
        [ScriptableCall(@"
<summary>
重设指定时间线
</summary>
<param name=""id"">时间线ID，若不存在则创建</param>
<param name=""delta"">当每次调用NextTimePoint函数时使用的单位值</param>
<param name=""value"">初始化时间</param>
")]
        public void ResetTimePoint(string id, string delta, string value)
        {
            TimePointDelta[id] = float.Parse(delta);
            TimePoints[id] = float.Parse(value);
        }

        /// <summary>
        /// 推动时间线前进
        /// </summary>
        /// <param name="id">时间线ID</param>
        /// <param name="times">前进次数，最终时间的增量为前进次数乘该时间线的单位值</param>
        [ScriptableCall(@"
<summary>
推动时间线前进
</summary>
<param name=""id"">时间线ID</param>
<param name=""times"">前进次数，最终时间的增量为前进次数乘该时间线的单位值</param>
")]
        public void NextTimePoint(string id, string times)
        {
            TimePoints[id] += TimePointDelta[id] * float.Parse(times);
        }

        /// <summary>
        /// 设置时间线的值
        /// </summary>
        /// <param name="id">时间线ID</param>
        /// <param name="value">次数，时间线的值将被设置为次数乘该时间线的单位值</param>
        [ScriptableCall(@"
<summary>
设置时间线的值
</summary>
<param name=""id"">时间线ID</param>
<param name=""value"">次数，时间线的值将被设置为次数乘该时间线的单位值</param>
")]
        public void SetTimePoint(string id, string value)
        {
            TimePoints[id] = TimePointDelta[id] * float.Parse(value);
        }
    }

    /// <summary>
    /// 上下文系统
    /// </summary>
    public partial class ScriptableObject
    {
        [Content] public Dictionary<string, float> ScriptContextSpace = new();

        public bool GetCompleteScriptContext(string key, out float value)
        {
            if (ScriptContextSpace.TryGetValue(key, out value) == false)
            {
                if (Parent == null)
                    return false;
                return Parent.GetCompleteScriptContext(key, out value);
            }
            return true;
        }

        public void GetCompleteScriptContext(ref Dictionary<string, float> context)
        {
            var current = this;
            while (current != null)
            {
                foreach (var key in current.ScriptContextSpace.Keys)
                {
                    context[key] = current.ScriptContextSpace[key];
                }
                current = current.Parent;
            }
        }

        /// <summary>
        /// 设置局部上下文变量，将会传递给子物体使用
        /// </summary>
        /// <param name="name">字符串</param>
        /// <param name="value">浮点数</param>
        [ScriptableCall(@"
<summary>
设置局部上下文变量，将会传递给子物体使用
</summary>
<param name=""name"">字符串</param>
<param name=""value"">浮点数</param>
")]
        public void SetContext(string name, string value)
        {
            ScriptContextSpace[name] = Parse(value);
        }

    }

    /// <summary>
    /// 数值解析工具
    /// </summary>
    public partial class ScriptableObject
    {
        private ExpressionContext ExpressionParserCreater()
        {
            ExpressionContext context = new();
            context.Imports.AddType(typeof(Mathf));
            Dictionary<string, float> vars = new();
            GetCompleteScriptContext(ref vars);
            foreach (var item in vars)
            {
                context.Variables[item.Key] = item.Value;
            }
            return context;
        }
        public static float OneBarTime = 1;

        /// <summary>
        /// <list type="bullet">从时间点列表<see cref="TimePoints"/>中获取</list>
        /// <list type="bullet">或是从上下文变量<see cref="GetCompleteScriptContext"/>中获取</list>
        /// <list type="bullet">或是从数据驱动对象<see cref="DDT{float}"/>的<see cref="float"/>泛型中获取</list>
        /// <list type="bullet">或是直接调用<see cref="float.Parse(string)"/></list>
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public float Parse(string value)
        {
            value = value.Trim();
            if(value.StartsWith("\"")&&value.EndsWith("\""))
            {
                value = value[1..^1];
            }
            if (TimePoints.TryGetValue(value, out var result))
                return result;
            if (GetCompleteScriptContext(value, out result))
                return result;
            if(value.EndsWith(']'))
            {
                {
                    Regex regex = new(@"^(.+)\[(.+)\]$");
                    var match = regex.Match(value);
                    if (match.Success)
                    {
                        return (FindWithPath(match.Groups[1].Value) as DDT).Datas[(int)this.Parse(match.Groups[2].Value)];
                    }
                }
                {
                    Regex regex = new(@"^(.+)\[\]$");
                    var match = regex.Match(value);
                    if (match.Success)
                    {
                        return (FindWithPath(match.Groups[1].Value) as DDT).Datas.Count;
                    }
                }
                throw new ArgumentException("value is end by ']' but not match on any invlid parse");
            }
            if (value.EndsWith('}'))
            {
                {
                    Regex regex = new(@"^\{\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\}$");
                    var match = regex.Match(value);
                    if (match.Success)
                    {
                        int barSplitTimes = int.Parse(match.Groups[1].Value);
                        int barCount = int.Parse(match.Groups[2].Value);
                        int tickCount = int.Parse(match.Groups[3].Value);
                        return (barCount + tickCount / (float)barSplitTimes) * OneBarTime;
                    }
                }
                throw new ArgumentException("value is end by '}' but not match on any invlid parse");
            }
            try
            {
                if (float.TryParse(value, out var _result))
                    return _result;
                else
                    return ExpressionParserCreater().CompileGeneric<float>(value).Evaluate();
            }
            catch(Exception ex)
            {
                throw new FormatException($"{value} is not support any Parser", ex);
            }
        }


        protected T ConvertValue<T>(string str)
        {
            return ConventionUtility.convert_xvalue<T>(str);
        }
    }

    /// <summary>
    /// 先天支持的工具函数
    /// </summary>
    public partial class ScriptableObject
    {
        [Content, SerializeField] private Vector3 
            EnterGameLocalPosition = Vector3.zero,
            EnterGameEulerAngles = Vector3.zero,
            EnterGameLocalScaling = Vector3.one;
        [Content, SerializeField] private bool IsSetObjectDisable = false;

        /// <summary>
        /// 设置坐标
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        [ScriptableCall(@"
<summary>
设置坐标
</summary>
<param name=""result""></param>
<param name=""y""></param>
<param name=""z""></param>
")]
        public void SetLocalPosition(string x, string y, string z)
        {
            EnterGameLocalPosition = new(Parse(x), Parse(y), Parse(z));
        }
        /// <summary>
        /// 设置欧拉角
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        [ScriptableCall(@"
<summary>
设置欧拉角
</summary>
<param name=""result""></param>
<param name=""y""></param>
<param name=""z""></param>
")]
        public void SetLocalEulerAngles(string x, string y, string z)
        {
            EnterGameEulerAngles = new(Parse(x), Parse(y), Parse(z));
        }
        /// <summary>
        /// 设置缩放
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        [ScriptableCall(@"
<summary>
设置缩放
</summary>
<param name=""result""></param>
<param name=""y""></param>
<param name=""z""></param>
")]
        public void SetLocalScaling(string x, string y, string z)
        {
            EnterGameLocalScaling = new(Parse(x), Parse(y), Parse(z));
        }

        /// <summary>
        /// 关闭该物体，
        /// 在面对如多Game场景时关闭某些GameWorld中默认存在的全局灯光等场景时非常有用
        /// </summary>
        [ScriptableCall(@"
<summary>
关闭该物体，
在面对如多Game场景时关闭某些GameWorld中默认存在的全局灯光等场景时非常有用
</summary>
")]
        public void SetObjectDisable()
        {
            IsSetObjectDisable = true;
        }

        private void ResetScriptableObjectEnterGameStatus()
        {
            transform.localPosition = EnterGameLocalPosition;
            transform.localEulerAngles = EnterGameEulerAngles;
            transform.localScale = EnterGameLocalScaling;
            if (IsSetObjectDisable)
            {
                gameObject.SetActive(false);
            }
        }
    }

    /// <summary>
    /// UpdatePerFrame相关
    /// </summary>
    public partial class ScriptableObject
    {
        [Content] public int UpdatePerFrame = 1;

        /// <summary>
        /// 指定多少个<see cref="TickType.Update"/>状态的<see cref="UpdateTicks(float, float, TickType)"/>执行一次更新,不会影响到子物体
        /// 属于性能优化的高级选项
        /// </summary>
        /// <param name="frame">每frame帧更新一次, 等于0代表不会在<see cref="TickType.Update"/>状态运行</param>
        [ScriptableCall(@"
<summary>
指定多少个Update状态的UpdateTicks执行一次更新,不会影响到子物体
属于性能优化的高级选项
</summary>
<param name=""frame"">每frame帧更新一次, 等于0代表不会在Update状态运行</param>
")]
        public void SetUpdatePerFrame(string frame)
        {
            UpdatePerFrame = Mathf.Max(1, int.Parse(frame));
        }
    }

    /// <summary>
    /// EnableScript相关
    /// </summary>
    public partial class ScriptableObject
    {

        private bool isEnableScript = false;

        public void EnableScript(string sourcePath, string scriptPath, string scriptType, ScriptableObject parent)
        {
#if UNITY_EDITOR||true
            s_PreparePerfMarker = new(ScriptName);
#endif
            if (isEnableScript)
            {
                Debug.LogError($"ScriptableObject is currently enableScript, start coroutine {nameof(UnloadScript)} to disable", this);
                return;
            }
            this.SourcePath = sourcePath;
            this.ScriptPath = scriptPath;
            this.ScriptTypename = scriptType;
            this.Parent = parent;

            this.name = ScriptName;

            isEnableScript = true;
            // 只有RootObject的parent会是空的
            if (parent != null)
            {
                MyHierarchyItem = parent.MyHierarchyItem.GetHierarchyItem().CreateSubPropertyItem(1)[0];
            }
            else
            {
                MyHierarchyItem = HierarchyWindow.instance.CreateRootItemEntryWithBinders(1)[0];
            }
            MyHierarchyItem.GetHierarchyItem().title = this.ScriptName + $"<{scriptType}>";
            MyHierarchyItem.GetHierarchyItem().target = this;
            MyHierarchyItem.GetHierarchyItem().ButtonGameObject.GetComponent<Editor.UI.RightClick>().ScriptObjectMenu = OnHierarchyItemRightClick;
            //var parentHierarchyItem = MyHierarchyItem.GetParent();
            //if (parentHierarchyItem != null)
            //    parentHierarchyItem.GetPropertyListItem().RefreshChilds();
        }

        public bool EnsureEnableScript()
        {
            if (isEnableScript == false)
            {
                Debug.LogError("ScriptableObject is currently disableScript", this);
            }
            return isEnableScript;
        }
    }

    /// <summary>
    /// <para>使用<see cref="ScriptableCallAttribute"/>标记可编辑脚本所能够调用的函数，并附加注释</para>
    /// <para>使用<see cref="DefaultScriptAttribute"/>标记派生类，并附加默认模板</para>
    /// </summary>
    public partial class ScriptableObject : SerializedMonoBehaviour, IHierarchyItemClickEventListener
    {

        public static Dictionary<string, Type> FastScriptableObjectTypen = new();
        public static bool IsAutoPlay = false;

        public string SourcePath = "";
        public string ScriptName = "";
        public string ScriptPath;
        public string ScriptTypename;

#if UNITY_EDITOR||true
        public ProfilerMarker s_PreparePerfMarker;
#endif
        public ScriptableObject Parent;

        public RootObject GetRoot()
        {
            if (Parent == null)
                return this as RootObject;
            if (Parent is RootObject result)
                return result;
            else return Parent.GetRoot();
        }

        public List<ScriptableObject> Childs = new();

        // Hierarchy

        public PropertiesWindow.ItemEntry MyHierarchyItem;
        public static PropertiesWindow.ItemEntry AllScriptableObjectCounterHierarchyItem;
        public static int AllScriptableObjectCounter = 0;

        // Cache

        public static Dictionary<Type, Dictionary<string, MemberInfo>> MethodInvokerCache = new();

        public const string RootObjectQuickPath = "project/";

        public ScriptableObject FindWithPath(string path, bool isMustExist = true)
        {
            if (string.IsNullOrEmpty(path))
            {
                if (isMustExist)
                    throw new Exception("path is null or empty");
                else
                    return null;
            }

            // GetParent
            ScriptableObject result = Parent;
            if (path.Replace('\\','/').ToLower().StartsWith(RootObjectQuickPath))
            {
                result = GetRoot();
                path = path[RootObjectQuickPath.Length..];
            }

            if (Parent == null)
            {
                throw new InvalidOperationException($"Root is nosupport to {nameof(FindWithPath)}");
            }

            // Find
            var components = path.Split('/', '\\');
            components[^1] = new ToolFile(components[^1]).GetFilename(true);
            foreach (var component in components)
            {
                if (component == "..")
                    result = result.Parent;
                else if (component == "." || string.IsNullOrEmpty(component))
                    continue;
                else
                {
                    int index = 0;
                    string targetScriptObjectPath = component;
                    Regex regex = new(@"^(.*)\[(\d*)\]$");
                    var match = regex.Match(component);
                    if (match.Success)
                    {
                        targetScriptObjectPath = match.Groups[1].Value;
                        index = int.Parse(match.Groups[2].Value);
                    }
                    var target = result.Childs.FirstOrDefault(x =>
                    {
                        bool stats = x.ScriptName == targetScriptObjectPath;
                        if (index == 0)
                            return stats;
                        else if (stats)
                            index--;
                        return false;
                    });
                    if (target != null)
                        result = target;
                    else
                    {
                        if (isMustExist)
                            throw new Exception($"{component} in {path} is not found");
                        else
                        {
                            Debug.Log($"{component} in {path} is not found", this);
                            return null;
                        }
                    }
                }
            }
            return result;
        }

        public IEnumerator LoadSubScriptAsync([In] string type, [In] string path, [Opt] Action<ScriptableObject> callback)
        {
            // 判断类型是否合法
            if (DefaultInstantiate.GetScriptableObjectInstantiate().TryGetValue(type, out var creater) == false)
            {
                Debug.LogError($"{type} is not exist or {type}'s Instantiater is not valid", this);
                callback?.Invoke(null);
                yield break;
            }
            // 生成对象
            var child = creater();
            // 路径预处理
            if (path.Replace('\\', '/').ToLower().StartsWith(RootObjectQuickPath))
                path = $"{new ToolFile(GetRoot().SourcePath) | path[RootObjectQuickPath.Length..]}";
            // 获取文件
            ToolFile file;
            if (File.Exists(path))
                file = new(path);
            else
                file = new ToolFile(SourcePath) | path;
            // 找不到脚本
            if (file.Exists() == false)
            {
                Debug.LogError($"{file}<{path}> is not found", this);
                callback?.Invoke(null);
                yield break;
            }
            child.ScriptName = file.GetName(true);
            child.transform.SetParent(this.transform);
            child.transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
            child.transform.localScale = Vector3.one;
            child.EnableScript(file.GetCurrentDirName(), Path.Combine(file.GetCurrentDirName(), file.GetName(false)), type, this);

            // Add Child
            Childs.Add(child);

            // Load Child Script
            yield return child.LoadScript(file.LoadAsText());

            callback?.Invoke(child);
        }

        /// <summary>
        /// 加载子脚本
        /// </summary>
        /// <param name="type">指定类型</param>
        /// <param name="path">指定脚本，可用决定路径或与当前脚本目录的相对路径</param> 
        [ScriptableCall(@"
<summary>
加载子脚本
</summary>
<param name=""type"">指定类型</param>
<param name=""path"">指定脚本，可用决定路径或与当前脚本目录的相对路径</param>
")]
        public IEnumerator LoadSubScript([In] string type, [In] string path)
        {
            yield return LoadSubScriptAsync(type, path, null);
        }

        private enum ParseStats
        {
            None,
            Continue,
            Break
        }

        // TODO : 过多的逻辑都挤在这里, 需要拆分
        // TODO : 如何统计整个游戏关卡是否加载完成, 尤其是此处的resultEnumerator与ILoadAssetBundle, 将会同时存在多条异步加载的时间线
        private IEnumerator ParseScript2Expr(string script)
        {
            // 预处理
            var lines = script.Split('\n');
            string preprocessing = "";
            foreach (var line in lines)
            {
                var expr = line.Trim();
                //注释语句(py风格与c风格)
                if (expr.StartsWith('#') || expr.StartsWith("//"))
                    continue;
                preprocessing += expr;
            }
            var exprs = preprocessing.Split(';');

            ParseStats ParseCommandAndParamaterWords(int commandIterator, ref string command, ref string[] words, ref Dictionary<string,string> withVariables)
            {
                var expr = exprs[commandIterator].Trim();
                //空语句
                if (string.IsNullOrEmpty(expr))
                    return ParseStats.Continue;
                //作用域标识符
                if (expr.StartsWith('{') || expr.EndsWith('}'))
                    //忽略导入语句(py风格)
                    if (expr.StartsWith("import ") || expr.StartsWith("from "))
                        return ParseStats.Continue;
                //进入主函数后中断读取
                if (expr.StartsWith("if __name__") || expr.StartsWith("int main") || expr.StartsWith("void main"))
                    return ParseStats.Break;
                if (MethodInvokerCache.ContainsKey(this.GetType()) == false)
                {
                    MethodInvokerCache.Add(this.GetType(), new());
                }
                //函数解析
                (command, words, withVariables) = ScriptCallUtility.ParseFunctionCall(expr);
                if (string.IsNullOrEmpty(command))
                    return ParseStats.Continue;
                for (int i = 0, e = words.Length; i < e; i++)
                {
                    //去除
                    words[i] = words[i].Trim('\"');
                }

                return ParseStats.None;
            }

            // Runtime Structures
            Dictionary<string, int> commandLabels = new();
            for (int commandIterator = 0; commandIterator < exprs.Length; commandIterator++)
            {
                string command = null;
                string[] words = null;
                Dictionary<string, string> withVariables = new();
                var stats = ParseCommandAndParamaterWords(commandIterator, ref command, ref words,ref withVariables);
                if (stats == ParseStats.Continue)
                    continue;
                else if (stats == ParseStats.Break)
                    break;
                var expr = exprs[commandIterator].Trim();
                if (command=="label")
                {
                    if(words.Length<1)
                    {
                        Debug.LogError($"in line \"{expr}\", label miss argument", this);
                    }
                    commandLabels[words[0]] = commandIterator;
                }
            }
            // Main Loop
            for (int commandIterator = 0; commandIterator < exprs.Length; commandIterator++)
            {
                // Run Stats
                string command = null;
                string[] words = null;
                Dictionary<string, string> withVariables = new();
                var stats = ParseCommandAndParamaterWords(commandIterator, ref command, ref words, ref withVariables);
                if (stats == ParseStats.Continue)
                    continue;
                else if (stats == ParseStats.Break)
                    break;

                // Logic
                if (command == "label")
                {
                    continue;
                }
                var expr = exprs[commandIterator].Trim();
                if (command == "goto")
                {
                    if (words.Length < 3)
                    {
                        Debug.LogError($"in line \"{expr}\", goto need 3 arguments, but currently less", this);
                        yield break;
                    }
                    float a = Parse(words[0]), b = Parse(words[1]);
                    if (a > b)
                    {
                        commandIterator = commandLabels[words[2]];
                    }
                    continue;
                }

                // Functions
                var paramsList = (from word in words where string.IsNullOrEmpty(word.Trim()) == false select (object)word.Trim()).ToArray();
                if (MethodInvokerCache[this.GetType()].TryGetValue(command, out MemberInfo commandInfo) == false)
                {
                    var commandInfo_try = ConventionUtility.SeekMemberInfo(this, new Type[] { typeof(ScriptableCallAttribute) }, null);
                    commandInfo_try.RemoveAll(x => x.Name != command);
                    if (commandInfo_try.Count <= 0)
                    {
                        Debug.LogError($"in line {expr}, {command} is unable to invoke, because the function is not found", this);
                        continue;
                    }
                    commandInfo = commandInfo_try[0];
                    MethodInvokerCache[this.GetType()].Add(command, commandInfo);
                }
                Debug.Log($"in line \"{expr}\" of \"{ScriptPath}\", {command} is try to invoke", this);
                IEnumerator resultEnumerator = null;

                // 处理 with 子句：保存当前变量状态并设置新变量
                Dictionary<string, float> originalVariables = new Dictionary<string, float>();
                if (withVariables.Count > 0)
                {
                    foreach (var kvp in withVariables)
                    {
                        // 保存原始值（如果存在）
                        if (ScriptContextSpace.TryGetValue(kvp.Key, out var originalValue))
                        {
                            originalVariables[kvp.Key] = originalValue;
                        }
                        // 设置新值
                        ScriptContextSpace[kvp.Key] = Parse(kvp.Value);
                    }
                }

                try
                {
                    // 调用成功
                    if (ConventionUtility.TryInvokeMember(commandInfo, this, out var invokeResult, paramsList) == true)
                    {
                        Debug.Log($"in line \"{expr}\" of \"{ScriptPath}\", {command} is invoke succeed", this);
                        // 尤其用于加载子类时
                        if (invokeResult != null && invokeResult is IEnumerator _resultEnumerator)
                        {
                            resultEnumerator = _resultEnumerator;
                        }
                    }
                    // 调用失败
                    else
                    {
                        MethodInvokerCache[this.GetType()].Remove(command);
                        var attr = commandInfo.GetCustomAttribute<ScriptableCallAttribute>();
                        if (attr == null)
                            Debug.LogError($"in line \"{expr}\" of \"{ScriptPath}\", {command} is unable to invoke", this);
                        else
                            Debug.LogError($"in line \"{expr}\" of \"{ScriptPath}\", {command} is failed to invoke, see: {attr.Description}", this);
                    }
                }
                catch (Exception ex)
                {
                    Debug.LogError($"in line \"{expr}\" of \"{ScriptPath}\", {command}({string.Join(',', words)}) is failed to invoke , see: {ex.Message}", this);
                    Debug.LogException(ex, this);
                    yield break;
                }

                yield return resultEnumerator;

                // 恢复 with 子句中的变量状态
                if (withVariables.Count > 0)
                {
                    foreach (var kvp in withVariables)
                    {
                        if (originalVariables.ContainsKey(kvp.Key))
                        {
                            // 恢复原始值
                            ScriptContextSpace[kvp.Key] = originalVariables[kvp.Key];
                        }
                        else
                        {
                            // 删除不存在的变量
                            ScriptContextSpace.Remove(kvp.Key);
                        }
                    }
                }
            }
        }

        [Content] private bool IsEnableUpdate = false;

        public virtual IEnumerator LoadScript(string script)
        {
            if (EnsureEnableScript() == false)
            {
                yield break;
            }
            // 增数
            {
                AllScriptableObjectCounter++;
                AllScriptableObjectCounterHierarchyItem.GetHierarchyItem().text = $"ScriptableObjectCount: {AllScriptableObjectCounter}";
            }
            yield return ParseScript2Expr(script);
            IsEnableUpdate = true;
        }

        private void Reset()
        {
            StartCoroutine(UnloadScript());
        }

        public virtual IEnumerator UnloadScript()
        {
            if (EnsureEnableScript())
            {
                this.name = "<Unloading>";
                try
                {
                    foreach (var child in Childs)
                    {
                        yield return child.UnloadScript();
                    }
                }
                finally
                {
                    // 清理各种状态
                    IsEnableUpdate = false;
                    if (MyHierarchyItem != null)
                    {
                        // 卸载UI
                        MyHierarchyItem.Release();
                        MyHierarchyItem = null;
                    }
                    this.isEnableScript = false;
                    this.Parent = null;
                    this.name = "<Unload>";
                    // 清理Cache
                    //
                    // 减数
                    AllScriptableObjectCounter--;
                    AllScriptableObjectCounterHierarchyItem.GetHierarchyItem().text = $"ScriptableObjectCount: {AllScriptableObjectCounter}";
                }
            }
        }

        public enum TickType
        {
            Reset,
            Pause,
            Start,
            Update//,
            //LateUpdate
        }

        [Content, SerializeField] private int ScriptUpdateCounter = 0;
        public void ScriptUpdate(float currentTime, float deltaTime, TickType tickType)
        {
            if (IsEnableUpdate == false)
                return;
            if (gameObject.activeInHierarchy == false)
                return;
#if UNITY_EDITOR||true
            s_PreparePerfMarker.Begin(this);
#endif
            if (tickType == TickType.Reset)
            {
                ResetEnterGameStatus();
            }
            // UpdateTicks
            if (UpdatePerFrame > 0)
            {
                if (ScriptUpdateCounter % UpdatePerFrame == 0)
                    UpdateTicks(currentTime, deltaTime, tickType);
                ScriptUpdateCounter += tickType == TickType.Update ? 1 : 0;
            }
            // Childs UpdateTicks
            foreach (var child in Childs)
            {
                child.ScriptUpdate(currentTime, deltaTime, tickType);
            }
#if UNITY_EDITOR||true
            s_PreparePerfMarker.End();
#endif
        }

        protected virtual void UpdateTicks(float currentTime, float deltaTime, TickType tickType)
        {

        }

        public virtual void ResetEnterGameStatus()
        {
            ResetScriptableObjectEnterGameStatus();
        }

        public virtual void OnHierarchyItemRightClick(RectTransform item)
        {
            DefaultInstantiate.OpenInstantiateMenu(this, item);
        }

        public virtual void OnHierarchyItemClick(HierarchyItem item)
        {

        }
    }

    #endregion

    public interface IAssetBundleLoader : IScriptableObject
    {
        public RootObject GetRoot();
    }

    public static class AssetBundlesLoadHelper
    {
        public struct Entry
        {
            public AssetBundle assetBundle;
            public int referenceCounter;
            public PropertiesWindow.ItemEntry entry;

            public Entry(AssetBundle assetBundle, int referenceCounter = 0, PropertiesWindow.ItemEntry entry = null)
            {
                this.assetBundle = assetBundle;
                this.referenceCounter = referenceCounter;
                this.entry = entry;
            }
        }

        public static Dictionary<string, Entry> AssetBundleCounter = new();
        private static Dictionary<string, IEnumerator> AssetBundleLoading = new();
        private static PropertiesWindow.ItemEntry AssetBundlesItemEntry = null;

        public static IEnumerator LoadAssetBundleAsync(string ab, Action<AssetBundle> callback)
        {
            if (AssetBundleCounter.TryGetValue(ab, out var result))
            {
                result.referenceCounter++;
                callback?.Invoke(result.assetBundle);
                yield break;
            }
            if (AssetBundleLoading.TryGetValue(ab, out var tir))
            {
                yield return tir;
                if (AssetBundleCounter.TryGetValue(ab, out result))
                {
                    result.referenceCounter++;
                    callback?.Invoke(result.assetBundle);
                    yield break;
                }
            }
            var file = new ToolFile(PlatformIndicator.StreamingAssetsPath) | "AssetBundle/";
#if PLATFORM_WINDOWS
            file = file | "Windows";
#endif
            file = file | ab;
#if ENABLE_CLASS_Interaction
            var downloader = new Interaction(file.GetFullPath());
#else
            var downloader = new ToolFile(file.GetFullPath());
#endif
            if (AssetBundlesItemEntry == null)
            {
                var hierarchy = HierarchyWindow.instance;
                AssetBundlesItemEntry = hierarchy.CreateRootItemEntryWithBinders(nameof(AssetBundlesLoadHelper))[0];
                AssetBundlesItemEntry.ref_value.GetComponent<HierarchyItem>().title = nameof(AssetBundlesLoadHelper);
            }
            var abLoadingItem = AssetBundlesItemEntry.ref_value.GetComponent<HierarchyItem>().CreateSubPropertyItem(1)[0];
            var loadingHierarchyItem = abLoadingItem.ref_value.GetComponent<HierarchyItem>();
            loadingHierarchyItem.title = $"{ab}<Loading>";
            var ir = downloader.LoadAsAssetBundle(p =>
            {
                loadingHierarchyItem.title = $"{ab}<Loading{(int)(p * 100)}%>";
            }, x =>
            {
                if (x != null)
                {
                    loadingHierarchyItem.title = $"{ab}";
                    var assets = x.GetAllAssetNames();
                    var subAssetsItems = loadingHierarchyItem.CreateSubPropertyItem(assets.Length);
                    for (int i = 0, e = assets.Length; i < e; i++)
                    {
                        subAssetsItems[i].ref_value.GetComponent<HierarchyItem>().title = Path.GetFileName(assets[i]);
                    }
                    AssetBundleCounter[ab] = new(x, 1, abLoadingItem);
                }
                else
                {
                    loadingHierarchyItem.title = $"{ab}<Failed>";
                }
                AssetBundleLoading.Remove(ab);
                callback?.Invoke(x);
            });
            AssetBundleLoading.Add(ab, ir);
            yield return ir;
            AssetBundleLoading.Remove(ab);
        }

        public static IEnumerator LoadAssetBundle(this IAssetBundleLoader self, string ab, Action<AssetBundle> callback)
        {
            Debug.Log($"{self.SharedInterfaceScriptObject.ScriptName}.{nameof(LoadAssetBundle)}({ab})", self.SharedInterfaceScriptObject);
            yield return LoadAssetBundleAsync(ab, callback);
        }

        public static IEnumerator UnloadAssetBundle(this IAssetBundleLoader self, string ab)
        {
            // Editor中暂时忽略卸载功能
            yield break;
        }
    }

    public abstract class TimelineScriptObject : ScriptableObject
    {
        public static PropertiesWindow TimelineWindow;
        private PropertiesWindow.ItemEntry MyTimelineEntry;
        private Editor.UI.TimelineItem MyTimelineItem;
        //[SerializeField] private bool IsTimelineItemShow = false;
        private static List<TimelineScriptObject> TimelineScriptObjectWhichOnShow = new();

        private static UnityEngine.UI.Image CacheLastFocusImage;
        private static Color CacheLastFocusImageOriginColor = new(1, 1, 1, 0.01f);
        private static Color FocusImageColor = new Color(1f, 47f / 51f, 0.0156862754f, 0.1f);

        public override IEnumerator LoadScript(string script)
        {
            MyTimelineEntry = TimelineWindow.CreateRootItemEntries(1)[0];
            MyTimelineItem = MyTimelineEntry.ref_value.GetComponent<Editor.UI.TimelineItem>();
            yield return base.LoadScript(script);
            MyTimelineItem.title = ScriptName;
            MyTimelineItem.AddListener(() =>
            {
                HierarchyWindow.instance.MakeFocusOn(MyHierarchyItem.GetHierarchyItem());
                if (CacheLastFocusImage != null)
                    CacheLastFocusImage.color = CacheLastFocusImageOriginColor;
                CacheLastFocusImage = MyHierarchyItem.GetHierarchyItem().ButtonGameObject.GetComponent<UnityEngine.UI.Image>();
                CacheLastFocusImage.color = FocusImageColor;
            });
            SetupTimelineItem(MyTimelineItem);
            // 暂时的逻辑是总是展示的
            {
                TimelineScriptObjectWhichOnShow.Add(this);
                //IsTimelineItemShow = true;
            }
        }

        public override void OnHierarchyItemClick(HierarchyItem item)
        {
            //foreach (var tso in TimelineScriptObjectWhichOnShow)
            //{
            //    tso.IsTimelineItemShow = false;
            //    tso.MyTimelineItem.RawButton.gameObject.SetActive(false);
            //}
            //TimelineScriptObjectWhichOnShow.Clear();
            //ShowTimelineItemWithChilds();
        }

        //protected virtual void ShowTimelineItemWithChilds()
        //{
        //    ScriptableObject parent = this;
        //    List<ScriptableObject> childs = this.Childs;
        //    if (parent is TimelineScriptObject ptso)
        //    {
        //        ptso.IsTimelineItemShow = true;
        //    }
        //    foreach (var child in childs)
        //    {
        //        if (child is TimelineScriptObject tso)
        //        {
        //            tso.IsTimelineItemShow = true;
        //        }
        //    }
        //}

        protected override void UpdateTicks(float currentTime, float deltaTime, TickType tickType)
        {
            base.UpdateTicks(currentTime, deltaTime, tickType);
            //if (IsTimelineItemShow)
            //{
                MyTimelineItem.ResizeOnTimeline();
            //}
        }

        protected abstract void SetupTimelineItem(Editor.UI.TimelineItem item);

        protected virtual Color GetTimelineItemColor()
        {
            static float Foo(uint hash)
            {
                float a= (hash % 10) * 0.1f;
                return a;
            }

            var a1 = (uint)this.GetType().GetHashCode();
            var a2 = (uint)a1.ToString().GetHashCode();
            var a3 = (uint)(a2.ToString().GetHashCode() >> 5);
            var color = new Vector3(Foo(a1), Foo(a2), Foo(a3)).normalized;
            return new(color.x, color.y, color.z);
        }

        public override IEnumerator UnloadScript()
        {
            yield return base.UnloadScript();
            MyTimelineItem.RawButton.onClick.RemoveAllListeners();
            MyTimelineEntry.Release();
            MyTimelineEntry = null;
            MyTimelineItem = null;
        }
    }
}