using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;

namespace AssetBundleMaster.AssetLoad
{
    using AssetBundleMaster.Common;
    using AssetBundleMaster.GameUtilities;
    using AssetBundleMaster.Extention;
    using TypeDataPool = ObjectPool.GlobalAllocator<AssetLoadManager.TypeData>;            // obj pool
    using TypeDataListPool = ObjectPool.GlobalAllocator<List<AssetLoadManager.TypeData>>;  // obj pool

    public enum ResourcesLoadMode
    {
        Resources = 1,                          // load orgin resource -- not bundled
        AssetBundle_StreamingAssets = 2,        // build assetbundle to streaming assets
        AssetBundle_PersistentDataPath = 3,     // release assetbundle to PersistentDataPath
        AssetBundle_Remote = 4,                 // load from resource servre by webrequest
#if UNITY_EDITOR
        AssetBundle_EditorTest = 5,             // test mode in editor
        AssetDataBase_Editor = 6,               // straight load in editor
#endif
    }

    // load mark for Async / Sync
    public enum LoadThreadMode
    {
        Asynchronous = 1,
        Synchronous = 2,
    }

    public class AssetLoadManager : SingletonComponent<AssetLoadManager>
    {
        #region Defines
        public class TypeData
        {
            public Type type { get; private set; }
            public AssetLoaderBase loader { get; private set; }

            public TypeData Set(Type type, AssetLoaderBase value)
            {
                this.type = type;
                this.loader = value;
                return this;
            }

            public void Clear()
            {
                type = null;
                loader = null;
            }

            public static implicit operator AssetLoader(TypeData typeData)
            {
                return typeData != null ? typeData.loader as AssetLoader : null;
            }
            public static implicit operator AssetList(TypeData typeData)
            {
                return typeData != null ? typeData.loader as AssetList : null;
            }
            public static implicit operator LevelLoader(TypeData typeData)
            {
                return typeData != null ? typeData.loader as LevelLoader : null;
            }
        }

        public class CountDown
        {
            public float countDownTime = 0.0f;
            public bool started { get; private set; }
            public float startTime { get; private set; }
            private float timeNow
            {
                get
                {
#if UNITY_EDITOR
                    return Time.time;
#else
                    return Time.unscaledTime;
#endif
                }
            }
            public float waitingTime
            {
                get
                {
                    return started ? startTime + countDownTime - timeNow : 0.0f;
                }
            }

            public void Start()
            {
                started = true;
                startTime = timeNow;
            }

            public bool Finished()
            {
                bool finished = started && (timeNow - startTime) >= countDownTime;
                if(finished)
                {
                    started = false;
                }
                return finished;
            }

            public void Stop()
            {
                started = false;
            }
        }

        public struct AssetLoadInfo
        {
            public bool isBundleMode;
            public string assetLoadPath;
            public System.Type systemTypeInstance;
            public LoadThreadMode loadThreadMode;
            public bool unloadable;
            public AssetList assetList;
        }

        public class Configs
        {
            public bool isBundleMode;
            public bool isResourcesMode;
            public bool isRemoteAssets;
            public int downloadTimes;
            public bool forceUnloadMode;

            public static Configs LoadFromGameConfig(GameConfig gameConfig)
            {
                var configs = new Configs();
                configs.isBundleMode = gameConfig.isBundleMode;
                configs.isResourcesMode = gameConfig.isResourcesMode;
                configs.isRemoteAssets = gameConfig.isRemoteAssets;
                configs.downloadTimes = gameConfig.gameConfigSetting.DownloadTryTimes;
                configs.forceUnloadMode = gameConfig.isResourcesMode;
#if UNITY_EDITOR
                configs.forceUnloadMode |= gameConfig.isEditorMode;
#endif
                return configs;
            }
        }
        #endregion

        #region Variables
        // wait time for unloading assets
        [System.NonSerialized]
        public float unloadPaddingTime = 30f;
        [System.NonSerialized]
        public int minUnloadAssetCounter = 60;        // the auto unload will be call after _unusedAssetCount is greater than minUnloadAssetCounter
        #endregion

        #region cached datas
        // assetbundle loader cache
        private Dictionary<string, AssetBundleLoader> _assetBundleRequests = new Dictionary<string, AssetBundleLoader>();

        // asset loaders
        private Dictionary<string, List<TypeData>> _assetLoaders = new Dictionary<string, List<TypeData>>();
        // asset list loaders
        private Dictionary<string, List<TypeData>> _assetLists = new Dictionary<string, List<TypeData>>();
        // level loaders
        private Dictionary<string, List<TypeData>> _levelLoaders = new Dictionary<string, List<TypeData>>();

        // a hash reference for the asset loader
        private Dictionary<int, AssetList> _assetLoaderHashDict = new Dictionary<int, AssetList>();
        private Dictionary<int, LevelLoader> _levelLoaderHashDict = new Dictionary<int, LevelLoader>();

        // marks different level load with same asset bundle name
        private Dictionary<string, string> _uniqueLevelNames = new Dictionary<string, string>();

        // control marks
        private bool _unloadUnloadedLoaders = false;
        private static int _unusedAssetCount = 0;

        private System.Text.StringBuilder _uniqueNameSB = new System.Text.StringBuilder();

        private static readonly CountDown ms_assetUnloadCountDown = new CountDown();
        private static readonly CountDown ms_resourceUnloadCountDown = new CountDown();
        private CountDown m_inverseUnloadCountDown = null;

        private Common.QueueCommands m_initWait = null;

        private static readonly HashSet<string> ms_unloadedAssets = new HashSet<string>();
        private static readonly HashSet<string> ms_unloadingAssets = new HashSet<string>();
        #endregion

        #region Properties
        public bool Prepared { get; private set; }

        public AssetBundleManifest assetBundleManifest { get; private set; }
        public Configs configs { get; private set; }

#if UNITY_EDITOR
        public float unloadAssetsWaitingTime { get { return ms_assetUnloadCountDown.waitingTime; } }
        public float unloadResourcesWaitingTime { get { return ms_resourceUnloadCountDown.waitingTime; } }
#endif
        #endregion

        #region Events
        public static event System.Action<HashSet<string>> onResourcesUnloaded = null;
        #endregion

        #region Override Funcs
        protected override void Initialize()
        {
            CoroutineRoot.Create();
            Prepared = false;
            configs = Configs.LoadFromGameConfig(GameConfig.Instance);

            // pools
            TypeDataPool.Set(create: () => { return new TypeData(); }, deAllocate: (_typeData) =>
            {
                ms_unloadingAssets.Add(_typeData.loader.loadPath);
                _typeData.Clear();
            });
            TypeDataListPool.Set(create: () => { return new List<TypeData>(); }, deAllocate: (_list) =>
            {
                _list.Clear();
            });

            Debug.Log("Program Basic Version is : " + GameConfig.Instance.gameConfigSetting.Version);
            Debug.Log("Asset Load Mode is : " + GameConfig.Instance.resourceLoadMode);
#if UNITY_EDITOR
            Debug.Log("Asset Load Root is : " + GameConfig.Instance.ShowLoadRootPath());
#endif

            if(configs.isBundleMode)
            {
                LoadAssetBundleManifest();
                m_inverseUnloadCountDown = new CountDown() { countDownTime = 2.0f };
                m_inverseUnloadCountDown.Start();
            }
            AssetList.assetChanged += OnAssetListAssetChanged;
            CheckPrepared();
        }
        protected override void UnInitialize()
        {
            throw new Exception("Don't Destroy AssetLoadManager in Runtime !");
        }
        #endregion

        #region Main Funcs
        /// <summary>
        /// only if the asset bundle load from remote url, should do load assets after Inided
        /// </summary>
        /// <param name="onloaded"></param>
        public void OnAssetLoadModuleInited(System.Action onloaded)
        {
            if(m_initWait != null)
            {
                m_initWait.Enqueue(new Command() { cmd = (_) => { onloaded.Invoke(); } });
            }
            else
            {
                onloaded.Invoke();
            }
        }

        /// <summary>
        /// Load Assets From Path, their are multi assets in a same load path maybe
        /// </summary>
        /// <param name="assetLoadPath"></param>
        /// <param name="loadAllAssets"></param>
        /// <param name="systemTypeInstance"></param>
        /// <returns></returns>
        public UnityEngine.Object[] LoadAssets(string assetLoadPath, System.Type systemTypeInstance, bool unloadable)
        {
            var list = LoadAssetList(assetLoadPath, systemTypeInstance, unloadable);
            return list.Assets;
        }
        // intermedia func
        public AssetList LoadAssetList(string assetLoadPath, System.Type systemTypeInstance, bool unloadable)
        {
            var list = LoadAssetsWrapped(assetLoadPath, false, systemTypeInstance, LoadThreadMode.Synchronous, unloadable, null);
            return list;
        }


        /// <summary>
        /// Load All Assets From Path Async
        /// </summary>
        /// <param name="assetLoadPath"></param>
        /// <param name="loadAllAssets"></param>
        /// <param name="systemTypeInstance"></param>
        /// <param name="loaded"></param>
        public AssetList LoadAssetsAsync(string assetLoadPath, System.Type systemTypeInstance, bool unloadable,
            System.Action<UnityEngine.Object[]> loaded)
        {
            var list = LoadAssetsWrapped(assetLoadPath, false, systemTypeInstance, LoadThreadMode.Asynchronous, unloadable, loaded);
            return list;
        }

        /// <summary>
        /// Load All Assets From Path, Folder load integrated
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="assetLoadPath"></param>
        /// <returns></returns>
        public UnityEngine.Object[] LoadAllAssets(string assetLoadPath, System.Type systemTypeInstance, bool unloadable)
        {
            var list = LoadAllAssetList(assetLoadPath, systemTypeInstance, unloadable);
            return list.Assets;
        }
        // intermedia func
        public AssetList LoadAllAssetList(string assetLoadPath, System.Type systemTypeInstance, bool unloadable)
        {
            var list = LoadAssetsWrapped(assetLoadPath, true, systemTypeInstance, LoadThreadMode.Synchronous, unloadable, null);
            return list;
        }

        /// <summary>
        ///  Load All Assets From Path Async, Folder load integrated
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="assetLoadPath"></param>
        /// <param name="loaded"></param>
        public AssetList LoadAllAssetsAsync(string assetLoadPath, System.Type systemTypeInstance, bool unloadable, System.Action<UnityEngine.Object[]> loaded)
        {
            return LoadAssetsWrapped(assetLoadPath, true, systemTypeInstance, LoadThreadMode.Asynchronous, unloadable, loaded);
        }

        /// <summary>
        /// base load all func
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="assetLoadPath"></param>
        /// <param name="loadThreadMode"></param>
        /// <param name="loadAll"></param>
        /// <param name="loaded"></param>
        /// <returns></returns>
        private AssetList LoadAssetsWrapped(string assetLoadPath,
            bool loadAll,
            System.Type systemTypeInstance,
            LoadThreadMode loadThreadMode,
            bool unloadable,
            System.Action<UnityEngine.Object[]> loaded)
        {
            var typeData = GetTypeData(_assetLists, assetLoadPath, systemTypeInstance);
            AssetList assetList = typeData;     // auto cast
            bool isNewAssetList = (assetList == null || assetList.unloaded);
            bool newLoad = isNewAssetList || (loadAll && assetList.loadAll != loadAll);
            if(newLoad)
            {
                if(isNewAssetList)
                {
                    assetList = new AssetList(assetLoadPath, systemTypeInstance, loadThreadMode, loadAll);
                    typeData.Set(systemTypeInstance, assetList);
                }

                AssetLoadInfo assetLoadInfo = new AssetLoadInfo()
                {
                    isBundleMode = configs.isBundleMode,
                    assetLoadPath = assetLoadPath,
                    systemTypeInstance = systemTypeInstance,
                    loadThreadMode = loadThreadMode,
                    unloadable = unloadable,
                    assetList = assetList
                };
                AccessLoadPathFiles(assetLoadPath, assetLoadInfo, (_filePath, _assetName, _assetLoadInfo) =>
                {
                    // the load mode diferent, the loadpath and assetbundle name is inverted
                    var assetLoader = AssetLoadManager.Instance.GetUniqueAssetLoader(_assetLoadInfo.isBundleMode ? _assetLoadInfo.assetLoadPath : _filePath,
                        _assetLoadInfo.isBundleMode ? _filePath : _assetLoadInfo.assetLoadPath,
                        _assetName,
                        _assetLoadInfo.systemTypeInstance,
                        _assetLoadInfo.loadThreadMode,
                        _assetLoadInfo.unloadable);
                    _assetLoadInfo.assetList.AddLoader(assetLoader);
                });
            }
            assetList.unloadable &= unloadable;
            AssetListLoadRequest(assetList, loadThreadMode, loadAll, loaded);
            return assetList;
        }

        /// <summary>
        /// Unload asset by has code
        /// </summary>
        /// <param name="hashCode"></param>
        /// <param name="unloadImmediate"></param>
        public void UnloadAsset(int hashCode)
        {
            var assetList = _assetLoaderHashDict.TryGetValue(hashCode);
            if(assetList != null)
            {
                _assetLoaderHashDict.Remove(hashCode);
                if(assetList.Unload())
                {
                    if(configs.isBundleMode == false)
                    {
                        _unusedAssetCount++;    // need to call Resources.UnloadUnusedAssets();
                    }
                }
                ClearRequest();
            }
        }

        /// <summary>
        /// Load Level
        /// Notice: the LevelLoaded callback, Unity load scene in an Async way even in Sync Mode!
        /// Notice: the same named level is the same in memory though they are not the same assetbundle name!
        /// </summary>
        /// <param name="levelLoadPath"></param>
        /// <param name="loadMode"></param>
        /// <param name="loadSceneMode"></param>
        /// <param name="callBack"> even Async Mode, should wait for the call back </param>
        /// <returns></returns>
        public int LoadLevel(string levelLoadPath, LoadThreadMode loadMode, UnityEngine.SceneManagement.LoadSceneMode loadSceneMode,
            System.Action<int, UnityEngine.SceneManagement.Scene> callBack)
        {
            int hashCode = 0;
            var levelLoader = GetLevelLoader(levelLoadPath, loadSceneMode, loadMode, true);   // level loader alywas new         
            hashCode = levelLoader.GetHashCode();
            if(callBack != null)
            {
                // complete call is from SceneManagement
                levelLoader.completed.PushCall((_loader) =>
                {
                    var _levelLoader = _loader as LevelLoader;
                    if(_levelLoader != null)
                    {
                        if(callBack != null)
                        {
                            callBack.Invoke(_levelLoader.GetHashCode(), _levelLoader.scene);    // call back should not ref an outer data
                        }
                    }
                });
            }
            if(levelLoader.assetBundleLoader != null)
            {
                levelLoader.assetBundleLoader.IncreaseReferenceCount(1);
            }
            levelLoader.LoadRequest(loadMode);
            return hashCode;
        }

        /// <summary>
        /// Unload loaded / loading scene with unique ID
        /// </summary>
        /// <param name="hashCode"></param>
        /// <param name="unloaded"></param>
        /// <param name="unloadImmediate"></param>
        /// <returns></returns>
        public bool UnloadLevel(int hashCode, System.Action<int, UnityEngine.SceneManagement.Scene> unloaded = null)
        {
            var levelLoader = _levelLoaderHashDict.TryGetValue(hashCode);
            if(levelLoader != null)
            {
                _levelLoaderHashDict.Remove(hashCode);
                // unload scene and assets
                levelLoader.UnloadScene((_scene) =>
                {
                    ClearRequest();
                    if(false == levelLoader.unloadable || configs.forceUnloadMode)
                    {
                        TickUnloadedLoaders();
                        if(_levelLoaders.ContainsKey(levelLoader.loadPath) == false)
                        {
                            _unusedAssetCount++;
                            if(ms_assetUnloadCountDown.started == false)
                            {
                                RequestUnloadUnusedAssets();    // force to unload in case the Scene assets is already unloaded
                            }
                        }
                    }

                    if(unloaded != null)
                    {
                        unloaded.Invoke(hashCode, _scene);
                    }
                });
                return true;
            }
            return false;
        }

        /// <summary>
        /// Unload scene assets only, keep the scene alive
        /// </summary>
        /// <param name="hashCode"></param>
        /// <returns></returns>
        public bool UnloadLevelAssets(int hashCode)
        {
            var levelLoader = _levelLoaderHashDict.TryGetValue(hashCode);
            if(levelLoader != null)
            {
                levelLoader.ChangeAllUnloadable(false);     // scene assets changed to be not unloadable
                levelLoader.Unload(false);                  // unload scene assets, bit keep ref in _assetLoaderHash, don't remove it
                ClearRequest();
                return true;
            }
            return false;
        }
        #endregion

        #region Help Funcs
        /// <summary>
        /// Access load path, get real asset load path
        /// </summary>
        /// <param name="loadPath"></param>
        /// <param name="filePathAccess"></param>
        public void AccessLoadPathFiles(string loadPath, AssetLoadInfo assetLoadInfo, System.Action<string, string, AssetLoadInfo> filePathAccess)
        {
            if(filePathAccess != null)
            {
                loadPath = Utility.LeftSlash(loadPath);
                switch(GameConfig.Instance.resourceLoadMode)
                {
#if UNITY_EDITOR
                    case ResourcesLoadMode.AssetDataBase_Editor:
                        {
                            Utility.AccessEditorPath(loadPath, assetLoadInfo, filePathAccess);
                        }
                        break;
#endif
                    case ResourcesLoadMode.Resources:
                        {
                            filePathAccess.Invoke(loadPath, System.IO.Path.GetFileName(loadPath), assetLoadInfo);  // load a folder just use folder path in Resources Load Mode
                        }
                        break;
                    default:
                        {
                            if(Utility.CheckIsFolder(loadPath))
                            {
                                foreach(var assetFile in LocalVersion.Instance.versionInfo.AccessFilesEnumerable(loadPath, System.IO.SearchOption.TopDirectoryOnly))
                                {
                                    if(assetFile != null && assetFile.FinalFullNames != null && assetFile.FinalFullNames.Count > 0)
                                    {
                                        for(int i = 0; i < assetFile.FinalFullNames.Count; i++)
                                        {
                                            filePathAccess.Invoke(assetFile.FinalFullNames[i], assetFile.FileName, assetLoadInfo);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                var assetFile = LocalVersion.Instance.versionInfo.SearchFile(loadPath);
                                if(assetFile != null && assetFile.FinalFullNames != null && assetFile.FinalFullNames.Count > 0)
                                {
                                    for(int i = 0, imax = assetFile.FinalFullNames.Count; i < imax; i++)
                                    {
                                        filePathAccess.Invoke(assetFile.FinalFullNames[i], assetFile.FileName, assetLoadInfo);
                                    }
                                }
                            }
                        }
                        break;
                }
            }
        }

        /// <summary>
        /// every level loader is a new loader
        /// </summary>
        /// <param name="levelLoadPath"></param>
        /// <param name="loadSceneMode"></param>
        /// <param name="loadMode"></param>
        /// <returns></returns>
        private LevelLoader GetLevelLoader(string levelLoadPath, UnityEngine.SceneManagement.LoadSceneMode loadSceneMode, LoadThreadMode loadMode, bool unloadable)
        {
            var levelName = System.IO.Path.GetFileNameWithoutExtension(levelLoadPath);
            LevelLoader levelLoader = null;
            AssetBundleLoader assetBundleLoader = null;
            var assetSource = GetAssetSource();
            if(configs.isBundleMode)
            {
                /* level loader is kind of special, on assetbundle mode, the scene name is an unique mark for assetbundle, it can't be load at the same time */
                var existsLoadPath = _uniqueLevelNames.TryGetValue(levelName);
                if(string.IsNullOrEmpty(existsLoadPath) == false && string.Equals(existsLoadPath, levelLoadPath, StringComparison.Ordinal) == false)
                {
                    _uniqueLevelNames.Remove(levelName);
                    // get old asset bundle loader
                    assetBundleLoader = _assetBundleRequests.TryGetValue(Utility.AssetPathToAssetBundleName(existsLoadPath));
                    if(assetBundleLoader != null)
                    {
                        if(assetBundleLoader.mainAssetBundle != null)
                        {
                            assetBundleLoader.mainAssetBundle.Release(true); // unload main Asset Bundle
                        }
                    }
                }

                var assetBundleName = Utility.AssetPathToAssetBundleName(levelLoadPath);
                assetBundleLoader = GetAssetBundleLoader(assetBundleName, loadMode, assetSource, unloadable);
                _uniqueLevelNames[levelName] = levelLoadPath;
            }

            // level loader is always new one
            levelLoader = new LevelLoader(levelLoadPath, levelName, loadSceneMode, assetSource, assetBundleLoader);
            _levelLoaderHashDict[levelLoader.GetHashCode()] = levelLoader;      // the Assets is Null
            // add every time, not unique
            var typeDatas = _levelLoaders.GetValue(levelLoadPath, () => { return TypeDataListPool.Allocate(); });
            var typeData = TypeDataPool.Allocate().Set(null, levelLoader);
            typeDatas.Add(typeData);

            return levelLoader;
        }

        /// <summary>
        /// Get asset bundle loader from cache or new
        /// </summary>
        /// <param name="assetBundleName"></param>
        /// <param name="loadBundleMode"></param>
        /// <param name="assetSource"></param>
        /// <returns></returns>
        private AssetBundleLoader GetAssetBundleLoader(string assetBundleName, LoadThreadMode loadBundleMode, AssetSource assetSource, bool unloadable)
        {
            AssetBundleLoader assetBundleLoader = _assetBundleRequests.TryGetValue(assetBundleName);
            if(assetBundleLoader == null || assetBundleLoader.unloaded)
            {
                assetBundleLoader = new AssetBundleLoader(assetBundleName, assetSource);
                _assetBundleRequests[assetBundleName] = assetBundleLoader;
            }
            assetBundleLoader.unloadable &= unloadable;
            assetBundleLoader.LoadRequest(loadBundleMode);
            return assetBundleLoader;
        }

        /// <summary>
        /// load asset as unique in case we have multiple same named resource files
        /// </summary>
        /// <param name="assetLoadPath"></param>
        /// <param name="assetBundleName"></param>
        /// <param name="assetName"></param>
        /// <param name="systemTypeInstance"></param>
        /// <param name="loadMode"></param>
        /// <param name="isNew"></param>
        /// <returns></returns>
        private AssetLoader GetUniqueAssetLoader(string assetLoadPath,
            string assetBundleName,
            string assetName,
            System.Type systemTypeInstance,
            LoadThreadMode loadMode,
            bool unloadable)
        {
            string uniqueName = GenerateUniqueName(assetLoadPath, assetBundleName, assetName);
            var typeData = GetTypeData(_assetLoaders, uniqueName, systemTypeInstance);
            AssetLoader assetLoader = typeData;
            if((assetLoader == null || assetLoader.unloaded))
            {
                AssetBundleLoader assetBundleLoader = null;
                var assetSource = GetAssetSource();
                if(configs.isBundleMode)
                {
                    assetBundleLoader = GetAssetBundleLoader(assetBundleName, loadMode, assetSource, unloadable);
                }
                assetLoader = new AssetLoader(assetLoadPath, assetName, systemTypeInstance, assetSource, assetBundleLoader, false);
                typeData.Set(systemTypeInstance, assetLoader);
            }
            assetLoader.unloadable &= unloadable;
            return assetLoader;
        }

        /// <summary>
        /// Asset list to load
        /// </summary>
        /// <param name="assetList"></param>
        /// <param name="loadThreadMode"></param>
        /// <param name="loadAll"></param>
        /// <param name="loaded"></param>
        private void AssetListLoadRequest(AssetList assetList,
            LoadThreadMode loadThreadMode,
            bool loadAll,
            System.Action<UnityEngine.Object[]> loaded)
        {
            assetList.loadAll = loadAll;
            assetList.LoadRequest(loadThreadMode);
            if(loaded != null)
            {
                if(assetList.isDone)
                {
                    loaded.Invoke(assetList.Assets);
                }
                else
                {
                    assetList.completed.PushCall((_loader) =>
                    {
                        loaded.Invoke(_loader.Assets);
                    });
                }
            }
        }

        /// <summary>
        /// loaded asset changed, switch the reference
        /// </summary>
        /// <param name="assetList"></param>
        /// <param name="from"></param>
        /// <param name="to"></param>
        private void OnAssetListAssetChanged(AssetList assetList, UnityEngine.Object[] from)
        {
            HashLog(assetList);
            if(from != null)
            {
                _assetLoaderHashDict.Remove(from.GetHashCode());
            }
        }

        /// <summary>
        /// Cache loader hash
        /// </summary>
        /// <param name="loader"></param>
        private void HashLog(AssetList loader)
        {
            if(loader != null && loader.Assets != null)
            {
                _assetLoaderHashDict[loader.Assets.GetHashCode()] = loader;
            }
        }

        /// <summary>
        /// make unique name from asset load path etc.
        /// </summary>
        /// <param name="assetLoadPath"></param>
        /// <param name="assetBundleName"></param>
        /// <param name="assetName"></param>
        /// <returns></returns>
        private string GenerateUniqueName(string assetLoadPath, string assetBundleName, string assetName)
        {
            _uniqueNameSB.Length = 0;
            _uniqueNameSB.Append(assetLoadPath);
            if(string.IsNullOrEmpty(assetBundleName) == false)
            {
                _uniqueNameSB.Append(":");
                _uniqueNameSB.Append(assetBundleName);
            }
            if(string.IsNullOrEmpty(assetName) == false)
            {
                _uniqueNameSB.Append(":");
                _uniqueNameSB.Append(assetName);
            }
            return _uniqueNameSB.ToString();
        }

        /// <summary>
        /// deferent asset mode has different asset sources
        /// </summary>
        /// <returns></returns>
        private AssetSource GetAssetSource()
        {
            switch(GameConfig.Instance.resourceLoadMode)
            {
                case ResourcesLoadMode.Resources:
                    {
                        return AssetSource.Resources;
                    }
#if UNITY_EDITOR
                case ResourcesLoadMode.AssetDataBase_Editor:
                    {
                        return AssetSource.AssetDataBase;
                    }
                case ResourcesLoadMode.AssetBundle_EditorTest:
#endif
                case ResourcesLoadMode.AssetBundle_StreamingAssets:
                case ResourcesLoadMode.AssetBundle_PersistentDataPath:
                    {
                        return AssetSource.LocalAssetBundle;
                    }
                case ResourcesLoadMode.AssetBundle_Remote:
                    {
                        return AssetSource.RemoteAssetBundle;
                    }
                default:
                    { return AssetSource.Resources; }
            }
        }

        /// <summary>
        /// Wrapped to get target type data
        /// </summary>
        /// <param name="dict"></param>
        /// <param name="uniqueName"></param>
        /// <param name="systemTypeInstance"></param>
        /// <returns></returns>
        private TypeData GetTypeData(Dictionary<string, List<TypeData>> dict, string uniqueName, System.Type systemTypeInstance)
        {
            var typeData = dict.GetValue(uniqueName, () =>
            {
                return TypeDataListPool.Allocate();
            }).GetValue((_typeData) =>
            {
                return _typeData.type == systemTypeInstance;
            }, () =>
            {
                return TypeDataPool.Allocate();
            });
            return typeData;
        }
        #endregion

        #region Others
        private void LoadAssetBundleManifest()
        {
            if(configs.isRemoteAssets)
            {
                AssetBundleWebRequestController.Instance.MaxFailedCount = configs.downloadTimes;
                m_initWait = new Common.QueueCommands();
                EnqueueDownloadCommand(m_initWait, string.Concat(GameConfig.Instance.gameConfigSetting.RemoteURL, "/", typeof(AssetBundleManifest).Name), OnAssetBundleManifest);
                EnqueueDownloadCommand(m_initWait, string.Concat(GameConfig.Instance.gameConfigSetting.RemoteURL, "/", LocalVersion.VersionInfoBundleName), (_assetBundle) =>
                {
                    LocalVersion.Instance.versionInfo = LocalVersion.OnVersionInfoAssetBundle(_assetBundle);
                    Debug.Log("Current BundleVerison Version is : [" + LocalVersion.Instance.versionInfo.BundleVerison + "]");
                    CheckPrepared();
                });
            }
            else
            {
                var assetBundleManifestBundle = AssetBundle.LoadFromFile(Utility.AssetBundleNameToAssetBundlePath(GameConfig.AssetBundleManifestName, GameConfig.Instance.resourceLoadMode));
                OnAssetBundleManifest(assetBundleManifestBundle);
                Debug.Log("Current BundleVerison Version is : [" + LocalVersion.Instance.versionInfo.BundleVerison + "]");
                CheckPrepared();
            }
        }
        private void OnAssetBundleManifest(AssetBundle assetBundleManifestBundle)
        {
            if(assetBundleManifestBundle)
            {
                assetBundleManifest = assetBundleManifestBundle.LoadAsset<AssetBundleManifest>(GameConfig.AssetBundleManifestName);
                AssetBundleLoader.AssetBundleManifest = assetBundleManifest;
                assetBundleManifestBundle.Unload(false);
            }
        }

        private void EnqueueDownloadCommand(Common.QueueCommands queue, string url, System.Action<AssetBundle> access)
        {
            var download = new Command() { data = false, finishFunc = (_cmd) => { return (bool)_cmd.data; } };
            AssetBundleWebRequestController.Instance.DownloadAssetBundle(url, null,
                (_assetBundle) =>
                {
                    if(access != null)
                    {
                        access.Invoke(_assetBundle);
                    }
                    download.data = true;
                });
            queue.Enqueue(download);
        }
        private void CheckPrepared()
        {
            if(configs.isBundleMode)
            {
                Prepared = assetBundleManifest && LocalVersion.Instance.versionInfo != null;
            }
            else
            {
                Prepared = true;
            }
        }
        #endregion

        #region Auto Unload
        private void ClearRequest()
        {
            _unloadUnloadedLoaders = true;
            ms_assetUnloadCountDown.countDownTime = configs.isBundleMode ? unloadPaddingTime : 0.0f;     // if no assetBundle Mode, no need wait.
            ms_resourceUnloadCountDown.countDownTime = unloadPaddingTime;                        // call unload should always wait
        }
        private void RequestUnloadUnusedAssets()
        {
            ms_resourceUnloadCountDown.Start();
        }
        private void ClearUnusedAssetLoaders(Dictionary<string, List<TypeData>> dict)
        {
            if(dict.Count > 0)
            {
                dict.RemoveAll((_uniqueName, _typeDataList) =>
                {
                    if(_typeDataList.Count > 0)
                    {
                        _typeDataList.RemoveAll((_typeData) =>
                        {
                            if(_typeData == null)
                            {
                                return true;
                            }
                            bool unload = (_typeData.loader == null) || (_typeData.loader.unloaded);
                            if(unload)
                            {
                                TypeDataPool.DeAllocate(_typeData);
                            }
                            return unload;
                        });
                    }
                    // only main assets has no more used, should call unload func, especially important for None-AssetBundle mode
                    bool remove = _typeDataList.Count == 0;
                    if(remove)
                    {
                        if(ms_assetUnloadCountDown.started == false)
                        {
                            ms_assetUnloadCountDown.Start();
                        }
                        TypeDataListPool.DeAllocate(_typeDataList);
                    }
                    return remove;
                });
            }
        }
        private void TickUnferencedAssetBundleLoader()
        {
            if(_assetBundleRequests.Count > 0)
            {
                _assetBundleRequests.RemoveAll((_uniqueName, _assetBundleLoader) =>
                {
                    if(_assetBundleLoader == null)
                    {
                        return true;
                    }
                    if(_assetBundleLoader.mainAssetBundle != null && (_assetBundleLoader.mainAssetBundle.referenceCount <= 0 || _assetBundleLoader.unloaded))
                    {
                        if(_assetBundleLoader.Unload())
                        {
                            _unusedAssetCount += _assetBundleLoader.unmanagedAssetCount;
                        }
                        return true;
                    }
                    return false;
                });
            }
        }
        private void TickUnloadedLoaders()
        {
            _unloadUnloadedLoaders = false;
            ClearUnusedAssetLoaders(_assetLists);
            ClearUnusedAssetLoaders(_assetLoaders);
            ClearUnusedAssetLoaders(_levelLoaders);
        }
        private void UpdateUnload()
        {
            if(_unloadUnloadedLoaders)
            {
                TickUnloadedLoaders();
            }

            if(ms_assetUnloadCountDown.Finished())
            {
                if(configs.isBundleMode)
                {
                    TickUnferencedAssetBundleLoader();
                    RequestUnloadUnusedAssets();        // in AssetBundle mode, only when assetbundle unloaded, should call res unload
                }
                else
                {
                    RequestUnloadUnusedAssets();
                }
            }
            if(ms_resourceUnloadCountDown.Finished())
            {
                if(_unusedAssetCount > minUnloadAssetCounter)
                {
                    _unusedAssetCount = 0;
                    if(CoroutineRoot.Instance.IsCoroutineRunning(_unloadID) == false)
                    {
                        _unloadID = CoroutineRoot.Instance.StartCoroutineEx(UnloadUnusedAssets());
                    }
                }
            }

            if(configs.isBundleMode)
            {
                AssetLostUnload();
            }
        }

        private int _unloadID = CoroutineRoot.NULL;
        private IEnumerator UnloadUnusedAssets()
        {
            //System.GC.Collect(0);
            yield return new WaitForSeconds(unloadPaddingTime);

#if UNITY_EDITOR || DEVELOPMENT_BUILD
            Debug.Log("Resources.UnloadUnusedAssets ...");
#endif
            ms_unloadedAssets.UnionWith(ms_unloadingAssets);
            ms_unloadingAssets.Clear();
            yield return Resources.UnloadUnusedAssets();
            if(onResourcesUnloaded != null)
            {
                onResourcesUnloaded.Invoke(ms_unloadedAssets);
            }
            ms_unloadedAssets.Clear();

            _unloadID = CoroutineRoot.NULL;
        }

        private void AssetLostUnload()
        {
            if(_unloadID != CoroutineRoot.NULL)
            {
                return;
            }
            if(m_inverseUnloadCountDown != null && m_inverseUnloadCountDown.Finished())
            {
                m_inverseUnloadCountDown.Start();
                AssetLoader.CheckUnload();
            }
        }
        #endregion

        private void Update()
        {
            UpdateUnload();
        }

    }
}