using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.ResourceManagement.AsyncOperations;

namespace BrewMonster.Scripts
{
    public class AddressableManager : MonoSingleton<AddressableManager>
    {
        private bool _isInitialized = false;

        private Dictionary<string, AsyncOperationHandle<GameObject>> _loadedPrefabAssets = new();
        private Dictionary<string, AsyncOperationHandle<TextAsset>> _loadedTextAssets = new();

        /// <summary>
        /// Whenever we release an asset, we store the timestamp of the release.
        /// After a certain amount of time, we will release the asset from the cache.
        /// </summary>
        private Dictionary<string, float> _releaseAssetTimestamps = new();
        [SerializeField]private float _releaseAssetTimeout = 10f;

        public event Action OnDispose;

        /// <summary>Get the count of currently loaded assets.</summary>
        public int LoadedPrefabCount => _loadedPrefabAssets.Count;

        public bool IsInitialized() => _isInitialized;

        protected override void Initialize()
        {
            base.Initialize();
            _isInitialized = false;
            Addressables.InitializeAsync().Completed += OnInitializeComplete;
        }   

#region Unity lifecycle
        private List<string> _assetToForceRelease = new();
        private void Update()
        {
            foreach (var kvp in _releaseAssetTimestamps)
            {
                if (Time.realtimeSinceStartup - kvp.Value > _releaseAssetTimeout)
                {
                    ForceReleaseAsset(kvp.Key);
                    _assetToForceRelease.Add(kvp.Key);
                }
            }

            if (_assetToForceRelease.Count > 0)
            {
                for (int i = 0; i < _assetToForceRelease.Count; i++)
                {
                    ForceReleaseAsset(_assetToForceRelease[i]);
                }
                _assetToForceRelease.Clear();
            }
        }
#endregion

#region private functions
        private void OnInitializeComplete(AsyncOperationHandle<IResourceLocator> handle)
        {
            if (handle.Status == AsyncOperationStatus.Succeeded)
            {
                _isInitialized = true;
                BMLogger.Log($"AddressableManager: Initialized");
            }
            else
            {
                // print out the error
                BMLogger.LogError($"AddressableManager: Failed to initialize: {handle.OperationException?.Message} {handle.OperationException?.StackTrace}");
            }
        }

        private void RemoveFromReleaseAssetDictionary(string assetPath)
        {
            if (_releaseAssetTimestamps.ContainsKey(assetPath))
            {
                _releaseAssetTimestamps.Remove(assetPath);
            }
        }
#endregion

#region public functions
        /// <summary>
        /// Load a text asset asynchronously.
        /// NOTE: The key must match the Addressables "Address" (or another valid key like a label/GUID).
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="assetPath"></param>
        /// <returns></returns>
        public async Task<TextAsset> LoadTextAssetAsync(string assetPath)
        {
            // remove the asset from the release timestamp dictionary. So it won't be released.
            RemoveFromReleaseAssetDictionary(assetPath);

            if (_loadedTextAssets.ContainsKey(assetPath))
            {
                return _loadedTextAssets[assetPath].Result;
            }
            try
            {
                var handle = Addressables.LoadAssetAsync<TextAsset>(assetPath);
                await handle.Task;
                _loadedTextAssets[assetPath] = handle;
                return handle.Result;
            }
            catch (Exception e)
            {
                BMLogger.LogError($"AddressableManager: Failed to load TextAsset '{assetPath}': {e}");
                return null;
            }
        }


        /// <summary>
        /// Load an asset asynchronously. The address should look like this: "models/npcs/npc/魅灵首领/魅灵首领/魅灵首领.prefab"
        /// </summary>
        /// <returns></returns>
        public async Task<GameObject> LoadPrefabAsync(string assetPath)
        {
            // remove the asset from the release timestamp dictionary. So it won't be released.
            RemoveFromReleaseAssetDictionary(assetPath);

            if (_loadedPrefabAssets.ContainsKey(assetPath))
            {
                BMLogger.Log($"AddressableManager: Asset already loaded: {assetPath} is valid: (${_loadedPrefabAssets[assetPath].Result != null})");
                return _loadedPrefabAssets[assetPath].Result;
            }

            try
            {
                var handle = Addressables.LoadAssetAsync<GameObject>(assetPath);
                await handle.Task;
                _loadedPrefabAssets[assetPath] = handle;
                return handle.Result;
            }
            catch (System.Exception e)
            {
                BMLogger.LogError(e.StackTrace);
                return null;
            }
        }

        /// <summary>
        /// When the asset is no longer needed, call this method to unload it. <br/>
        /// The asset will be released after a certain amount of time. <br/>
        /// </summary>
        /// <param name="assetPath">The asset path used when loading the asset</param>
        public void ReleaseAsset(string assetPath)
        {
            // If multiple release requests are made for the same asset, we only need to store the earliest release time.
            float currentReleaseTime = Time.realtimeSinceStartup;
            if (_releaseAssetTimestamps.TryGetValue(assetPath, out var timeStamp))
            {
                currentReleaseTime = Mathf.Min(currentReleaseTime, timeStamp);
            }
            _releaseAssetTimestamps[assetPath] = currentReleaseTime;
        }

        public void ForceReleaseAsset(string assetPath)
        {
            if (_loadedPrefabAssets.TryGetValue(assetPath, out var loadedPrefabHandle))
            {
                if (loadedPrefabHandle.IsValid())
                {
                    Addressables.Release(loadedPrefabHandle);
                }
                _loadedPrefabAssets.Remove(assetPath);
                BMLogger.Log($"AddressableManager: Released asset: {assetPath}");
            }
            else if (_loadedTextAssets.TryGetValue(assetPath, out var loadedTextHandle))
            {
                if (loadedTextHandle.IsValid())
                {
                    Addressables.Release(loadedTextHandle);
                }
                _loadedTextAssets.Remove(assetPath);
                BMLogger.Log($"AddressableManager: Released text asset: {assetPath}");
            }
        }

        /// <summary>
        /// Release a specific asset by its handle directly.
        /// </summary>
        /// <param name="handle">The async operation handle to release</param>
        public void ReleaseAsset(AsyncOperationHandle<GameObject> handle)
        {
            if (handle.IsValid())
            {
                Addressables.Release(handle);
            }
        }

        /// <summary>
        /// Release all loaded assets from the cache.
        /// </summary>
        public void ReleaseAllAssets()
        {
            foreach (var kvp in _loadedPrefabAssets)
            {
                if (kvp.Value.IsValid())
                {
                    Addressables.Release(kvp.Value);
                }
            }
            _loadedPrefabAssets.Clear();
            BMLogger.Log("AddressableManager: Released all assets");
        }

        /// <summary>
        /// Check if an asset is currently loaded in the cache.
        /// </summary>
        /// <param name="assetPath">The asset path to check</param>
        /// <returns>True if the asset is loaded</returns>
        public bool IsAssetLoaded(string assetPath)
        {
            return _loadedPrefabAssets.ContainsKey(assetPath) && _loadedPrefabAssets[assetPath].IsValid();
        }
#endregion

        

        private void OnDestroy()
        {
            OnDispose?.Invoke();
            ReleaseAllAssets();
        }
    }
}