AnkiMediaCollection.cs

using System.Security.Cryptography;
 
namespace AnkiIO;

public sealed class AnkiMediaCollection
{
    private readonly Dictionary<string, AnkiMediaFile> files = new(StringComparer.Ordinal);

    public AnkiMediaCollection()
    {
    }

    public IReadOnlyCollection<AnkiMediaFile> Files => Array.AsReadOnly(files.Values.OrderBy(file => file.FileName, StringComparer.Ordinal).ToArray());

    public async Task<AnkiMediaFile> AddFileAsync(string path, CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        var fullPath = Path.GetFullPath(path);
        var name = Path.GetFileName(fullPath);
        ValidateFileName(name);
 
        await using var stream = new FileStream(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read, 81920, FileOptions.Asynchronous | FileOptions.SequentialScan);
        var hash = Convert.ToHexString(await SHA256.HashDataAsync(stream, cancellationToken).ConfigureAwait(false)).ToLowerInvariant();
        var media = new AnkiMediaFile(name, stream.Length, hash, token =>
        {
            token.ThrowIfCancellationRequested();
            return ValueTask.FromResult<Stream>(new FileStream(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read, 81920, FileOptions.Asynchronous | FileOptions.SequentialScan));
        });
        return AddChecked(media);
    }

    public AnkiMediaFile AddBytes(string fileName, ReadOnlySpan<byte> content)
    {
        ValidateFileName(fileName);
        var bytes = content.ToArray();
        var hash = Convert.ToHexString(SHA256.HashData(bytes)).ToLowerInvariant();
        var media = new AnkiMediaFile(fileName, bytes.LongLength, hash, token =>
        {
            token.ThrowIfCancellationRequested();
            return ValueTask.FromResult<Stream>(new MemoryStream(bytes, writable: false));
        });
        return AddChecked(media);
    }

    public bool Remove(string fileName) => files.Remove(fileName);
 
    internal static void ValidateFileName(string fileName)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(fileName);
        if (Path.IsPathRooted(fileName)
            || fileName is "." or ".."
            || fileName.EndsWith(' ')
            || fileName.EndsWith('.')
            || fileName.Any(character => char.IsControl(character) || "<>:\"/\\|?*".Contains(character, StringComparison.Ordinal))
            || fileName.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0
            || IsWindowsReservedName(fileName))
        {
            throw new ArgumentException("Media names must be portable simple filenames without reserved names, path separators, control characters, or trailing spaces and periods.", nameof(fileName));
        }
    }
 
    private static bool IsWindowsReservedName(string fileName)
    {
        var period = fileName.IndexOf('.');
        var stem = period < 0 ? fileName : fileName[..period];
        if (stem.Equals("CON", StringComparison.OrdinalIgnoreCase)
            || stem.Equals("PRN", StringComparison.OrdinalIgnoreCase)
            || stem.Equals("AUX", StringComparison.OrdinalIgnoreCase)
            || stem.Equals("NUL", StringComparison.OrdinalIgnoreCase))
        {
            return true;
        }
 
        return stem.Length == 4
            && (stem.StartsWith("COM", StringComparison.OrdinalIgnoreCase) || stem.StartsWith("LPT", StringComparison.OrdinalIgnoreCase))
            && stem[3] is >= '1' and <= '9';
    }
 
    private AnkiMediaFile AddChecked(AnkiMediaFile media)
    {
        if (files.TryGetValue(media.FileName, out var existing))
        {
            if (!string.Equals(existing.Sha256, media.Sha256, StringComparison.Ordinal))
            {
                throw new InvalidOperationException($"Media filename '{media.FileName}' has colliding content.");
            }
 
            return existing;
        }
 
        files.Add(media.FileName, media);
        return media;
    }
}