AnkiPackageWriter.cs

using System.IO.Compression;
using System.Security.Cryptography;
using System.Text.Json;
 
namespace AnkiIO;

public static class AnkiPackageWriter
{
    public static async Task WriteAsync(AnkiDeck deck, string path, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(deck);
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        var plan = CreateWritePlan([deck], packageMedia: null);
        await WritePathAsync(plan, path, cancellationToken).ConfigureAwait(false);
    }

    public static async Task WriteAsync(AnkiPackage package, string path, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(package);
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        var plan = CreatePackageWritePlan(package);
        await WritePathAsync(plan, path, cancellationToken).ConfigureAwait(false);
    }

    public static async Task WriteAsync(AnkiDeck deck, Stream destination, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(deck);
        ArgumentNullException.ThrowIfNull(destination);
        EnsureWritable(destination);
        var plan = CreateWritePlan([deck], packageMedia: null);
        await WriteArchiveAsync(plan, destination, cancellationToken).ConfigureAwait(false);
    }

    public static async Task WriteAsync(AnkiPackage package, Stream destination, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(package);
        ArgumentNullException.ThrowIfNull(destination);
        EnsureWritable(destination);
        var plan = CreatePackageWritePlan(package);
        await WriteArchiveAsync(plan, destination, cancellationToken).ConfigureAwait(false);
    }
 
    private static AnkiPackageWritePlan CreatePackageWritePlan(AnkiPackage package)
    {
        var roots = package.Decks.ToArray();
        if (roots.Length == 0)
        {
            throw new ArgumentException("A package must contain at least one top-level deck.", nameof(package));
        }
 
        return CreateWritePlan(roots, package.Media.Files);
    }
 
    private static AnkiPackageWritePlan CreateWritePlan(IReadOnlyList<AnkiDeck> roots, IEnumerable<AnkiMediaFile>? packageMedia)
    {
        var validation = AnkiValidator.Validate(roots);
        if (!validation.IsValid)
        {
            throw new AnkiValidationException(validation);
        }
 
        var mediaByName = new Dictionary<string, AnkiMediaFile>(StringComparer.Ordinal);
        if (packageMedia is not null)
        {
            foreach (var media in packageMedia)
            {
                AddMedia(mediaByName, media);
            }
        }
 
        foreach (var media in roots.SelectMany(root => root.Traverse()).SelectMany(deck => deck.Media.Files))
        {
            AddMedia(mediaByName, media);
        }
 
        return new AnkiPackageWritePlan(roots, mediaByName.Values.OrderBy(media => media.FileName, StringComparer.Ordinal).ToArray());
    }
 
    private static void AddMedia(Dictionary<string, AnkiMediaFile> mediaByName, AnkiMediaFile media)
    {
        if (!mediaByName.TryGetValue(media.FileName, out var existing))
        {
            mediaByName.Add(media.FileName, media);
            return;
        }
 
        if (existing.Length != media.Length || !string.Equals(existing.Sha256, media.Sha256, StringComparison.Ordinal))
        {
            throw new InvalidOperationException($"Media filename '{media.FileName}' is registered with conflicting content.");
        }
    }
 
    private static void EnsureWritable(Stream destination)
    {
        if (!destination.CanWrite)
        {
            throw new ArgumentException("Package output must be writable.", nameof(destination));
        }
    }
 
    private static async Task WritePathAsync(AnkiPackageWritePlan plan, string path, CancellationToken cancellationToken)
    {
        var destinationPath = Path.GetFullPath(path);
        var destinationDirectory = Path.GetDirectoryName(destinationPath) ?? Directory.GetCurrentDirectory();
        var temporaryPath = Path.Combine(destinationDirectory, ".AnkiIO-write-" + Guid.NewGuid().ToString("N") + ".tmp");
        var committed = false;
        try
        {
            await using (var stream = new FileStream(temporaryPath, FileMode.CreateNew, FileAccess.Write, FileShare.None, 81920, FileOptions.Asynchronous | FileOptions.SequentialScan))
            {
                await WriteArchiveAsync(plan, stream, cancellationToken).ConfigureAwait(false);
                await stream.FlushAsync(cancellationToken).ConfigureAwait(false);
            }
 
            cancellationToken.ThrowIfCancellationRequested();
            File.Move(temporaryPath, destinationPath, overwrite: true);
            committed = true;
        }
        finally
        {
            if (!committed && File.Exists(temporaryPath))
            {
                File.Delete(temporaryPath);
            }
        }
    }
 
    private static async Task WriteArchiveAsync(AnkiPackageWritePlan plan, Stream destination, CancellationToken cancellationToken)
    {
        var tempDirectory = Path.Combine(Path.GetTempPath(), "AnkiIO-write-" + Guid.NewGuid().ToString("N"));
        Directory.CreateDirectory(tempDirectory);
        try
        {
            var databasePath = Path.Combine(tempDirectory, "collection.anki2");
            await LegacyCollectionDatabase.WriteAsync(databasePath, plan.Roots, cancellationToken).ConfigureAwait(false);
            using var archive = new ZipArchive(destination, ZipArchiveMode.Create, leaveOpen: true);
            var collectionEntry = archive.CreateEntry("collection.anki2", CompressionLevel.Optimal);
            await using (var entryStream = collectionEntry.Open())
            await using (var database = new FileStream(databasePath, FileMode.Open, FileAccess.Read, FileShare.Read, 81920, FileOptions.Asynchronous | FileOptions.SequentialScan))
            {
                await database.CopyToAsync(entryStream, cancellationToken).ConfigureAwait(false);
            }
 
            var map = new SortedDictionary<string, string>(StringComparer.Ordinal);
            for (var index = 0; index < plan.Media.Count; index++)
            {
                cancellationToken.ThrowIfCancellationRequested();
                var item = plan.Media[index];
                var entryName = index.ToString(System.Globalization.CultureInfo.InvariantCulture);
                map.Add(entryName, item.FileName);
                var entry = archive.CreateEntry(entryName, CompressionLevel.Optimal);
                await using var destinationMedia = entry.Open();
                await using var sourceMedia = await item.OpenReadAsync(cancellationToken).ConfigureAwait(false);
                using var hasher = IncrementalHash.CreateHash(HashAlgorithmName.SHA256);
                var buffer = new byte[81920];
                int read;
                while ((read = await sourceMedia.ReadAsync(buffer, cancellationToken).ConfigureAwait(false)) > 0)
                {
                    hasher.AppendData(buffer, 0, read);
                    await destinationMedia.WriteAsync(buffer.AsMemory(0, read), cancellationToken).ConfigureAwait(false);
                }
 
                var actual = Convert.ToHexString(hasher.GetHashAndReset()).ToLowerInvariant();
                if (!string.Equals(actual, item.Sha256, StringComparison.Ordinal))
                {
                    throw new InvalidDataException($"Media '{item.FileName}' changed after registration; expected SHA-256 {item.Sha256}, got {actual}.");
                }
            }
 
            var mediaEntry = archive.CreateEntry("media", CompressionLevel.Optimal);
            await using var mediaStream = mediaEntry.Open();
            await JsonSerializer.SerializeAsync(mediaStream, map, cancellationToken: cancellationToken).ConfigureAwait(false);
        }
        finally
        {
            if (Directory.Exists(tempDirectory))
            {
                Directory.Delete(tempDirectory, recursive: true);
            }
        }
    }
 
}