Mimante/Mimante/Utilities/FinishedAuctionCleanup.cs

using AutoBidder.Models;

namespace AutoBidder.Utilities
{
    /// <summary>
    /// Decide se un'asta conclusa può sparire da sola dall'elenco del monitor.
    ///
    /// <para><b>Perché serve.</b> Le aste concluse restano nel monitor finché non le si
    /// toglie a mano, e con l'aggiunta automatica accesa se ne accumulano centinaia: quelle
    /// vive finiscono sepolte sotto quelle finite, che è il contrario di quello che serve
    /// guardando un cruscotto.</para>
    ///
    /// <para><b>Perché non basta togliere tutto.</b> Un'asta su cui si è puntato è l'unica
    /// che vale la pena riguardare: quanto è costata, se il ritiro dal duello è scattato al
    /// momento giusto, se il prezzo finale sta dove ci si aspettava. Farla sparire da sola
    /// significa perdere l'occasione di controllarla, e i soldi erano veri. Le altre — quelle
    /// solo osservate — non hanno niente da dire che lo storico non dica meglio.</para>
    ///
    /// <para>Da qui la forma della regola: si toglie di serie, si trattiene ciò su cui c'è
    /// stato un esborso. Classe pura: nessuno stato, nessun orologio, nessun disco.</para>
    /// </summary>
    public static class FinishedAuctionCleanup
    {
        /// <summary>Cosa fare delle aste concluse, e cosa risparmiare.</summary>
        public sealed class Options
        {
            /// <summary>Togliere da sole le aste concluse. Acceso di serie.</summary>
            public bool Enabled { get; set; } = true;

            /// <summary>
            /// Trattenere le aste su cui si è puntato, per poterle controllare a mano.
            /// Acceso di serie: sono quelle costate qualcosa.
            /// </summary>
            public bool KeepWithMyBids { get; set; } = true;

            /// <summary>
            /// Trattenere le aste vinte. Acceso di serie: c'è da confermare l'acquisto su
            /// Bidoo, e una vittoria sparita dall'elenco è il modo più semplice di
            /// dimenticarsene.
            /// </summary>
            public bool KeepWon { get; set; } = true;

            /// <summary>
            /// Trattenere le aste finite con un errore o senza esito leggibile: sono
            /// esattamente quelle da guardare. Acceso di serie.
            /// </summary>
            public bool KeepUnclear { get; set; } = true;
        }

        /// <summary>Esito della decisione, col motivo per il registro.</summary>
        public readonly record struct Verdict(bool Remove, string Reason);

        /// <summary>
        /// Quest'asta conclusa si può togliere dall'elenco?
        ///
        /// <para>L'ordine dei controlli è quello che conta: prima le ragioni per
        /// <b>trattenere</b>, poi la rimozione. Un'asta vinta su cui si è anche puntato deve
        /// restare per il primo motivo che si incontra, non per l'ultimo, così il messaggio
        /// nel registro dice la cosa più importante.</para>
        /// </summary>
        public static Verdict Decide(bool conclusa, bool vinta, int puntateMie, bool fineVista, Options options)
        {
            options ??= new Options();

            if (!options.Enabled)
                return new Verdict(false, "rimozione automatica spenta");

            if (!conclusa)
                return new Verdict(false, "asta non conclusa");

            if (options.KeepWon && vinta)
                return new Verdict(false, "vinta: resta in elenco per la conferma su Bidoo");

            if (options.KeepWithMyBids && puntateMie > 0)
                return new Verdict(false,
                    $"trattenuta: ci hai speso {puntateMie} puntate, controllala a mano");

            if (options.KeepUnclear && !fineVista)
                return new Verdict(false, "trattenuta: la fine non è stata vista, esito da controllare");

            return new Verdict(true, "conclusa senza puntate mie: tolta dall'elenco");
        }

        /// <summary>
        /// Comodità per il motore: legge dall'asta i quattro numeri che servono.
        ///
        /// <para>Le puntate si prendono dal massimo fra il contatore dell'asta e quello di
        /// sessione: uno dei due può essere a zero a seconda di come l'asta è entrata nel
        /// monitor, e trattenere per eccesso è l'errore giusto da fare.</para>
        /// </summary>
        public static Verdict Decide(AuctionInfo auction, bool vinta, Options options)
        {
            if (auction == null) return new Verdict(false, "nessuna asta");

            var perAsta = auction.BidsUsedOnThisAuction ?? 0;
            var puntate = perAsta > auction.SessionBidCount ? perAsta : auction.SessionBidCount;

            return Decide(
                conclusa: !string.IsNullOrWhiteSpace(auction.ConcludedOutcome),
                vinta: vinta,
                puntateMie: puntate,
                fineVista: auction.ObservedToEnd,
                options);
        }
    }
}