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

namespace BrewMonster.Scripts
{
    /// <summary>
    /// Scene Bootstrap (index 1): Addressables luôn được init thẳng vì
    /// <see cref="GameContentBootstrap"/> đã chạy xong ở scene 0 (<see cref="GameContentBootstrapSession.IsContentReady"/> = true).
    /// </summary>
    [DefaultExecutionOrder(-1990)]
    public class AddressableManager : MonoSingleton<AddressableManager>
    {
        private bool _isInitialized = false;
        private UniTaskCompletionSource _initializationTcs;

        private Dictionary<string, AsyncOperationHandle<GameObject>> _loadedPrefabAssets = new();
        private Dictionary<string, AsyncOperationHandle<TextAsset>> _loadedTextAssets = new();
        private Dictionary<string, AsyncOperationHandle<AudioClip>> _loadedAudioAssets = new();
        private Dictionary<string, AsyncOperationHandle<Sprite>> _loadedSpriteAssets = new();
        private Dictionary<string, AsyncOperationHandle<SpriteAtlas>> _loadedSpriteAtlasAssets = new();

        private Dictionary<string, int> _loadedAssetReferenceCount = 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;

        /// <summary>
        /// Returns immediately if already initialized; otherwise waits for the
        /// Addressables initialization callback without per-frame polling.
        /// </summary>
        public UniTask WaitUntilInitializedAsync()
        {
            if (_isInitialized) return UniTask.CompletedTask;
            return _initializationTcs.Task;
        }

        protected override void Awake()
        {
            Debug.Log($"[Cuong] AddressableManager: Awake | id={GetInstanceID()} frame={Time.frameCount}");
            base.Awake();
        }

        protected override void Initialize()
        {
            base.Initialize();
            _isInitialized = false;
            _initializationTcs = new UniTaskCompletionSource();
            StartAddressablesInitAsync().Forget();
        }

        async UniTaskVoid StartAddressablesInitAsync()
        {
            Debug.Log("[Cuong] AddressableManager: Đang InitializeAsync Addressables...");
            try
            {
                await AddressablesInitService.EnsureInitializedAsync();
                _isInitialized = true;
                _initializationTcs.TrySetResult();
                BMLogger.Log("AddressableManager: Initialized");
                Debug.Log("[Cuong] AddressableManager: InitializeAsync xong — sẵn sàng load asset.");
            }
            catch (Exception e)
            {
                BMLogger.LogError($"AddressableManager: Failed to initialize: {e.Message}");
                Debug.LogError($"[Cuong] AddressableManager: InitializeAsync thất bại — {e.Message}");
            }
        }

#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 RemoveFromReleaseAssetDictionary(string assetPath)
        {
            if (_releaseAssetTimestamps.ContainsKey(assetPath))
            {
                _releaseAssetTimestamps.Remove(assetPath);
            }
        }

        private void IncreaseReferenceCount(string assetPath)
        {
            if (!_loadedAssetReferenceCount.ContainsKey(assetPath))
            {
                _loadedAssetReferenceCount[assetPath] = 0;
            }
            _loadedAssetReferenceCount[assetPath]++;
        }

        private void DecreaseReferenceCount(string assetPath)
        {
            if (_loadedAssetReferenceCount.TryGetValue(assetPath, out int count))
            {
                count--;
                if (count <= 0)
                {
                    _loadedAssetReferenceCount.Remove(assetPath);
                    // put into the release asset timestamp dictionary.
                    _releaseAssetTimestamps[assetPath] = Time.realtimeSinceStartup;
                }
            }
        }
#endregion

#region public functions
        AsyncOperationHandle<TextAsset> _loadedTextAssetHandle;
        /// <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)
        {
            // increase the reference count of the asset.
            if (!_loadedAssetReferenceCount.ContainsKey(assetPath))
            {
                _loadedAssetReferenceCount[assetPath] = 0;
            }
            _loadedAssetReferenceCount[assetPath]++;

            // remove the asset from the release timestamp dictionary. So it won't be released.
            RemoveFromReleaseAssetDictionary(assetPath);

            if (_loadedTextAssets.TryGetValue(assetPath, out _loadedTextAssetHandle))
            {
                if (_loadedTextAssetHandle.IsValid() && _loadedTextAssetHandle.Result != null)
                {
                    BMLogger.Log($"AddressableManager: Loaded text asset from cache: {assetPath}");
                    return _loadedTextAssetHandle.Result;
                }
                else
                {
                    BMLogger.Log($"AddressableManager: Text asset handle is invalid or result is null, need to load new one: {assetPath}");
                }
            }

            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;
            }
        }


        AsyncOperationHandle<SpriteAtlas> _loadedSpriteAtlasHandle;
        /// <summary>Load a sprite atlas asynchronously.</summary>
        public async Task<SpriteAtlas> LoadSpriteAtlasAsync(string assetPath)
        {
           // increase the reference count of the asset.
            if (!_loadedAssetReferenceCount.ContainsKey(assetPath))
            {
                _loadedAssetReferenceCount[assetPath] = 0;
            }
            _loadedAssetReferenceCount[assetPath]++;

            // remove the asset from the release timestamp dictionary. So it won't be released.
            RemoveFromReleaseAssetDictionary(assetPath);

            if (_loadedSpriteAtlasAssets.TryGetValue(assetPath, out _loadedSpriteAtlasHandle))
            {
                if (_loadedTextAssetHandle.IsValid() && _loadedTextAssetHandle.Result != null)
                {
                    BMLogger.Log($"AddressableManager: Loaded text asset from cache: {assetPath}");
                    return _loadedSpriteAtlasHandle.Result;
                }
                else
                {
                    BMLogger.Log($"AddressableManager: Text asset handle is invalid or result is null, need to load new one: {assetPath}");
                }
            }

            try
            {
                var handle = Addressables.LoadAssetAsync<SpriteAtlas>(assetPath);
                await handle.Task;
                if (handle.OperationException != null)
                {
                    BMLogger.Log($"AddressableManager: Failed to load Sprite Atlas '{assetPath}': {handle.OperationException.Message} {handle.OperationException.StackTrace}");
                    #if UNITY_EDITOR
                    _invalidAssetPaths.Add(assetPath);
                    #endif
                    return null;
                }
                _loadedSpriteAtlasAssets[assetPath] = handle;
                return handle.Result;
            }
            catch (Exception e)
            {
                BMLogger.LogError($"AddressableManager: Failed to load SpriteAtlas '{assetPath}': {e}");
                return null;
            }
        }


        AsyncOperationHandle<GameObject> _loadedPrefabHandle;
        /// <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 (!KeyExists(assetPath, typeof(GameObject)))
            {
                BMLogger.LogWarning($"AddressableManager: Prefab '{assetPath}' does not exist");
                return null;
            }

            if (_loadedPrefabAssets.TryGetValue(assetPath, out _loadedPrefabHandle))
            {
                if (_loadedPrefabHandle.IsValid() && _loadedPrefabHandle.Result != null)
                {
                    // BMLogger.Log($"AddressableManager: Loaded prefab from cache: {assetPath}");
                    return _loadedPrefabHandle.Result;
                }
                else
                {
                    // BMLogger.Log($"AddressableManager: Prefab handle is invalid or result is null, need to load new one: {assetPath}");
                }
            }

            try
            {
                var handle = Addressables.LoadAssetAsync<GameObject>(assetPath);
                await handle.Task;
                if (handle.OperationException != null)
                {
                    BMLogger.Log($"AddressableManager: Failed to load Prefab '{assetPath}': {handle.OperationException.Message} {handle.OperationException.StackTrace}");
                    #if UNITY_EDITOR
                    _invalidAssetPaths.Add(assetPath);
                    #endif
                    return null;
                }
                _loadedPrefabAssets[assetPath] = handle;
                return handle.Result;
            }
            catch (System.Exception e)
            {
                BMLogger.Log($"AddressableManager: Failed to load Prefab '{assetPath}': {e.Message} {e.StackTrace}");
                #if UNITY_EDITOR
                _invalidAssetPaths.Add(assetPath);
                #endif
                return null;
            }
        }

        AsyncOperationHandle<AudioClip> _loadedAudioClipHandle;

        /// <summary>
        /// Load an AudioClip asynchronously (e.g. skill SFX). Key must match the Addressables address.
        /// </summary>
        public async Task<AudioClip> LoadAudioClipAsync(string assetPath)
        {
            RemoveFromReleaseAssetDictionary(assetPath);

            if (_loadedAudioAssets.TryGetValue(assetPath, out _loadedAudioClipHandle))
            {
                if (_loadedAudioClipHandle.IsValid() && _loadedAudioClipHandle.Result != null)
                {
                    BMLogger.Log($"AddressableManager: Loaded audio from cache: {assetPath}");
                    return _loadedAudioClipHandle.Result;
                }
            }

            try
            {
                var handle = Addressables.LoadAssetAsync<AudioClip>(assetPath.Trim());
                await handle.Task;
                if (handle.OperationException != null)
                {
                    BMLogger.Log($"AddressableManager: Failed to load AudioClip '{assetPath}': {handle.OperationException.Message}");
                    return null;
                }
                _loadedAudioAssets[assetPath] = handle;
                return handle.Result;
            }
            catch (Exception e)
            {
                BMLogger.LogError($"AddressableManager: Failed to load AudioClip '{assetPath}': {e.Message}");
                return null;
            }
        }

        AsyncOperationHandle<Sprite> _loadedSpriteHandle;

        /// <summary>
        /// Load a Sprite asynchronously (e.g. UI art). Key must match the Addressables address.
        /// </summary>
        public async Task<Sprite> LoadSpriteAsync(string assetPath)
        {
            RemoveFromReleaseAssetDictionary(assetPath);

            if (_loadedSpriteAssets.TryGetValue(assetPath, out _loadedSpriteHandle))
            {
                if (_loadedSpriteHandle.IsValid() && _loadedSpriteHandle.Result != null)
                {
                    BMLogger.Log($"AddressableManager: Loaded sprite from cache: {assetPath}");
                    return _loadedSpriteHandle.Result;
                }
            }

            try
            {
                var handle = Addressables.LoadAssetAsync<Sprite>(assetPath.Trim());
                await handle.Task;
                if (handle.OperationException != null)
                {
                    BMLogger.Log($"AddressableManager: Failed to load Sprite '{assetPath}': {handle.OperationException.Message}");
                    return null;
                }
                _loadedSpriteAssets[assetPath] = handle;
                return handle.Result;
            }
            catch (Exception e)
            {
                BMLogger.LogError($"AddressableManager: Failed to load Sprite '{assetPath}': {e.Message}");
                return null;
            }
        }

        /// <summary>
        /// True if this address is already in the audio cache (play immediately vs async load).
        /// </summary>
        public bool TryGetCachedAudioClip(string assetPath, out AudioClip clip)
        {
            clip = null;
            if (string.IsNullOrEmpty(assetPath))
                return false;
            if (_loadedAudioAssets.TryGetValue(assetPath, out var h) && h.IsValid() && h.Result != null)
            {
                clip = h.Result;
                return true;
            }
            return false;
        }

        /// <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);
            }
            else if (_loadedTextAssets.TryGetValue(assetPath, out var loadedTextHandle))
            {
                if (loadedTextHandle.IsValid())
                {
                    Addressables.Release(loadedTextHandle);
                }
                _loadedTextAssets.Remove(assetPath);
            }
            else if (_loadedAudioAssets.TryGetValue(assetPath, out var loadedAudioHandle))
            {
                if (loadedAudioHandle.IsValid())
                {
                    Addressables.Release(loadedAudioHandle);
                }
                _loadedAudioAssets.Remove(assetPath);
                BMLogger.Log($"AddressableManager: Force released audio asset: {assetPath}");
            }
            else if (_loadedSpriteAssets.TryGetValue(assetPath, out var loadedSpriteHandle))
            {
                if (loadedSpriteHandle.IsValid())
                {
                    Addressables.Release(loadedSpriteHandle);
                }
                _loadedSpriteAssets.Remove(assetPath);
                BMLogger.Log($"AddressableManager: Force released sprite 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();
            foreach (var kvp in _loadedAudioAssets)
            {
                if (kvp.Value.IsValid())
                {
                    Addressables.Release(kvp.Value);
                }
            }
            _loadedAudioAssets.Clear();
            foreach (var kvp in _loadedSpriteAssets)
            {
                if (kvp.Value.IsValid())
                {
                    Addressables.Release(kvp.Value);
                }
            }
            _loadedSpriteAssets.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();
        }

        #if UNITY_EDITOR
        private HashSet<string> _invalidAssetPaths = new();
        #endif

        /// <summary>
        /// Checks if a given Addressable key or path exists in the current catalogs.
        /// </summary>
        /// <param name="key">The Addressable key, path, or label to check.</param>
        /// <param name="type">Optional: The specific type of asset you are looking for.</param>
        /// <returns>True if the key exists, false otherwise.</returns>
        public static bool KeyExists(object key, System.Type type = null)
        {
            string keyStr = key?.ToString();
            if (string.IsNullOrEmpty(keyStr))
                return false;

            #if UNITY_EDITOR
            // Failed loads are cached; still verify against catalog (do not assume unknown keys exist).
            if (Instance != null && Instance._invalidAssetPaths.Contains(keyStr))
                return false;
            #endif

            foreach (IResourceLocator locator in Addressables.ResourceLocators)
            {
                if (locator.Locate(key, type, out var locations)
                    && locations != null
                    && locations.Count > 0)
                {
                    return true;
                }
            }

            return false;
        }
#endregion



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