using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.EntityFrameworkCore;
using MilliSim.Common.Entities;
using MilliSim.Data;
using COSXML;
using COSXML.Auth;
using COSXML.Model.Object;
using COSXML.Model.Tag;
using COSXML.Model.Bucket;
using System.IO.Compression;
using System.Security.Cryptography;
using System.Text;

namespace MilliSim.Services.Infrastructure;

/// <summary>
/// 文件存储服务接口
/// </summary>
public interface IFileStorageService
{
    /// <summary>
    /// 上传文件
    /// </summary>
    Task<string> UploadAsync(IFormFile file, string folder);

    /// <summary>
    /// 删除文件
    /// </summary>
    Task DeleteAsync(string fileUrl);

    /// <summary>
    /// 获取文件URL（返回对象键）
    /// </summary>
    string GetFileUrl(string relativePath);

    /// <summary>
    /// 下载文件
    /// </summary>
    Task<(Stream Stream, string ContentType, string FileName)> DownloadAsync(string fileUrl);

    /// <summary>
    /// 生成预签名URL（COS私有读写必须用预签名URL访问）
    /// </summary>
    string GetSignedUrl(string fileUrl, int expireMinutes = 60);

    /// <summary>
    /// 从文件URL中提取对象键（用于数据库存储，避免签名URL过期导致数据丢失）
    /// </summary>
    string ExtractKey(string fileUrl);

    /// <summary>
    /// 清除存储配置缓存（在后台修改存储设置后调用，确保后续请求读取最新配置）
    /// </summary>
    void ClearConfigCache();

    /// <summary>
    /// 解压 ZIP 文件到 COS（用于 WebGL 资源在线运行）
    /// </summary>
    /// <param name="zipFile">ZIP 文件</param>
    /// <param name="folder">COS 目标目录</param>
    /// <returns>解压后的根目录对象键前缀（如 webgl/xxx/）</returns>
    Task<string> ExtractZipAsync(IFormFile zipFile, string folder);

    /// <summary>
    /// 读取文件文本内容（用于 WebGL index.html 代理读取）
    /// </summary>
    /// <param name="fileUrl">文件URL或对象键</param>
    /// <returns>文件文本内容</returns>
    Task<string> ReadFileTextAsync(string fileUrl);

    /// <summary>
    /// 列出存储桶内所有对象键（分页列出，用于工厂重置清理）
    /// </summary>
    Task<List<string>> ListAllObjectsAsync();

    /// <summary>
    /// 批量删除对象（每批最多 1000 个，用于工厂重置清理）
    /// </summary>
    Task<int> DeleteObjectsAsync(IEnumerable<string> keys);

    /// <summary>
    /// 将 COS 中所有对象迁移到本地存储（用于从 COS 切换到 Local 模式后补齐旧文件）
    /// </summary>
    /// <returns>迁移的文件数量</returns>
    Task<int> MigrateCosToLocalAsync();

    /// <summary>
    /// 迁移已有的 APK/IPA 文件扩展名（COS 禁止通过默认域名分发 APK/IPA 文件）
    /// 将对象键从 xxx.apk 复制为 xxx.apk.bin，删除旧对象，更新数据库
    /// </summary>
    /// <returns>迁移的文件数量</returns>
    Task<int> MigrateApkExtensionsAsync();
}

/// <summary>
/// 文件存储服务实现
/// 支持本地存储和腾讯云COS存储，默认使用COS模式
/// 配置信息从数据库 SystemSettings 表读取
/// </summary>
public class FileStorageService : IFileStorageService
{
    private readonly MilliSimDbContext _db;
    private readonly IWebHostEnvironment _env;
    private readonly IConfiguration _config;

    // 缓存的COS客户端（静态，避免每次请求都创建）
    private static CosXml? _cachedCosXml;
    // 缓存的配置签名，用于检测配置是否变更
    private static string? _cachedConfigSignature;
    // 锁对象，保证COS客户端创建的线程安全
    private static readonly object _lock = new();

    // 缓存的存储配置（静态，避免每次 GetSignedUrl 都查库）
    private static StorageConfig? _cachedStorageConfig;
    // 缓存的存储配置过期时间
    private static DateTime _cachedStorageConfigExpiry;
    // 存储配置缓存锁
    private static readonly object _configLock = new();
    // 存储配置缓存有效期（分钟）
    private const int ConfigCacheMinutes = 5;
    // 静态 HttpClient（用于 COS 预签名 URL 流式下载，避免每次请求创建实例）
    private static readonly HttpClient _downloadHttpClient = new HttpClient();

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="db">数据库上下文</param>
    /// <param name="env">Web主机环境</param>
    /// <param name="config">配置（用于读取 Jwt:SecretKey 作为本地签名URL的签名密钥）</param>
    public FileStorageService(MilliSimDbContext db, IWebHostEnvironment env, IConfiguration config)
    {
        _db = db;
        _env = env;
        _config = config;
    }

    /// <summary>
    /// 上传文件
    /// COS模式返回对象键（folder/filename），本地模式返回访问URL
    /// </summary>
    /// <param name="file">表单文件</param>
    /// <param name="folder">存储目录</param>
    /// <returns>COS对象键或本地访问URL</returns>
    public async Task<string> UploadAsync(IFormFile file, string folder)
    {
        // 从数据库读取存储配置
        var config = await GetStorageConfigAsync();

        // 根据存储模式选择上传方式
        if (config.Mode.Equals("Cos", StringComparison.OrdinalIgnoreCase))
        {
            return await UploadToCosAsync(file, folder, config);
        }
        return await UploadToLocalAsync(file, folder, config);
    }

    /// <summary>
    /// 删除文件
    /// </summary>
    /// <param name="fileUrl">文件URL或对象键</param>
    public async Task DeleteAsync(string fileUrl)
    {
        // 空值检查
        if (string.IsNullOrEmpty(fileUrl)) return;

        // 从数据库读取存储配置
        var config = await GetStorageConfigAsync();

        // 根据存储模式选择删除方式
        if (config.Mode.Equals("Cos", StringComparison.OrdinalIgnoreCase))
        {
            await DeleteFromCosAsync(fileUrl, config);
        }
        else
        {
            DeleteFromLocal(fileUrl, config);
        }
    }

    /// <summary>
    /// 获取文件URL（返回对象键，不直接返回可访问URL）
    /// COS模式下需要通过GetSignedUrl获取可访问的预签名URL
    /// </summary>
    /// <param name="relativePath">相对路径/对象键</param>
    /// <returns>对象键</returns>
    public string GetFileUrl(string relativePath)
    {
        if (string.IsNullOrEmpty(relativePath)) return string.Empty;
        // 直接返回对象键，需要通过GetSignedUrl获取可访问URL
        return relativePath;
    }

    /// <summary>
    /// 下载文件
    /// 当前存储模式下载失败时（如文件上传于另一模式后系统切换了存储模式），回退到另一模式尝试
    /// </summary>
    /// <param name="fileUrl">文件URL或对象键</param>
    /// <returns>文件流、内容类型、文件名</returns>
    public async Task<(Stream Stream, string ContentType, string FileName)> DownloadAsync(string fileUrl)
    {
        var config = await GetStorageConfigAsync();
        var isCosMode = config.Mode.Equals("Cos", StringComparison.OrdinalIgnoreCase);

        Exception? primaryEx = null;
        try
        {
            if (isCosMode)
            {
                return await DownloadFromCosAsync(fileUrl, config);
            }
            return await DownloadFromLocalAsync(fileUrl, config);
        }
        catch (Exception ex)
        {
            primaryEx = ex;
        }

        // 回退：尝试另一存储模式（文件可能上传于切换存储模式之前）
        try
        {
            if (isCosMode)
            {
                return await DownloadFromLocalAsync(fileUrl, config);
            }
            return await DownloadFromCosAsync(fileUrl, config);
        }
        catch
        {
            // 两种模式都失败，抛出原始异常
            throw primaryEx;
        }
    }

    /// <summary>
    /// 生成预签名URL（COS私有读写必须用预签名URL访问）
    /// </summary>
    /// <param name="fileUrl">文件URL或对象键</param>
    /// <param name="expireMinutes">过期时间（分钟），默认60分钟</param>
    /// <returns>预签名URL</returns>
    public string GetSignedUrl(string fileUrl, int expireMinutes = 60)
    {
        // 空值检查
        if (string.IsNullOrEmpty(fileUrl)) return string.Empty;

        // 同步获取存储配置（ASP.NET Core中安全调用）
        var config = GetStorageConfigAsync().GetAwaiter().GetResult();

        // 本地模式：将对象键转为可访问的URL
        if (config.Mode.Equals("Local", StringComparison.OrdinalIgnoreCase))
        {
            var baseUrl = config.LocalBaseUrl.TrimEnd('/');
            var baseDir = config.LocalBaseUrl.Trim('/');
            var localKey = fileUrl;

            // 如果是完整URL（COS签名URL），提取对象键后转为本地URL
            // 旧数据可能存了 COS 签名 URL，切换到 Local 模式后仍会请求 COS，应转成本地路径
            if (fileUrl.StartsWith("http", StringComparison.OrdinalIgnoreCase))
            {
                try
                {
                    var uri = new Uri(fileUrl);
                    localKey = uri.AbsolutePath.TrimStart('/');
                }
                catch
                {
                    return fileUrl; // URL解析失败，原样返回
                }
            }
            // 如果已经是本地URL（以/开头），剥离前缀得到对象键
            else if (fileUrl.StartsWith("/"))
            {
                localKey = fileUrl.TrimStart('/');
            }

            // 兼容旧数据：如果对象键已包含 LocalBaseUrl 目录前缀（如 uploads/projects/...），剥离避免重复
            if (!string.IsNullOrEmpty(baseDir) && localKey.StartsWith(baseDir + "/", StringComparison.OrdinalIgnoreCase))
            {
                localKey = localKey.Substring((baseDir + "/").Length);
            }

            // 检查本地文件是否存在：存在则返回签名URL，不存在则返回空字符串
            // Local 模式下不回退到 COS，确保完全区分本地与 COS 资源请求
            // 旧数据（上传于 COS 模式但未迁移的文件）应通过迁移端点 /api/system/migrate-cos-to-local 补齐
            var localPath = Path.Combine(_env.ContentRootPath, config.LocalBasePath,
                localKey.Replace('/', Path.DirectorySeparatorChar));
            if (File.Exists(localPath))
            {
                // 生成签名URL：/uploads/{path}?exp={unix_ts}&sig={hmac_sha256}
                // 与 COS 临时签名URL对齐，防止 Local 模式资源被永久链接盗用
                return GenerateLocalSignedUrl(baseUrl, localKey, expireMinutes);
            }

            // 本地文件不存在，返回空字符串（前端展示占位图，不发起 COS 请求）
            return string.Empty;
        }

        // COS模式生成预签名URL
        var cosXml = GetCosXml(config);
        // 从文件URL中提取对象键
        var key = ExtractObjectKey(fileUrl);
        // 从存储桶名称中提取APPID
        var appid = ExtractAppid(config.CosBucket);

        // 构建预签名请求结构
        var preSignatureStruct = new PreSignatureStruct
        {
            appid = appid,                          // 腾讯云账号APPID
            region = config.CosRegion,              // 存储桶地域
            bucket = config.CosBucket,              // 存储桶名称
            key = key,                              // 对象键
            httpMethod = "GET",                     // HTTP请求方法
            isHttps = true,                         // 使用HTTPS
            signDurationSecond = expireMinutes * 60L, // 签名有效时长（秒）
            headers = null,                         // 签名中需要校验的header
            queryParameters = null                  // 签名中需要校验的URL请求参数
        };

        // 生成预签名URL
        return cosXml.GenerateSignURL(preSignatureStruct);
    }

    // ===== COS存储操作 =====

    /// <summary>
    /// 上传文件到COS
    /// </summary>
    /// <param name="file">表单文件</param>
    /// <param name="folder">存储目录</param>
    /// <param name="config">存储配置</param>
    /// <returns>COS对象键（folder/filename）</returns>
    private async Task<string> UploadToCosAsync(IFormFile file, string folder, StorageConfig config)
    {
        // 获取缓存的COS客户端
        var cosXml = GetCosXml(config);

        // 生成对象键：folder/时间戳_唯一ID.扩展名
        // COS 禁止通过默认域名分发 APK/IPA 文件，追加 .bin 绕过限制（原始文件名存于 FileName 字段）
        var ext = SanitizeExtension(Path.GetExtension(file.FileName));
        var fileName = $"{DateTime.Now:yyyyMMddHHmmss}_{Guid.NewGuid():N}{ext}";
        var key = $"{folder}/{fileName}";

        // 使用文件流上传到COS
        await using var stream = file.OpenReadStream();
        // 构建上传请求（存储桶、对象键、文件流、偏移量、长度）
        var request = new PutObjectRequest(config.CosBucket, key, stream, 0L, file.Length);

        // COS SDK的PutObject是同步方法，使用Task.Run包装为异步调用
        await Task.Run(() => cosXml.PutObject(request));

        // 返回对象键
        return key;
    }

    /// <summary>
    /// 从COS删除文件
    /// </summary>
    /// <param name="fileUrl">文件URL或对象键</param>
    /// <param name="config">存储配置</param>
    private async Task DeleteFromCosAsync(string fileUrl, StorageConfig config)
    {
        // 获取缓存的COS客户端
        var cosXml = GetCosXml(config);
        // 从文件URL中提取对象键
        var key = ExtractObjectKey(fileUrl);

        // 构建删除请求
        var request = new DeleteObjectRequest(config.CosBucket, key);

        // COS SDK的DeleteObject是同步方法，使用Task.Run包装为异步调用
        await Task.Run(() => cosXml.DeleteObject(request));
    }

    /// <summary>
    /// 从COS下载文件
    /// </summary>
    /// <param name="fileUrl">文件URL或对象键</param>
    /// <param name="config">存储配置</param>
    /// <returns>文件流、内容类型、文件名</returns>
    private async Task<(Stream Stream, string ContentType, string FileName)> DownloadFromCosAsync(string fileUrl, StorageConfig config)
    {
        // 从文件URL中提取对象键
        var key = ExtractObjectKey(fileUrl);
        // 获取文件名和内容类型
        var fileName = Path.GetFileName(key);
        var contentType = GetContentType(fileName);

        // 生成COS预签名URL（与浏览器下载使用相同的签名机制）
        // 不调用 GetSignedUrl()，因为它会根据当前存储模式返回本地URL或COS URL
        // DownloadFromCosAsync 专门处理COS下载，直接生成COS预签名URL
        var cosXml = GetCosXml(config);
        var appid = ExtractAppid(config.CosBucket);
        var preSignatureStruct = new PreSignatureStruct
        {
            appid = appid,
            region = config.CosRegion,
            bucket = config.CosBucket,
            key = key,
            httpMethod = "GET",
            isHttps = true,
            signDurationSecond = 10 * 60L, // 10分钟有效期
            headers = null,
            queryParameters = null
        };
        var signedUrl = cosXml.GenerateSignURL(preSignatureStruct);

        // 使用 HttpClient 流式下载（避免将大文件全部加载到内存）
        var response = await _downloadHttpClient.GetAsync(signedUrl, HttpCompletionOption.ResponseHeadersRead);
        if (!response.IsSuccessStatusCode)
        {
            var errorBody = await response.Content.ReadAsStringAsync();
            response.Dispose();
            throw new InvalidOperationException(
                $"COS下载失败（对象键：{key}，存储桶：{config.CosBucket}，地域：{config.CosRegion}，HTTP {(int)response.StatusCode}）：{errorBody}");
        }

        var stream = await response.Content.ReadAsStreamAsync();
        return (stream, contentType, fileName);
    }

    // ===== 本地存储操作 =====

    /// <summary>
    /// 上传到本地文件系统
    /// </summary>
    /// <param name="file">表单文件</param>
    /// <param name="folder">存储目录</param>
    /// <param name="config">存储配置</param>
    /// <returns>COS对象键（folder/fileName），与COS模式保持一致</returns>
    private async Task<string> UploadToLocalAsync(IFormFile file, string folder, StorageConfig config)
    {
        // 构建本地存储根目录
        var uploadsRoot = Path.Combine(_env.ContentRootPath, config.LocalBasePath);
        var targetDir = Path.Combine(uploadsRoot, folder);
        // 创建目录（如果不存在）
        Directory.CreateDirectory(targetDir);

        // 生成文件名：时间戳_唯一ID.扩展名（与 COS 模式保持一致，APK/IPA 追加 .bin）
        var ext = SanitizeExtension(Path.GetExtension(file.FileName));
        var fileName = $"{DateTime.Now:yyyyMMddHHmmss}_{Guid.NewGuid():N}{ext}";
        var filePath = Path.Combine(targetDir, fileName);

        // 写入文件
        await using var stream = new FileStream(filePath, FileMode.Create);
        await file.CopyToAsync(stream);

        // 返回对象键（folder/fileName），与COS模式保持一致
        return $"{folder}/{fileName}";
    }

    /// <summary>
    /// 从本地文件系统删除文件
    /// </summary>
    /// <param name="fileUrl">文件URL</param>
    /// <param name="config">存储配置</param>
    private void DeleteFromLocal(string fileUrl, StorageConfig config)
    {
        // 获取本地文件路径
        var localPath = GetLocalPath(fileUrl, config);
        // 删除文件（如果存在）
        if (File.Exists(localPath))
        {
            File.Delete(localPath);
        }
    }

    /// <summary>
    /// 从本地文件系统下载文件
    /// </summary>
    /// <param name="fileUrl">文件URL</param>
    /// <param name="config">存储配置</param>
    /// <returns>文件流、内容类型、文件名</returns>
    private Task<(Stream Stream, string ContentType, string FileName)> DownloadFromLocalAsync(string fileUrl, StorageConfig config)
    {
        // 获取本地文件路径
        var localPath = GetLocalPath(fileUrl, config);
        // 检查文件是否存在
        if (!File.Exists(localPath))
            throw new FileNotFoundException("文件不存在", localPath);

        // 创建文件流
        Stream stream = new FileStream(localPath, FileMode.Open, FileAccess.Read);
        // 获取内容类型
        var contentType = GetContentType(localPath);
        // 获取文件名
        var fileName = Path.GetFileName(localPath);
        return Task.FromResult((stream, contentType, fileName));
    }

    // ===== 辅助方法 =====

    /// <summary>
    /// 从数据库读取设置值
    /// </summary>
    /// <param name="key">设置键</param>
    /// <param name="defaultValue">默认值</param>
    /// <returns>设置值</returns>
    private async Task<string> GetSettingAsync(string key, string defaultValue)
    {
        // 从SystemSettings表查询指定键的值
        var setting = await _db.SystemSettings.FirstOrDefaultAsync(s => s.Key == key);
        return setting?.Value ?? defaultValue;
    }

    /// <summary>
    /// 获取存储配置（从数据库读取，带5分钟内存缓存，避免高频 GetSignedUrl 调用压垮数据库）
    /// </summary>
    /// <returns>存储配置</returns>
    private async Task<StorageConfig> GetStorageConfigAsync()
    {
        // 快速路径：缓存未过期直接返回（无锁，绝大多数请求走这里）
        if (_cachedStorageConfig != null && DateTime.UtcNow < _cachedStorageConfigExpiry)
        {
            return _cachedStorageConfig;
        }

        lock (_configLock)
        {
            // 双重检查：其他线程可能已经刷新了缓存
            if (_cachedStorageConfig != null && DateTime.UtcNow < _cachedStorageConfigExpiry)
            {
                return _cachedStorageConfig;
            }
        }

        // 一次性查询所有存储相关配置，减少数据库访问次数
        // 注意：使用 List<string> 并先 ToListAsync 再转字典，避免 EF Core 在 .NET 10 下
        // 对数组 + ToDictionaryAsync 的 LINQ 翻译出现 ReadOnlySpan<string> 类型加载异常
        var keys = new List<string> { "StorageMode", "CosSecretId", "CosSecretKey", "CosBucket", "CosRegion",
            "CosSignedUrlExpireMinutes", "LocalBasePath", "LocalBaseUrl" };
        var settingsList = await _db.SystemSettings
            .Where(s => keys.Contains(s.Key))
            .ToListAsync();
        var settings = settingsList.ToDictionary(s => s.Key, s => s.Value);

        // 构建存储配置对象
        var config = new StorageConfig
        {
            Mode = GetValue(settings, "StorageMode", "Cos"),
            CosSecretId = GetValue(settings, "CosSecretId", ""),
            CosSecretKey = GetValue(settings, "CosSecretKey", ""),
            CosBucket = GetValue(settings, "CosBucket", ""),
            CosRegion = GetValue(settings, "CosRegion", ""),
            CosExpireMinutes = int.Parse(GetValue(settings, "CosSignedUrlExpireMinutes", "60")),
            LocalBasePath = GetValue(settings, "LocalBasePath", "wwwroot/uploads"),
            LocalBaseUrl = GetValue(settings, "LocalBaseUrl", "/uploads")
        };

        // 更新缓存
        lock (_configLock)
        {
            _cachedStorageConfig = config;
            _cachedStorageConfigExpiry = DateTime.UtcNow.AddMinutes(ConfigCacheMinutes);
        }

        return config;
    }

    /// <summary>
    /// 从字典中获取值（带默认值）
    /// </summary>
    private static string GetValue(Dictionary<string, string> dict, string key, string defaultValue)
    {
        return dict.TryGetValue(key, out var value) && !string.IsNullOrEmpty(value) ? value : defaultValue;
    }

    /// <summary>
    /// 获取COS客户端（带缓存，配置变更时重新创建）
    /// </summary>
    /// <param name="config">存储配置</param>
    /// <returns>COS客户端</returns>
    private CosXml GetCosXml(StorageConfig config)
    {
        // 生成配置签名，用于检测配置是否变更
        var signature = $"{config.CosSecretId}|{config.CosSecretKey}|{config.CosBucket}|{config.CosRegion}";

        lock (_lock)
        {
            // 配置未变更时返回缓存的客户端
            if (_cachedCosXml != null && _cachedConfigSignature == signature)
            {
                return _cachedCosXml;
            }

            // 创建COS配置
            var cosConfig = new CosXmlConfig.Builder()
                .SetRegion(config.CosRegion)  // 设置地域
                .IsHttps(true)                // 使用HTTPS
                .Build();

            // 创建密钥提供者（使用永久密钥，签名有效时长600秒）
            var provider = new DefaultQCloudCredentialProvider(
                config.CosSecretId, config.CosSecretKey, 600);

            // 创建COS客户端
            _cachedCosXml = new CosXmlServer(cosConfig, provider);
            _cachedConfigSignature = signature;

            return _cachedCosXml;
        }
    }

    /// <summary>
    /// 从文件URL中提取对象键
    /// 支持完整签名URL、本地URL路径、纯对象键
    /// 公开方法，供其他服务调用（保存到数据库前将签名URL转为对象键）
    /// Local模式下需剥离 LocalBaseUrl 前缀（如 /uploads/projects/cover/x.jpg → projects/cover/x.jpg）
    /// </summary>
    /// <param name="fileUrl">文件URL或对象键</param>
    /// <returns>对象键</returns>
    public string ExtractKey(string fileUrl)
    {
        if (string.IsNullOrEmpty(fileUrl)) return string.Empty;

        // 剥离查询字符串（Local模式签名URL带 ?exp=...&sig=...，COS签名URL也带查询参数）
        // 必须在提取对象键之前剥离，否则查询字符串会被当作对象键的一部分
        var queryIndex = fileUrl.IndexOf('?');
        if (queryIndex >= 0)
        {
            fileUrl = fileUrl.Substring(0, queryIndex);
        }

        // 完整URL（COS签名URL）：提取路径部分作为对象键
        if (fileUrl.StartsWith("http", StringComparison.OrdinalIgnoreCase))
        {
            var uri = new Uri(fileUrl);
            return uri.AbsolutePath.TrimStart('/');
        }

        // 本地URL（以 / 开头）：剥离 LocalBaseUrl 前缀，得到纯对象键
        if (fileUrl.StartsWith("/"))
        {
            var config = GetStorageConfigAsync().GetAwaiter().GetResult();
            var baseDir = config.LocalBaseUrl.Trim('/');
            var key = fileUrl.TrimStart('/');
            if (!string.IsNullOrEmpty(baseDir) && key.StartsWith(baseDir + "/", StringComparison.OrdinalIgnoreCase))
            {
                key = key.Substring((baseDir + "/").Length);
            }
            return key;
        }

        // 已经是对象键，直接返回
        return fileUrl;
    }

    /// <summary>
    /// 生成本地签名URL：{baseUrl}/{localKey}?exp={unix_ts}&sig={hmac_sha256_hex}
    /// 与 COS 临时签名URL对齐，使 Local 模式资源同样具有时效性，防止永久链接被盗用。
    /// 签名数据 = "{baseUrl}/{localKey}?exp={exp}"（即 URL 的 path + ?exp= 部分），
    /// 验证中间件只需 request.Path + query["exp"] 即可重新计算 HMAC，无需读 DB。
    /// </summary>
    /// <param name="baseUrl">本地访问基础URL（如 /uploads）</param>
    /// <param name="localKey">对象键（如 avatars/xxx.png）</param>
    /// <param name="expireMinutes">过期时间（分钟）</param>
    /// <returns>带 exp 与 sig 查询参数的签名URL</returns>
    private string GenerateLocalSignedUrl(string baseUrl, string localKey, int expireMinutes)
    {
        var path = $"{baseUrl}/{localKey}";
        var exp = DateTimeOffset.UtcNow.AddMinutes(expireMinutes).ToUnixTimeSeconds();
        var signingData = $"{path}?exp={exp}";
        var secretKey = _config["Jwt:SecretKey"]
            ?? throw new InvalidOperationException("Jwt:SecretKey 未配置，无法生成 Local 模式签名URL");
        var sig = ComputeHmacSha256Hex(signingData, secretKey);
        return $"{path}?exp={exp}&sig={sig}";
    }

    /// <summary>
    /// 验证本地签名URL（供 Program.cs 中间件调用）
    /// 签名数据 = "{requestPath}?exp={exp}"，与 GenerateLocalSignedUrl 一致。
    /// 同时校验 exp 是否过期，签名是否匹配（使用固定时间比较防止时序攻击）。
    /// </summary>
    /// <param name="requestPath">请求路径（如 /uploads/avatars/xxx.png），不含查询字符串</param>
    /// <param name="exp">exp 查询参数（Unix 时间戳，秒）</param>
    /// <param name="sig">sig 查询参数（HMAC-SHA256 十六进制）</param>
    /// <param name="secretKey">签名密钥（Jwt:SecretKey）</param>
    /// <returns>true=签名有效且未过期；false=签名缺失/无效/已过期</returns>
    public static bool ValidateLocalSignedUrl(string requestPath, string? exp, string? sig, string secretKey)
    {
        if (string.IsNullOrEmpty(exp) || string.IsNullOrEmpty(sig) || string.IsNullOrEmpty(secretKey))
            return false;
        if (!long.TryParse(exp, out var expTs))
            return false;
        // 检查过期时间（允许 30 秒时钟偏移）
        if (expTs < DateTimeOffset.UtcNow.ToUnixTimeSeconds() - 30)
            return false;

        var signingData = $"{requestPath}?exp={exp}";
        var expectedSig = ComputeHmacSha256Hex(signingData, secretKey);
        // 固定时间比较，防止时序攻击
        return CryptographicOperations.FixedTimeEquals(
            Encoding.ASCII.GetBytes(sig),
            Encoding.ASCII.GetBytes(expectedSig));
    }

    /// <summary>
    /// 计算 HMAC-SHA256 并返回小写十六进制字符串
    /// </summary>
    private static string ComputeHmacSha256Hex(string data, string secretKey)
    {
        using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
        var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(data));
        // Convert.ToHexString 在 .NET 5+ 可用，输出大写；统一转小写便于 URL 传递
        return Convert.ToHexString(hash).ToLowerInvariant();
    }

    /// <summary>
    /// 清除存储配置缓存（在后台修改存储设置后调用，确保后续请求读取最新配置）
    /// </summary>
    public void ClearConfigCache()
    {
        lock (_configLock)
        {
            _cachedStorageConfig = null;
            _cachedStorageConfigExpiry = DateTime.MinValue;
        }
    }

    /// <summary>
    /// 解压 ZIP 文件到 COS（用于 WebGL 资源在线运行）
    /// 将 ZIP 中的所有文件按原目录结构上传到 COS 指定目录
    /// </summary>
    /// <param name="zipFile">ZIP 文件</param>
    /// <param name="folder">COS 目标目录</param>
    /// <returns>解压后的根目录对象键前缀（如 webgl/xxx/）</returns>
    public async Task<string> ExtractZipAsync(IFormFile zipFile, string folder)
    {
        if (zipFile == null || zipFile.Length == 0)
        {
            throw new ArgumentException("ZIP 文件不能为空");
        }

        // 从数据库读取存储配置
        var config = await GetStorageConfigAsync();

        // 生成唯一子目录，避免不同资源包文件冲突
        var subFolder = $"{DateTime.Now:yyyyMMddHHmmss}_{Guid.NewGuid():N}";
        var basePath = $"{folder}/{subFolder}";

        // 打开 ZIP 文件流
        using var archive = new ZipArchive(zipFile.OpenReadStream(), ZipArchiveMode.Read);

        // 遍历 ZIP 中的所有条目
        foreach (var entry in archive.Entries)
        {
            // 跳过目录条目
            if (string.IsNullOrEmpty(entry.Name)) continue;

            // 构建对象键：basePath + ZIP 内相对路径
            // 统一使用正斜杠（COS 对象键使用正斜杠）
            var relativePath = entry.FullName.Replace('\\', '/').TrimStart('/');
            var key = $"{basePath}/{relativePath}";

            // 读取条目内容
            using var entryStream = entry.Open();
            using var ms = new MemoryStream();
            await entryStream.CopyToAsync(ms);
            var bytes = ms.ToArray();

            // 上传到 COS 或本地
            if (config.Mode.Equals("Cos", StringComparison.OrdinalIgnoreCase))
            {
                await UploadBytesToCosAsync(bytes, key, config);
            }
            else
            {
                UploadBytesToLocal(bytes, key, config);
            }
        }

        // 返回解压后的根目录对象键前缀
        return basePath + "/";
    }

    /// <summary>
    /// 上传字节数组到 COS
    /// </summary>
    private async Task UploadBytesToCosAsync(byte[] bytes, string key, StorageConfig config)
    {
        var cosXml = GetCosXml(config);
        using var stream = new MemoryStream(bytes);
        var request = new PutObjectRequest(config.CosBucket, key, stream, 0L, bytes.Length);
        await Task.Run(() => cosXml.PutObject(request));
    }

    /// <summary>
    /// 读取文件文本内容（用于 WebGL index.html 代理读取）
    /// 复用 DownloadAsync 获取文件流，再读取为文本
    /// </summary>
    public async Task<string> ReadFileTextAsync(string fileUrl)
    {
        var (stream, _, _) = await DownloadAsync(fileUrl);
        using var reader = new StreamReader(stream);
        return await reader.ReadToEndAsync();
    }

    /// <summary>
    /// 上传字节数组到本地
    /// </summary>
    private void UploadBytesToLocal(byte[] bytes, string key, StorageConfig config)
    {
        var localPath = Path.Combine(_env.ContentRootPath, config.LocalBasePath, key.Replace('/', Path.DirectorySeparatorChar));
        var dir = Path.GetDirectoryName(localPath);
        if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir);
        File.WriteAllBytes(localPath, bytes);
    }

    /// <summary>
    /// 从文件URL中提取COS对象键
    /// 支持完整URL、本地URL路径、纯对象键
    /// </summary>
    /// <param name="fileUrl">文件URL或对象键</param>
    /// <returns>COS对象键</returns>
    private static string ExtractObjectKey(string fileUrl)
    {
        if (string.IsNullOrEmpty(fileUrl)) return string.Empty;

        // 如果是完整URL，提取路径部分作为对象键
        if (fileUrl.StartsWith("http", StringComparison.OrdinalIgnoreCase))
        {
            var uri = new Uri(fileUrl);
            return uri.AbsolutePath.TrimStart('/');
        }

        // 如果以斜杠开头（本地URL格式），去掉前导斜杠
        if (fileUrl.StartsWith("/"))
        {
            return fileUrl.TrimStart('/');
        }

        // 已经是对象键，直接返回
        return fileUrl;
    }

    /// <summary>
    /// 规范化文件扩展名
    /// COS 禁止通过默认域名分发 APK/IPA 文件（返回 DownloadForbidden 403）
    /// 追加 .bin 后缀绕过限制，原始文件名保存在 ProjectPackage.FileName 字段
    /// </summary>
    private static string SanitizeExtension(string ext)
    {
        if (string.IsNullOrEmpty(ext)) return ext;
        if (ext.Equals(".apk", StringComparison.OrdinalIgnoreCase) ||
            ext.Equals(".ipa", StringComparison.OrdinalIgnoreCase))
        {
            return ext + ".bin";
        }
        return ext;
    }

    /// <summary>
    /// 从存储桶名称中提取APPID
    /// 存储桶格式：bucketname-APPID（如 millisim-1300718495）
    /// </summary>
    /// <param name="bucket">存储桶名称</param>
    /// <returns>APPID</returns>
    private static string ExtractAppid(string bucket)
    {
        if (string.IsNullOrEmpty(bucket)) return string.Empty;
        // 取最后一个"-"之后的部分作为APPID
        var lastIndex = bucket.LastIndexOf('-');
        return lastIndex >= 0 ? bucket.Substring(lastIndex + 1) : string.Empty;
    }

    /// <summary>
    /// 获取本地文件路径
    /// </summary>
    /// <param name="fileUrl">文件URL</param>
    /// <param name="config">存储配置</param>
    /// <returns>本地文件绝对路径</returns>
    private string GetLocalPath(string fileUrl, StorageConfig config)
    {
        // 统一提取对象键（兼容 /uploads/folder/file、folder/file、/folder/file 等格式）
        var key = ExtractObjectKey(fileUrl);

        // 剥离 LocalBasePath 前缀（如 wwwroot/uploads/）
        var localBasePath = config.LocalBasePath.Replace('/', Path.DirectorySeparatorChar).TrimStart(Path.DirectorySeparatorChar);
        if (key.StartsWith(localBasePath, StringComparison.OrdinalIgnoreCase))
        {
            key = key.Substring(localBasePath.Length).TrimStart(Path.DirectorySeparatorChar, '/');
        }

        // 剥离 LocalBaseUrl 目录前缀（如 uploads/），兼容旧数据中误存了 URL 目录前缀的对象键
        var baseUrlDir = config.LocalBaseUrl.Trim('/');
        if (!string.IsNullOrEmpty(baseUrlDir) && key.StartsWith(baseUrlDir + "/", StringComparison.OrdinalIgnoreCase))
        {
            key = key.Substring((baseUrlDir + "/").Length);
        }

        return Path.Combine(_env.ContentRootPath, config.LocalBasePath, key.Replace('/', Path.DirectorySeparatorChar));
    }

    /// <summary>
    /// 根据文件扩展名获取内容类型
    /// </summary>
    /// <param name="path">文件路径或文件名</param>
    /// <returns>内容类型</returns>
    private static string GetContentType(string path)
    {
        var ext = Path.GetExtension(path).ToLower();
        return ext switch
        {
            ".jpg" or ".jpeg" => "image/jpeg",
            ".png" => "image/png",
            ".gif" => "image/gif",
            ".svg" => "image/svg+xml",
            ".webp" => "image/webp",
            ".mp4" => "video/mp4",
            ".webm" => "video/webm",
            ".zip" => "application/zip",
            ".rar" => "application/x-rar-compressed",
            ".apk" => "application/vnd.android.package-archive",
            ".pdf" => "application/pdf",
            ".json" => "application/json",
            ".html" => "text/html",
            _ => "application/octet-stream"
        };
    }

    /// <summary>
    /// 列出存储桶内所有对象键（分页列出，用于工厂重置清理）
    /// </summary>
    public async Task<List<string>> ListAllObjectsAsync()
    {
        var config = await GetStorageConfigAsync();
        if (config.Mode.Equals("Cos", StringComparison.OrdinalIgnoreCase))
        {
            return await ListAllCosObjectsAsync(config);
        }
        return ListAllLocalObjects(config);
    }

    /// <summary>
    /// 列出 COS 桶内所有对象（分页，每页 1000）
    /// </summary>
    private async Task<List<string>> ListAllCosObjectsAsync(StorageConfig config)
    {
        var cosXml = GetCosXml(config);
        var allKeys = new List<string>();
        string? marker = null;

        do
        {
            var request = new GetBucketRequest(config.CosBucket);
            // 不设置 prefix（空字符串会导致 COS 返回 400 Bad Request），默认列出全部对象
            if (!string.IsNullOrEmpty(marker))
            {
                request.SetMarker(marker);
            }
            request.SetMaxKeys("1000");

            var result = await Task.Run(() => cosXml.GetBucket(request));
            if (result?.listBucket == null) break;

            foreach (var content in result.listBucket.contentsList)
            {
                if (!string.IsNullOrEmpty(content.key))
                {
                    allKeys.Add(content.key);
                }
            }

            marker = result.listBucket.isTruncated ? result.listBucket.nextMarker : null;
        } while (!string.IsNullOrEmpty(marker));

        return allKeys;
    }

    /// <summary>
    /// 列出本地存储根目录下所有文件（相对路径，正斜杠分隔）
    /// </summary>
    private List<string> ListAllLocalObjects(StorageConfig config)
    {
        var uploadsRoot = Path.Combine(_env.ContentRootPath, config.LocalBasePath);
        if (!Directory.Exists(uploadsRoot)) return new List<string>();
        return Directory.GetFiles(uploadsRoot, "*", SearchOption.AllDirectories)
            .Select(p => Path.GetRelativePath(uploadsRoot, p).Replace('\\', '/'))
            .ToList();
    }

    /// <summary>
    /// 批量删除对象（每批最多 1000 个，用于工厂重置清理）
    /// </summary>
    public async Task<int> DeleteObjectsAsync(IEnumerable<string> keys)
    {
        var keyList = keys.Where(k => !string.IsNullOrEmpty(k)).ToList();
        if (keyList.Count == 0) return 0;

        var config = await GetStorageConfigAsync();
        if (config.Mode.Equals("Cos", StringComparison.OrdinalIgnoreCase))
        {
            return await DeleteMultiCosObjectsAsync(keyList, config);
        }
        return DeleteLocalObjects(keyList, config);
    }

    /// <summary>
    /// COS 批量删除（DeleteMultiObject，每批 1000）
    /// </summary>
    private async Task<int> DeleteMultiCosObjectsAsync(List<string> keys, StorageConfig config)
    {
        var cosXml = GetCosXml(config);
        var deletedCount = 0;

        foreach (var chunk in keys.Chunk(1000))
        {
            var request = new DeleteMultiObjectRequest(config.CosBucket);
            foreach (var key in chunk)
            {
                request.SetDeleteKey(key);
            }
            await Task.Run(() => cosXml.DeleteMultiObjects(request));
            deletedCount += chunk.Length;
        }

        return deletedCount;
    }

    /// <summary>
    /// 本地批量删除文件
    /// </summary>
    private int DeleteLocalObjects(List<string> keys, StorageConfig config)
    {
        var deletedCount = 0;
        foreach (var key in keys)
        {
            try
            {
                var localPath = Path.Combine(_env.ContentRootPath, config.LocalBasePath,
                    key.Replace('/', Path.DirectorySeparatorChar));
                if (File.Exists(localPath))
                {
                    File.Delete(localPath);
                    deletedCount++;
                }
            }
            catch
            {
                // 静默失败，继续删除其他文件
            }
        }
        return deletedCount;
    }

    /// <summary>
    /// 将 COS 中所有对象迁移到本地存储（用于从 COS 切换到 Local 模式后补齐旧文件）
    /// 遍历 COS 桶内所有对象，下载到本地对应的目录结构中
    /// </summary>
    /// <returns>迁移的文件数量</returns>
    public async Task<int> MigrateCosToLocalAsync()
    {
        var config = await GetStorageConfigAsync();

        // 必须有完整的 COS 配置才能迁移
        if (string.IsNullOrEmpty(config.CosSecretId) || string.IsNullOrEmpty(config.CosSecretKey)
            || string.IsNullOrEmpty(config.CosBucket) || string.IsNullOrEmpty(config.CosRegion))
        {
            throw new InvalidOperationException("COS 配置不完整，无法迁移");
        }

        // 列出 COS 中所有对象
        var cosKeys = await ListAllCosObjectsAsync(config);
        if (cosKeys.Count == 0) return 0;

        var uploadsRoot = Path.Combine(_env.ContentRootPath, config.LocalBasePath);
        if (!Directory.Exists(uploadsRoot))
            Directory.CreateDirectory(uploadsRoot);

        var migrated = 0;
        var cosXml = GetCosXml(config);

        foreach (var key in cosKeys)
        {
            // 跳过目录标记对象（以 / 结尾的空对象）
            if (key.EndsWith("/")) continue;

            // 计算本地文件路径
            var localPath = Path.Combine(uploadsRoot, key.Replace('/', Path.DirectorySeparatorChar));

            // 如果本地已存在同名文件，跳过（避免重复下载）
            if (File.Exists(localPath))
            {
                migrated++;
                continue;
            }

            try
            {
                // 从 COS 下载文件内容
                var request = new GetObjectBytesRequest(config.CosBucket, key);
                var result = await Task.Run(() => cosXml.GetObject(request));
                var bytes = result.content;

                // 确保本地目录存在
                var dir = Path.GetDirectoryName(localPath);
                if (!string.IsNullOrEmpty(dir))
                    Directory.CreateDirectory(dir);

                // 写入本地文件
                await File.WriteAllBytesAsync(localPath, bytes);
                migrated++;
            }
            catch
            {
                // 单个文件下载失败不影响整体迁移，继续下一个
            }
        }

        return migrated;
    }

    /// <summary>
    /// 迁移已有的 APK/IPA 文件扩展名
    /// COS 禁止通过默认域名分发 APK/IPA 文件（返回 DownloadForbidden 403）
    /// 将对象键从 xxx.apk 服务端复制为 xxx.apk.bin，删除旧对象，更新数据库
    /// </summary>
    public async Task<int> MigrateApkExtensionsAsync()
    {
        var config = await GetStorageConfigAsync();
        if (!config.Mode.Equals("Cos", StringComparison.OrdinalIgnoreCase))
        {
            throw new InvalidOperationException("当前非 COS 模式，无需迁移 APK 扩展名");
        }

        // 查询所有 .apk/.ipa 结尾的资源包
        var packages = await _db.ProjectPackages
            .Where(p => p.Url.EndsWith(".apk") || p.Url.EndsWith(".ipa"))
            .ToListAsync();

        if (packages.Count == 0) return 0;

        var cosXml = GetCosXml(config);
        var appid = ExtractAppid(config.CosBucket);
        int migrated = 0;

        foreach (var pkg in packages)
        {
            var oldKey = ExtractObjectKey(pkg.Url);
            var newKey = oldKey + ".bin";

            try
            {
                // 服务端复制（COS 内部操作，不受 APK 分发限制）
                var source = new CopySourceStruct(appid, config.CosBucket, config.CosRegion, oldKey);
                var copyRequest = new CopyObjectRequest(config.CosBucket, newKey);
                copyRequest.SetCopySource(source);
                await Task.Run(() => cosXml.CopyObject(copyRequest));

                // 删除旧对象
                var deleteRequest = new DeleteObjectRequest(config.CosBucket, oldKey);
                await Task.Run(() => cosXml.DeleteObject(deleteRequest));

                // 更新数据库对象键
                pkg.Url = newKey;
                migrated++;
            }
            catch (Exception ex)
            {
                // 单个文件迁移失败不影响整体，继续下一个
                Console.WriteLine($"迁移 APK 文件失败（{oldKey}）：{ex.Message}");
            }
        }

        if (migrated > 0)
        {
            await _db.SaveChangesAsync();
        }

        return migrated;
    }

    /// <summary>
    /// 存储配置内部类
    /// </summary>
    private class StorageConfig
    {
        /// <summary>存储模式：Local=本地存储，Cos=腾讯云COS</summary>
        public string Mode { get; set; } = "Cos";

        /// <summary>腾讯云COS SecretId</summary>
        public string CosSecretId { get; set; } = "";

        /// <summary>腾讯云COS SecretKey</summary>
        public string CosSecretKey { get; set; } = "";

        /// <summary>腾讯云COS 存储桶名称（格式：bucketname-APPID）</summary>
        public string CosBucket { get; set; } = "";

        /// <summary>腾讯云COS 地域（如 ap-guangzhou）</summary>
        public string CosRegion { get; set; } = "";

        /// <summary>COS临时URL有效期（分钟）</summary>
        public int CosExpireMinutes { get; set; } = 60;

        /// <summary>本地存储根目录</summary>
        public string LocalBasePath { get; set; } = "wwwroot/uploads";

        /// <summary>本地访问基础URL</summary>
        public string LocalBaseUrl { get; set; } = "/uploads";
    }
}