Notes

namespace anh_cus_dev_api01.Models
{
public class MultiDownloadRequest
{
public string SubmissionId { get; set; }

public string DocIngestionId { get; set; }

public List<AttachmentItem> Attachments { get; set; } = new();
}

public class AttachmentItem
{
public string DocId { get; set; }

public string BlobPath { get; set; }

public string FileName { get; set; }

// Classification (Email Body / Big File / etc.)
public string AttachmentType { get; set; }

public DateTime ReceivedDate { get; set; }

// 🔹 true → email row → use archive zip
public bool IsEmailRow { get; set; }

public string FolderBlobPath { get; set; }
}

public class DownloadResult
{
public Stream Stream { get; set; }
public string ContentType { get; set; }
public string FileName { get; set; }
}
}
using anh_cus_dev_api01.Models;
using Azure.Storage.Blobs;
using System.IO.Compression;


public interface IMultiDownloadService
{
Task<DownloadResult> DownloadAsync(MultiDownloadRequest request);
}

public class MultiDownloadService : IMultiDownloadService
{
private readonly BlobServiceClient _blobServiceClient;
private readonly IConfiguration _configuration;

public MultiDownloadService(
BlobServiceClient blobServiceClient,
IConfiguration configuration)
{
_blobServiceClient = blobServiceClient;
_configuration = configuration;
}

public async Task<DownloadResult> DownloadAsync(MultiDownloadRequest request)
{
var containerName = _configuration["BlobStorage:ContainerName"];
if (string.IsNullOrWhiteSpace(containerName))
throw new Exception("BlobStorage:ContainerName is missing.");

var containerClient = _blobServiceClient.GetBlobContainerClient(containerName);

if (request.Attachments == null || !request.Attachments.Any())
throw new ArgumentException("No attachments provided");


// SINGLE FILE DOWNLOAD

if (request.Attachments.Count == 1)
{
var file = request.Attachments.First();

var blobName = GetBlobNameFromUrl(file.BlobPath, containerName);
var blobClient = containerClient.GetBlobClient(blobName);

if (!await blobClient.ExistsAsync())
throw new Exception($"Blob does not exist: {blobClient.Uri}");

var stream = new MemoryStream();
await blobClient.DownloadToAsync(stream);
stream.Position = 0;

return new DownloadResult
{
Stream = stream,
ContentType = "application/octet-stream",
FileName = file.FileName
};
}

// MULTI FILE DOWNLOAD (ZIP)

var zipStream = new MemoryStream();

using (var archive = new ZipArchive(zipStream, ZipArchiveMode.Create, true))
{
var usedNamesPerFolder =
new Dictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase);

foreach (var file in request.Attachments)
{
var blobName = GetBlobNameFromUrl(file.BlobPath, containerName);
var blobClient = containerClient.GetBlobClient(blobName);

if (!await blobClient.ExistsAsync())
continue;

// ✅ Folder = AttachmentType
var folderName = !string.IsNullOrWhiteSpace(file.AttachmentType)
? SanitizeFolderName(file.AttachmentType)
: "Others";

if (!usedNamesPerFolder.ContainsKey(folderName))
usedNamesPerFolder[folderName] =
new HashSet<string>(StringComparer.OrdinalIgnoreCase);

var usedNames = usedNamesPerFolder[folderName];

var safeFileName = ResolveDuplicateName(file.FileName, usedNames);

var zipEntryPath = $"{folderName}/{safeFileName}";

var entry = archive.CreateEntry(zipEntryPath);
using var entryStream = entry.Open();
await blobClient.DownloadToAsync(entryStream);
}
}

zipStream.Position = 0;

return new DownloadResult
{
Stream = zipStream,
ContentType = "application/zip",

// ZIP name = AppId + Timestamp
FileName = $"Base AppID {request.DocIngestionId} {DateTime.UtcNow:yyyyMMdd HHmm}.zip"
};
}

private string SanitizeFolderName(string folderName)
{
foreach (var invalidChar in Path.GetInvalidFileNameChars())
{
folderName = folderName.Replace(invalidChar, '_');
}

return folderName.Trim();
}

private string GetBlobNameFromUrl(string blobUrl, string containerName)
{
var uri = new Uri(blobUrl);

var prefix = $"/{containerName}/";

if (!uri.AbsolutePath.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
throw new Exception($"Blob URL does not match container: {blobUrl}");

var blobPath = uri.AbsolutePath.Substring(prefix.Length);

blobPath = Uri.UnescapeDataString(blobPath);

return blobPath;
}

// Resolve duplicate file names in zip
private string ResolveDuplicateName(string fileName, HashSet<string> usedNames)
{
var originalName = fileName;
var counter = 1;

while (usedNames.Contains(fileName))
{
var name = Path.GetFileNameWithoutExtension(originalName);
var ext = Path.GetExtension(originalName);
fileName = $"{name}_{counter++}{ext}";
}

usedNames.Add(fileName);
return fileName;
}
}