mabibli/MaBibli.Shared/Catalogue/RafaleIsbn.cs

namespace MaBibli.Shared.Catalogue;

/// <summary>
/// Où en est un code scanné dans une rafale.
/// </summary>
/// <remarks>
/// ⚠️ <b>C'est l'existence de ces états qui rend la reprise possible</b>, et la reprise est ce
/// qui distingue une rafale d'une simple liste de codes. Sans <see cref="Cree"/>, reprendre une
/// rafale à moitié traitée recréerait les livres déjà enregistrés — la case « passer si déjà
/// existant » les rattraperait sans doute, mais <b>par accident, pas par construction</b>.
/// </remarks>
public enum EtatCodeRafale
{
    /// <summary>Scanné, pas encore interrogé.</summary>
    ATraiter = 0,

    /// <summary>Livre enregistré. Ne jamais le refaire à la reprise.</summary>
    Cree,

    /// <summary>Déjà au catalogue, écarté par la case à cocher.</summary>
    Passe,

    /// <summary>Plusieurs notices : l'utilisateur doit choisir l'édition.</summary>
    AChoisir,

    /// <summary>Aucune source ne connaît ce code. À saisir à la main.</summary>
    Introuvable,

    /// <summary>Code de périodique (préfixe 977) : mis de côté, traité à la fin.</summary>
    Revue,

    /// <summary>La source n'a pas répondu. ⚠️ À distinguer d'<see cref="Introuvable"/>.</summary>
    Echec,
}

/// <summary>
/// Un code de la file, et ce qu'on en sait.
/// </summary>
public record CodeRafale
{
    public required string Code { get; init; }

    public EtatCodeRafale Etat { get; init; } = EtatCodeRafale.ATraiter;

    /// <summary>Titre trouvé, ou saisi. Sert à reconnaître la ligne dans le compte rendu.</summary>
    public string? Titre { get; init; }

    /// <summary>Renseigné quand l'état est <see cref="EtatCodeRafale.Cree"/>.</summary>
    public int? LivreId { get; init; }

    /// <summary>
    /// Ce qui s'est passé, écrit pour un humain.
    /// </summary>
    /// <remarks>
    /// ⚠️ Jamais un message HTTP brut : c'est la règle déjà tenue partout ailleurs, et le compte
    /// rendu d'une rafale est précisément un endroit où l'on est tenté de recopier l'erreur telle
    /// quelle pour aller vite.
    /// </remarks>
    public string? Motif { get; init; }

    /// <summary>Reste-t-il quelque chose à faire sur cette ligne ?</summary>
    public bool Termine => Etat is EtatCodeRafale.Cree or EtatCodeRafale.Passe;
}

/// <summary>
/// Une rafale de catalogage : les codes scannés, et où en est chacun.
/// </summary>
/// <remarks>
/// <b>Persistée dans IndexedDB, magasin <c>rafale</c></b> — séparé des instantanés, qui portent
/// ce que le serveur a rendu. Celle-ci porte ce que l'utilisateur a scanné, et qui n'existe
/// nulle part ailleurs.
/// <para>
/// ⚠️ <b>Ce ne sont PAS des écritures en attente</b>, et la nuance est ce qui la rend acceptable
/// dans un projet qui refuse toute file de synchronisation : ce sont des <b>codes à
/// interroger</b>. Rien n'est promis à la base, rien ne peut entrer en conflit, et l'utilisateur
/// voit sa liste. Ne pas confondre les deux, sous peine de rouvrir la question.
/// </para>
/// </remarks>
public record Rafale
{
    public List<CodeRafale> Codes { get; init; } = [];

    /// <summary>
    /// Passer les livres déjà au catalogue plutôt que de demander à chaque fois.
    /// </summary>
    /// <remarks>
    /// Coché par défaut : quand on catalogue cinquante livres, on ne veut pas être arrêté
    /// cinquante fois. ⚠️ Mais le compte rendu doit <b>dire combien ont été passés</b> — posséder
    /// deux exemplaires est légitime (c'est pourquoi l'ISBN ne porte pas d'index unique), et
    /// passer en silence contredirait cet esprit.
    /// </remarks>
    public bool PasserLesDoublons { get; init; } = true;

    /// <summary>
    /// Série à laquelle rattacher chaque livre créé, quand la rafale a été lancée depuis une saga.
    /// </summary>
    /// <remarks>
    /// ⚠️ Elle vit <b>dans la file</b> et non dans l'écran : une rafale se reprend plus tard, et
    /// la reprise doit rattacher au même endroit. Elle est reprise du paramètre d'adresse au
    /// lancement, une fois pour toutes.
    /// </remarks>
    public int? SerieId { get; init; }

    public DateTimeOffset Debut { get; init; } = DateTimeOffset.UtcNow;

    public int Total => Codes.Count;

    public int Traites => Codes.Count(c => c.Etat != EtatCodeRafale.ATraiter);

    public int Crees => Codes.Count(c => c.Etat == EtatCodeRafale.Cree);

    public int Passes => Codes.Count(c => c.Etat == EtatCodeRafale.Passe);

    /// <summary>Ce qui attend encore une décision de l'utilisateur.</summary>
    public IReadOnlyList<CodeRafale> Residus =>
        [.. Codes.Where(c => c.Etat
            is EtatCodeRafale.AChoisir or EtatCodeRafale.Introuvable
            or EtatCodeRafale.Revue or EtatCodeRafale.Echec)];

    public bool ResteATraiter => Codes.Any(c => c.Etat == EtatCodeRafale.ATraiter);

    /// <summary>Pourcentage traité, pour l'indicateur d'avancement.</summary>
    public int Pourcentage => Total == 0 ? 0 : Traites * 100 / Total;
}

/// <summary>
/// Découpe une saisie en codes, dans l'ordre, sans doublon.
/// </summary>
public static class SaisieRafale
{
    /// <summary>
    /// Un code par ligne — c'est ce que produit une douchette, qui envoie <c>Entrée</c> après
    /// chaque lecture. Les espaces et tirets sont tolérés, la casse aussi.
    /// </summary>
    /// <remarks>
    /// ⚠️ <b>Les doublons de la saisie sont écartés ici</b>, et non au traitement : scanner deux
    /// fois le même livre par mégarde est le geste le plus banal d'une rafale, et interroger la
    /// BnF deux fois pour le même code ne peut rien apporter. Le doublon avec le <i>catalogue</i>,
    /// lui, est une tout autre question, traitée par <c>PasserLesDoublons</c>.
    /// </remarks>
    public static IReadOnlyList<string> Decouper(string? saisie)
    {
        if (string.IsNullOrWhiteSpace(saisie))
        {
            return [];
        }

        var vus = new HashSet<string>(StringComparer.Ordinal);
        var codes = new List<string>();

        foreach (var ligne in saisie.Split(['\n', '\r'], StringSplitOptions.RemoveEmptyEntries))
        {
            var code = new string([.. ligne.Where(c => char.IsAsciiDigit(c) || c is 'X' or 'x')])
                .ToUpperInvariant();

            if (code.Length > 0 && vus.Add(code))
            {
                codes.Add(code);
            }
        }

        return codes;
    }
}