Titano/Titano/UI/SponsorPanel.cs

using System.Diagnostics;
using System.Text;
using Titano.Pipeline;

namespace Titano.UI;

/// <summary>Un annuncio del listino locale.</summary>
internal sealed record Sponsor(string Title, string Body, string? ImagePath, string? Link, int Weight)
{
    public bool HasLink => !string.IsNullOrWhiteSpace(Link);
}

/// <summary>
/// Listino degli sponsor, letto da una cartella locale.
///
/// Nessuna rete: il programma non contatta alcun servizio, non invia identificativi e non
/// registra clic. È una scelta, non una mancanza — un circuito pubblicitario vero
/// richiederebbe di integrarne l'SDK, che il vincolo sulle dipendenze esclude, e comunque
/// significherebbe far uscire dati dalla macchina di chi sta soltanto montando un
/// time-lapse. Le campagne si aggiornano copiando file in una cartella.
///
/// Il formato è lo stesso delle impostazioni: blocchi introdotti da [campagna], una riga per
/// campo. Le immagini stanno accanto al listino.
/// </summary>
internal static class SponsorCatalogue
{
    public const string ManifestName = "campagne.txt";

    public static List<Sponsor> Load(string folder)
    {
        var sponsors = new List<Sponsor>();
        try
        {
            string manifest = Path.Combine(folder, ManifestName);
            if (!File.Exists(manifest)) return sponsors;

            string? title = null, body = null, image = null, link = null;
            int weight = 1;

            void Flush()
            {
                if (string.IsNullOrWhiteSpace(title)) return;
                string? resolved = string.IsNullOrWhiteSpace(image) ? null : Path.Combine(folder, image);
                if (resolved is not null && !File.Exists(resolved)) resolved = null;
                sponsors.Add(new Sponsor(title!, body ?? string.Empty, resolved, Sanitize(link), Math.Clamp(weight, 1, 10)));
            }

            foreach (string raw in File.ReadAllLines(manifest, Encoding.UTF8))
            {
                string line = raw.Trim();
                if (line.Length == 0 || line[0] == '#') continue;

                if (line.StartsWith('[') && line.EndsWith(']'))
                {
                    Flush();
                    title = body = image = link = null;
                    weight = 1;
                    continue;
                }

                int separator = line.IndexOf('=');
                if (separator <= 0) continue;
                string key = line[..separator].Trim().ToLowerInvariant();
                string value = line[(separator + 1)..].Trim();

                switch (key)
                {
                    case "titolo": title = value; break;
                    case "testo": body = value; break;
                    case "immagine": image = value; break;
                    case "collegamento": link = value; break;
                    case "peso": weight = AppSettings.ParseInt(value, 1); break;
                }
            }
            Flush();
        }
        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException)
        {
            // Listino illeggibile: restano gli annunci interni, che non mancano mai.
        }

        return sponsors;
    }

    /// <summary>
    /// Crea la cartella e, se è vuota, vi scrive un listino di esempio commentato. Il formato
    /// si impara guardando un file che c'è già, non cercando dove sia documentato.
    /// </summary>
    public static void EnsureExample(string folder)
    {
        try
        {
            Directory.CreateDirectory(folder);
            string manifest = Path.Combine(folder, ManifestName);
            if (File.Exists(manifest)) return;

            File.WriteAllText(manifest, """
                # Listino delle campagne mostrate durante l'esportazione.
                #
                # Un blocco per annuncio, introdotto da [campagna]. Le immagini stanno in
                # questa stessa cartella; sono facoltative, e vengono ridimensionate
                # conservando le proporzioni. Il collegamento deve essere http o https:
                # qualunque altra cosa viene ignorata.
                #
                # Il peso governa la frequenza: peso 3 compare tre volte più spesso di peso 1.
                #
                # Titano non contatta nessun servizio e non registra i clic: questo file è
                # l'unica sorgente degli annunci.

                [campagna]
                titolo = Titolo dell'annuncio
                testo = Una o due righe di testo. Chi legge sta aspettando la fine di una codifica, quindi può leggere una frase intera.
                immagine = esempio.jpg
                collegamento = https://esempio.it
                peso = 1
                """, Encoding.UTF8);
        }
        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
        {
            // Cartella non scrivibile: restano gli annunci interni.
        }
    }

    /// <summary>
    /// Accetta solo indirizzi web. Il listino è un file locale, ma aprire alla cieca ciò che
    /// vi si trova scritto significherebbe eseguire quello che qualcuno vi ha messo dentro.
    /// </summary>
    private static string? Sanitize(string? link)
    {
        if (string.IsNullOrWhiteSpace(link)) return null;
        return Uri.TryCreate(link, UriKind.Absolute, out var uri) &&
               (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps)
            ? uri.AbsoluteUri
            : null;
    }

    /// <summary>
    /// Contenuti interni, mostrati quando il listino è vuoto. Non sono un riempitivo: sono
    /// le cose che un'attesa di mezz'ora è il momento giusto per leggere.
    /// </summary>
    public static List<Sponsor> House() =>
    [
        new("Il profilo di qualità governa il tempo",
            "Massima infittisce il campo vettoriale e i campioni della scia. Su una sequenza senza " +
            "movimento, Standard dà lo stesso risultato in un terzo del tempo.", null, null, 1),
        new("La finestra della mediana vive in memoria",
            "I fotogrammi della finestra sono vivi tutti insieme, perché la mediana li vuole " +
            "simultaneamente. Il tetto di memoria governa la lettura in anticipo, non la finestra.", null, null, 1),
        new("Un cielo più scuro del terreno è normale",
            "Di notte, con un primo piano illuminato, la regione superiore è la più scura. " +
            "La divisione per orizzonte se ne accorge e non la scambia per un errore.", null, null, 1),
        new("I cambi di esposizione invisibili restano tali",
            "Se il fotogramma è già saturo, cambiare sensibilità non lo scurisce. Titano lo verifica " +
            "prima di correggere: togliere un gradino che non c'è significa introdurlo.", null, null, 1),
    ];
}

/// <summary>
/// Riquadro degli sponsor, mostrato durante l'attesa dell'esportazione.
///
/// Sta soltanto qui, nella scheda dove per forza di cose si aspetta, e non compare mai
/// altrove: un annuncio accanto a un cursore che si sta regolando sarebbe un ostacolo, uno
/// accanto a una barra di avanzamento è qualcosa da guardare mentre passa il tempo. È
/// dichiarato come tale, non si muove da solo se il sistema chiede di ridurre le animazioni,
/// e si spegne dalle impostazioni.
/// </summary>
internal sealed class SponsorPanel : Control
{
    private readonly System.Windows.Forms.Timer _rotation = new();
    private List<Sponsor> _sponsors = [];
    private readonly List<int> _order = [];
    private int _position;
    private Image? _image;
    private string? _imagePath;
    private bool _hoverLink;
    private bool _hoverNext;

    public SponsorPanel()
    {
        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
                 ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw, true);
        BackColor = Theme.Surface;
        Height = 132;

        _rotation.Tick += (_, _) => Advance();
    }

    public Sponsor? Current => _order.Count > 0 && _position < _order.Count
        ? _sponsors[_order[_position]]
        : null;

    /// <summary>Carica il listino e avvia la rotazione secondo le preferenze.</summary>
    public void Configure(AppSettings settings)
    {
        Visible = settings.ShowSponsors;
        if (!settings.ShowSponsors)
        {
            _rotation.Stop();
            return;
        }

        var loaded = SponsorCatalogue.Load(settings.ResolvedSponsorFolder);
        _sponsors = loaded.Count > 0 ? loaded : SponsorCatalogue.House();

        // L'ordine tiene conto del peso ripetendo le voci: una campagna di peso tre compare
        // tre volte nel giro, senza bisogno di estrazioni casuali che potrebbero saltarla.
        _order.Clear();
        for (int i = 0; i < _sponsors.Count; i++)
        {
            for (int repeat = 0; repeat < _sponsors[i].Weight; repeat++) _order.Add(i);
        }
        Shuffle(_order);

        _position = 0;
        LoadImage();

        _rotation.Interval = Math.Clamp(settings.SponsorRotationSeconds, 5, 600) * 1000;
        _rotation.Start();
        Invalidate();
    }

    /// <summary>Ferma la rotazione quando la scheda non è in vista: non serve a nessuno girare a vuoto.</summary>
    public void SetActive(bool active)
    {
        if (!Visible) return;
        if (active) _rotation.Start(); else _rotation.Stop();
    }

    private static void Shuffle(List<int> values)
    {
        for (int i = values.Count - 1; i > 0; i--)
        {
            int j = Random.Shared.Next(i + 1);
            (values[i], values[j]) = (values[j], values[i]);
        }
    }

    private void Advance()
    {
        if (_order.Count == 0) return;
        _position = (_position + 1) % _order.Count;
        LoadImage();
        Invalidate();
    }

    private void LoadImage()
    {
        string? path = Current?.ImagePath;
        if (path == _imagePath) return;

        _image?.Dispose();
        _image = null;
        _imagePath = path;

        if (path is null) return;
        try
        {
            using var stream = new FileStream(path, FileMode.Open, FileAccess.Read);
            _image = Image.FromStream(stream);
        }
        catch (Exception ex) when (ex is IOException or ArgumentException or OutOfMemoryException)
        {
            _image = null;
        }
    }

    // ------------------------------------------------------------------ interazione

    private Rectangle NextButton => new(Width - 26, 6, 18, 18);

    private Rectangle TextArea
    {
        get
        {
            int left = _image is null ? 14 : 14 + ThumbWidth + 14;
            return new Rectangle(left, 26, Math.Max(40, Width - left - 16), Math.Max(20, Height - 36));
        }
    }

    private int ThumbWidth => Math.Min(168, Math.Max(80, (Height - 28) * 16 / 9));

    protected override void OnMouseMove(MouseEventArgs e)
    {
        bool overNext = NextButton.Contains(e.Location);
        bool overLink = Current is { HasLink: true } && TextArea.Contains(e.Location);

        if (overNext != _hoverNext || overLink != _hoverLink)
        {
            _hoverNext = overNext;
            _hoverLink = overLink;
            Cursor = overNext || overLink ? Cursors.Hand : Cursors.Default;
            Invalidate();
        }
        base.OnMouseMove(e);
    }

    protected override void OnMouseLeave(EventArgs e)
    {
        _hoverNext = _hoverLink = false;
        Cursor = Cursors.Default;
        Invalidate();
        base.OnMouseLeave(e);
    }

    protected override void OnMouseDown(MouseEventArgs e)
    {
        if (e.Button != MouseButtons.Left) return;

        if (NextButton.Contains(e.Location)) { Advance(); return; }

        if (Current is { HasLink: true, Link: { } link } && TextArea.Contains(e.Location))
        {
            try
            {
                Process.Start(new ProcessStartInfo(link) { UseShellExecute = true });
            }
            catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or IOException)
            {
                // Nessun browser predefinito: non c'è nulla di sensato da fare.
            }
        }
        base.OnMouseDown(e);
    }

    // ------------------------------------------------------------------ disegno

    protected override void OnPaint(PaintEventArgs e)
    {
        var g = e.Graphics;
        Theme.HighQuality(g);
        g.Clear(Parent?.BackColor ?? Theme.Background);

        var bounds = new RectangleF(0.5f, 0.5f, Width - 1, Height - 1);
        Theme.FillAndStroke(g, bounds, 6f, Theme.Surface, Theme.Border);

        if (Current is not { } sponsor)
        {
            TextRenderer.DrawText(g, "Nessuna campagna nel listino", Theme.Small,
                                  new Rectangle(0, 0, Width, Height), Theme.TextFaint,
                                  TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter);
            return;
        }

        // L'etichetta è la prima cosa che si legge: chi guarda deve sapere subito che cos'è.
        TextRenderer.DrawText(g, "SPONSOR", Theme.SmallBold, new Rectangle(14, 5, 120, 16),
                              Theme.TextFaint, TextFormatFlags.Left | TextFormatFlags.VerticalCenter);

        if (_order.Count > 1) DrawNextButton(g);

        if (_image is not null)
        {
            var box = new Rectangle(14, 26, ThumbWidth, Height - 40);
            DrawImageFitted(g, _image, box);
        }

        var text = TextArea;
        TextRenderer.DrawText(g, sponsor.Title, Theme.BodyBold,
                              new Rectangle(text.Left, text.Top, text.Width, 20),
                              _hoverLink ? Theme.Accent : Theme.Text,
                              TextFormatFlags.Left | TextFormatFlags.VerticalCenter | TextFormatFlags.EndEllipsis);

        TextRenderer.DrawText(g, sponsor.Body, Theme.Small,
                              new Rectangle(text.Left, text.Top + 22, text.Width, text.Height - 40),
                              Theme.TextMuted, TextFormatFlags.Left | TextFormatFlags.Top | TextFormatFlags.WordBreak);

        if (sponsor.HasLink)
        {
            TextRenderer.DrawText(g, _hoverLink ? "Apri nel browser →" : "Clic per saperne di più",
                                  Theme.Small, new Rectangle(text.Left, Height - 20, text.Width, 16),
                                  _hoverLink ? Theme.Accent : Theme.TextFaint,
                                  TextFormatFlags.Left | TextFormatFlags.VerticalCenter);
        }
    }

    private void DrawNextButton(Graphics g)
    {
        var box = NextButton;
        if (_hoverNext) Theme.FillRounded(g, box, 4f, Theme.SurfaceAlt);

        using var pen = new Pen(_hoverNext ? Theme.Text : Theme.TextFaint, 1.5f)
        {
            StartCap = System.Drawing.Drawing2D.LineCap.Round,
            EndCap = System.Drawing.Drawing2D.LineCap.Round,
        };
        float cx = box.Left + box.Width / 2f;
        float cy = box.Top + box.Height / 2f;
        g.DrawLines(pen,
        [
            new PointF(cx - 2.5f, cy - 4f),
            new PointF(cx + 2.5f, cy),
            new PointF(cx - 2.5f, cy + 4f),
        ]);
    }

    /// <summary>Disegna l'immagine dentro il riquadro conservandone le proporzioni.</summary>
    private static void DrawImageFitted(Graphics g, Image image, Rectangle box)
    {
        double scale = Math.Min(box.Width / (double)image.Width, box.Height / (double)image.Height);
        int width = Math.Max(1, (int)(image.Width * scale));
        int height = Math.Max(1, (int)(image.Height * scale));
        var target = new Rectangle(box.Left + (box.Width - width) / 2,
                                   box.Top + (box.Height - height) / 2, width, height);

        g.DrawImage(image, target);
        using var border = new Pen(Theme.Border);
        g.DrawRectangle(border, target);
    }

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            _rotation.Stop();
            _rotation.Dispose();
            _image?.Dispose();
        }
        base.Dispose(disposing);
    }
}