using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.Networking;
using Kill.Network;
using Kill.Managers;
using Kill.Core;
using Kill.UI.Components;
using UnityEngine.UI;

namespace Kill.Network
{
    /// <summary>
    /// 请求头配置
    /// </summary>
    [System.Serializable]
    public class HeaderConfig
    {
        public string key;
        public string value;
    }

    public class NetworkCtrl : MonoBehaviour
    {
        public static NetworkCtrl Instance;

        public string localPath;
        public string streamingPath;

        #region 网络配置区域 - 直接修改以下配置
        public string[] serverBaseUrls;
        [Header("服务器配置")]
        [Tooltip("服务器基础URL，例如: https://api.example.com")]
        public string serverBaseUrl = "https://api.example.com";

        [Header("请求配置")]
        [Tooltip("默认请求超时时间(秒)")]
        public int defaultTimeout = 30;

        [Tooltip("默认最大重试次数")]
        public int defaultMaxRetries = 3;

        [Tooltip("是否使用指数退避重试")]
        public bool useExponentialBackoff = true;

        [Header("全局请求头")]
        [Tooltip("添加全局请求头，如Authorization等")]
        public List<HeaderConfig> globalHeaders = new List<HeaderConfig>
        {
            // 示例: 在这里添加你的全局请求头
            // new HeaderConfig { key = "Authorization", value = "Bearer your_token" },
            // new HeaderConfig { key = "X-App-Version", value = "1.0.0" },
            new HeaderConfig { key = "Content-Type", value = "application/json" },
        };

        [Header("队列配置")]
        [Tooltip("最大并发请求数")]
        public int maxConcurrentRequests = 5;

        #endregion

        public string BaseServerUrl { get; set; } = "";

        void Awake()
        {
            Instance = this;
            localPath = Application.persistentDataPath;
            streamingPath = Application.streamingAssetsPath;
             // 设置目标帧率为 60 FPS
            Application.targetFrameRate = 120;

            // 禁用垂直同步，允许更高帧率
            QualitySettings.vSyncCount = 0;
            #if UNITY_ANDROID
            AndroidStatusBar.statusBarState = AndroidStatusBar.States.TranslucentOverContent;
            #endif

        }

        async void Start()
        {

#if UNITY_IOS
            platform = "IOS";
#else
             platform = "ANDROID";
#endif
            Debug.Log("Init");
            await Init();
        }

        public async Task Init()
        {
            Debug.Log("初始化网络控制");
            await LoadRes.Instance.Init();
            LoadingUI.Show();
            // 初始化网络管理器
            await InitializeNetworkManagers();
            await NetworkStateManager.Instance.Init();
            await GetNewBundle();
            // 检查并清理过期资源
            await CheckAndCleanOutdatedResources();
            
            if (LoadRes.Instance.resPosition == LoadRes.ResPosition.资源包)
            {
                await GetNowBundleList();
                if (nowResVersion < new Version(resourceVersion))
                {
                    LoadingUI.Show();
                    await GetBundleList();
                    LoadingUI.Hide();
                    await UpdateResources();
                }
            }
            
            await LoadRes.Instance.Init();
            await DataManager.Instance.Init();
            await UI.UIManager.Instance.Init();
            LoadingUI.Hide();
        }

        /// <summary>
        /// 初始化网络管理器组件
        /// </summary>
        private async Task InitializeNetworkManagers()
        {
            // 确保 NetworkStateManager 存在
            if (NetworkStateManager.Instance == null)
            {
                var nsManagerObj = new GameObject("NetworkStateManager");
                nsManagerObj.AddComponent<NetworkStateManager>();
            }

            // 确保 HttpRequestManager 存在并配置
            if (HttpRequestManager.Instance == null)
            {
                var httpManagerObj = new GameObject("HttpRequestManager");
                httpManagerObj.AddComponent<HttpRequestManager>();
            }

            // 配置 HttpRequestManager
            var httpManager = HttpRequestManager.Instance;
            if (httpManager != null)
            {
                // 设置基础URL
                if (!string.IsNullOrEmpty(serverBaseUrl))
                {
                    httpManager.SetBaseUrl(serverBaseUrl);
                    BaseServerUrl = serverBaseUrl;
                }

                // 设置默认配置
                var config = new HttpRequestConfig
                {
                    Timeout = defaultTimeout,
                    MaxRetries = defaultMaxRetries,
                    UseExponentialBackoff = useExponentialBackoff
                };
                httpManager.SetDefaultConfig(config);

                // 添加全局请求头
                foreach (var header in globalHeaders)
                {
                    if (!string.IsNullOrEmpty(header.key))
                    {
                        httpManager.AddGlobalHeader(header.key, header.value);
                    }
                }
            }

            // 确保 RequestQueueManager 存在并配置
            if (RequestQueueManager.Instance == null)
            {
                var queueManagerObj = new GameObject("RequestQueueManager");
                var queueManager = queueManagerObj.AddComponent<RequestQueueManager>();
                queueManager.SetMaxConcurrentRequests(maxConcurrentRequests);
            }

            Debug.Log($"[NetworkCtrl] 网络管理器初始化完成 - 服务器: {serverBaseUrl}");
        }

        #region 便捷的网络请求API

        /// <summary>
        /// 发送GET请求
        /// </summary>
        public async Task<HttpResponse<T>> Get<T>(string url, Dictionary<string, string> queryParams = null, HttpRequestConfig config = null)
        {
            return await HttpRequestManager.Instance.Get<T>(url, queryParams, config);
        }

        /// <summary>
        /// 发送GET请求(返回字符串)
        /// </summary>
        public async Task<HttpResponse<string>> Get(string url, Dictionary<string, string> queryParams = null, HttpRequestConfig config = null)
        {
            return await HttpRequestManager.Instance.Get(url, queryParams, config);
        }

        /// <summary>
        /// 发送POST请求
        /// </summary>
        public async Task<HttpResponse<T>> Post<T>(string url, object data = null, HttpRequestConfig config = null)
        {
            return await HttpRequestManager.Instance.Post<T>(url, data, config);
        }

        /// <summary>
        /// 发送POST请求(表单数据)
        /// </summary>
        public async Task<HttpResponse<T>> PostForm<T>(string url, WWWForm formData, HttpRequestConfig config = null)
        {
            return await HttpRequestManager.Instance.PostForm<T>(url, formData, config);
        }
        public async Task<HttpResponse<T>> PostFormData<T>(string url,  List<IMultipartFormSection> formData, HttpRequestConfig config = null)
        {
            return await HttpRequestManager.Instance.PostFormData<T>(url, formData, config);
        }

        /// <summary>
        /// 发送PUT请求
        /// </summary>
        public async Task<HttpResponse<T>> Put<T>(string url, object data = null, HttpRequestConfig config = null)
        {
            return await HttpRequestManager.Instance.Put<T>(url, data, config);
        }
        /// <summary>
        /// 发送PUTform请求
        /// </summary>
        public async Task<HttpResponse<T>> PutForm<T>(string url, WWWForm formData, HttpRequestConfig config = null)
        {
            return await HttpRequestManager.Instance.PutForm<T>(url, formData, config);
        }

        /// <summary>
        /// 发送DELETE请求
        /// </summary>
        public async Task<HttpResponse<T>> Delete<T>(string url, object data = null, HttpRequestConfig config = null)
        {
            if (data != null)
            {
                return await HttpRequestManager.Instance.Delete<T>(url, data, config);
            }
            return await HttpRequestManager.Instance.Delete<T>(url, config);
        }

        /// <summary>
        /// 下载文件
        /// </summary>
        public async Task<HttpResponse<string>> DownloadFile(string url, string savePath, Action<DownloadProgress> onProgress = null, HttpRequestConfig config = null)
        {
            return await HttpRequestManager.Instance.DownloadFile(url, savePath, onProgress, config);
        }

        /// <summary>
        /// 添加请求到队列
        /// </summary>
        public string EnqueueRequest<T>(Func<Task<HttpResponse<T>>> requestFunc, RequestPriority priority = RequestPriority.Normal, Action<HttpResponse<T>> onComplete = null)
        {
            return RequestQueueManager.Instance.Enqueue(requestFunc, priority, onComplete);
        }

        /// <summary>
        /// 取消请求
        /// </summary>
        public bool CancelRequest(string requestId)
        {
            return RequestQueueManager.Instance.CancelRequest(requestId);
        }

        /// <summary>
        /// 取消所有请求
        /// </summary>
        public void CancelAllRequests()
        {
            RequestQueueManager.Instance.CancelAllRequests();
        }

        /// <summary>
        /// 检查网络状态
        /// </summary>
        public bool IsNetworkConnected
        {
            get
            {
                return NetworkStateManager.Instance != null && NetworkStateManager.Instance.IsConnected;
            }
        }

        /// <summary>
        /// 获取当前网络类型
        /// </summary>
        public NetworkConnectivityState CurrentNetworkState
        {
            get
            {
                return NetworkStateManager.Instance != null ? NetworkStateManager.Instance.CurrentState : NetworkConnectivityState.Unknown;
            }
        }

        #endregion

        #region 全局配置

        /// <summary>
        /// 设置服务器基础URL
        /// </summary>
        public void SetServerUrl(string baseUrl)
        {
            BaseServerUrl = baseUrl;
            if (HttpRequestManager.Instance != null)
            {
                HttpRequestManager.Instance.SetBaseUrl(baseUrl);
            }
        }

        /// <summary>
        /// 添加全局请求头
        /// </summary>
        public void AddGlobalHeader(string key, string value)
        {
            HttpRequestManager.Instance?.AddGlobalHeader(key, value);
        }

        /// <summary>
        /// 移除全局请求头
        /// </summary>
        public void RemoveGlobalHeader(string key)
        {
            HttpRequestManager.Instance?.RemoveGlobalHeader(key);
        }

        /// <summary>
        /// 设置默认请求超时时间
        /// </summary>
        public void SetDefaultTimeout(int seconds)
        {
            var config = new HttpRequestConfig { Timeout = seconds };
            HttpRequestManager.Instance?.SetDefaultConfig(config);
        }

        /// <summary>
        /// 设置默认最大重试次数
        /// </summary>
        public void SetDefaultMaxRetries(int retries)
        {
            var config = new HttpRequestConfig { MaxRetries = retries };
            HttpRequestManager.Instance?.SetDefaultConfig(config);
        }

        #endregion

        #region 资源更新 (保留原有功能)

        string nowResourceUrl;
        public string resourceVersion;
        string platform;
        Version nowResVersion = new Version("0.0.0");
        public AssetBundleInfoList nowBundleList;
        public AssetBundleInfoList newBundleList;

        public async Task GetNowBundleList()
        {
            string localListPath = localPath + "/list.json";
            string streamingListPath = streamingPath + "/list.json";

            if (File.Exists(localListPath))
            {
                nowBundleList = JsonUtility.FromJson<AssetBundleInfoList>(File.ReadAllText(localListPath));
                Debug.Log("===获取本地资源列表成功");
            }
            else
            {
                string listJson = await ReadTextFileFromStreamingAssets(streamingListPath);
                if (!string.IsNullOrEmpty(listJson))
                {
                    nowBundleList = JsonUtility.FromJson<AssetBundleInfoList>(listJson);
                    Debug.Log("===获取更包资源列表成功");
                }
                else
                {
                    Debug.Log("===没有获取资源列表");
                    nowBundleList = null;
                }
            }
            if (nowBundleList != null)
            {
                nowResVersion = new Version(nowBundleList.version);
            }
        }

        /// <summary>
        /// 检查并清理过期的本地资源
        /// </summary>
        public async Task CheckAndCleanOutdatedResources()
        {
            try
            {
                string streamingListPath = Path.Combine(streamingPath, "list.json");
                string streamingListJson = await ReadTextFileFromStreamingAssets(streamingListPath);

                if (string.IsNullOrEmpty(streamingListJson))
                {
                    return;
                }

                AssetBundleInfoList streamingBundleList = JsonUtility.FromJson<AssetBundleInfoList>(streamingListJson);
                string localListPath = Path.Combine(localPath, "list.json");

                if (!File.Exists(localListPath))
                {
                    return;
                }

                string localListJson = File.ReadAllText(localListPath);
                AssetBundleInfoList localBundleList = JsonUtility.FromJson<AssetBundleInfoList>(localListJson);

                if (new Version(streamingBundleList.version) >= new Version(localBundleList.version))
                {
                    Debug.Log($"跟包资源版本: {localBundleList.version} -> {streamingBundleList.version}，正在清理本地过期资源...");
                    CleanLocalAssetBundleFiles();
                }
                else
                {
                    Debug.Log($"本地资源版本({localBundleList.version})更新，无需清理");
                }
            }
            catch (Exception ex)
            {
                Debug.LogError($"检查资源版本时出错: {ex.Message}");
            }
        }

        /// <summary>
        /// 清理本地的所有AssetBundle文件
        /// </summary>
        private void CleanLocalAssetBundleFiles()
        {
            try
            {
                string[] localAbFiles = Directory.GetFiles(localPath, "*.ab", SearchOption.AllDirectories);
                foreach (string abFile in localAbFiles)
                {
                    try
                    {
                        File.Delete(abFile);
                        Debug.Log($"已删除过期资源文件: {abFile}");
                    }
                    catch (Exception ex)
                    {
                        Debug.LogError($"删除文件失败 {abFile}: {ex.Message}");
                    }
                }

                File.Delete(localPath + "/list.json");
                Debug.Log("本地过期资源清理完成");
            }
            catch (Exception ex)
            {
                Debug.LogError($"清理本地资源时出错: {ex.Message}");
            }
        }

        public async Task GetBundleList()
        {
            string url = nowResourceUrl + "/list.json";
            using (UnityWebRequest webRequest = UnityWebRequest.Get(url))
            {
                var operation = webRequest.SendWebRequest();
                while (!operation.isDone)
                {
                    await Task.Yield();
                }
                if (webRequest.result == UnityWebRequest.Result.Success)
                {
                    AssetBundleInfoList list = JsonUtility.FromJson<AssetBundleInfoList>(webRequest.downloadHandler.text);
                    newBundleList = list;
                }
                else
                {
                    Debug.LogError(url + "获取资源列表失败" + webRequest.error);
                }
            }
        }

        /// <summary>
        /// 从StreamingAssets目录读取文本文件（兼容各平台）
        /// </summary>
        private async Task<string> ReadTextFileFromStreamingAssets(string filePath)
        {
            string result = null;

#if UNITY_ANDROID && !UNITY_EDITOR
            UnityWebRequest www = UnityWebRequest.Get(filePath);
            var operation = www.SendWebRequest();
            
            while (!operation.isDone)
            {
                await Task.Yield();
            }
            
            if (www.result == UnityWebRequest.Result.Success)
            {
                result = www.downloadHandler.text;
            }
            else
            {
                Debug.LogError($"读取StreamingAssets文件失败: {www.error}");
            }
            
            www.Dispose();
#else
            if (File.Exists(filePath))
            {
                result = File.ReadAllText(filePath);
            }
#endif

            return result;
        }

        public async Task UpdateResources()
        {
            List<AssetBundleInfo> updateList = GetUpdateList();

            if (updateList.Count > 0)
            {
                UpdateLoadingUI.Instance.Show();
                bool success = await DownloadUpdateFiles(updateList, (downloaded, total) =>
                {
                    float progress = (float)downloaded / total;
                    UpdateLoadingUI.Instance.SetPrecent(progress);
                    Debug.Log($"更新进度: {progress:P}");
                });
                UpdateLoadingUI.Instance.Hide();
                if (success)
                {
                    Debug.Log("资源更新完成");
                }
                else
                {
                    ToastUI.ShowText("resource error");
                    Debug.LogError("资源更新失败");
                }
            }
            else
            {
                Debug.Log("资源已是最新版本");
            }
        }

        /// <summary>
        /// 对比当前资源列表和新资源列表，找出需要更新的文件
        /// </summary>
        public List<AssetBundleInfo> GetUpdateList()
        {
            List<AssetBundleInfo> updateList = new List<AssetBundleInfo>();

            if (nowBundleList == null || nowBundleList.assetbundles == null)
            {
                return newBundleList.assetbundles ?? new List<AssetBundleInfo>();
            }

            Dictionary<string, AssetBundleInfo> nowBundleDict = new Dictionary<string, AssetBundleInfo>();
            foreach (var bundle in nowBundleList.assetbundles)
            {
                nowBundleDict[bundle.name] = bundle;
            }

            foreach (var newBundle in newBundleList.assetbundles)
            {
                if (!nowBundleDict.ContainsKey(newBundle.name) ||
                    nowBundleDict[newBundle.name].md5 != newBundle.md5)
                {
                    updateList.Add(newBundle);
                }
            }

            return updateList;
        }

        /// <summary>
        /// 计算需要更新的总大小
        /// </summary>
        public long CalculateUpdateSize(List<AssetBundleInfo> updateList)
        {
            long totalSize = 0;
            foreach (var bundle in updateList)
            {
                totalSize += bundle.size;
            }
            return totalSize;
        }

        /// <summary>
        /// 下载更新文件并实时返回进度
        /// </summary>
        public async Task<bool> DownloadUpdateFiles(List<AssetBundleInfo> updateList, Action<long, long> progressCallback)
        {
            long totalSize = CalculateUpdateSize(updateList);
            long downloadedSize = 0;

            if (nowBundleList == null || nowBundleList.assetbundles == null)
            {
                nowBundleList = new AssetBundleInfoList(new List<AssetBundleInfo>());
            }

            Dictionary<string, AssetBundleInfo> nowBundleDict = new Dictionary<string, AssetBundleInfo>();
            foreach (var bundle in nowBundleList.assetbundles)
            {
                nowBundleDict[bundle.name] = bundle;
            }

            foreach (var bundle in updateList)
            {
                string url = nowResourceUrl + $"/{bundle.name}";
                string savePath = Path.Combine(localPath, bundle.name);

                string directory = Path.GetDirectoryName(savePath);
                if (!Directory.Exists(directory))
                {
                    Directory.CreateDirectory(directory);
                }

                bool downloadSuccess = await DownloadSingleFile(url, savePath, bundle.md5);
                if (!downloadSuccess)
                {
                    Debug.LogError($"下载文件失败: {bundle.name}");
                    return false;
                }

                nowBundleDict[bundle.name] = bundle;
                downloadedSize += bundle.size;
                progressCallback?.Invoke(downloadedSize, totalSize);

                await Task.Yield();
            }

            nowBundleList.assetbundles = new List<AssetBundleInfo>(nowBundleDict.Values);
            nowBundleList.version = resourceVersion;
            SaveNewBundleList();

            return true;
        }

        /// <summary>
        /// 下载单个文件并校验MD5
        /// </summary>
        private async Task<bool> DownloadSingleFile(string url, string savePath, string expectedMd5)
        {
            int maxRetries = 5;
            for (int i = 0; i <= maxRetries; i++)
            {
                using (UnityWebRequest webRequest = UnityWebRequest.Get(url))
                {
                    var operation = webRequest.SendWebRequest();
                    while (!operation.isDone)
                    {
                        await Task.Yield();
                    }

                    if (webRequest.result == UnityWebRequest.Result.Success)
                    {
                        File.WriteAllBytes(savePath, webRequest.downloadHandler.data);

                        string actualMd5 = CalculateMD5(savePath);
                        if (actualMd5.ToLower() == expectedMd5.ToLower())
                        {
                            return true;
                        }
                        else
                        {
                            Debug.LogError($"MD5校验失败 {url}: 期望 {expectedMd5}, 实际 {actualMd5}");
                            if (File.Exists(savePath))
                            {
                                File.Delete(savePath);
                            }
                        }
                    }
                    else
                    {
                        Debug.LogError($"下载失败 {url}: {webRequest.error} (尝试 {i + 1}/{maxRetries + 1})");
                    }

                    if (i < maxRetries)
                    {
                        await Task.Delay(1000 * (i + 1));
                    }
                }
            }

            return false;
        }

        /// <summary>
        /// 计算文件的MD5值
        /// </summary>
        public string CalculateMD5(string filePath)
        {
            using (var md5 = System.Security.Cryptography.MD5.Create())
            {
                using (var stream = File.OpenRead(filePath))
                {
                    byte[] hash = md5.ComputeHash(stream);
                    return BitConverter.ToString(hash).Replace("-", "").ToLower();
                }
            }
        }

        /// <summary>
        /// 保存新的资源列表到本地
        /// </summary>
        public void SaveNewBundleList()
        {
            if (newBundleList != null)
            {
                string json = JsonUtility.ToJson(newBundleList, true);
                string savePath = Path.Combine(localPath, "list.json");
                File.WriteAllText(savePath, json);
                Debug.Log("新的资源列表已保存到本地");
            }
        }

        #endregion

        #region 图片加载与缓存

        /// <summary>
        /// 图片缓存目录名
        /// </summary>
        private const string IMAGE_CACHE_DIR = "ImageCache";

        /// <summary>
        /// 获取图片缓存目录路径
        /// </summary>
        private string GetImageCacheDirectory()
        {
            string cacheDir = Path.Combine(localPath, IMAGE_CACHE_DIR);
            if (!Directory.Exists(cacheDir))
            {
                Directory.CreateDirectory(cacheDir);
            }
            return cacheDir;
        }

        /// <summary>
        /// 根据URL生成缓存文件名（使用MD5哈希）
        /// </summary>
        private string GetCacheFileName(string url)
        {
            using (System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create())
            {
                byte[] hashBytes = md5.ComputeHash(System.Text.Encoding.UTF8.GetBytes(url));
                string hashString = BitConverter.ToString(hashBytes).Replace("-", "").ToLower();
                
                // 尝试从URL获取扩展名，如果没有则使用.jpg
                string extension = ".jpg";
                try
                {
                    string urlPath = new Uri(url).AbsolutePath;
                    string urlExt = Path.GetExtension(urlPath);
                    if (!string.IsNullOrEmpty(urlExt))
                    {
                        extension = urlExt;
                    }
                }
                catch { }
                
                return hashString + extension;
            }
        }

        /// <summary>
        /// 获取图片缓存的完整路径
        /// </summary>
        private string GetImageCachePath(string url)
        {
            string cacheDir = GetImageCacheDirectory();
            string fileName = GetCacheFileName(url);
            return Path.Combine(cacheDir, fileName);
        }

        /// <summary>
        /// 检查图片是否已缓存
        /// </summary>
        public bool IsImageCached(string url)
        {
            string cachePath = GetImageCachePath(url);
            return File.Exists(cachePath);
        }

        /// <summary>
        /// 加载网络图片（带缓存）
        /// </summary>
        /// <param name="url">图片URL</param>
        /// <param name="onProgress">下载进度回调 (0-1)</param>
        /// <returns>Texture2D对象，失败返回null</returns>
        public async Task<Texture2D> LoadImageAsync(string url, Action<float> onProgress = null)
        {
            if (string.IsNullOrEmpty(url))
            {
                Debug.LogWarning("[NetworkCtrl] 图片URL为空");
                return null;
            }

            // 首先检查本地缓存
            string cachePath = GetImageCachePath(url);
            if (File.Exists(cachePath))
            {
                Debug.Log($"[NetworkCtrl] 从缓存加载图片: {url}");
                return await LoadImageFromCacheAsync(cachePath);
            }

            // 从网络下载
            Debug.Log($"[NetworkCtrl] 从网络下载图片: {url}");
            return await DownloadAndCacheImageAsync(url, cachePath, onProgress);
        }

        /// <summary>
        /// 从本地缓存加载图片
        /// </summary>
        private async Task<Texture2D> LoadImageFromCacheAsync(string cachePath)
        {
            try
            {
                byte[] imageData = await File.ReadAllBytesAsync(cachePath);
                Texture2D texture = new Texture2D(2, 2, TextureFormat.RGBA32, false);
                
                if (texture.LoadImage(imageData))
                {
                    return texture;
                }
                else
                {
                    Debug.LogError($"[NetworkCtrl] 缓存图片加载失败: {cachePath}");
                    // 删除损坏的缓存文件
                    File.Delete(cachePath);
                    return null;
                }
            }
            catch (Exception ex)
            {
                Debug.LogError($"[NetworkCtrl] 读取缓存图片失败: {ex.Message}");
                return null;
            }
        }

        /// <summary>
        /// 下载并缓存图片
        /// </summary>
        private async Task<Texture2D> DownloadAndCacheImageAsync(string url, string cachePath, Action<float> onProgress)
        {
            try
            {
                using (UnityWebRequest request = UnityWebRequest.Get(url))
                {
                    request.downloadHandler = new DownloadHandlerBuffer();
                    
                    var operation = request.SendWebRequest();
                    
                    // 报告进度
                    while (!operation.isDone)
                    {
                        onProgress?.Invoke(request.downloadProgress);
                        await Task.Yield();
                    }
                    
                    onProgress?.Invoke(1f);

                    if (request.result == UnityWebRequest.Result.Success)
                    {
                        byte[] imageData = request.downloadHandler.data;
                        
                        // 保存到缓存
                        try
                        {
                            await File.WriteAllBytesAsync(cachePath, imageData);
                            Debug.Log($"[NetworkCtrl] 图片已缓存: {cachePath}");
                        }
                        catch (Exception ex)
                        {
                            Debug.LogWarning($"[NetworkCtrl] 图片缓存保存失败: {ex.Message}");
                        }
                        
                        // 创建Texture2D
                        Texture2D texture = new Texture2D(2, 2, TextureFormat.RGBA32, false);
                        if (texture.LoadImage(imageData))
                        {
                            return texture;
                        }
                        else
                        {
                            Debug.LogError($"[NetworkCtrl] 图片数据解析失败: {url}");
                            Destroy(texture);
                            return null;
                        }
                    }
                    else
                    {
                        Debug.LogError($"[NetworkCtrl] 图片下载失败: {url}, 错误: {request.error}");
                        return null;
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogError($"[NetworkCtrl] 下载图片异常: {ex.Message}");
                return null;
            }
        }

        /// <summary>
        /// 加载图片并应用到Image组件（带缓存）
        /// </summary>
        /// <param name="url">图片URL</param>
        /// <param name="image">UI Image组件</param>
        /// <param name="onProgress">下载进度回调</param>
        public async Task LoadImageToUIImageAsync(string url, Image image, Action<float> onProgress = null)
        {
            if (image == null)
            {
                Debug.LogWarning("[NetworkCtrl] Image组件为空");
                return;
            }

            Texture2D texture = await LoadImageAsync(url, onProgress);
            
            if (texture != null)
            {
                Sprite sprite = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), Vector2.one * 0.5f);
                image.sprite = sprite;
            }
            image.gameObject.SetActive(true);
        }

        /// <summary>
        /// 加载图片并应用到RawImage组件（带缓存）
        /// </summary>
        public async Task LoadImageToUIRawImageAsync(string url, RawImage rawImage, Action<float> onProgress = null)
        {
            if (rawImage == null)
            {
                Debug.LogWarning("[NetworkCtrl] RawImage组件为空");
                return;
            }

            Texture2D texture = await LoadImageAsync(url, onProgress);
            
            if (texture != null)
            {
                rawImage.texture = texture;
            }
        }

        /// <summary>
        /// 加载图片并应用到SpriteRenderer（带缓存）
        /// </summary>
        public async Task LoadImageToSpriteRendererAsync(string url, SpriteRenderer spriteRenderer, Action<float> onProgress = null)
        {
            if (spriteRenderer == null)
            {
                Debug.LogWarning("[NetworkCtrl] SpriteRenderer组件为空");
                return;
            }

            Texture2D texture = await LoadImageAsync(url, onProgress);
            
            if (texture != null)
            {
                Sprite sprite = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), Vector2.one * 0.5f);
                spriteRenderer.sprite = sprite;
            }
        }

        /// <summary>
        /// 清除指定URL的图片缓存
        /// </summary>
        public void ClearImageCache(string url)
        {
            string cachePath = GetImageCachePath(url);
            if (File.Exists(cachePath))
            {
                File.Delete(cachePath);
                Debug.Log($"[NetworkCtrl] 已清除图片缓存: {url}");
            }
        }

        /// <summary>
        /// 清除所有图片缓存
        /// </summary>
        public void ClearAllImageCache()
        {
            string cacheDir = GetImageCacheDirectory();
            if (Directory.Exists(cacheDir))
            {
                string[] files = Directory.GetFiles(cacheDir);
                foreach (string file in files)
                {
                    try
                    {
                        File.Delete(file);
                    }
                    catch (Exception ex)
                    {
                        Debug.LogWarning($"[NetworkCtrl] 删除缓存文件失败: {ex.Message}");
                    }
                }
                Debug.Log($"[NetworkCtrl] 已清除所有图片缓存，共 {files.Length} 个文件");
            }
        }

        /// <summary>
        /// 获取图片缓存总大小（字节）
        /// </summary>
        public long GetImageCacheSize()
        {
            string cacheDir = GetImageCacheDirectory();
            if (!Directory.Exists(cacheDir))
                return 0;

            long totalSize = 0;
            string[] files = Directory.GetFiles(cacheDir);
            foreach (string file in files)
            {
                try
                {
                    FileInfo fileInfo = new FileInfo(file);
                    totalSize += fileInfo.Length;
                }
                catch { }
            }
            return totalSize;
        }

        /// <summary>
        /// 获取图片缓存文件数量
        /// </summary>
        public int GetImageCacheCount()
        {
            string cacheDir = GetImageCacheDirectory();
            if (!Directory.Exists(cacheDir))
                return 0;

            return Directory.GetFiles(cacheDir).Length;
        }

        public async Task GetNewBundle()
        {
            LoadingUI.Show();
            var response = await Instance.Get<BundleDataResponse>($"/api/v1/app/version/bundle?version={Application.version}&platform={platform}");
            ResponseCodeHandler.HandleResponse(response,
                onSuccess: (data) =>
                {
                    resourceVersion=data.data.bundle_version;
                    nowResourceUrl=data.data.bundle_url;
                }
            );
            LoadingUI.Hide();
        }

        #endregion

        #region 设备控制指令接口

        #endregion
    }

    #region 设备控制接口数据模型

    /// <summary>
    /// 设备控制指令请求
    /// </summary>
    [System.Serializable]
    public class DeviceControlRequest
    {
        public string device_sn;
        public string command;
    }

    /// <summary>
    /// 设备控制指令响应
    /// </summary>
    [System.Serializable]
    public class DeviceControlResponse
    {
        public int code;
        public string message;
        public DeviceControlResponseData data;
    }

    [System.Serializable]
    public class DeviceControlResponseData
    {
        public int seq;
        public bool success;
        public string message;
    }

    #endregion
}