/// <summary>
/// 大文件分片上傳客戶端（使用 HttpClient）
/// </summary>
public class ChunkUploader
{
    private static readonly HttpClient _httpClient = new HttpClient();
    private const int CHUNK_SIZE = 5 * 1024 * 1024; // 5MB 每片
    private const string UPLOAD_URL = "https://localhost:5001/api/upload/chunk";
    private const string MERGE_URL = "https://localhost:5001/api/upload/merge";

    public async Task<bool> UploadLargeFileAsync(string filePath, string fileId)
    {
        using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, 
                                                FileShare.Read, 81920, FileOptions.Asynchronous);
        long fileSize = fileStream.Length;
        int totalChunks = (int)Math.Ceiling((double)fileSize / CHUNK_SIZE);
        
        // 1. 查詢服務(wù)端已上傳的分片（斷點續(xù)傳）
        var uploadedChunks = await GetUploadedChunksAsync(fileId);
        
        for (int chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++)
        {
            if (uploadedChunks.Contains(chunkIndex)) continue; // 跳過已上傳的分片
            
            // 2. 讀取分片數(shù)據(jù)
            int offset = chunkIndex * CHUNK_SIZE;
            int currentChunkSize = (int)Math.Min(CHUNK_SIZE, fileSize - offset);
            byte[] chunkData = new byte[currentChunkSize];
            
            fileStream.Seek(offset, SeekOrigin.Begin);
            await fileStream.ReadAsync(chunkData, 0, currentChunkSize);
            
            // 3. 計算當(dāng)前分片的哈希值（用于完整性校驗）
            string chunkHash = ComputeSha256Hash(chunkData);
            
            // 4. 上傳分片
            bool success = await UploadChunkAsync(fileId, chunkIndex, totalChunks, 
                                                    chunkData, chunkHash);
            if (!success)
            {
                // 失敗重試（帶指數(shù)退避）
                success = await RetryUploadAsync(fileId, chunkIndex, totalChunks, chunkData, chunkHash);
                if (!success) return false;
            }
        }
        
        // 5. 所有分片上傳完成，觸發(fā)合并
        return await MergeChunksAsync(fileId, Path.GetFileName(filePath), fileSize);
    }
    
    private async Task<bool> UploadChunkAsync(string fileId, int chunkIndex, int totalChunks, 
                                                byte[] chunkData, string chunkHash)
    {
        using var content = new MultipartFormDataContent();
        content.Add(new ByteArrayContent(chunkData), "file", $"chunk_{chunkIndex}");
        content.Add(new StringContent(fileId), "fileId");
        content.Add(new StringContent(chunkIndex.ToString()), "chunkIndex");
        content.Add(new StringContent(totalChunks.ToString()), "totalChunks");
        content.Add(new StringContent(chunkHash), "chunkHash");
        
        var response = await _httpClient.PostAsync(UPLOAD_URL, content);
        return response.IsSuccessStatusCode;
    }
    
    private async Task<HashSet<int>> GetUploadedChunksAsync(string fileId)
    {
        var response = await _httpClient.GetAsync($"{UPLOAD_URL}/status?fileId={fileId}");
        if (!response.IsSuccessStatusCode) return new HashSet<int>();
        
        var json = await response.Content.ReadAsStringAsync();
        var uploaded = JsonSerializer.Deserialize<List<int>>(json);
        return new HashSet<int>(uploaded ?? new List<int>());
    }
    
    private async Task<bool> MergeChunksAsync(string fileId, string fileName, long fileSize)
    {
        var mergeData = new { fileId, fileName, fileSize };
        var content = new StringContent(JsonSerializer.Serialize(mergeData), 
                                        Encoding.UTF8, "application/json");
        var response = await _httpClient.PostAsync(MERGE_URL, content);
        return response.IsSuccessStatusCode;
    }
    
    private static string ComputeSha256Hash(byte[] data)
    {
        using var sha256 = SHA256.Create();
        byte[] hash = sha256.ComputeHash(data);
        return Convert.ToHexString(hash).ToLowerInvariant();
    }
}

var builder = WebApplication.CreateBuilder(args);

// 禁用默認(rèn)請求體大小限制（兩層都要配置）
builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxRequestBodySize = long.MaxValue; // 禁用 Kestrel 層限制
});

builder.Services.Configure<FormOptions>(options =>
{
    options.MultipartBodyLengthLimit = long.MaxValue; // 禁用 MVC 層限制
});

var app = builder.Build();

[ApiController]
[Route("api/[controller]")]
[DisableRequestSizeLimit] // 禁用請求大小限制
public class UploadController : ControllerBase
{
    private readonly IUploadService _uploadService;
    
    public UploadController(IUploadService uploadService)
    {
        _uploadService = uploadService;
    }
    
    /// <summary>
    /// 上傳單個分片（繞過 IFormFile，避免 OOM）
    /// </summary>
    [HttpPost("chunk")]
    public async Task<IActionResult> UploadChunk([FromForm] ChunkUploadRequest request)
    {
        // 驗證參數(shù)
        if (string.IsNullOrEmpty(request.FileId) || request.ChunkIndex < 0)
            return BadRequest("Invalid parameters");
        
        // 驗證分片哈希
        using var ms = new MemoryStream();
        await request.File.CopyToAsync(ms);
        byte[] chunkData = ms.ToArray();
        string computedHash = ComputeSha256Hash(chunkData);
        
        if (!computedHash.Equals(request.ChunkHash, StringComparison.OrdinalIgnoreCase))
            return BadRequest("Chunk hash mismatch");
        
        // 冪等保存：如果已存在則直接返回成功
        bool saved = await _uploadService.SaveChunkAsync(request.FileId, request.ChunkIndex, 
                                                          chunkData, request.ChunkHash);
        if (!saved)
            return Conflict(new { message = "Chunk already exists", index = request.ChunkIndex });
        
        return Ok(new { success = true, index = request.ChunkIndex });
    }
    
    /// <summary>
    /// 查詢已上傳的分片索引（斷點續(xù)傳核心）
    /// </summary>
    [HttpGet("chunk/status")]
    public async Task<IActionResult> GetUploadedChunks([FromQuery] string fileId)
    {
        var uploadedChunks = await _uploadService.GetUploadedChunkIndicesAsync(fileId);
        return Ok(uploadedChunks);
    }
    
    /// <summary>
    /// 合并所有分片
    /// </summary>
    [HttpPost("merge")]
    public async Task<IActionResult> MergeChunks([FromBody] MergeRequest request)
    {
        // 加鎖防止并發(fā)合并
        bool merged = await _uploadService.MergeChunksAsync(request.FileId, request.FileName);
        if (!merged)
            return Conflict(new { message = "Merge failed or already in progress" });
        
        return Ok(new { success = true, filePath = $"/uploads/{request.FileName}" });
    }
}

public class ChunkUploadRequest
{
    public string FileId { get; set; }
    public int ChunkIndex { get; set; }
    public int TotalChunks { get; set; }
    public string ChunkHash { get; set; }
    public IFormFile File { get; set; }
}

public class MergeRequest
{
    public string FileId { get; set; }
    public string FileName { get; set; }
    public long FileSize { get; set; }
}

/// <summary>
/// 安全合并分片（使用 Seek 定位寫入，避免內(nèi)存溢出）
/// </summary>
public async Task<bool> MergeChunksAsync(string fileId, string finalFileName)
{
    var chunks = await GetChunksOrderedAsync(fileId);
    if (chunks.Count == 0) return false;
    
    // 檢查是否所有分片都已到達(dá)
    int totalChunks = await GetTotalChunksCountAsync(fileId);
    if (chunks.Count != totalChunks) return false;
    
    string tempDir = Path.Combine(_config["Storage:ChunkPath"], fileId);
    string finalPath = Path.Combine(_config["Storage:FinalPath"], finalFileName);
    
    // 使用 FileStream 配合 Seek 定位寫入，而非全量加載
    using var finalStream = new FileStream(finalPath, FileMode.Create, FileAccess.Write, 
                                           FileShare.None, 81920, useAsync: true);
    
    int chunkSize = _config.GetValue<int>("ChunkSize", 5 * 1024 * 1024);
    
    foreach (var chunk in chunks)
    {
        long offset = chunk.ChunkIndex * (long)chunkSize;
        finalStream.Seek(offset, SeekOrigin.Begin);
        
        string chunkPath = Path.Combine(tempDir, $"{fileId}_{chunk.ChunkIndex}.tmp");
        using var chunkStream = new FileStream(chunkPath, FileMode.Open, FileAccess.Read);
        await chunkStream.CopyToAsync(finalStream);
    }
    
    await finalStream.FlushAsync();
    
    // 合并完成后校驗全文件哈希（可選）
    string finalHash = await ComputeFileSha256Async(finalPath);
    if (!finalHash.Equals(await GetExpectedFileHashAsync(fileId), StringComparison.OrdinalIgnoreCase))
    {
        File.Delete(finalPath);
        return false;
    }
    
    // 清理臨時分片文件和目錄
    foreach (var chunk in chunks)
    {
        File.Delete(Path.Combine(tempDir, $"{fileId}_{chunk.ChunkIndex}.tmp"));
    }
    Directory.Delete(tempDir);
    
    return true;
}

// 使用 SemaphoreSlim 控制最大并發(fā)數(shù)
private static readonly SemaphoreSlim _semaphore = new SemaphoreSlim(3); // 最多 3 個并發(fā)

public async Task UploadWithConcurrencyAsync(string filePath, string fileId, int totalChunks)
{
    var tasks = new List<Task>();
    
    for (int chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++)
    {
        await _semaphore.WaitAsync();
        int index = chunkIndex; // 捕獲變量
        
        tasks.Add(Task.Run(async () =>
        {
            try
            {
                await UploadSingleChunkAsync(filePath, fileId, index, totalChunks);
            }
            finally
            {
                _semaphore.Release();
            }
        }));
    }
    
    await Task.WhenAll(tasks);
}