Notes

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()) &&
(request.Emails == null || !request.Emails.Any()))
throw new ArgumentException("No files provided");

// SINGLE FILE DOWNLOAD (attachments only, no emails)
if (request.Attachments?.Count == 1 && (request.Emails == null || !request.Emails.Any()))
{
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);

// 🔹 ADD EMAILS AND THEIR ATTACHMENTS
if (request.Emails != null)
{
if (!usedNamesPerFolder.ContainsKey("ROOT"))
usedNamesPerFolder["ROOT"] = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

foreach (var email in request.Emails)
{
// Add email body (eml or html) at ROOT
if (!string.IsNullOrWhiteSpace(email.EmlLocation))
{
var emailBlobName = GetBlobNameFromUrl(email.EmlLocation, containerName);
var emailBlobClient = containerClient.GetBlobClient(emailBlobName);

if (await emailBlobClient.ExistsAsync())
{
var emailFileName = Path.GetFileName(emailBlobName);
var safeEmailName = ResolveDuplicateName(emailFileName, usedNamesPerFolder["ROOT"]);

var entry = archive.CreateEntry(safeEmailName);
using var entryStream = entry.Open();
await emailBlobClient.DownloadToAsync(entryStream);
}
}

// Add attachments for this email
if (email.Attachments != null)
{
foreach (var file in email.Attachments)
{
var blobName = GetBlobNameFromUrl(file.BlobPath, containerName);
var blobClient = containerClient.GetBlobClient(blobName);

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

var folderName = !string.IsNullOrWhiteSpace(file.Classification)
? SanitizeFolderName(file.Classification)
: "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);
}
}
}
}

// 🔹 ADD ATTACHMENTS NOT LINKED TO EMAILS
if (request.Attachments != null)
{
foreach (var file in request.Attachments)
{
var blobName = GetBlobNameFromUrl(file.BlobPath, containerName);
var blobClient = containerClient.GetBlobClient(blobName);

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

var folderName = !string.IsNullOrWhiteSpace(file.Classification)
? SanitizeFolderName(file.Classification)
: "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;

// ZIP NAME FORMAT
var accountName20 = GetFirst20Characters(request.GroupName);
var timeStamp = DateTime.Now.ToString("yyyyMMdd HHmm");
var zipFileName = $"{accountName20} {request.DocIngestionId} {timeStamp}.zip";

return new DownloadResult
{
Stream = zipStream,
ContentType = "application/zip",
FileName = zipFileName
};
}
private string GetFirst20Characters(string input)
{
if (string.IsNullOrWhiteSpace(input))
return "";

input = input.Trim();

return input.Length <= 20
? input
: input.Substring(0, 20);
}

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;
}
}