#region Copyright RenGuiYou. All rights reserved.
//=====================================================
// NeatlyFrameWork
// Author:      RenGuiyou
// Feedback: 	mailto:750539605@qq.com
//=====================================================
#endregion

using System;
using System.Collections.Generic;
using Neatly.Module;
using UnityEngine;

namespace Neatly.Load
{
    public class LoaderPool : IPoolBase<Loader>
    {
        private const int SECOND_ONE = 1;
        private float m_RecordTime = 0;

        //总loader
        private readonly Dictionary<string, Loader> m_AllLoaders = new Dictionary<string, Loader>();

        //临时loader
        private readonly List<Loader> m_TempLoader = new List<Loader>();

        //异步loader
        private readonly List<Loader> m_AsyncLoaders = new List<Loader>();

        //总AtlasLoader
        private readonly Dictionary<string, Loader> m_AllAtlasLoaders = new Dictionary<string, Loader>();

        public void Add(string name, Loader loader)
        {
            loader.LiveTime = 0;
            //是否图集bundle
            if (loader.IsAtlas)
            {
                if (m_AllAtlasLoaders.ContainsKey(loader.AtlasName))
                {
                    m_AllAtlasLoaders.Remove(loader.AtlasName);
                }
                m_AllAtlasLoaders.Add(loader.AtlasName, loader);
            }
            if (!loader.Persistent)
            {
                if (loader.IsSync)
                {
                    m_TempLoader.Add(loader);
                }
                else
                {
                    m_AsyncLoaders.Add(loader);
                }
            }
            if (!m_AllLoaders.ContainsKey(name))
            {
                m_AllLoaders.Add(name, loader);
            }
        }

        public Loader Get(string key, bool isDependency)
        {
            Loader loader = null;
            m_AllLoaders.TryGetValue(key, out loader);
            //非常驻,非图集
            if (loader != null && isDependency)
            {
                loader.AddDependCount();
            }
            return loader;
        }

        //获取AtlasLoader
        public Loader GetAtlasLoader(string key)
        {
            Loader loader = null;
            m_AllAtlasLoaders.TryGetValue(key, out loader);
            return loader;
        }

        public void LoseRef(string assetName)
        {
            if (string.IsNullOrEmpty(assetName))
            {
                return;
            }
            for (int i = 0; i < m_TempLoader.Count; i++)
            {
                if (m_TempLoader[i].ContainAsset(assetName))
                {
                    m_TempLoader[i].LoseRefenceCount();
                    break;
                }
            }
        }

        //增加Atlas引用
        public void AddAtlasRef(string key)
        {
            m_AllAtlasLoaders[key].AddRefenceCount();
        }

        //解除Atlas引用
        public void LoseAtlasRef(string key)
        {
            m_AllAtlasLoaders[key].LoseRefenceCount();
        }

        public void Update()
        {
            //异步完成情况
            for (int i = m_AsyncLoaders.Count - 1; i >= 0; i--)
            {
                m_AsyncLoaders[i].Update();
                if (m_AsyncLoaders[i].IsCompleted)
                {
                    m_TempLoader.Add(m_AsyncLoaders[i]);
                    m_AsyncLoaders.RemoveAt(i);
                }
            }

            //定时清理资源
            m_RecordTime += Time.deltaTime;
            if (m_RecordTime >= SECOND_ONE)
            {
                m_RecordTime -= SECOND_ONE;
                var curDeltaTime = Time.realtimeSinceStartup - NeatlyConfig.TIME_BUNDLE_CACHE;
                //清理临时bundle
                for (int i = m_TempLoader.Count - 1; i >= 0; i--)
                {
                    var loader = m_TempLoader[i];
                    if (loader.RefCount <= 0 && loader.DependCount <= 0)
                    {
                        if (loader.LiveTime <= curDeltaTime)
                        {
                            if (NeatlyConfig.AssetBundleEnable)
                            {
                                string[] dependencies = LoadModule.Instance.GetAllDependencies(loader.Path);
                                //处理依赖关联资源引用计数
                                for (int j = 0; j < dependencies.Length; j++)
                                {
                                    Loader dependLoader = null;
                                    m_AllLoaders.TryGetValue(dependencies[j], out dependLoader);
                                    if (dependLoader != null)
                                    {
                                        m_AllLoaders[dependencies[j]].LoseDependCount();
                                    }
                                }
                                loader.Unload(true);
                            }

                            if (loader.IsAtlas)
                            {
                                m_AllAtlasLoaders.Remove(loader.AtlasName);
                            }
                            m_AllLoaders.Remove(loader.Path);
                            m_TempLoader.RemoveAt(i);
                            return;
                        }
                    }
                }
            }
        }

        public void Remove(string key)
        {
        }

        public void ClearVersion()
        {
            foreach (var kv in m_AllLoaders)
            {
                kv.Value.Unload(false);
            }
            m_AllLoaders.Clear();
            m_TempLoader.Clear();
        }

        #region 可视化接口
        public Dictionary<string, Loader> GetAllLoader()
        {
            return m_AllLoaders;
        }
        #endregion
    }
}