AnkiJsonSerializer.cs

using System.Text.Json;
using System.Text.Json.Serialization;
 
namespace AnkiIO;

public static class AnkiJsonSerializer
{
    private const string CurrentGeneratorName = "AnkiIO/1.0";

    public const int CurrentFormatVersion = 1;
 
    private static readonly JsonSerializerOptions Options = new()
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        WriteIndented = true,
        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    };

    public static string Serialize(AnkiDeck deck)
    {
        ArgumentNullException.ThrowIfNull(deck);
        EnsureValid(deck);
        return JsonSerializer.Serialize(ToDocument(deck), Options) + "\n";
    }

    public static AnkiDeck Deserialize(string json)
    {
        ArgumentNullException.ThrowIfNull(json);
        var document = JsonSerializer.Deserialize<NativeDocument>(json, Options) ?? throw new JsonException("The JSON document was empty.");
        return FromDocument(document);
    }

    public static async Task WriteAsync(AnkiDeck deck, Stream destination, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(destination);
        EnsureValid(deck);
        await JsonSerializer.SerializeAsync(destination, ToDocument(deck), Options, cancellationToken).ConfigureAwait(false);
    }

    public static async Task<AnkiDeck> ReadAsync(Stream source, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(source);
        var document = await JsonSerializer.DeserializeAsync<NativeDocument>(source, Options, cancellationToken).ConfigureAwait(false) ?? throw new JsonException("The JSON document was empty.");
        return FromDocument(document);
    }
 
    private static AnkiDeck FromDocument(NativeDocument document)
    {
        if (document.FormatVersion != CurrentFormatVersion)
        {
            throw new JsonException($"Unsupported AnkiIO JSON format version {document.FormatVersion}; expected {CurrentFormatVersion}.");
        }
 
        var serializedTypes = document.NoteTypes ?? throw new JsonException("The noteTypes collection cannot be null.");
        var types = serializedTypes.ToDictionary(
            value => (value ?? throw new JsonException("The noteTypes collection contains a null entry.")).Id,
            value => FromDto(value!));
        var deck = FromDto(document.Deck ?? throw new JsonException("The root deck is missing."), types);
        EnsureValid(deck);
        return deck;
    }
 
    private static NativeDocument ToDocument(AnkiDeck deck)
    {
        var types = deck.Traverse().SelectMany(value => value.Notes).Select(note => note.NoteType).GroupBy(type => type.Id).Select(group => group.First()).OrderBy(type => type.Id).Select(ToDto).ToList();
        return new NativeDocument { FormatVersion = CurrentFormatVersion, Generator = CurrentGeneratorName, NoteTypes = types, Deck = ToDto(deck) };
    }
 
    private static NoteTypeDto ToDto(AnkiNoteType value) => new()
    {
        Id = value.Id,
        Name = value.Name,
        Kind = value.Kind,
        Css = value.Css,
        Fields = value.Fields.ToList(),
        Templates = value.Templates.ToList(),
    };
 
    private static DeckDto ToDto(AnkiDeck value) => new()
    {
        Id = value.Id,
        Name = value.Name,
        Description = value.Description,
        Metadata = new SortedDictionary<string, string>(value.Metadata, StringComparer.Ordinal),
        Notes = value.Notes.OrderBy(note => note.Id).Select(ToDto).ToList(),
        Subdecks = value.Subdecks.OrderBy(deck => deck.Name, StringComparer.Ordinal).ThenBy(deck => deck.Id).Select(ToDto).ToList(),
        ExtensionData = value.UnknownData.Count == 0 ? null : new SortedDictionary<string, JsonElement>(value.UnknownData, StringComparer.Ordinal),
    };
 
    private static NoteDto ToDto(AnkiNote value) => new()
    {
        Id = value.Id,
        Guid = value.Guid,
        NoteTypeId = value.NoteType.Id,
        Fields = value.NoteType.Fields.Select(field => value.Fields[field.Name]).ToList(),
        Tags = value.Tags.Order(StringComparer.Ordinal).ToList(),
        Cards = value.Cards.OrderBy(card => card.TemplateOrdinal).Select(card => new CardDto
        {
            Id = card.Id,
            DeckId = card.DeckId,
            TemplateOrdinal = card.TemplateOrdinal,
            Flag = card.Flag,
            Scheduling = card.Scheduling,
            ReviewHistory = card.ReviewHistory.OrderBy(review => review.Id).ToList(),
        }).ToList(),
    };
 
    private static AnkiNoteType FromDto(NoteTypeDto value)
    {
        var type = new AnkiNoteType(value.Name, value.Kind, value.Id) { Css = value.Css };
        foreach (var field in value.Fields ?? throw new JsonException($"Note type {value.Id} has a null fields collection."))
        {
            type.AddConfiguredField(field ?? throw new JsonException($"Note type {value.Id} contains a null field definition."));
        }
 
        foreach (var template in value.Templates ?? throw new JsonException($"Note type {value.Id} has a null templates collection."))
        {
            type.AddConfiguredTemplate(template ?? throw new JsonException($"Note type {value.Id} contains a null template definition."));
        }
 
        return type;
    }
 
    private static AnkiDeck FromDto(DeckDto value, IReadOnlyDictionary<long, AnkiNoteType> noteTypes)
    {
        var deck = new AnkiDeck(value.Name, value.Id) { Description = value.Description };
        foreach (var pair in value.Metadata ?? throw new JsonException($"Deck {value.Id} has a null metadata object."))
        {
            deck.Metadata.Add(pair.Key, pair.Value ?? throw new JsonException($"Deck {value.Id} metadata '{pair.Key}' has a null value."));
        }
 
        if (value.ExtensionData is not null)
        {
            foreach (var pair in value.ExtensionData)
            {
                deck.UnknownData[pair.Key] = pair.Value.Clone();
            }
        }
 
        foreach (var valueNote in value.Notes ?? throw new JsonException($"Deck {value.Id} has a null notes collection."))
        {
            if (valueNote is null)
            {
                throw new JsonException($"Deck {value.Id} contains a null note.");
            }
 
            if (!noteTypes.TryGetValue(valueNote.NoteTypeId, out var type))
            {
                throw new JsonException($"Note {valueNote.Id} references missing note type {valueNote.NoteTypeId}.");
            }
 
            var serializedFields = valueNote.Fields ?? throw new JsonException($"Note {valueNote.Id} has a null fields collection.");
            if (serializedFields.Count != type.Fields.Count)
            {
                throw new JsonException($"Note {valueNote.Id} has {serializedFields.Count} fields; note type {type.Id} requires {type.Fields.Count}.");
            }
 
            var fields = type.Fields.Select((field, index) => (field.Name, Value: serializedFields[index] ?? throw new JsonException($"Note {valueNote.Id} contains a null value for field '{field.Name}'."))).ToDictionary(pair => pair.Name, pair => pair.Value, StringComparer.Ordinal);
            var tags = valueNote.Tags ?? throw new JsonException($"Note {valueNote.Id} has a null tags collection.");
            if (tags.Any(tag => tag is null))
            {
                throw new JsonException($"Note {valueNote.Id} contains a null tag.");
            }
 
            var note = deck.AddNote(type, fields, tags, valueNote.Guid, valueNote.Id);
            var cards = valueNote.Cards ?? throw new JsonException($"Note {valueNote.Id} has a null cards collection.");
            note.RestoreCards(cards.Select(cardValue =>
            {
                var card = cardValue ?? throw new JsonException($"Note {valueNote.Id} contains a null card.");
                var scheduling = card.Scheduling ?? throw new JsonException($"Card {card.Id} has a null scheduling object.");
                var restored = new AnkiCard(card.Id, valueNote.Id, card.DeckId, card.TemplateOrdinal, scheduling) { Flag = card.Flag };
                foreach (var review in card.ReviewHistory ?? throw new JsonException($"Card {card.Id} has a null reviewHistory collection."))
                {
                    restored.ReviewHistory.Add(review ?? throw new JsonException($"Card {card.Id} contains a null review-history entry."));
                }
 
                return restored;
            }));
        }
 
        foreach (var child in value.Subdecks ?? throw new JsonException($"Deck {value.Id} has a null subdecks collection."))
        {
            deck.AddExistingSubdeck(FromDto(child ?? throw new JsonException($"Deck {value.Id} contains a null subdeck."), noteTypes));
        }
 
        return deck;
    }
 
    private static void EnsureValid(AnkiDeck deck)
    {
        var result = AnkiValidator.Validate(deck);
        if (!result.IsValid)
        {
            throw new AnkiValidationException(result);
        }
    }
 
}