using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
using AssetManagement;
using Games.GlobeDefine;
using GCGame.Table;
using Module.Log;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.UI;
using Object = UnityEngine.Object;
#if UNITY_EDITOR
using UnityEditor;

#endif

/// <summary>
///     Author: Blastom
///     通用工具类型代码
/// </summary>
public static class CommonUtility
{
    /// <summary>
    ///     客户端转到服务器位置精度的倍数
    /// </summary>
    public const float clientToServerPos = 10000f;

    /// <summary>
    ///     服务器转到客户端位置的精度倍数
    /// </summary>
    public const float serverToClientPos = 1f / clientToServerPos;

    private const int _maxJumpRecursive = 10;

    // 默认每次跳跃动画花费的时间
    private const float _jumpAnimTime = 1f;

    private static float _lastGetUnityTime;
    private static int   _lastGetTime;

    /// <summary>
    ///     数组Find方法
    /// </summary>
    public static T Find<T>(this T[] array, Predicate<T> condition)
    {
        var index = array.FindIndex(condition);
        return index < 0 ? default(T) : array[index];
    }

    /// <summary>
    ///     数组FindIndex方法
    /// </summary>
    public static int FindIndex<T>(this T[] array, Predicate<T> condition)
    {
        var index = -1;
        for (var i = 0; i < array.Length; i++)
            if (condition(array[i]))
            {
                index = i;
                break;
            }

        return index;
    }

    public static string RemoveExtension(this string assetPath)
    {
        var i = assetPath.LastIndexOf('.');
        if (i > 0)
            assetPath = assetPath.Remove(i);
        return assetPath;
    }

    /// <summary>
    ///     数组Contain方法
    /// </summary>
    public static bool Contain<T>(this T[] array, T item)
    {
        var result = false;
        for (var i = 0; i < array.Length; i++)
            if (array[i].Equals(item))
            {
                result = true;
                break;
            }

        return result;
    }

    public static string GetHierarchyName(this Transform transform)
    {
        var builder = new StringBuilder();
        builder.Append(transform.gameObject.name);
        transform = transform.parent;
        while (transform)
        {
            builder.Insert(0, transform.gameObject.name + "/");
            transform = transform.parent;
        }

        return builder.ToString();
    }

    public static void ToCopyClip(string text)
    {
        var textEditor = new TextEditor { text = text };
        textEditor.SelectAll();
        textEditor.Copy();
    }

    /// <summary>
    ///     将用Vector2表示的方向，转换为服务器弧度值
    /// </summary>
    public static int DirToServerRadian(Vector2 axis)
    {
        return DirToServerRadian(axis.x, axis.y);
    }

    /// <summary>
    ///     将用x和z表示的方向，转换为服务器弧度值
    /// </summary>
    public static int DirToServerRadian(float x, float z)
    {
        var dirRadian = Mathf.Atan2(z, x);
        if (dirRadian < 0)
            dirRadian += 2 * Mathf.PI;
        return Mathf.FloorToInt(dirRadian * 100f);
    }

    /// <summary>
    ///     将服务器弧度值转换为客户端旋转方向
    /// </summary>
    public static Quaternion ServerRadianToQuaternion(int dirRadian)
    {
        var radian = Mathf.PI * 0.5f - dirRadian * 0.01f;
        return Quaternion.Euler(0f, radian * Mathf.Rad2Deg, 0f);
    }

    /// <summary>
    ///     确保物体拥有组件T
    /// </summary>
    public static T EnsureComponent<T>(this GameObject gameObject) where T : Component
    {
        var component = gameObject.GetComponent<T>();
        if (component == null)
            component = gameObject.AddComponent<T>();
        return component;
    }

    /// <summary>
    ///     检查物体是否拥有组件
    /// </summary>
    public static bool HasComponent<T>(this GameObject gameObject) where T : Component
    {
        var component = gameObject.GetComponent<T>();
        return component != null;
    }

    /// <summary>
    ///     检查物体是否拥有组件
    /// </summary>
    public static bool HasComponent<T>(this Component item) where T : Component
    {
        return HasComponent<T>(item.gameObject);
    }

    /// <summary>
    ///     删除GameObject名称后面的（Clone）
    /// </summary>
    public static void TrimCloneInName(this GameObject gameObject)
    {
        const string clone = "(Clone)";
        var          name  = gameObject.name;
        if (name.EndsWith(clone))
        {
            name            = name.Remove(name.Length - clone.Length);
            gameObject.name = name;
        }
    }

    /// <summary>
    ///     获得平方数
    /// </summary>
    public static float ToSquare(this float source)
    {
        return source * source;
    }

    /// <summary>
    ///     整数转换为掩码数值
    /// </summary>
    public static int ToFlag(this int i)
    {
        return 1 << i;
    }

    /// <summary>
    ///     千分秒整数时间转化为浮点时间
    /// </summary>
    public static float ToClientTime(this int time)
    {
        return time * 0.001f;
    }

    /// <summary>
    ///     检查一个整数是否包含一个标志位
    /// </summary>
    public static bool ContainFlag(this int source, int flag)
    {
        return flag > 0 && (source & flag) == flag;
    }

    /// <summary>
    ///     将一个整数位替换为新的数值
    /// </summary>
    public static int ReplaceFlag(this int source, int flag, bool isOn)
    {
        return isOn ? source | flag : source & ~flag;
    }

    /// <summary>
    ///     复制RectTransform参数
    /// </summary>
    public static void CopyTo(this RectTransform source, RectTransform target)
    {
        target.pivot            = source.pivot;
        target.anchorMin        = source.anchorMin;
        target.anchorMax        = source.anchorMax;
        target.anchoredPosition = source.anchoredPosition;
        target.sizeDelta        = source.sizeDelta;
        target.SetParent(source.parent, false);
    }

    /// <summary>
    ///     高精度输出Vector3数值的方法
    /// </summary>
    public static string ToPreciseString(this Vector3 source)
    {
        return string.Format("({0}, {1}, {2})", source.x, source.y, source.z);
    }

    /// <summary>
    ///     高精度输出Vector2数值的方法
    /// </summary>
    public static string ToPreciseString(this Vector2 source)
    {
        return string.Format("({0}, {1})", source.x, source.y);
    }

    /// <summary>
    ///     按照Root偏移一个本地Offset之后的世界位置
    /// </summary>
    /// <param name="root">原始坐标</param>
    /// <param name="offset">偏移数值</param>
    /// <returns>偏移后世界坐标</returns>
    public static Vector3 RootOffsetPosition(Transform root, Vector3 offset)
    {
        return root.localToWorldMatrix.MultiplyPoint3x4(offset);
    }

    public static AnimationCurve GetAnimationCurveById(int shakeId)
    {
        AnimationCurve result = null;
        if (shakeId > 0)
        {
            var keyFrameList = TableManager.GetAnimationCurveByID(shakeId);
            if (keyFrameList != null && keyFrameList.Count > 0)
            {
                result = new AnimationCurve();
                for (var i = 0; i < keyFrameList.Count; i++)
                {
                    var data = keyFrameList[i];
                    var keyFrame =
                        new Keyframe(data.Time, data.Value, data.InTangent, data.OutTangent)
                        {
                            tangentMode = data.TangentMode
                        };
                    result.AddKey(keyFrame);
                }

                result.preWrapMode  = (WrapMode)keyFrameList[0].PreWrapMode;
                result.postWrapMode = (WrapMode)keyFrameList[0].PostWrapMode;
            }
        }
#if UNITY_EDITOR
        if (result == null)
            LogModule.ErrorLog(string.Format("无法获得id为{0}的动画曲线！", shakeId));
#endif
        return result;
    }

    /// <summary>
    ///     将一个数值校正到循环范围内
    /// </summary>
    public static float LoopFloat(float source, float minValue, float maxValue)
    {
        var cycle      = maxValue - minValue;
        var multiplier = Mathf.Floor((source - minValue) / cycle);
        return source - multiplier * cycle;
    }

    /// <summary>
    ///     设置自己和子节点到某个layer
    /// </summary>
    public static void SetLayerRecursively(this GameObject gameObject, string layerName)
    {
        var layer = LayerMask.NameToLayer(layerName);
        SetLayerRecursively(gameObject, layer);
    }

    /// <summary>
    ///     设置自己和子节点到某个layer
    /// </summary>
    public static void SetLayerRecursively(this GameObject gameObject, int layer)
    {
        SetLayerRecursively(gameObject.transform, layer);
    }

    private static void SetLayerRecursively(Transform transform, int layer)
    {
        transform.gameObject.layer = layer;
        foreach (Transform child in transform)
            SetLayersRecursively(child, layer);
    }

    public static Transform FindIgnoreCase(this Transform root, string name)
    {
        Transform result = null;
        foreach (Transform child in root)
            if (string.Equals(child.gameObject.name, name, StringComparison.CurrentCultureIgnoreCase))
            {
                result = child;
                break;
            }

        return result;
    }

    /// <summary>
    ///     将物体转换为目标类型，转换失败输出错误和物体路径，用于代替项目中使用as转换屏蔽错误的情况。
    /// </summary>
    public static TTarget TryCastToType<TTarget>(this MonoBehaviour source) where TTarget : MonoBehaviour
    {
        var target = source as TTarget;
        if (target == null)
            LogModule.ErrorLog(string.Format("无法将组件{0}转换为{1}, 所在路径{2}", source.GetType(), typeof(TTarget),
                                             source.transform.GetHierarchyName()));
        return target;
    }

    /// <summary>
    ///     试图获得一个数据表，获得失败输出错误，用于代替项目中获得空数据后跳过的情况
    /// </summary>
    public static TTarget TryGetTable<TTarget>(int index, Func<int, TTarget> func) where TTarget : class
    {
        var target = func(index);
        if (target == null)
            LogModule.ErrorLog(string.Format("无法获得id = {0}，类型 = {1}的数据表！", index, typeof(TTarget)));
        return target;
    }

    // 临时使用的Resources.Load接口 - 后期考虑改为同步读取预加载的AssetBundle
    public static Material LoadSharedMaterial(string name)
    {
        return LoadFromResources<Material>(name);
    }

    public static bool IsCharacterShader(this Shader shader)
    {
        //return shader.name.StartsWith(_characterShaderHeading, StringComparison.CurrentCultureIgnoreCase);
        // 2019.04.08 过滤粒子
        // 之前有不过滤Shader名的情况，无法确认具体需要哪一些组合
        // 注：particle 有particle/ 和 particles/ 等多种组合，搞正则表达式Loose End会更多
        return !shader.name.Contains("particle", StringComparison.CurrentCultureIgnoreCase);
    }

    /// <summary>
    ///     技能是否是一个以地面为目标的技能
    /// </summary>
    public static bool IsTargetGround(this Tab_SkillEx skillEx)
    {
        var selector = GetSkillSelector(skillEx);
        if (selector == null)
            return false;
        return selector.RangCenter > 0 || selector.RangType > 2;
    }

    /// <summary>
    ///     技能是否是一个冲锋技能
    /// </summary>
    public static bool IsMoveSkill(this Tab_SkillEx skillEx)
    {
        return GetMoveSkillImpact(skillEx) != null;
    }

    /// <summary>
    ///     获得技能的冲锋模块Impact
    /// </summary>
    public static Tab_Impact GetMoveSkillImpact(this Tab_SkillEx skillEx)
    {
        Tab_Impact result      = null;
        var        impactCount = skillEx.getImpactIdCount();
        for (var i = 0; i < impactCount; i++)
        {
            var impactId = skillEx.GetImpactIdbyIndex(i);
            if (impactId >= 0)
            {
                var impact = TableManager.GetImpactByID(impactId);
                if (GlobeVar.moveSkillLogicIds.Contain(impact.LogicID))
                {
                    result = impact;
                    break;
                }
            }
        }

        return result;
    }

    /// <summary>
    ///     技能是否存在下一段。注：普攻不是这个逻辑。
    /// </summary>
    public static bool HasNextCombo(this Tab_SkillEx skillEx)
    {
        //var hasNext = false;
        //if (skillEx.NextStageSkillId >= 0)
        //{
        //    var nextSkill = GameManager.gameManager.PlayerDataPool.GetOwnSkillInfo(skillEx.NextStageSkillId);
        //    if (nextSkill != null)
        //        hasNext = nextSkill.IsCooldownFinish();
        //}

        //return hasNext;
        return skillEx.NextStageSkillId                                                         >= 0 &&
               GameManager.gameManager.PlayerDataPool.GetOwnSkillInfo(skillEx.NextStageSkillId) != null;
    }

    /// <summary>
    ///     通过SkillEx获得SkillSelector
    /// </summary>
    public static Tab_SkillTargetSelector GetSkillSelector(this Tab_SkillEx skillEx)
    {
        Tab_SkillTargetSelector result     = null;
        var                     selectorId = skillEx.GetSelectorIdbyIndex(0);
        if (selectorId > -1)
            result = TryGetTable(selectorId, a => TableManager.GetSkillTargetSelectorByID(a));
        return result;
    }

    /// <summary>
    ///     配置Root以及其以下的GameObject的layer
    /// </summary>
    public static void SetLayersRecursively(Transform root, int layer)
    {
        var transforms = root.GetComponentsInChildren<Transform>(true);
        for (var i = 0; i < transforms.Length; i++)
            transforms[i].gameObject.layer = layer;
    }

    /// <summary>
    ///     防止值重复赋值引起的重绘
    /// </summary>
    /// <param name="text"></param>
    /// <param name="val"></param>
    /// <returns></returns>
    public static Text EnsureVal(this Text text, string val)
    {
        if (!text.text.Equals(val))
            text.text = val;
        return text;
    }

    /// <summary>
    ///     支持增加StringComparison标签的Contain函数
    /// </summary>
    public static bool Contains(this string source, string target, StringComparison comparison)
    {
        return !string.IsNullOrEmpty(source) && !string.IsNullOrEmpty(target) &&
               source.IndexOf(target, comparison) >= 0;
    }

    public static Vector3 InsertY(this Vector2 source, float y = 0f)
    {
        return new Vector3(source.x, y, source.y);
    }

    public static Vector2 RemoveY(this Vector3 source)
    {
        return new Vector2(source.x, source.z);
    }

    /// <summary>
    ///     获得当前的时间描述
    /// </summary>
    public static string GetCurrentTimeString(bool showInterval = true)
    {
        var time   = GetCurrentTimeInMilliseconds();
        var result = time.ToString();
        if (showInterval)
            result = string.Format("({0} - {1})", result, time - _lastGetTime);
        _lastGetTime = time;
        return result;
    }

    public static string GetCurrentUnityTimeString(bool showInterval = true)
    {
        var result = showInterval
            ? string.Format("({0} - {1})", Time.unscaledTime, Time.unscaledTime - _lastGetUnityTime)
            : Time.unscaledTime.ToString(CultureInfo.InvariantCulture);
        _lastGetUnityTime = Time.unscaledTime;
        return result;
    }

    /// <summary>
    ///     获得当前时间的毫秒数值
    /// </summary>
    private static int GetCurrentTimeInMilliseconds()
    {
        return (int)(DateTime.Now - DateTime.Today).TotalMilliseconds;
    }

    public static Vector3 ParseVector3(string source)
    {
        var result   = Vector3.zero;
        var segments = source.Split(';');
        result.x = float.Parse(segments[0]);
        result.y = float.Parse(segments[1]);
        result.z = float.Parse(segments[2]);
        return result;
    }

    /// <summary>
    ///     服务器位置坐标转换为客户端位置坐标
    /// </summary>
    public static float ToClientPos(this int source)
    {
        return source * serverToClientPos;
    }

    /// <summary>
    ///     服务器位置坐标转换为客户端位置坐标
    /// </summary>
    public static Vector2 ToClientPos(this Vector2 source)
    {
        return source * serverToClientPos;
    }

    /// <summary>
    ///     服务器位置坐标转换为客户端位置坐标
    /// </summary>
    public static Vector3 ToClientPos(this Vector3 source)
    {
        return source * serverToClientPos;
    }

    /// <summary>
    ///     客户端坐标位置转换为服务器使用的整数坐标
    /// </summary>
    public static int ToServerPos(this float source)
    {
        return Mathf.FloorToInt(source * clientToServerPos);
    }

    /// <summary>
    ///     检查一个资源路径是否为项目资源路径
    /// </summary>
    public static bool IsCommonAssetPath(this string assetPath)
    {
        return !string.IsNullOrEmpty(assetPath) && assetPath.StartsWith(AssetConst.nonInternalHeader);
    }

    public static T GetMaxValue<T>(params T[] values) where T : IComparable
    {
        if (values.Length > 0)
        {
            var result = values[0];
            for (var i = 1; i < values.Length; i++)
                if (result.CompareTo(values[i]) < 0)
                    result = values[i];
            return result;
        }

        return default(T);
    }

    public static bool IsAutoCombatCopyScene(int fubenId)
    {
        var fubenData = TableManager.GetFubenByID(fubenId);
        return IsAutoCombatCopyScene(fubenData);
    }

    public static bool IsAutoCombatCopyScene(Tab_Fuben fubenData)
    {
        return FubenAutoType(fubenData) == Games.GlobeDefine.FubenAutoType.auto;
    }

    public static int FubenAutoType()
    {
        var fubenId = GlobeVar.INVALID_ID;
        var cache   = GameManager.gameManager.PlayerDataPool.EnterSceneCache;
        if (cache != null)
            fubenId = cache.EnterCopySceneID;
        if (fubenId <= GlobeVar.INVALID_ID)
            fubenId = GameManager.gameManager.RunningScene;
        return FubenAutoType(fubenId);
    }

    public static int FubenAutoType(int fubenId)
    {
        var fubenData = TableManager.GetFubenByID(fubenId);
        return FubenAutoType(fubenData);
    }

    public static int FubenAutoType(Tab_Fuben fubenData)
    {
        return fubenData == null ? 0 : fubenData.AutoType;
    }

    public static bool IsCopyScene(this Tab_SceneClass sceneClassData)
    {
        return sceneClassData.SceneID != (int)GameDefine_Globe.SCENE_DEFINE.SCENE_GUILD &&
               sceneClassData.Type    == (int)GameDefine_Globe.SCENE_TYPE.SCENETYPE_COPYSCENE;
    }

    public static Tab_Jump GetFinialJumpData(this Tab_Jump jumpData)
    {
        var firstId = jumpData.JumpId;
        for (var i = 0; i < _maxJumpRecursive; i++)
            if (jumpData.NextJumpId > GlobeVar.INVALID_ID)
            {
                var temp = TableManager.GetJumpByID(jumpData.NextJumpId);
                if (temp == null)
                {
                    LogModule.ErrorLog(string.Format("无法Jump{0}的NextJump{1}", jumpData.JumpId, jumpData.NextJumpId));
                    break;
                }

                jumpData = temp;
            }
            else
            {
                break;
            }

        if (jumpData.NextJumpId > -1)
            LogModule.ErrorLog(string.Format("跳跃点{0}迭代超过{1}次，检查是否配表问题，或者提高代码中迭代上限！", firstId, _maxJumpRecursive));
        return jumpData;
    }

    public static Tab_Jump GetFinialJumpData(this Tab_Jump jumpData, out float jumpTime)
    {
        jumpTime = 0f;
        var firstId = jumpData.JumpId;
        for (var i = 0; i < _maxJumpRecursive; i++)
        {
            jumpTime += jumpData.Duration.ToClientTime();
            if (jumpData.NextJumpId > GlobeVar.INVALID_ID)
            {
                var temp = TableManager.GetJumpByID(jumpData.NextJumpId);
                if (temp == null)
                {
                    LogModule.ErrorLog(string.Format("无法Jump{0}的NextJump{1}", jumpData.JumpId, jumpData.NextJumpId));
                    break;
                }

                jumpData = temp;
            }
            else
            {
                break;
            }
        }

        if (jumpData.NextJumpId > -1)
            LogModule.ErrorLog(string.Format("跳跃点{0}迭代超过{1}次，检查是否配表问题，或者提高代码中迭代上限！", firstId, _maxJumpRecursive));
        // 如果不是瞬间传送，则增加最后一段的落地动画时间
        if (jumpTime > 0f)
            jumpTime += _jumpAnimTime;
        return jumpData;
    }

    public static Tab_SkillEx GetSkillMaxLevelByBaseId(int baseId)
    {
        Tab_SkillEx result      = null;
        var         maxLevel    = int.MinValue;
        var         skillExDict = TableManager.GetSkillEx();
        foreach (var value in skillExDict.Values)
        {
            var skillEx = value;
            if (skillEx.BaseId == baseId && skillEx.Level > maxLevel)
            {
                result   = skillEx;
                maxLevel = skillEx.Level;
            }
        }

        return result;
    }

    // 注：C#不支持对泛型限制为枚举
    public static T GetMaxEnum<T>() where T : struct, IComparable
    {
        var values = (T[])Enum.GetValues(typeof(T));
        return GetMaxValue(values);
    }

    /// <summary>
    ///     计算射线同水平面的交点
    /// </summary>
    public static Vector3 RayToHorizontalPlane(Ray ray, float y)
    {
        if (ray.direction.y == 0f)
        {
            LogModule.ErrorLog("水平射线无法同水平面相交！");
            return ray.origin;
        }

        var a = (y - ray.origin.y) / ray.direction.y;
        return ray.origin + ray.direction * a;
    }

    /// <summary>
    ///     从路径上获得一段距离后的点
    /// </summary>
    public static Vector3 GetPointOnPath(this NavMeshPath path, Vector3 startPos, float distance)
    {
        var corners = path.corners;
        if (corners.Length > 1)
            for (var i = 1; i < corners.Length; i++)
            {
                var length = Vector3.Distance(corners[i], startPos);
                if (length >= distance)
                {
                    startPos = Vector3.Lerp(startPos, corners[i], distance / length);
                    break;
                }

                startPos =  corners[i];
                distance -= length;
            }

        return startPos;
    }

    /// <summary>
    ///     对一个数组进行冒泡排序
    /// </summary>
    public static void SortArray<T>(this T[] array, Comparison<T> comparison)
    {
        for (var i = 0; i < array.Length; i++)
        for (var j = i + 1; j < array.Length; j++)
            if (comparison(array[i], array[j]) > 0)
            {
                var temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
    }

    /// <summary>
    ///     获得路径总长度
    /// </summary>
    public static float GetTotalDistance(this NavMeshPath path)
    {
        var length  = 0f;
        var corners = path.corners;
        if (corners.Length > 1)
            for (var i = 1; i < corners.Length; i++)
                length += Vector3.Distance(corners[i], corners[i - 1]);
        return length;
    }

    public static T Max<T>(params T[] items) where T : IComparable
    {
        if (items.Length > 0)
        {
            var result = items[0];
            for (var i = 1; i < items.Length; i++)
                if (items[i].CompareTo(result) > 0)
                    result = items[i];

            return result;
        }

        return default(T);
    }

    public static TV GetItem<T, TV>(this List<TV> list, T id, ListGetMode mode) where TV : ListItemBase<T>, new()
    {
        TV result = null;
        for (var i = 0; i < list.Count; i++)
            if (list[i].id.Equals(id))
            {
                result = list[i];
                if (mode == ListGetMode.remove)
                    list.RemoveAt(i);
                break;
            }

        if (mode == ListGetMode.create && result == null)
        {
            result = new TV { id = id };
            list.Add(result);
        }

        return result;
    }

    public static int GetIndex<T, TV>(this List<TV> list, T id) where TV : ListItemBase<T>, new()
    {
        var result = -1;
        for (var i = 0; i < list.Count; i++)
            if (list[i].id.Equals(id))
            {
                result = i;
                break;
            }

        return result;
    }

    #region 编辑器测试加载方式

#if UNITY_EDITOR
    private static List<string> _resourcePaths;
#endif

    public static T LoadFromResources<T>(string name) where T : Object
    {
        T result = null;
        name = Path.GetFileNameWithoutExtension(name);
#if UNITY_EDITOR
        if (AssetUpdateManager.useResources)
        {
            if (_resourcePaths == null)
            {
                var assetPaths = AssetDatabase.GetAllAssetPaths();
                _resourcePaths = new List<string>();
                for (var i = 0; i < assetPaths.Length; i++)
                {
                    var assetPath = assetPaths[i];
                    if (assetPath.StartsWith("Assets/Project/GameRes"))
                    {
                        var extension = Path.GetExtension(assetPath);
                        if (!string.IsNullOrEmpty(extension))
                            _resourcePaths.Add(assetPath);
                    }
                }
            }

            var assetHeader = ObjectTypeToGameResPath(typeof(T));

            for (var i = 0; i < _resourcePaths.Count; i++)
                if (_resourcePaths[i].StartsWith(assetHeader) &&
                    Path.GetFileNameWithoutExtension(_resourcePaths[i]) == name)
                {
                    result = AssetDatabase.LoadAssetAtPath<T>(_resourcePaths[i]);
                    if (result != null)
                        break;
                }

            return result;
        }
#endif
        var bundleName = LoadAssetBundle.FixBundleName(LoadAssetBundle.BUNDLE_PATH_GAMERES);

        if (AssetManager.instance == null)
        {
            throw new Exception("AssetManager.instance is null");
        }

        return AssetManager.instance.LoadAssetSync<T>(bundleName, name);
    }

#if UNITY_EDITOR
    public static string ObjectTypeToGameResPath(Type itemType)
    {
        var typeName = itemType.ToString();
        var dotIndex = typeName.LastIndexOf('.');
        if (dotIndex >= 0)
            typeName = typeName.Substring(dotIndex + 1);
        return "Assets/Project/GameRes".Open(typeName);
    }
#endif

    //    public static void LoadGameObjectInstance(string bundleName, string assetName, LoadBundleAssetCallback<GameObject> callBack, bool archive)
    //    {
    //#if UNITY_EDITOR
    //        if (AssetBundleManager.SimulateAssetBundleInEditor)
    //        {
    //            var result = EditorTestUtility.LoadGameObject(assetName);
    //            callBack(assetName, result, null);
    //            return;
    //        }
    //#endif
    //        LoadAssetBundle.Instance.LoadGameObject(bundleName, assetName, callBack, null, archive);
    //    }

    public static void LoadAssetInstance(string                              bundleName, string assetName,
                                         LoadBundleAssetCallback<GameObject> callBack,   bool   archive)
    {
#if UNITY_EDITOR
        if (AssetUpdateManager.useResources)
        {
            var result = EditorTestUtility.LoadGameObject(assetName);
            callBack(assetName, result, null);
            return;
        }
#endif
        // 使用LoadUI接口，统一处理所有类型的加载；LoadGameObject会将bundleName额外加上assetName
        LoadAssetBundle.Instance.LoadUI(bundleName, assetName, callBack, null, archive);
    }

    #endregion
}

/// <summary>
///     列表用键值对，KeyValue是struct不易用于存在判断
/// </summary>
public class MyTuple<T1, T2>
{
    public T1 first;
    public T2 second;

    public MyTuple()
    {
    }

    public MyTuple(T1 first, T2 second)
    {
        this.first  = first;
        this.second = second;
    }
}

#region 安全列表系统

// 不想再重复处理列表匹配、添加、删除之类的事情了，新的列表元素都继承匹配方法，直接用扩展统一处理
public abstract class ListItemBase<T>
{
    public T id;
}

/// <summary>
///     列表获取方法，用来让频繁访问的列表，避开匿名委托，又能用单个访问方法处理多种需求的工具
/// </summary>
public enum ListGetMode
{
    get,
    create,
    remove
}

#endregion