using System;
using Cysharp.Threading.Tasks;
using UnityEngine;
using UnityEngine.SceneManagement;
using YooAsset;
using Object = UnityEngine.Object;

namespace ZC
{
    public interface IResourcesLocalComponent
    {
        UniTask<T> LoadAssetAsync<T>(string location, uint priority = 0) where T : UnityEngine.Object;
        UniTask<Object> LoadAssetAsync(string location, uint priority = 0);
        T LoadAssetSync<T>(string location) where T : UnityEngine.Object;
        GameObject LoadUIGameObjectSync(string location, UILayer uiLayer);
        GameObject LoadGameObjectSync(string location);
        Object LoadAssetSync(string location);
        UniTask LoadSceneAsync(string location, LoadSceneMode sceneMode = LoadSceneMode.Single, bool suspendLoad = false, uint priority = 100, Action<float> callback = null);
    }

    public class ResourcesLocalComponent : IResourcesLocalComponent
    {
        private static ResourcesLocalComponent instance;

        public static ResourcesLocalComponent Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = new ResourcesLocalComponent();
                }

                return instance;
            }
        }

        ResourcePackage resourcePackage;
        Transform Min;
        Transform Low;
        Transform Mid;
        Transform Hid;
        Transform Parent;

        public ResourcesLocalComponent()
        {
            resourcePackage = YooAssets.GetPackage("DefaultPackage");
            var transform = ZCGame.Self.transform;

            Min = transform.Find("UI/UICanvas/Min");
            Low = transform.Find("UI/UICanvas/Low");
            Mid = transform.Find("UI/UICanvas/Mid");
            Hid = transform.Find("UI/UICanvas/Hid");
            Parent = transform.Find("ObjectPool");
        }

        public async UniTask<T> LoadAssetAsync<T>(string location, uint priority = 0) where T : UnityEngine.Object
        {
            var loadAssetAsync = YooAssets.LoadAssetAsync<T>(location, priority);
            while (!loadAssetAsync.IsDone)
            {
                Debug.Log($"加载{location}中，进度：{loadAssetAsync.Progress}");
                await UniTask.Yield();
            }

            Debug.Log($"加载{location}完成");
            var assetObject = loadAssetAsync.AssetObject as T;
            return assetObject;
        }

        public async UniTask<Object> LoadAssetAsync(string location, uint priority = 0)
        {
            var loadAssetAsync = YooAssets.LoadAssetAsync(location, priority);
            while (!loadAssetAsync.IsDone)
            {
                Debug.Log($"加载{location}中，进度：{loadAssetAsync.Progress}");
                await UniTask.Yield();
            }

            Debug.Log($"加载{location}完成");
            return loadAssetAsync.AssetObject;
        }

        public T LoadAssetSync<T>(string location) where T : Object
        {
            var loadAssetAsync = YooAssets.LoadAssetSync<T>(location);
            Debug.Log($"加载{location}完成");
            var assetObject = loadAssetAsync.AssetObject as T;
            return assetObject;
        }

        public GameObject LoadUIGameObjectSync(string location, UILayer uiLayer)
        {
            var loadAssetAsync = YooAssets.LoadAssetSync(location);
            Debug.Log($"加载{location}完成");
            GameObject go = null;
            switch (uiLayer)
            {
                case UILayer.Min:
                    go = Object.Instantiate(loadAssetAsync.AssetObject, this.Min) as GameObject;
                    break;
                case UILayer.Low:
                    go = Object.Instantiate(loadAssetAsync.AssetObject, this.Low) as GameObject;
                    break;
                case UILayer.Mid:
                    go = Object.Instantiate(loadAssetAsync.AssetObject, this.Mid) as GameObject;
                    break;
                case UILayer.High:
                    go = Object.Instantiate(loadAssetAsync.AssetObject, this.Hid) as GameObject;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(uiLayer), uiLayer, null);
            }

            return go;
        }

        public GameObject LoadGameObjectSync(string location)
        {
            var loadAssetAsync = YooAssets.LoadAssetSync(location);
            Debug.Log($"加载{location}完成");
            GameObject go = null;
            go = Object.Instantiate(loadAssetAsync.AssetObject, this.Parent) as GameObject;
            return go;
        }

        public Object LoadAssetSync(string location)
        {
            var loadAssetAsync = YooAssets.LoadAssetSync(location);
            Debug.Log($"加载{location}完成");
            return loadAssetAsync.AssetObject;
        }

        public async UniTask<GameObject> LoadAssetAndInsAsync(string location, Transform parent = null, uint priority = 0)
        {
            var loadAssetAsync = YooAssets.LoadAssetAsync(location, priority);
            while (!loadAssetAsync.IsDone)
            {
                Debug.Log($"加载{location}中，进度：{loadAssetAsync.Progress}");
                await UniTask.Yield();
            }

            var instantiateOperation = loadAssetAsync.InstantiateAsync(parent);
            await instantiateOperation.Task;
            return instantiateOperation.Result;
        }

        public async UniTask LoadSceneAsync(string location, LoadSceneMode sceneMode = LoadSceneMode.Single, bool suspendLoad = false, uint priority = 100U, Action<float> callback = null)
        {
            var loadAssetAsync = YooAssets.LoadSceneAsync(location, sceneMode, suspendLoad, priority);
            while (!loadAssetAsync.IsDone)
            {
                Debug.Log($"加载{location}中，进度：{loadAssetAsync.Progress}");
                callback?.Invoke(loadAssetAsync.Progress);
                await UniTask.Yield();
            }
        }

        public void Dispose()
        {
            YooAssets.GetPackage("DefaultPackage").UnloadUnusedAssets();
        }
    }
}