AnkiNoteType.cs

using System.Collections.ObjectModel;
 
namespace AnkiIO;

public sealed class AnkiNoteType
{
    internal const string DefaultCss = ".card { font-family: Arial; font-size: 20px; text-align: center; color: black; background: white; }";
 
    private readonly List<AnkiField> fields = [];
    private readonly List<AnkiCardTemplate> templates = [];
    private readonly ReadOnlyCollection<AnkiField> fieldsView;
    private readonly ReadOnlyCollection<AnkiCardTemplate> templatesView;
    private string css = DefaultCss;
    private bool isFrozen;

    public AnkiNoteType(string name, AnkiNoteTypeKind kind = AnkiNoteTypeKind.Standard, long? id = null)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(name);
        Name = name;
        Kind = kind;
        Id = id ?? AnkiId.New();
        fieldsView = fields.AsReadOnly();
        templatesView = templates.AsReadOnly();
    }

    public long Id { get; }

    public string Name { get; }

    public AnkiNoteTypeKind Kind { get; }

    public string Css
    {
        get => css;
        set
        {
            ArgumentNullException.ThrowIfNull(value);
            EnsureMutable();
            css = value;
        }
    }

    public bool IsFrozen => isFrozen;

    public IReadOnlyList<AnkiField> Fields => fieldsView;

    public IReadOnlyList<AnkiCardTemplate> Templates => templatesView;

    public AnkiNoteType AddField(string name)
    {
        EnsureMutable();
        ArgumentException.ThrowIfNullOrWhiteSpace(name);
        if (fields.Any(field => string.Equals(field.Name, name, StringComparison.OrdinalIgnoreCase)))
        {
            throw new ArgumentException($"Field '{name}' already exists.", nameof(name));
        }
 
        fields.Add(new AnkiField(name));
        return this;
    }

    public AnkiNoteType AddConfiguredField(AnkiField field)
    {
        EnsureMutable();
        ArgumentNullException.ThrowIfNull(field);
        ArgumentException.ThrowIfNullOrWhiteSpace(field.Name);
        ArgumentException.ThrowIfNullOrWhiteSpace(field.Font);
        ArgumentOutOfRangeException.ThrowIfLessThan(field.FontSize, 1);
        if (fields.Any(existing => string.Equals(existing.Name, field.Name, StringComparison.OrdinalIgnoreCase)))
        {
            throw new ArgumentException($"Field '{field.Name}' already exists.", nameof(field));
        }
 
        fields.Add(field);
        return this;
    }

    public AnkiNoteType AddTemplate(string name, string questionFormat, string answerFormat)
    {
        EnsureMutable();
        ArgumentException.ThrowIfNullOrWhiteSpace(name);
        ArgumentNullException.ThrowIfNull(questionFormat);
        ArgumentNullException.ThrowIfNull(answerFormat);
        if (templates.Any(template => string.Equals(template.Name, name, StringComparison.OrdinalIgnoreCase)))
        {
            throw new ArgumentException($"Template '{name}' already exists.", nameof(name));
        }
 
        templates.Add(new AnkiCardTemplate(name, questionFormat, answerFormat));
        return this;
    }

    public AnkiNoteType AddConfiguredTemplate(AnkiCardTemplate template)
    {
        EnsureMutable();
        ArgumentNullException.ThrowIfNull(template);
        ArgumentException.ThrowIfNullOrWhiteSpace(template.Name);
        ArgumentNullException.ThrowIfNull(template.QuestionFormat);
        ArgumentNullException.ThrowIfNull(template.AnswerFormat);
        if (templates.Any(existing => string.Equals(existing.Name, template.Name, StringComparison.OrdinalIgnoreCase)))
        {
            throw new ArgumentException($"Template '{template.Name}' already exists.", nameof(template));
        }
 
        templates.Add(template);
        return this;
    }
 
    internal bool HasEquivalentDefinition(AnkiNoteType other) =>
        string.Equals(Name, other.Name, StringComparison.Ordinal)
        && Kind == other.Kind
        && string.Equals(Css, other.Css, StringComparison.Ordinal)
        && fields.SequenceEqual(other.fields)
        && templates.SequenceEqual(other.templates);
 
    internal void Freeze() => isFrozen = true;
 
    private void EnsureMutable()
    {
        if (isFrozen)
        {
            throw new InvalidOperationException($"Note type '{Name}' is frozen because it is already used by a note.");
        }
    }
}