using UnityEngine;
using System.Collections.Generic;
using Spine.Unity;

public class BattleCacheManager
{
    /// <summary>
    /// 资源引用信息（战场 + 角色维度）
    /// </summary>
    private class ResourceReference
    {
        public BattleResCache.CachedResource CachedResource;
        // 记录哪些战场的哪些角色在使用这个资源
        // Key: battleGuid, Value: ownerIds
        public Dictionary<string, HashSet<string>> BattlefieldOwners = new Dictionary<string, HashSet<string>>();
        
        public int RefCount
        {
            get
            {
                int count = 0;
                foreach (var owners in BattlefieldOwners.Values)
                {
                    count += owners.Count;
                }
                return count;
            }
        }
        
        /// <summary>
        /// 添加战场+角色的引用
        /// </summary>
        public void AddBattlefieldOwner(string battleGuid, string ownerId)
        {
            if (!BattlefieldOwners.ContainsKey(battleGuid))
            {
                BattlefieldOwners[battleGuid] = new HashSet<string>();
            }
            BattlefieldOwners[battleGuid].Add(ownerId);
        }
        
        /// <summary>
        /// 移除整个战场的所有引用
        /// </summary>
        public void RemoveBattlefield(string battleGuid)
        {
            BattlefieldOwners.Remove(battleGuid);
        }
    }
    
    // ===== 全局统一资源池（不再区分红蓝队）=====
    private static Dictionary<string, ResourceReference> globalSpineCache = 
        new Dictionary<string, ResourceReference>();
    
    private static Dictionary<string, ResourceReference> globalAudioCache = 
        new Dictionary<string, ResourceReference>();
    
    /// <summary>
    /// 注册战场资源需求（红队+蓝队一起注册）
    /// </summary>
    public void RegisterBattlefieldResources(string battleGuid, 
        List<BattleResCache.ResourceIdentifier> spineResources, 
        List<BattleResCache.ResourceIdentifier> audioResources)
    {
        // 注册Spine资源
        foreach (var res in spineResources)
        {
            if (string.IsNullOrEmpty(res.OwnerId))
                continue;
                
            string key = res.GetKey();
            
            if (!globalSpineCache.ContainsKey(key))
            {
                // 把 ResourceIdentifier 的 IsPersistent 传递给 CachedResource
                globalSpineCache[key] = new ResourceReference
                {
                    CachedResource = new BattleResCache.CachedResource(res, null, res.IsPersistent)
                };
            }
            
            globalSpineCache[key].AddBattlefieldOwner(battleGuid, res.OwnerId);
        }
        
        // 注册Audio资源
        foreach (var res in audioResources)
        {
            if (string.IsNullOrEmpty(res.OwnerId))
                continue;
                
            string key = res.GetKey();
            
            if (!globalAudioCache.ContainsKey(key))
            {
                // 把 ResourceIdentifier 的 IsPersistent 传递给 CachedResource
                globalAudioCache[key] = new ResourceReference
                {
                    CachedResource = new BattleResCache.CachedResource(res, null, res.IsPersistent)
                };
            }
            
            globalAudioCache[key].AddBattlefieldOwner(battleGuid, res.OwnerId);
        }
        
        Debug.Log($"BattleCacheManager: Registered battlefield {battleGuid} - Spine: {spineResources.Count}, Audio: {audioResources.Count}");
    }
    
    /// <summary>
    /// 注销战场（卸载该战场的所有资源引用）
    /// </summary>
    /// <param name="battleGuid">战场GUID</param>
    /// <param name="forceUnloadPersistent">是否强制卸载常驻（红队）资源，默认为 false</param>
    public void UnregisterBattlefield(string battleGuid, bool forceUnloadPersistent = false)
    {
        // 处理Spine资源
        var spineKeysToRemove = new List<string>();
        foreach (var kvp in globalSpineCache)
        {
            kvp.Value.RemoveBattlefield(battleGuid);
            
            if (kvp.Value.RefCount == 0)
            {
                // 仅在非常驻或被强制卸载时才真正移除资源
                if (forceUnloadPersistent || kvp.Value.CachedResource.CanUnload())
                {
                    spineKeysToRemove.Add(kvp.Key);
                }
                else
                {
                    Debug.Log($"BattleCacheManager: Skipped unloading persistent spine resource: {kvp.Key}");
                }
            }
        }
        
        foreach (var key in spineKeysToRemove)
        {
            var res = globalSpineCache[key];
            if (res.CachedResource.Asset != null)
            {
                ResManager.Instance.UnloadAsset(
                    res.CachedResource.Identifier.Directory, 
                    res.CachedResource.Identifier.AssetName
                );
            }
            globalSpineCache.Remove(key);
            Debug.Log($"BattleCacheManager: Unloaded spine (refCount=0): {key}");
        }
        
        // 处理Audio资源
        var audioKeysToRemove = new List<string>();
        foreach (var kvp in globalAudioCache)
        {
            kvp.Value.RemoveBattlefield(battleGuid);
            
            if (kvp.Value.RefCount == 0)
            {
                // 仅在非常驻或被强制卸载时才真正移除资源
                if (forceUnloadPersistent || kvp.Value.CachedResource.CanUnload())
                {
                    audioKeysToRemove.Add(kvp.Key);
                }
                else
                {
                    Debug.Log($"BattleCacheManager: Skipped unloading persistent audio resource: {kvp.Key}");
                }
            }
        }
        
        foreach (var key in audioKeysToRemove)
        {
            var res = globalAudioCache[key];
            if (res.CachedResource.Asset != null)
            {
                ResManager.Instance.UnloadAsset(
                    res.CachedResource.Identifier.Directory, 
                    res.CachedResource.Identifier.AssetName
                );
            }
            globalAudioCache.Remove(key);
            Debug.Log($"BattleCacheManager: Unloaded audio (refCount=0): {key}");
        }
        
        Debug.Log($"BattleCacheManager: Unregistered battlefield {battleGuid}");
    }
    
    /// <summary>
    /// 获取或加载Spine资源
    /// </summary>
    public SkeletonDataAsset GetSpineResource(string directory, string assetName, string battleGuid = "")
    {
        string key = $"{directory}/{assetName}";
        
        if (globalSpineCache.TryGetValue(key, out var refInfo))
        {
            return refInfo.CachedResource.Asset as SkeletonDataAsset;
        }
        
        // 自动加载
        Debug.LogWarning($"BattleCacheManager: Spine cache miss for {key}, loading on-demand...");
        var asset = ResManager.Instance.LoadAsset<SkeletonDataAsset>(directory, assetName);
        
        if (asset != null)
        {
            var identifier = new BattleResCache.ResourceIdentifier
            {
                Directory = directory,
                AssetName = assetName,
                Type = BattleResCache.ResourceType.Spine,
                IsPersistent = false // on-demand 加载的默认非常驻
            };
            
            globalSpineCache[key] = new ResourceReference
            {
                CachedResource = new BattleResCache.CachedResource(identifier, asset, identifier.IsPersistent)
            };
        }
        
        return asset;
    }
    
    /// <summary>
    /// 获取或加载Audio资源
    /// </summary>
    public AudioClip GetAudioResource(string directory, string assetName, string battleGuid = "")
    {
        string key = $"{directory}/{assetName}";
        
        if (globalAudioCache.TryGetValue(key, out var refInfo))
        {
            return refInfo.CachedResource.Asset as AudioClip;
        }
        
        // 自动加载
        Debug.LogWarning($"BattleCacheManager: Audio cache miss for {key}, loading on-demand...");
        var asset = ResManager.Instance.LoadAsset<AudioClip>(directory, assetName, false);
        
        if (asset != null)
        {
            var identifier = new BattleResCache.ResourceIdentifier
            {
                Directory = directory,
                AssetName = assetName,
                Type = BattleResCache.ResourceType.Audio,
                IsPersistent = false // on-demand 加载的默认非常驻
            };
            
            globalAudioCache[key] = new ResourceReference
            {
                CachedResource = new BattleResCache.CachedResource(identifier, asset, identifier.IsPersistent)
            };
        }
        
        return asset;
    }
    
    /// <summary>
    /// 更新已加载资源的引用（由加载器调用）
    /// </summary>
    public void UpdateResourceReference(string key, BattleResCache.CachedResource resource, string battleGuid, string ownerId)
    {
        // 确保 CachedResource 的 IsPersistent 与 Identifier 一致
        resource.IsPersistent = resource.Identifier.IsPersistent;

        if (resource.Identifier.Type == BattleResCache.ResourceType.Spine)
        {
            if (globalSpineCache.ContainsKey(key))
            {
                globalSpineCache[key].CachedResource = resource;
            }
        }
        else if (resource.Identifier.Type == BattleResCache.ResourceType.Audio)
        {
            if (globalAudioCache.ContainsKey(key))
            {
                globalAudioCache[key].CachedResource = resource;
            }
        }
    }
    
    public string GetCacheStats(string battleGuid = "")
    {
        int spineTotal = globalSpineCache.Count;
        int audioTotal = globalAudioCache.Count;
        
        return $"Spine: {spineTotal}, Audio: {audioTotal}";
    }

    /// <summary>
    /// 获取已注册到某个战场的所有 OwnerId（可选择只返回常驻资源的 owner）
    /// </summary>
    public HashSet<string> GetRegisteredOwners(string battleGuid, bool onlyPersistent = false)
    {
        var owners = new HashSet<string>();

        foreach (var kvp in globalSpineCache)
        {
            if (!kvp.Value.BattlefieldOwners.ContainsKey(battleGuid))
                continue;

            if (onlyPersistent && kvp.Value.CachedResource.IsPersistent == false)
                continue;

            foreach (var owner in kvp.Value.BattlefieldOwners[battleGuid])
                owners.Add(owner);
        }

        foreach (var kvp in globalAudioCache)
        {
            if (!kvp.Value.BattlefieldOwners.ContainsKey(battleGuid))
                continue;

            if (onlyPersistent && kvp.Value.CachedResource.IsPersistent == false)
                continue;

            foreach (var owner in kvp.Value.BattlefieldOwners[battleGuid])
                owners.Add(owner);
        }

        return owners;
    }

    /// <summary>
    /// 仅注销战场中指定的 owner（按 owner granularity 移除），仅卸载因此变为无人引用的资源
    /// </summary>
    /// <param name="battleGuid">战场 GUID</param>
    /// <param name="ownersToRemove">要移除的 OwnerId 集合</param>
    public void UnregisterBattlefieldOwners(string battleGuid, HashSet<string> ownersToRemove)
    {
        if (ownersToRemove == null || ownersToRemove.Count == 0)
        {
            Debug.Log($"BattleCacheManager: UnregisterBattlefieldOwners called with empty owners for {battleGuid}");
            return;
        }

        var spineKeysToRemove = new List<string>();
        foreach (var kvp in globalSpineCache)
        {
            if (!kvp.Value.BattlefieldOwners.ContainsKey(battleGuid))
                continue;

            var owners = kvp.Value.BattlefieldOwners[battleGuid];
            bool changed = false;
            foreach (var owner in ownersToRemove)
            {
                if (owners.Contains(owner))
                {
                    owners.Remove(owner);
                    changed = true;
                }
            }

            if (owners.Count == 0)
                kvp.Value.BattlefieldOwners.Remove(battleGuid);

            // 如果全局引用数为0，说明没有任何战场/角色在使用这个资源，安全卸载
            if (kvp.Value.RefCount == 0)
            {
                spineKeysToRemove.Add(kvp.Key);
            }
            else if (changed)
            {
                Debug.Log($"BattleCacheManager: Updated spine owners for {kvp.Key} after removing owners for {battleGuid}");
            }
        }

        foreach (var key in spineKeysToRemove)
        {
            var res = globalSpineCache[key];
            if (res.CachedResource.Asset != null)
            {
                ResManager.Instance.UnloadAsset(
                    res.CachedResource.Identifier.Directory,
                    res.CachedResource.Identifier.AssetName
                );
            }
            globalSpineCache.Remove(key);
            Debug.Log($"BattleCacheManager: Unloaded spine (no owners left): {key}");
        }

        var audioKeysToRemove = new List<string>();
        foreach (var kvp in globalAudioCache)
        {
            if (!kvp.Value.BattlefieldOwners.ContainsKey(battleGuid))
                continue;

            var owners = kvp.Value.BattlefieldOwners[battleGuid];
            bool changed = false;
            foreach (var owner in ownersToRemove)
            {
                if (owners.Contains(owner))
                {
                    owners.Remove(owner);
                    changed = true;
                }
            }

            if (owners.Count == 0)
                kvp.Value.BattlefieldOwners.Remove(battleGuid);

            if (kvp.Value.RefCount == 0)
            {
                audioKeysToRemove.Add(kvp.Key);
            }
            else if (changed)
            {
                Debug.Log($"BattleCacheManager: Updated audio owners for {kvp.Key} after removing owners for {battleGuid}");
            }
        }

        foreach (var key in audioKeysToRemove)
        {
            var res = globalAudioCache[key];
            if (res.CachedResource.Asset != null)
            {
                ResManager.Instance.UnloadAsset(
                    res.CachedResource.Identifier.Directory,
                    res.CachedResource.Identifier.AssetName
                );
            }
            globalAudioCache.Remove(key);
            Debug.Log($"BattleCacheManager: Unloaded audio (no owners left): {key}");
        }

        Debug.Log($"BattleCacheManager: Unregistered specific owners for battlefield {battleGuid}. Removed owners: {ownersToRemove.Count}");
    }

    /// <summary>
    /// 判断该战场是否已注册（有任意资源引用）
    /// </summary>
    public bool HasBattleRegistered(string battleGuid)
    {
        foreach (var kvp in globalSpineCache)
        {
            if (kvp.Value.BattlefieldOwners.ContainsKey(battleGuid)) return true;
        }
        foreach (var kvp in globalAudioCache)
        {
            if (kvp.Value.BattlefieldOwners.ContainsKey(battleGuid)) return true;
        }
        return false;
    }
    
    // ===== 编辑器调试接口 =====
#if UNITY_EDITOR
    // 编辑器模式下的资源引用调试类
    public class ResourceReferenceDebug
    {
        public BattleResCache.CachedResource CachedResource;
        public Dictionary<string, HashSet<string>> BattlefieldOwners;
        
        public int RefCount
        {
            get
            {
                int count = 0;
                foreach (var owners in BattlefieldOwners.Values)
                {
                    count += owners.Count;
                }
                return count;
            }
        }
        
        // 私有构造函数，只能由 DebugAPI 调用
        internal ResourceReferenceDebug()
        {
        }
    }
    
    public static class DebugAPI
    {
        public static Dictionary<string, ResourceReferenceDebug> GetSpineCache()
        {
            var result = new Dictionary<string, ResourceReferenceDebug>();
            foreach (var kvp in globalSpineCache)
            {
                // 直接在这里赋值，不通过构造函数传递私有类
                result[kvp.Key] = new ResourceReferenceDebug
                {
                    CachedResource = kvp.Value.CachedResource,
                    BattlefieldOwners = kvp.Value.BattlefieldOwners
                };
            }
            return result;
        }
        
        public static Dictionary<string, ResourceReferenceDebug> GetAudioCache()
        {
            var result = new Dictionary<string, ResourceReferenceDebug>();
            foreach (var kvp in globalAudioCache)
            {
                result[kvp.Key] = new ResourceReferenceDebug
                {
                    CachedResource = kvp.Value.CachedResource,
                    BattlefieldOwners = kvp.Value.BattlefieldOwners
                };
            }
            return result;
        }
        
        public static int GetTotalSpineCount() => globalSpineCache.Count;
        public static int GetTotalAudioCount() => globalAudioCache.Count;
        
        public static HashSet<string> GetAllBattleGuids()
        {
            var guids = new HashSet<string>();
            foreach (var refInfo in globalSpineCache.Values)
            {
                foreach (var guid in refInfo.BattlefieldOwners.Keys)
                {
                    guids.Add(guid);
                }
            }
            foreach (var refInfo in globalAudioCache.Values)
            {
                foreach (var guid in refInfo.BattlefieldOwners.Keys)
                {
                    guids.Add(guid);
                }
            }
            return guids;
        }
        
        public static void ClearAllCache()
        {
            globalSpineCache.Clear();
            globalAudioCache.Clear();
            Debug.Log("BattleCacheManager: All cache cleared (Editor only)");
        }
    }
    
    // 资源引用视图类（供编辑器使用）
    public class ResourceReferenceView
    {
        public string ResourceKey;
        public string ResourcePath;
        public bool IsLoaded;
        public int TotalRefCount;
        public Dictionary<string, int> BattlefieldRefCounts = new Dictionary<string, int>();
        
        public ResourceReferenceView(string key, ResourceReferenceDebug refInfo)
        {
            ResourceKey = key;
            ResourcePath = refInfo.CachedResource.Identifier.Directory + "/" + refInfo.CachedResource.Identifier.AssetName;
            IsLoaded = refInfo.CachedResource.Asset != null;
            TotalRefCount = refInfo.RefCount;
            
            foreach (var kvp in refInfo.BattlefieldOwners)
            {
                BattlefieldRefCounts[kvp.Key] = kvp.Value.Count;
            }
        }
    }
#endif
}