AnkiNote.cs

using System.Collections.ObjectModel;
using System.Text.RegularExpressions;
 
namespace AnkiIO;

public sealed partial class AnkiNote
{
    private readonly Dictionary<string, string> fields;
    private readonly HashSet<string> tags;
    private readonly List<AnkiCard> cards = [];
    private readonly ReadOnlyDictionary<string, string> fieldsView;
    private readonly ReadOnlyCollection<AnkiCard> cardsView;
    private long? generatedDeckId;
    private bool cardsHaveBeenGenerated;

    public AnkiNote(AnkiNoteType noteType, IReadOnlyDictionary<string, string> fields, IEnumerable<string>? tags = null, long? id = null, string? guid = null)
    {
        ArgumentNullException.ThrowIfNull(noteType);
        ArgumentNullException.ThrowIfNull(fields);
        Id = id ?? AnkiId.New();
        Guid = string.IsNullOrWhiteSpace(guid) ? System.Guid.NewGuid().ToString("N")[..10] : guid;
        this.fields = new Dictionary<string, string>(StringComparer.Ordinal);
        foreach (var field in noteType.Fields)
        {
            this.fields[field.Name] = fields.TryGetValue(field.Name, out var value) ? value : string.Empty;
        }
 
        var unknown = fields.Keys.FirstOrDefault(key => !this.fields.ContainsKey(key));
        if (unknown is not null)
        {
            throw new ArgumentException($"Field '{unknown}' is not defined by note type '{noteType.Name}'.", nameof(fields));
        }
 
        this.tags = new HashSet<string>(StringComparer.Ordinal);
        foreach (var tag in tags ?? [])
        {
            ValidateTag(tag, nameof(tags));
            this.tags.Add(tag);
        }
 
        fieldsView = new ReadOnlyDictionary<string, string>(this.fields);
        cardsView = cards.AsReadOnly();
        NoteType = noteType;
        noteType.Freeze();
    }

    public long Id { get; }

    public string Guid { get; }

    public AnkiNoteType NoteType { get; }

    public IReadOnlyDictionary<string, string> Fields => fieldsView;

    public IReadOnlyCollection<string> Tags => Array.AsReadOnly(tags.Order(StringComparer.Ordinal).ToArray());

    public IReadOnlyList<AnkiCard> Cards => cardsView;

    public void SetField(string name, string value)
    {
        ArgumentNullException.ThrowIfNull(value);
        if (!fields.ContainsKey(name))
        {
            throw new ArgumentException($"Field '{name}' is not defined by note type '{NoteType.Name}'.", nameof(name));
        }
 
        int[]? clozeOrdinals = null;
        if (cardsHaveBeenGenerated
            && NoteType.Kind == AnkiNoteTypeKind.Cloze
            && string.Equals(name, "Text", StringComparison.Ordinal))
        {
            clozeOrdinals = GetClozeOrdinals(value, nameof(value));
        }
 
        fields[name] = value;
        if (clozeOrdinals is not null)
        {
            ReconcileClozeCards(clozeOrdinals, generatedDeckId ?? throw new InvalidOperationException("The generated note is not associated with a deck."));
        }
    }

    public void AddTag(string tag)
    {
        ValidateTag(tag, nameof(tag));
        tags.Add(tag);
    }

    public bool RemoveTag(string tag) => tags.Remove(tag);
 
    internal void GenerateCards(long deckId, string invalidClozeParameterName)
    {
        if (NoteType.Kind == AnkiNoteTypeKind.Cloze)
        {
            fields.TryGetValue("Text", out var text);
            var ordinals = GetClozeOrdinals(text ?? string.Empty, invalidClozeParameterName);
            cards.Clear();
            cards.AddRange(ordinals.Select(ordinal => CreateNewCard(deckId, ordinal)));
            generatedDeckId = deckId;
            cardsHaveBeenGenerated = true;
            return;
        }
 
        cards.Clear();
        for (var ordinal = 0; ordinal < NoteType.Templates.Count; ordinal++)
        {
            cards.Add(CreateNewCard(deckId, ordinal));
        }
 
        generatedDeckId = deckId;
        cardsHaveBeenGenerated = true;
    }
 
    internal void RestoreCards(IEnumerable<AnkiCard> restored)
    {
        ArgumentNullException.ThrowIfNull(restored);
        var restoredCards = restored.ToArray();
        cards.Clear();
        cards.AddRange(restoredCards);
        generatedDeckId ??= restoredCards.FirstOrDefault()?.DeckId;
        cardsHaveBeenGenerated = true;
    }
 
    internal void AttachToDeck(long deckId) => generatedDeckId ??= deckId;
 
    private static int[] GetClozeOrdinals(string text, string invalidClozeParameterName) => ClozePattern().Matches(text)
        .Select(match => int.TryParse(
            match.Groups[1].Value,
            System.Globalization.NumberStyles.None,
            System.Globalization.CultureInfo.InvariantCulture,
            out var index)
            ? index
            : throw new ArgumentException(
                $"The cloze Text field contains index '{match.Groups[1].Value}', which is outside the range supported by System.Int32.",
                invalidClozeParameterName))
        .Where(index => index > 0)
        .Select(index => index - 1)
        .Distinct()
        .Order()
        .ToArray();
 
    private void ReconcileClozeCards(IEnumerable<int> ordinals, long deckId)
    {
        var existing = cards
            .GroupBy(card => card.TemplateOrdinal)
            .ToDictionary(group => group.Key, group => group.First());
        var reconciled = ordinals
            .Select(ordinal => existing.GetValueOrDefault(ordinal) ?? CreateNewCard(deckId, ordinal))
            .ToArray();
        cards.Clear();
        cards.AddRange(reconciled);
    }
 
    private AnkiCard CreateNewCard(long deckId, int ordinal) => new(AnkiId.New(), Id, deckId, ordinal, AnkiScheduling.New);
 
    private static void ValidateTag(string tag, string parameterName)
    {
        if (tag is null)
        {
            throw new ArgumentNullException(parameterName);
        }
 
        if (string.IsNullOrWhiteSpace(tag) || tag.Any(char.IsWhiteSpace))
        {
            throw new ArgumentException("Anki tags cannot be blank or contain whitespace.", parameterName);
        }
    }
 
    [GeneratedRegex(@"\{\{c(\d+)::", RegexOptions.CultureInvariant)]
    private static partial Regex ClozePattern();
}