using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class ConcurrentLoadController : MonoBehaviour
{
    [System.Serializable]
    public class LoadRequest
    {
        public string address;
        public System.Type type;
        public System.Action<UnityEngine.Object> onComplete;
        public System.Action<string> onError;
        public float priority; // 优先级，数值越小优先级越高
        public DateTime requestTime;
    }
    
    [Header("并发设置")]
    public int maxConcurrentLoads = 4;
    public float requestTimeout = 30f;
    public bool enablePriorityBasedLoading = true;
    
    [Header("性能监控")]
    public bool enablePerformanceMonitoring = true;
    public float performanceReportInterval = 5f;
    
    private Queue<LoadRequest> requestQueue = new Queue<LoadRequest>();
    private List<AsyncOperationHandle> activeLoads = new List<AsyncOperationHandle>();
    private Dictionary<string, LoadRequest> pendingRequests = new Dictionary<string, LoadRequest>();
    private int totalRequests = 0;
    private int completedRequests = 0;
    private int failedRequests = 0;
    
    void Start()
    {
        if (enablePerformanceMonitoring && performanceReportInterval > 0)
        {
            InvokeRepeating("ReportPerformanceStats", 1f, performanceReportInterval);
        }
    }
    
    /// <summary>
    /// 请求加载资源
    /// </summary>
    public void RequestLoad(string address, System.Type type, 
        System.Action<UnityEngine.Object> onComplete = null, 
        System.Action<string> onError = null,
        float priority = 0)
    {
        var request = new LoadRequest
        {
            address = address,
            type = type,
            onComplete = onComplete,
            onError = onError,
            priority = priority,
            requestTime = DateTime.Now
        };
        
        // 检查是否已经在加载中
        if (pendingRequests.ContainsKey(address))
        {
            Debug.LogWarning($"资源已在加载队列中: {address}");
            return;
        }
        
        // 检查当前活跃加载数
        if (activeLoads.Count < maxConcurrentLoads)
        {
            StartLoad(request);
        }
        else
        {
            // 添加到队列等待
            EnqueueRequest(request);
        }
        
        totalRequests++;
        pendingRequests[address] = request;
        
        Debug.Log($"请求加载: {address}, 当前队列: {requestQueue.Count}, 活跃: {activeLoads.Count}");
    }
    
    /// <summary>
    /// 请求加载GameObject
    /// </summary>
    public void RequestLoadGameObject(string address, 
        System.Action<GameObject> onComplete = null, 
        System.Action<string> onError = null,
        float priority = 0)
    {
        RequestLoad(address, typeof(GameObject), 
            obj => onComplete?.Invoke(obj as GameObject), onError, priority);
    }
    
    /// <summary>
    /// 请求加载Texture
    /// </summary>
    public void RequestLoadTexture(string address, 
        System.Action<Texture> onComplete = null, 
        System.Action<string> onError = null,
        float priority = 0)
    {
        RequestLoad(address, typeof(Texture), 
            obj => onComplete?.Invoke(obj as Texture), onError, priority);
    }
    
    private void EnqueueRequest(LoadRequest request)
    {
        if (enablePriorityBasedLoading)
        {
            // 按优先级插入队列
            var queueList = new List<LoadRequest>(requestQueue);
            int insertIndex = 0;
            
            for (int i = 0; i < queueList.Count; i++)
            {
                if (request.priority < queueList[i].priority)
                {
                    insertIndex = i;
                    break;
                }
                insertIndex = i + 1;
            }
            
            queueList.Insert(insertIndex, request);
            requestQueue = new Queue<LoadRequest>(queueList);
        }
        else
        {
            requestQueue.Enqueue(request);
        }
    }
    
    private void StartLoad(LoadRequest request)
    {
        AsyncOperationHandle handle;
        
        if (request.type == typeof(GameObject))
        {
            handle = Addressables.LoadAssetAsync<GameObject>(request.address);
        }
        else if (request.type == typeof(Texture))
        {
            handle = Addressables.LoadAssetAsync<Texture>(request.address);
        }
        else if (request.type == typeof(Sprite))
        {
            handle = Addressables.LoadAssetAsync<Sprite>(request.address);
        }
        else
        {
            handle = Addressables.LoadAssetAsync<UnityEngine.Object>(request.address);
        }
        
        activeLoads.Add(handle);
        
        // 设置超时检测
        System.DateTime startTime = DateTime.Now;
        
        handle.Completed += (op) =>
        {
            float loadTime = (float)(DateTime.Now - startTime).TotalSeconds;
            
            if (op.Status == AsyncOperationStatus.Succeeded)
            {
                completedRequests++;
                request.onComplete?.Invoke(op.Result);
                Debug.Log($"加载完成: {request.address}, 耗时: {loadTime:F3}s");
            }
            else
            {
                failedRequests++;
                request.onError?.Invoke(op.OperationException?.Message ?? "未知错误");
                Debug.LogError($"加载失败: {request.address}, 错误: {op.OperationException?.Message}");
            }
            
            // 从活跃列表中移除
            activeLoads.Remove(handle);
            pendingRequests.Remove(request.address);
            
            // 处理队列中的下一个请求
            ProcessNextRequest();
            
            // 释放句柄
            Addressables.Release(handle);
        };
        
        // 监控超时
        StartCoroutine(MonitorLoadTimeout(request.address, startTime));
    }
    
    private System.Collections.IEnumerator MonitorLoadTimeout(string address, DateTime startTime)
    {
        yield return new UnityEngine.WaitForSeconds(requestTimeout);
        
        if (pendingRequests.ContainsKey(address))
        {
            var request = pendingRequests[address];
            request.onError?.Invoke($"加载超时: {requestTimeout}秒");
            Debug.LogWarning($"加载超时: {address}");
            
            // 从队列中移除超时请求
            pendingRequests.Remove(address);
            ProcessNextRequest();
        }
    }
    
    private void ProcessNextRequest()
    {
        if (requestQueue.Count > 0 && activeLoads.Count < maxConcurrentLoads)
        {
            var nextRequest = requestQueue.Dequeue();
            StartLoad(nextRequest);
        }
    }
    
    /// <summary>
    /// 取消加载请求
    /// </summary>
    public bool CancelLoadRequest(string address)
    {
        if (pendingRequests.ContainsKey(address))
        {
            var request = pendingRequests[address];
            pendingRequests.Remove(address);
            
            // 如果请求在队列中，从队列移除
            var queueList = new List<LoadRequest>(requestQueue);
            queueList.RemoveAll(r => r.address == address);
            requestQueue = new Queue<LoadRequest>(queueList);
            
            Debug.Log($"取消加载请求: {address}");
            return true;
        }
        
        return false;
    }
    
    /// <summary>
    /// 取消所有加载请求
    /// </summary>
    public void CancelAllRequests()
    {
        // 清空队列
        requestQueue.Clear();
        
        // 清空待处理请求
        pendingRequests.Clear();
        
        Debug.Log($"取消所有加载请求，共 {totalRequests} 个");
    }
    
    /// <summary>
    /// 动态调整并发数
    /// </summary>
    public void AdjustConcurrency(int newConcurrency)
    {
        maxConcurrentLoads = Mathf.Max(1, newConcurrency);
        Debug.Log($"调整并发数至: {maxConcurrentLoads}");
        
        // 尝试处理队列中的请求
        ProcessNextRequest();
    }
    
    /// <summary>
    /// 获取加载统计
    /// </summary>
    public string GetLoadStats()
    {
        float successRate = totalRequests > 0 ? (float)completedRequests / totalRequests * 100 : 0;
        
        return $"总请求: {totalRequests}, 完成: {completedRequests}, " +
               $"失败: {failedRequests}, 成功率: {successRate:F1}%, " +
               $"队列: {requestQueue.Count}, 活跃: {activeLoads.Count}";
    }
    
    private void ReportPerformanceStats()
    {
        if (enablePerformanceMonitoring)
        {
            Debug.Log($"[性能报告] 并发加载统计: {GetLoadStats()}");
        }
    }
    
    void OnDestroy()
    {
        CancelAllRequests();
        if (enablePerformanceMonitoring)
        {
            CancelInvoke();
        }
    }
}

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Networking;

public class SmartConcurrencyManager : MonoBehaviour
{
    [System.Serializable]
    public class ConcurrencyRule
    {
        public string assetType; // "Texture", "Audio", "Model", "Prefab", etc.
        public int maxConcurrentLoads;
        public int optimalBandwidthKBps; // 最优带宽KB/s
        public float priorityWeight; // 优先级权重
    }
    
    [Header("智能并发规则")]
    public ConcurrencyRule[] concurrencyRules;
    
    [Header("网络检测")]
    public bool enableNetworkAdaptation = true;
    public float networkCheckInterval = 10f;
    
    private Dictionary<string, int> typeConcurrentLimits = new Dictionary<string, int>();
    private Dictionary<string, int> typeActiveLoads = new Dictionary<string, int>();
    private int currentNetworkKBps = 0;
    private bool isNetworkFast = true;
    
    void Start()
    {
        InitializeConcurrencyRules();
        
        if (enableNetworkAdaptation)
        {
            InvokeRepeating("CheckNetworkCondition", 2f, networkCheckInterval);
        }
    }
    
    private void InitializeConcurrencyRules()
    {
        foreach (var rule in concurrencyRules)
        {
            typeConcurrentLimits[rule.assetType] = rule.maxConcurrentLoads;
            typeActiveLoads[rule.assetType] = 0;
        }
        
        // 设置默认规则
        if (!typeConcurrentLimits.ContainsKey("Default"))
        {
            typeConcurrentLimits["Default"] = 4;
            typeActiveLoads["Default"] = 0;
        }
    }
    
    /// <summary>
    /// 检查是否可以开始加载指定类型的资源
    /// </summary>
    public bool CanStartLoad(string assetType)
    {
        string typeKey = GetAssetTypeKey(assetType);
        
        if (typeActiveLoads.ContainsKey(typeKey))
        {
            return typeActiveLoads[typeKey] < typeConcurrentLimits[typeKey];
        }
        
        return typeActiveLoads["Default"] < typeConcurrentLimits["Default"];
    }
    
    /// <summary>
    /// 开始加载（更新计数）
    /// </summary>
    public void StartLoad(string assetType)
    {
        string typeKey = GetAssetTypeKey(assetType);
        
        if (typeActiveLoads.ContainsKey(typeKey))
        {
            typeActiveLoads[typeKey]++;
        }
        else
        {
            typeActiveLoads["Default"]++;
        }
    }
    
    /// <summary>
    /// 完成加载（更新计数）
    /// </summary>
    public void CompleteLoad(string assetType)
    {
        string typeKey = GetAssetTypeKey(assetType);
        
        if (typeActiveLoads.ContainsKey(typeKey) && typeActiveLoads[typeKey] > 0)
        {
            typeActiveLoads[typeKey]--;
        }
        else if (typeActiveLoads.ContainsKey("Default") && typeActiveLoads["Default"] > 0)
        {
            typeActiveLoads["Default"]--;
        }
    }
    
    private string GetAssetTypeKey(string assetType)
    {
        return typeConcurrentLimits.ContainsKey(assetType) ? assetType : "Default";
    }
    
    /// <summary>
    /// 检查网络条件并调整并发策略
    /// </summary>
    private void CheckNetworkCondition()
    {
        StartCoroutine(DetectNetworkSpeed());
    }
    
    private System.Collections.IEnumerator DetectNetworkSpeed()
    {
        string testUrl = "https://httpbin.org/bytes/1048576"; // 1MB测试文件
        var request = UnityWebRequest.Get(testUrl);
        
        System.DateTime startTime = DateTime.Now;
        yield return request.SendWebRequest();
        
        if (request.result == UnityWebRequest.Result.Success)
        {
            float duration = (float)(DateTime.Now - startTime).TotalSeconds;
            if (duration > 0)
            {
                currentNetworkKBps = (int)(1024 / duration); // 1MB / duration 秒 = KB/s
                isNetworkFast = currentNetworkKBps > 1024; // > 1MB/s认为是快速网络
                
                Debug.Log($"网络速度: {currentNetworkKBps} KB/s, 快速网络: {isNetworkFast}");
                
                // 根据网络速度调整并发数
                AdjustConcurrencyForNetworkSpeed();
            }
        }
        else
        {
            Debug.LogWarning($"网络速度检测失败: {request.error}");
        }
    }
    
    private void AdjustConcurrencyForNetworkSpeed()
    {
        // 根据网络速度调整并发限制
        float multiplier = isNetworkFast ? 1.5f : 0.7f;
        
        foreach (var rule in concurrencyRules)
        {
            int newLimit = Mathf.RoundToInt(rule.maxConcurrentLoads * multiplier);
            newLimit = Mathf.Clamp(newLimit, 1, 10); // 限制在1-10之间
            typeConcurrentLimits[rule.assetType] = newLimit;
        }
        
        Debug.Log($"根据网络速度调整并发限制，倍数: {multiplier:F2}");
    }
    
    /// <summary>
    /// 获取类型加载统计
    /// </summary>
    public string GetTypeLoadStats()
    {
        var stats = new System.Text.StringBuilder();
        stats.AppendLine("=== 类型加载统计 ===");
        
        foreach (var pair in typeActiveLoads)
        {
            int limit = typeConcurrentLimits.ContainsKey(pair.Key) ? 
                       typeConcurrentLimits[pair.Key] : typeConcurrentLimits["Default"];
            stats.AppendLine($"{pair.Key}: {pair.Value}/{limit}");
        }
        
        stats.AppendLine($"当前网络速度: {currentNetworkKBps} KB/s");
        stats.AppendLine($"快速网络: {isNetworkFast}");
        
        return stats.ToString();
    }
    
    void OnDestroy()
    {
        if (enableNetworkAdaptation)
        {
            CancelInvoke();
        }
    }
}

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AddressableAssets;

public class PriorityLoadSystem : MonoBehaviour
{
    [System.Serializable]
    public class PriorityGroup
    {
        public string groupName;
        public int priorityLevel; // 数值越小优先级越高
        public float loadDelay; // 加载延迟（秒）
        public bool loadOnStart;
        public string[] assetAddresses;
    }
    
    [System.Serializable]
    public class LoadTask
    {
        public string address;
        public int priority;
        public float delay;
        public System.Type type;
        public System.Action<UnityEngine.Object> onComplete;
        public System.Action<string> onError;
        public DateTime scheduledTime;
    }
    
    [Header("优先级配置")]
    public PriorityGroup[] priorityGroups;
    
    [Header("系统设置")]
    public int maxConcurrentLoads = 3;
    public bool enablePriorityScheduling = true;
    public float priorityCheckInterval = 0.1f;
    
    private List<LoadTask> scheduledTasks = new List<LoadTask>();
    private List<LoadTask> readyTasks = new List<LoadTask>();
    private List<string> activeLoads = new List<string>();
    private Dictionary<string, PriorityGroup> groupMap = new Dictionary<string, PriorityGroup>();
    private ConcurrentLoadController loadController;
    private SmartConcurrencyManager concurrencyManager;
    
    void Start()
    {
        loadController = GetComponent<ConcurrentLoadController>();
        if (loadController == null)
        {
            loadController = gameObject.AddComponent<ConcurrentLoadController>();
        }
        
        concurrencyManager = GetComponent<SmartConcurrencyManager>();
        if (concurrencyManager == null)
        {
            concurrencyManager = gameObject.AddComponent<SmartConcurrencyManager>();
        }
        
        // 初始化组映射
        foreach (var group in priorityGroups)
        {
            groupMap[group.groupName] = group;
            
            if (group.loadOnStart)
            {
                ScheduleGroupLoad(group.groupName);
            }
        }
        
        // 开始优先级调度
        if (enablePriorityScheduling)
        {
            InvokeRepeating("ProcessPriorityQueue", 0f, priorityCheckInterval);
        }
    }
    
    /// <summary>
    /// 调度组加载
    /// </summary>
    public void ScheduleGroupLoad(string groupName)
    {
        if (!groupMap.ContainsKey(groupName))
        {
            Debug.LogError($"未找到优先级组: {groupName}");
            return;
        }
        
        var group = groupMap[groupName];
        
        foreach (string address in group.assetAddresses)
        {
            ScheduleLoad(address, group.priorityLevel, group.loadDelay);
        }
        
        Debug.Log($"调度组加载: {groupName}, 优先级: {group.priorityLevel}, 资源数: {group.assetAddresses.Length}");
    }
    
    /// <summary>
    /// 调度单个资源加载
    /// </summary>
    public void ScheduleLoad(string address, int priority = 0, float delay = 0f, System.Type type = null)
    {
        var task = new LoadTask
        {
            address = address,
            priority = priority,
            delay = delay,
            type = type ?? typeof(UnityEngine.Object),
            scheduledTime = DateTime.Now.AddSeconds(delay)
        };
        
        scheduledTasks.Add(task);
        
        Debug.Log($"调度加载: {address}, 优先级: {priority}, 延迟: {delay}s");
    }
    
    /// <summary>
    /// 立即加载高优先级资源
    /// </summary>
    public void LoadImmediate(string address, System.Action<UnityEngine.Object> onComplete = null, 
        System.Action<string> onError = null)
    {
        loadController.RequestLoad(address, typeof(UnityEngine.Object), onComplete, onError, -1000); // 最高优先级
        Debug.Log($"立即加载: {address}");
    }
    
    /// <summary>
    /// 按优先级加载资源
    /// </summary>
    public void LoadWithPriority(string address, int priority, 
        System.Action<UnityEngine.Object> onComplete = null, 
        System.Action<string> onError = null)
    {
        var task = new LoadTask
        {
            address = address,
            priority = priority,
            type = typeof(UnityEngine.Object),
            onComplete = onComplete,
            onError = onError,
            scheduledTime = DateTime.Now
        };
        
        // 直接添加到就绪队列（按优先级排序）
        AddToReadyQueue(task);
    }
    
    private void ProcessPriorityQueue()
    {
        // 检查计划任务是否到期
        var now = DateTime.Now;
        var readyToProcess = new List<LoadTask>();
        
        for (int i = scheduledTasks.Count - 1; i >= 0; i--)
        {
            if (scheduledTasks[i].scheduledTime <= now)
            {
                readyToProcess.Add(scheduledTasks[i]);
                scheduledTasks.RemoveAt(i);
            }
        }
        
        // 添加到就绪队列
        foreach (var task in readyToProcess)
        {
            AddToReadyQueue(task);
        }
        
        // 处理就绪队列
        ProcessReadyTasks();
    }
    
    private void AddToReadyQueue(LoadTask task)
    {
        // 按优先级插入
        int insertIndex = 0;
        for (int i = 0; i < readyTasks.Count; i++)
        {
            if (task.priority < readyTasks[i].priority)
            {
                insertIndex = i;
                break;
            }
            insertIndex = i + 1;
        }
        
        readyTasks.Insert(insertIndex, task);
    }
    
    private void ProcessReadyTasks()
    {
        // 处理就绪队列中的任务
        while (readyTasks.Count > 0 && activeLoads.Count < maxConcurrentLoads)
        {
            var task = readyTasks[0];
            readyTasks.RemoveAt(0);
            
            // 检查并发限制
            string assetType = GetAssetTypeFromAddress(task.address);
            if (concurrencyManager.CanStartLoad(assetType))
            {
                concurrencyManager.StartLoad(assetType);
                StartLoadTask(task);
            }
            else
            {
                // 如果不能开始加载，重新插入队列
                AddToReadyQueue(task);
                break; // 等待其他加载完成
            }
        }
    }
    
    private void StartLoadTask(LoadTask task)
    {
        activeLoads.Add(task.address);
        
        loadController.RequestLoad(task.address, task.type, 
            obj => OnLoadComplete(task, obj), 
            error => OnLoadError(task, error),
            task.priority);
    }
    
    private void OnLoadComplete(LoadTask task, UnityEngine.Object obj)
    {
        activeLoads.Remove(task.address);
        concurrencyManager.CompleteLoad(GetAssetTypeFromAddress(task.address));
        
        task.onComplete?.Invoke(obj);
        Debug.Log($"优先级加载完成: {task.address}");
    }
    
    private void OnLoadError(LoadTask task, string error)
    {
        activeLoads.Remove(task.address);
        concurrencyManager.CompleteLoad(GetAssetTypeFromAddress(task.address));
        
        task.onError?.Invoke(error);
        Debug.LogError($"优先级加载失败: {task.address}, 错误: {error}");
    }
    
    private string GetAssetTypeFromAddress(string address)
    {
        // 根据地址后缀判断资源类型
        if (address.EndsWith(".png") || address.EndsWith(".jpg"))
            return "Texture";
        else if (address.EndsWith(".mp3") || address.EndsWith(".wav"))
            return "Audio";
        else if (address.EndsWith(".fbx") || address.EndsWith(".obj"))
            return "Model";
        else if (address.EndsWith(".prefab"))
            return "Prefab";
        else
            return "Default";
    }
    
    /// <summary>
    /// 获取优先级队列状态
    /// </summary>
    public string GetPriorityQueueStatus()
    {
        return $"计划任务: {scheduledTasks.Count}, 就绪任务: {readyTasks.Count}, " +
               $"活跃加载: {activeLoads.Count}, 最大并发: {maxConcurrentLoads}";
    }
    
    /// <summary>
    /// 取消优先级加载
    /// </summary>
    public bool CancelPriorityLoad(string address)
    {
        // 从计划队列中移除
        scheduledTasks.RemoveAll(t => t.address == address);
        
        // 从就绪队列中移除
        readyTasks.RemoveAll(t => t.address == address);
        
        // 如果正在加载，尝试取消
        bool cancelled = loadController.CancelLoadRequest(address);
        
        Debug.Log($"取消优先级加载: {address}, 已取消: {cancelled}");
        return cancelled || !scheduledTasks.Exists(t => t.address == address) || 
               !readyTasks.Exists(t => t.address == address);
    }
    
    void OnDestroy()
    {
        if (enablePriorityScheduling)
        {
            CancelInvoke();
        }
    }
}

using System;
using System.Collections.Generic;
using UnityEngine;

public class DynamicPriorityAdjuster : MonoBehaviour
{
    [System.Serializable]
    public class PriorityAdjustmentRule
    {
        public string conditionType; // "ResourceType", "UserAction", "Scene", "Time"
        public string conditionValue;
        public int priorityAdjustment; // 调整值，可正可负
        public float duration; // 调整持续时间（秒）
    }
    
    [Header("动态调整规则")]
    public PriorityAdjustmentRule[] adjustmentRules;
    
    [Header("用户行为监控")]
    public bool monitorUserActions = true;
    
    private Dictionary<string, ActiveAdjustment> activeAdjustments = new Dictionary<string, ActiveAdjustment>();
    private Dictionary<string, int> basePriorities = new Dictionary<string, int>();
    private Dictionary<string, float> resourceUsage = new Dictionary<string, float>();
    
    [System.Serializable]
    public class ActiveAdjustment
    {
        public int adjustment;
        public DateTime endTime;
        public PriorityAdjustmentRule rule;
    }
    
    void Start()
    {
        if (monitorUserActions)
        {
            StartCoroutine(MonitorUserActions());
        }
    }
    
    /// <summary>
    /// 获取资源的实际优先级（考虑动态调整）
    /// </summary>
    public int GetAdjustedPriority(string resourceAddress, int basePriority = 0)
    {
        int adjustedPriority = basePriority;
        
        // 应用活跃的调整
        foreach (var adjustment in activeAdjustments.Values)
        {
            adjustedPriority += adjustment.adjustment;
        }
        
        // 应用资源使用频率调整
        if (resourceUsage.ContainsKey(resourceAddress))
        {
            // 使用频繁的资源提高优先级
            float usageFactor = Mathf.Clamp(resourceUsage[resourceAddress], 0, 10);
            adjustedPriority -= (int)(usageFactor * 10); // 使用越多，优先级越高（数值越小）
        }
        
        return adjustedPriority;
    }
    
    /// <summary>
    /// 应用优先级调整规则
    /// </summary>
    public void ApplyPriorityAdjustment(string resourceType, string conditionValue)
    {
        foreach (var rule in adjustmentRules)
        {
            if (rule.conditionType == "ResourceType" && rule.conditionValue == resourceType)
            {
                ApplyAdjustmentRule(rule);
            }
            else if (rule.conditionType == "UserAction" && rule.conditionValue == conditionValue)
            {
                ApplyAdjustmentRule(rule);
            }
        }
    }
    
    private void ApplyAdjustmentRule(PriorityAdjustmentRule rule)
    {
        string ruleKey = $"{rule.conditionType}_{rule.conditionValue}";
        
        if (activeAdjustments.ContainsKey(ruleKey))
        {
            // 更新现有调整
            var existing = activeAdjustments[ruleKey];
            existing.adjustment += rule.priorityAdjustment;
            existing.endTime = DateTime.Now.AddSeconds(rule.duration);
            existing.rule = rule;
        }
        else
        {
            // 添加新调整
            activeAdjustments[ruleKey] = new ActiveAdjustment
            {
                adjustment = rule.priorityAdjustment,
                endTime = DateTime.Now.AddSeconds(rule.duration),
                rule = rule
            };
        }
        
        Debug.Log($"应用优先级调整: {ruleKey}, 调整值: {rule.priorityAdjustment}, 持续: {rule.duration}s");
    }
    
    /// <summary>
    /// 记录资源使用
    /// </summary>
    public void RecordResourceUsage(string resourceAddress)
    {
        if (!resourceUsage.ContainsKey(resourceAddress))
        {
            resourceUsage[resourceAddress] = 0;
        }
        
        resourceUsage[resourceAddress] += 1.0f;
        
        // 限制使用计数，防止无限增长
        resourceUsage[resourceAddress] = Mathf.Min(resourceUsage[resourceAddress], 100);
        
        Debug.Log($"记录资源使用: {resourceAddress}, 使用次数: {resourceUsage[resourceAddress]}");
    }
    
    /// <summary>
    /// 监控用户行为
    /// </summary>
    private System.Collections.IEnumerator MonitorUserActions()
    {
        while (true)
        {
            // 检测用户交互
            if (Input.GetMouseButtonDown(0))
            {
                // 鼠标点击 - 可能需要UI资源
                ApplyPriorityAdjustment("UserAction", "UIInteraction");
            }
            
            if (Input.GetKeyDown(KeyCode.Space))
            {
                // 空格键 - 可能需要游戏资源
                ApplyPriorityAdjustment("UserAction", "GameAction");
            }
            
            // 清理过期的调整
            CleanupExpiredAdjustments();
            
            yield return new WaitForSeconds(0.1f);
        }
    }
    
    private void CleanupExpiredAdjustments()
    {
        var expiredKeys = new List<string>();
        
        foreach (var pair in activeAdjustments)
        {
            if (DateTime.Now >= pair.Value.endTime)
            {
                expiredKeys.Add(pair.Key);
            }
        }
        
        foreach (string key in expiredKeys)
        {
            activeAdjustments.Remove(key);
            Debug.Log($"清理过期优先级调整: {key}");
        }
    }
    
    /// <summary>
    /// 获取调整统计
    /// </summary>
    public string GetAdjustmentStats()
    {
        var stats = new System.Text.StringBuilder();
        stats.AppendLine("=== 优先级调整统计 ===");
        
        stats.AppendLine($"活跃调整数: {activeAdjustments.Count}");
        stats.AppendLine($"记录资源数: {resourceUsage.Count}");
        
        foreach (var pair in activeAdjustments)
        {
            float remainingTime = (float)(pair.Value.endTime - DateTime.Now).TotalSeconds;
            stats.AppendLine($"{pair.Key}: 调整 {pair.Value.adjustment}, 剩余 {remainingTime:F1}s");
        }
        
        return stats.ToString();
    }
    
    void Update()
    {
        // 每帧清理过期调整
        CleanupExpiredAdjustments();
    }
}

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class InitialPackageManager : MonoBehaviour
{
    [System.Serializable]
    public class InitialPackageResource
    {
        public string address;
        public string category; // "Core", "UI", "Audio", "Character", etc.
        public bool requiredForStartup; // 是否为启动必需
        public int priority; // 启动时加载优先级
        public long estimatedSize; // 预估大小
        public bool preloadDependencies; // 是否预加载依赖
    }
    
    [System.Serializable]
    public class PackageConfiguration
    {
        public string packageName;
        public InitialPackageResource[] resources;
        public long maxSize; // 最大包大小
        public float loadTimeout; // 加载超时
        public bool compressPackage; // 是否压缩
    }
    
    [Header("首包配置")]
    public PackageConfiguration initialPackage;
    
    [Header("分包配置")]
    public PackageConfiguration[] additionalPackages;
    
    [Header("加载设置")]
    public float startupLoadDelay = 0.1f; // 启动加载延迟
    public int maxStartupConcurrentLoads = 2; // 启动时最大并发
    public bool enablePreloading = true; // 启用预加载
    
    private Dictionary<string, InitialPackageResource> resourceMap = new Dictionary<string, InitialPackageResource>();
    private List<string> loadedResources = new List<string>();
    private Dictionary<string, AsyncOperationHandle> activeHandles = new Dictionary<string, AsyncOperationHandle>();
    private bool isStartupLoading = false;
    
    [Header("回调事件")]
    public System.Action<float> onStartupProgress; // 启动进度 (0-1)
    public System.Action onStartupComplete; // 启动完成
    public System.Action<string> onStartupError; // 启动错误
    
    void Start()
    {
        InitializeResourceMap();
        
        if (initialPackage.resources.Length > 0)
        {
            StartCoroutine(LoadInitialPackage());
        }
    }
    
    private void InitializeResourceMap()
    {
        // 初始化首包资源映射
        foreach (var resource in initialPackage.resources)
        {
            resourceMap[resource.address] = resource;
        }
        
        // 初始化分包资源映射
        foreach (var package in additionalPackages)
        {
            foreach (var resource in package.resources)
            {
                if (!resourceMap.ContainsKey(resource.address))
                {
                    resourceMap[resource.address] = resource;
                }
            }
        }
    }
    
    /// <summary>
    /// 加载首包资源
    /// </summary>
    private System.Collections.IEnumerator LoadInitialPackage()
    {
        isStartupLoading = true;
        Debug.Log($"开始加载首包，资源数量: {initialPackage.resources.Length}");
        
        // 按优先级排序资源
        var sortedResources = new List<InitialPackageResource>(initialPackage.resources);
        sortedResources.Sort((a, b) => a.priority.CompareTo(b.priority));
        
        int loadedCount = 0;
        int totalCount = sortedResources.Count;
        
        // 分批加载，控制并发
        var batch = new List<InitialPackageResource>();
        int currentBatchSize = 0;
        
        foreach (var resource in sortedResources)
        {
            if (currentBatchSize >= maxStartupConcurrentLoads)
            {
                // 加载当前批次
                yield return LoadResourceBatch(batch);
                
                batch.Clear();
                currentBatchSize = 0;
            }
            
            batch.Add(resource);
            currentBatchSize++;
            
            // 如果是必需资源，立即加载
            if (resource.requiredForStartup)
            {
                yield return LoadResourceBatch(batch);
                batch.Clear();
                currentBatchSize = 0;
            }
        }
        
        // 加载剩余资源
        if (batch.Count > 0)
        {
            yield return LoadResourceBatch(batch);
        }
        
        isStartupLoading = false;
        onStartupComplete?.Invoke();
        
        Debug.Log("首包加载完成");
    }
    
    private System.Collections.IEnumerator LoadResourceBatch(List<InitialPackageResource> batch)
    {
        var loadTasks = new List<System.Collections.IEnumerator>();
        
        foreach (var resource in batch)
        {
            loadTasks.Add(LoadSingleResource(resource));
        }
        
        // 并行执行加载任务
        foreach (var task in loadTasks)
        {
            yield return StartCoroutine(task);
        }
    }
    
    private System.Collections.IEnumerator LoadSingleResource(InitialPackageResource resource)
    {
        if (loadedResources.Contains(resource.address))
        {
            yield break; // 已加载
        }
        
        try
        {
            Debug.Log($"加载资源: {resource.address}, 类别: {resource.category}");
            
            var handle = Addressables.LoadAssetAsync<UnityEngine.Object>(resource.address);
            activeHandles[resource.address] = handle;
            
            // 监听进度
            float progress = 0;
            handle.PercentCompleteChanged += (op) =>
            {
                progress = op.PercentComplete;
                UpdateStartupProgress();
            };
            
            yield return handle;
            
            if (handle.Status == AsyncOperationStatus.Succeeded)
            {
                loadedResources.Add(resource.address);
                
                // 如果需要预加载依赖
                if (resource.preloadDependencies && enablePreloading)
                {
                    StartCoroutine(PreloadDependencies(resource.address));
                }
                
                Debug.Log($"资源加载成功: {resource.address}");
            }
            else
            {
                string errorMsg = handle.OperationException?.Message ?? "未知错误";
                Debug.LogError($"资源加载失败: {resource.address}, 错误: {errorMsg}");
                onStartupError?.Invoke($"资源加载失败: {resource.address}, {errorMsg}");
            }
        }
        catch (Exception e)
        {
            Debug.LogError($"加载资源异常: {resource.address}, 错误: {e.Message}");
            onStartupError?.Invoke($"资源加载异常: {resource.address}, {e.Message}");
        }
        finally
        {
            if (activeHandles.ContainsKey(resource.address))
            {
                Addressables.Release(activeHandles[resource.address]);
                activeHandles.Remove(resource.address);
            }
            
            UpdateStartupProgress();
        }
    }
    
    private System.Collections.IEnumerator PreloadDependencies(string resourceAddress)
    {
        var handle = Addressables.DownloadDependenciesAsync(resourceAddress, false);
        yield return handle;
        
        if (handle.Status == AsyncOperationStatus.Succeeded)
        {
            Debug.Log($"预加载依赖完成: {resourceAddress}");
        }
        else
        {
            Debug.LogWarning($"预加载依赖失败: {resourceAddress}");
        }
        
        Addressables.Release(handle);
    }
    
    private void UpdateStartupProgress()
    {
        if (initialPackage.resources.Length > 0)
        {
            float progress = (float)loadedResources.Count / initialPackage.resources.Length;
            onStartupProgress?.Invoke(progress);
        }
    }
    
    /// <summary>
    /// 加载分包
    /// </summary>
    public System.Collections.IEnumerator LoadAdditionalPackage(string packageName)
    {
        var package = System.Array.Find(additionalPackages, p => p.packageName == packageName);
        if (package == null)
        {
            Debug.LogError($"未找到分包: {packageName}");
            yield break;
        }
        
        Debug.Log($"开始加载分包: {packageName}, 资源数量: {package.resources.Length}");
        
        foreach (var resource in package.resources)
        {
            yield return LoadSingleResource(ConvertToInitialPackageResource(resource));
            yield return new WaitForSeconds(startupLoadDelay); // 添加延迟避免过于密集的加载
        }
        
        Debug.Log($"分包加载完成: {packageName}");
    }
    
    private InitialPackageResource ConvertToInitialPackageResource(InitialPackageResource resource)
    {
        // 简单转换，实际可能需要更多处理
        return resource;
    }
    
    /// <summary>
    /// 检查资源是否已加载
    /// </summary>
    public bool IsResourceLoaded(string address)
    {
        return loadedResources.Contains(address);
    }
    
    /// <summary>
    /// 获取首包统计
    /// </summary>
    public string GetInitialPackageStats()
    {
        long totalSize = 0;
        foreach (var resource in initialPackage.resources)
        {
            totalSize += resource.estimatedSize;
        }
        
        float progress = initialPackage.resources.Length > 0 ? 
                        (float)loadedResources.Count / initialPackage.resources.Length : 0;
        
        return $"首包资源: {loadedResources.Count}/{initialPackage.resources.Length}, " +
               $"进度: {(progress * 100):F1}%, 大小: {FormatFileSize(totalSize)}";
    }
    
    /// <summary>
    /// 获取分包统计
    /// </summary>
    public string GetAdditionalPackagesStats()
    {
        var stats = new System.Text.StringBuilder();
        stats.AppendLine("=== 分包统计 ===");
        
        foreach (var package in additionalPackages)
        {
            int loadedInPackage = 0;
            long packageSize = 0;
            
            foreach (var resource in package.resources)
            {
                if (loadedResources.Contains(resource.address))
                {
                    loadedInPackage++;
                }
                packageSize += resource.estimatedSize;
            }
            
            float packageProgress = package.resources.Length > 0 ? 
                                  (float)loadedInPackage / package.resources.Length : 0;
            
            stats.AppendLine($"{package.packageName}: {loadedInPackage}/{package.resources.Length}, " +
                           $"进度: {(packageProgress * 100):F1}%, 大小: {FormatFileSize(packageSize)}");
        }
        
        return stats.ToString();
    }
    
    private string FormatFileSize(long bytes)
    {
        string[] sizes = { "B", "KB", "MB", "GB" };
        double len = bytes;
        int order = 0;
        while (len >= 1024 && order < sizes.Length - 1)
        {
            order++;
            len = len / 1024;
        }
        return $"{len:F2}{sizes[order]}";
    }
    
    /// <summary>
    /// 取消启动加载
    /// </summary>
    public void CancelStartupLoading()
    {
        isStartupLoading = false;
        
        // 释放所有活跃句柄
        foreach (var handle in activeHandles.Values)
        {
            Addressables.Release(handle);
        }
        activeHandles.Clear();
        
        Debug.Log("启动加载已取消");
    }
    
    void OnDestroy()
    {
        CancelStartupLoading();
    }
}

using System;
using System.Collections.Generic;
using UnityEngine;

public class PackageStrategyManager : MonoBehaviour
{
    [System.Serializable]
    public class PackageStrategy
    {
        public string strategyName;
        public string[] resourceCategories; // 资源类别
        public long maxSize; // 最大包大小
        public int maxResources; // 最大资源数量
        public string[] dependencies; // 依赖的其他包
        public bool downloadable; // 是否可下载
        public bool cacheable; // 是否可缓存
        public int priority; // 加载优先级
    }
    
    [Header("分包策略")]
    public PackageStrategy[] strategies;
    
    [Header("策略设置")]
    public bool autoAssignResources = true;
    public bool validatePackageIntegrity = true;
    
    private Dictionary<string, PackageStrategy> strategyMap = new Dictionary<string, PackageStrategy>();
    private Dictionary<string, string> resourceToPackageMap = new Dictionary<string, string>();
    private Dictionary<string, List<string>> packageResources = new Dictionary<string, List<string>>();
    
    void Start()
    {
        InitializeStrategies();
        
        if (autoAssignResources)
        {
            AutoAssignResourcesToPackages();
        }
    }
    
    private void InitializeStrategies()
    {
        foreach (var strategy in strategies)
        {
            strategyMap[strategy.strategyName] = strategy;
            packageResources[strategy.strategyName] = new List<string>();
        }
    }
    
    /// <summary>
    /// 自动分配资源到包
    /// </summary>
    public void AutoAssignResourcesToPackages()
    {
        // 这里需要获取所有Addressable资源
        // 简化实现，使用示例数据
        var allResources = GetExampleResources();
        
        foreach (var resource in allResources)
        {
            string packageName = DeterminePackageForResource(resource);
            if (!string.IsNullOrEmpty(packageName))
            {
                AssignResourceToPackage(resource, packageName);
            }
        }
        
        Debug.Log("自动资源分配完成");
    }
    
    private List<string> GetExampleResources()
    {
        // 示例资源列表
        return new List<string>
        {
            "Assets/Prefabs/UI/MainMenu.prefab",
            "Assets/Prefabs/Characters/Player.prefab",
            "Assets/Textures/UI/Background.png",
            "Assets/Audio/Music/Battle.mp3",
            "Assets/Models/Environment/Tree.fbx"
        };
    }
    
    private string DeterminePackageForResource(string resourceAddress)
    {
        // 根据资源路径确定包
        if (resourceAddress.Contains("/UI/"))
            return "UIPackage";
        else if (resourceAddress.Contains("/Characters/"))
            return "CharacterPackage";
        else if (resourceAddress.Contains("/Audio/"))
            return "AudioPackage";
        else if (resourceAddress.Contains("/Models/Environment/"))
            return "EnvironmentPackage";
        else
            return "DefaultPackage";
    }
    
    private void AssignResourceToPackage(string resourceAddress, string packageName)
    {
        if (packageResources.ContainsKey(packageName))
        {
            // 检查包大小和数量限制
            var strategy = strategyMap[packageName];
            if (packageResources[packageName].Count >= strategy.maxResources)
            {
                Debug.LogWarning($"包 {packageName} 已达到最大资源数量限制");
                return;
            }
            
            packageResources[packageName].Add(resourceAddress);
            resourceToPackageMap[resourceAddress] = packageName;
            
            Debug.Log($"资源分配到包: {resourceAddress} -> {packageName}");
        }
    }
    
    /// <summary>
    /// 验证包完整性
    /// </summary>
    public bool ValidatePackageIntegrity(string packageName)
    {
        if (!packageResources.ContainsKey(packageName))
        {
            Debug.LogError($"包不存在: {packageName}");
            return false;
        }
        
        var strategy = strategyMap[packageName];
        var resources = packageResources[packageName];
        
        // 检查资源数量
        if (resources.Count > strategy.maxResources)
        {
            Debug.LogWarning($"包 {packageName} 资源数量超限: {resources.Count}/{strategy.maxResources}");
            return false;
        }
        
        // 检查包大小（需要估算）
        long estimatedSize = EstimatePackageSize(resources);
        if (estimatedSize > strategy.maxSize)
        {
            Debug.LogWarning($"包 {packageName} 大小超限: {FormatFileSize(estimatedSize)}/{FormatFileSize(strategy.maxSize)}");
            return false;
        }
        
        Debug.Log($"包完整性验证通过: {packageName}");
        return true;
    }
    
    private long EstimatePackageSize(List<string> resources)
    {
        // 估算包大小（简化实现）
        long estimatedSize = 0;
        foreach (string resource in resources)
        {
            // 根据资源类型估算大小
            if (resource.EndsWith(".png") || resource.EndsWith(".jpg"))
                estimatedSize += 1024 * 1024; // 1MB
            else if (resource.EndsWith(".mp3"))
                estimatedSize += 2048 * 1024; // 2MB
            else if (resource.EndsWith(".fbx"))
                estimatedSize += 5120 * 1024; // 5MB
            else
                estimatedSize += 128 * 1024; // 128KB
        }
        return estimatedSize;
    }
    
    /// <summary>
    /// 获取资源所属包
    /// </summary>
    public string GetPackageForResource(string resourceAddress)
    {
        if (resourceToPackageMap.ContainsKey(resourceAddress))
        {
            return resourceToPackageMap[resourceAddress];
        }
        return null;
    }
    
    /// <summary>
    /// 获取包中所有资源
    /// </summary>
    public string[] GetResourcesInPackage(string packageName)
    {
        if (packageResources.ContainsKey(packageName))
        {
            return packageResources[packageName].ToArray();
        }
        return new string[0];
    }
    
    /// <summary>
    /// 获取包策略
    /// </summary>
    public PackageStrategy GetPackageStrategy(string packageName)
    {
        if (strategyMap.ContainsKey(packageName))
        {
            return strategyMap[packageName];
        }
        return null;
    }
    
    /// <summary>
    /// 生成分包报告
    /// </summary>
    public string GeneratePackageReport()
    {
        var report = new System.Text.StringBuilder();
        report.AppendLine("=== 分包策略报告 ===");
        
        foreach (var strategy in strategies)
        {
            report.AppendLine();
            report.AppendLine($"策略: {strategy.strategyName}");
            report.AppendLine($"  类别: {string.Join(", ", strategy.resourceCategories)}");
            report.AppendLine($"  最大大小: {FormatFileSize(strategy.maxSize)}");
            report.AppendLine($"  最大资源数: {strategy.maxResources}");
            report.AppendLine($"  可下载: {strategy.downloadable}");
            report.AppendLine($"  可缓存: {strategy.cacheable}");
            report.AppendLine($"  优先级: {strategy.priority}");
            
            if (strategy.dependencies.Length > 0)
            {
                report.AppendLine($"  依赖: {string.Join(", ", strategy.dependencies)}");
            }
            
            // 包统计
            if (packageResources.ContainsKey(strategy.strategyName))
            {
                var resources = packageResources[strategy.strategyName];
                long packageSize = EstimatePackageSize(resources);
                
                report.AppendLine($"  实际资源数: {resources.Count}");
                report.AppendLine($"  实际大小: {FormatFileSize(packageSize)}");
                report.AppendLine($"  资源列表: {string.Join(", ", resources.GetRange(0, Math.Min(5, resources.Count)))}...");
            }
        }
        
        return report.ToString();
    }
    
    private string FormatFileSize(long bytes)
    {
        string[] sizes = { "B", "KB", "MB", "GB" };
        double len = bytes;
        int order = 0;
        while (len >= 1024 && order < sizes.Length - 1)
        {
            order++;
            len = len / 1024;
        }
        return $"{len:F2}{sizes[order]}";
    }
    
    /// <summary>
    /// 优化包分配
    /// </summary>
    public void OptimizePackageAssignment()
    {
        Debug.Log("开始优化包分配...");
        
        // 重新评估资源分配，确保包大小和数量在限制内
        foreach (var pair in packageResources)
        {
            var strategy = strategyMap[pair.Key];
            var resources = pair.Value;
            
            // 如果包超出了大小或数量限制，需要重新分配
            if (resources.Count > strategy.maxResources || 
                EstimatePackageSize(resources) > strategy.maxSize)
            {
                RebalancePackage(pair.Key, resources, strategy);
            }
        }
        
        Debug.Log("包分配优化完成");
    }
    
    private void RebalancePackage(string packageName, List<string> resources, PackageStrategy strategy)
    {
        // 将超出限制的资源移动到其他合适的包
        var remainingResources = new List<string>();
        var movedResources = new List<string>();
        
        long currentSize = 0;
        int currentCount = 0;
        
        foreach (string resource in resources)
        {
            long resourceSize = EstimateResourceSize(resource);
            
            if (currentCount >= strategy.maxResources || 
                currentSize + resourceSize > strategy.maxSize)
            {
                // 需要移动资源
                string targetPackage = FindAlternativePackage(resource, packageName);
                if (!string.IsNullOrEmpty(targetPackage))
                {
                    AssignResourceToPackage(resource, targetPackage);
                    movedResources.Add(resource);
                }
                else
                {
                    remainingResources.Add(resource);
                }
            }
            else
            {
                remainingResources.Add(resource);
                currentSize += resourceSize;
                currentCount++;
            }
        }
        
        // 更新包资源列表
        packageResources[packageName] = remainingResources;
        
        Debug.Log($"重新平衡包 {packageName}: 移动 {movedResources.Count} 个资源");
    }
    
    private long EstimateResourceSize(string resourceAddress)
    {
        // 估算单个资源大小
        if (resourceAddress.EndsWith(".png") || resourceAddress.EndsWith(".jpg"))
            return 1024 * 1024; // 1MB
        else if (resourceAddress.EndsWith(".mp3"))
            return 2048 * 1024; // 2MB
        else if (resourceAddress.EndsWith(".fbx"))
            return 5120 * 1024; // 5MB
        else
            return 128 * 1024; // 128KB
    }
    
    private string FindAlternativePackage(string resourceAddress, string originalPackage)
    {
        // 寻找其他可以容纳资源的包
        foreach (var strategy in strategies)
        {
            if (strategy.strategyName != originalPackage)
            {
                var resources = packageResources[strategy.strategyName];
                long newSize = EstimatePackageSize(resources) + EstimateResourceSize(resourceAddress);
                
                if (resources.Count < strategy.maxResources && newSize <= strategy.maxSize)
                {
                    return strategy.strategyName;
                }
            }
        }
        
        return null; // 没有找到合适的包
    }
}