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

namespace Game
{
    public enum LoadType
    {
        Editor,
        Single,
        Online
    }

    public enum SceneType
    {
        Init,
        Touch,
    }

    public class ResourceManager : ManagerBase, IResourceManager
    {
        private List<string> _packageName = new List<string>();
        private ResourcePackage _defaultPackage;
        private Dictionary<string, AssetHandle> _assetHandles = new Dictionary<string, AssetHandle>();
        private Dictionary<string, SceneHandle> _sceneHandles = new Dictionary<string, SceneHandle>();
        private Dictionary<string, GameObject> _gameObjects = new Dictionary<string, GameObject>();

        private Transform objectParent;
        private Transform uiParent;

        private Transform ui_Low;
        private Transform ui_Mid;
        private Transform ui_High;
        private Transform go_GameObject;

        private EPlayMode playMode;
        private bool isLoadFinish;

        protected override void OnInit()
        {
            base.OnInit();
            YooAssets.Initialize();

            // 
            ui_Low = GameObject.Find("Global/UICanvas/Low").transform;
            ui_Mid = GameObject.Find("Global/UICanvas/Mid").transform;
            ui_High = GameObject.Find("Global/UICanvas/High").transform;
            go_GameObject = GameObject.Find("Global/GameObject").transform;

            isLoadFinish = false;
            EventManager.Instance.Subscribe(UpdaterDoneEventArgs.EventId, UpdaterDoneEvent);
        }

        private void UpdaterDoneEvent(object sender, GameEventArgs e)
        {
            var args = e as UpdaterDoneEventArgs;
            isLoadFinish = true;
        }

        protected override void OnUpdate(float dateTime)
        {
            base.OnUpdate(dateTime);
        }

        public void LoadPackage(string packageName)
        {
            if (_packageName.Contains(packageName)) return;
            YooAssets.CreatePackage(packageName);
            _packageName.Add(packageName);
        }

        public void UnloadPackage(string packageName)
        {
            var resourcePackage = YooAssets.GetPackage(packageName);
            if (resourcePackage != null)
            {
                resourcePackage.UnloadUnusedAssets();
                YooAssets.DestroyPackage(packageName);
                _packageName.Remove(packageName);
            }
        }

        ResourceUpdatePackageHandle handle;

        public async UniTask InitLoadModeAsync(EPlayMode playMode)
        {
            this.playMode = playMode;
            handle = new ResourceUpdatePackageHandle(playMode, "DefaultPackage", EDefaultBuildPipeline.BuiltinBuildPipeline.ToString());
            await handle.InitPackageAsync();

            while (!this.isLoadFinish)
            {
                await UniTask.Yield();
            }

            _defaultPackage = YooAssets.GetPackage("DefaultPackage");
            YooAssets.SetDefaultPackage(_defaultPackage);

            return;
//            switch (_loadType)
//            {
//                case LoadType.Editor:
//#if UNITY_EDITOR
//                    Debug.Log("EditorMode-Loading");
//                    await InitializeYooAsset_Editor();
//#endif
//                    break;
//                case LoadType.Single:
//                    Debug.Log("SingleMode-Loading");
//                    await InitializeYooAsset_Single();
//                    break;
//                case LoadType.Online:
//                    break;
//                default:
//                    throw new ArgumentOutOfRangeException();
//            }
        }

#region 弃用了

#if UNITY_EDITOR
        private async UniTask InitializeYooAsset_Editor()
        {
            var initParameters = new EditorSimulateModeParameters();
            var simulateManifestFilePath =
                EditorSimulateModeHelper.SimulateBuild(EDefaultBuildPipeline.BuiltinBuildPipeline, "DefaultPackage");
            initParameters.SimulateManifestFilePath = simulateManifestFilePath;
            await _defaultPackage.InitializeAsync(initParameters);
            Debug.Log("EditorMode-LoadFinish");
        }
#endif

        private async UniTask InitializeYooAsset_Single()
        {
            var initParameters = new OfflinePlayModeParameters();
            await _defaultPackage.InitializeAsync(initParameters);
            Debug.Log("SingleMode-LoadFinish");
        }

        // 获取资源版本
        private async UniTask UpdatePackageVersion()
        {
            var package = YooAssets.GetPackage("DefaultPackage");
            var operation = package.UpdatePackageVersionAsync();
            await operation;

            if (operation.Status == EOperationStatus.Succeed)
            {
                //更新成功
                string packageVersion = operation.PackageVersion;
                Debug.Log($"Updated package Version : {packageVersion}");
            }
            else
            {
                //更新失败
                Debug.LogError(operation.Error);
            }
        }

        private async UniTask UpdatePackageManifest()
        {
            // 更新成功后自动保存版本号，作为下次初始化的版本。
            // 也可以通过operation.SavePackageVersion()方法保存。
            bool savePackageVersion = true;
            var package = YooAssets.GetPackage("DefaultPackage");
            string packageVersion = String.Empty;
            var operation = package.UpdatePackageManifestAsync(packageVersion, savePackageVersion);
            await operation;

            if (operation.Status == EOperationStatus.Succeed)
            {
                //更新成功
            }
            else
            {
                //更新失败
                Debug.LogError(operation.Error);
            }
        }

        async UniTask Download()
        {
            int downloadingMaxNum = 10;
            int failedTryAgain = 3;
            var package = YooAssets.GetPackage("DefaultPackage");
            var downloader = package.CreateResourceDownloader(downloadingMaxNum, failedTryAgain);

            //没有需要下载的资源
            if (downloader.TotalDownloadCount == 0)
            {
                return;
            }

            //需要下载的文件总数和总大小
            int totalDownloadCount = downloader.TotalDownloadCount;
            long totalDownloadBytes = downloader.TotalDownloadBytes;

            //注册回调方法
            downloader.OnDownloadErrorCallback = OnDownloadErrorFunction;
            downloader.OnDownloadProgressCallback = OnDownloadProgressUpdateFunction;
            downloader.OnDownloadOverCallback = OnDownloadOverFunction;
            downloader.OnStartDownloadFileCallback = OnStartDownloadFileFunction;

            //开启下载
            Debug.Log("开启下载");
            downloader.BeginDownload();
            await downloader;

            //检测下载结果
            if (downloader.Status == EOperationStatus.Succeed)
            {
                //下载成功
                Debug.Log("下载成功");
            }
            else
            {
                //下载失败
                Debug.Log("下载失败");
            }
        }

        private void OnStartDownloadFileFunction(string filename, long sizebytes)
        {
            Debug.Log("OnStartDownloadFileFunction");
        }

        private void OnDownloadOverFunction(bool issucceed)
        {
            Debug.Log("OnDownloadOverFunction");
        }

        private void OnDownloadProgressUpdateFunction(int totaldownloadcount, int currentdownloadcount, long totaldownloadbytes, long currentdownloadbytes)
        {
            Debug.Log("OnDownloadProgressUpdateFunction");
        }

        private void OnDownloadErrorFunction(string filename, string error)
        {
            Debug.Log("OnDownloadErrorFunction");
        }
        //        private async UniTask InitializeYooAsset_Online()
//        {
//            // 注意：GameQueryServices.cs 太空战机的脚本类，详细见StreamingAssetsHelper.cs
//            string defaultHostServer = "http://127.0.0.1/CDN/Android/v1.0";
//            string fallbackHostServer = "http://127.0.0.1/CDN/Android/v1.0";
//            var initParameters = new HostPlayModeParameters();
//            initParameters.BuildinQueryServices = new GameQueryServices();
//            initParameters.DecryptionServices = new FileOffsetDecryption();
//            initParameters.RemoteServices = new RemoteServices(defaultHostServer, fallbackHostServer);
//            var initOperation = package.InitializeAsync(initParameters);
//            yield return initOperation;
//        
//            if (initOperation.Status == EOperationStatus.Succeed)
//            {
//                Debug.Log("资源包初始化成功！");
//            }
//            else
//            {
//                Debug.LogError($"资源包初始化失败：{initOperation.Error}");
//            }
//        }

#endregion

        public AssetHandle LoadAssetSync(string name)
        {
            if (_assetHandles.TryGetValue(name, out var assetHandle))
            {
                return assetHandle;
            }

            var loadAssetSync = YooAssets.LoadAssetSync(name);
            _assetHandles.Add(name, loadAssetSync);
            return loadAssetSync;
        }

        public GameObject LoadGameObjectSync(string name)
        {
            var loadAssetSync = LoadAssetSync(name);
            var assetObject = loadAssetSync.AssetObject as GameObject;
            if (this.objectParent == null)
                this.objectParent = go_GameObject;

            var gameObject = Object.Instantiate(assetObject, this.objectParent);
            return gameObject;
        }

        public GameObject LoadUIGameObjectSync(string name, UILayer uiLayer)
        {
            var loadAssetSync = LoadAssetSync(name);
            var assetObject = loadAssetSync.AssetObject as GameObject;
//            if (this.uiParent == null)
//                this.uiParent = GameObject.Find("Global/UICanvas").transform;

            switch (uiLayer)
            {
                case UILayer.Low:
                    this.uiParent = ui_Low;
                    break;
                case UILayer.Mid:
                    this.uiParent = ui_Mid;
                    break;
                case UILayer.High:
                    this.uiParent = ui_High;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(uiLayer), uiLayer, null);
            }

            var gameObject = Object.Instantiate(assetObject, uiParent);
            return gameObject;
        }

        public async UniTask LoadSceneAsync(string location, LoadSceneMode loadSceneMode = LoadSceneMode.Single,
            bool suspendLoad = false)
        {
            // if (_assetHandles.TryGetValue(name, out var assetHandle))
            // {
            //     return assetHandle;
            // }

            var loadSceneAsync = YooAssets.LoadSceneAsync(location, loadSceneMode, suspendLoad);
            _sceneHandles.Add(location, loadSceneAsync);
//            await loadSceneAsync.Task;

            while (!loadSceneAsync.IsDone)
            {
                Debug.Log("进度：" + loadSceneAsync.Progress);
                await UniTask.Yield();
            }

//            await loadSceneAsync.Task;
            Debug.Log($"{location}场景加载成功！");
        }

        public async void UnloadSceneAsync(SceneType sceneType)
        {
            var name = sceneType.ToString();
            if (_sceneHandles.TryGetValue(name, out var handle))
            {
                await handle.UnloadAsync().Task;
                Debug.Log($"{name}场景卸载成功！");
            }
        }

        public async UniTask<Object> LoadAssetAsync(string name)
        {
            if (_assetHandles.TryGetValue(name, out var assetHandle))
            {
                return assetHandle.AssetObject;
            }

            var loadAssetSync = YooAssets.LoadAssetAsync(name);
            await loadAssetSync.Task;
            _assetHandles.Add(name, loadAssetSync);
            return loadAssetSync.AssetObject;
        }

        public async UniTask<GameObject> LoadGameObjectAsync(string name)
        {
            var loadAssetSync = await LoadAssetAsync(name);
            var assetObject = loadAssetSync as GameObject;
            var gameObject = Object.Instantiate(assetObject);

            return gameObject;
        }

        public void Release(string name)
        {
            if (_assetHandles.TryGetValue(name, out var assetHandle))
            {
                assetHandle.Release();
            }
        }

        protected override void OnDispose()
        {
            base.OnDispose();
            while (_packageName.Count > 0)
            {
                var packageName = _packageName[0];
                UnloadPackage(packageName);
                _packageName.Remove(packageName);
            }

            EventManager.Instance.Unsubscribe(UpdaterDoneEventArgs.EventId, UpdaterDoneEvent);

            // foreach (var handle in _sceneHandles.Values)
            // {
            //     UnloadSceneAsync(handle.SceneName);
            // }

            _sceneHandles = null;
            _packageName = null;
            _gameObjects = null;
            _assetHandles = null;
        }
    }

    // public class GO_S
    // {
    //     public string name;
    //     private AssetHandle AssetHandle;
    //     private GameObject go;
    //
    //     public GO_S(string name, AssetHandle assetHandle, GameObject go)
    //     {
    //         this.name = name;
    //         AssetHandle = assetHandle;
    //         this.go = go;
    //     }
    //
    //     public void Release()
    //     {
    //         AssetHandle.Release();
    //         GameObject.Destroy(go);
    //     }
    // }

    public interface IResourceManager
    {
        AssetHandle LoadAssetSync(string name);
        GameObject LoadGameObjectSync(string path);
        GameObject LoadUIGameObjectSync(string path, UILayer uiLayer);

        UniTask LoadSceneAsync(string location, LoadSceneMode loadSceneMode = LoadSceneMode.Single, bool suspendLoad = false);
    }
}