SpellTimerPlugin.cs

using System.Text;
using System.Text.RegularExpressions;
using Genie.Plugins;

namespace Genie.Plugins.SpellTimer;

/// <summary>
/// The V5 port of GenieClient/Plugin_SpellTimer (originally by UFTimmy for Genie 4).
/// Turns DR's <b>Active Spells</b> window into persistent script variables — exactly
/// the surface the Genie 4 plugin exposed — and re-renders the live list into the
/// host's "Active Spells" dock panel.
///
/// <para><b>How DR sends it.</b> The active-spells window is the <c>percWindow</c>
/// stream. Each refresh is a <c>&lt;clearStream id="percWindow"/&gt;</c> followed by
/// one <c>&lt;pushStream id="percWindow"/&gt;Spell Name  (N roisaen)</c> line per
/// currently-active spell. The full list is re-sent on every refresh, so a spell that
/// drops off simply stops appearing.</para>
///
/// <para><b>Why this is driven from <see cref="OnXml"/>.</b> The percWindow content
/// also surfaces through <see cref="OnGameText"/> (stream "percWindow"), but the host
/// dispatches text events and raw-XML events on two separate subscriptions, so their
/// relative order isn't guaranteed. Parsing the whole raw chunk in <see cref="OnXml"/>
/// keeps the <c>clearStream</c> boundary and its spell lines in their true on-the-wire
/// order within one string — which is what the "deactivate anything not in the latest
/// refresh" logic depends on. <see cref="OnGameText"/> is therefore observe-only.</para>
///
/// <para><b>Script surface (Genie 4 parity).</b> For each spell the plugin publishes
/// <c>$SpellTimer.&lt;Spell&gt;.active</c> (1/0), <c>$SpellTimer.&lt;Spell&gt;.duration</c>
/// (roisaen remaining), and, for Stellar Collector, <c>$SpellTimer.&lt;Spell&gt;.charge</c>.
/// The <c>&lt;Spell&gt;</c> token strips spaces, apostrophes and hyphens, matching the
/// Genie 4 variable names so existing <c>.cmd</c> scripts keep working:
/// <code>if (!$SpellTimer.ClearVision.active) then put cast cv</code></para>
///
/// Output is via the named-window seam, so the plugin has no UI/Avalonia dependency —
/// the host surfaces "Active Spells" as a dock panel. It references only
/// <c>Genie.Plugins.Abstractions</c> and loads as a DLL from the Plugins folder.
/// </summary>
public sealed class SpellTimerPlugin : IGeniePlugin
{
    // ── Identity / metadata ────────────────────────────────────────────────────
    public string Id             => "genie.spelltimer";
    public string Name           => "Spell Timer";
    public string Version        => "1.0";
    public string Author         => "Original by UFTimmy (ported to Genie 5)";
    public string Description     => "Exposes the Active Spells window as $SpellTimer.* script variables and a dock panel.";
    public string MinHostVersion => "5.0.0";

    /// <summary>Named window the host surfaces as a dock panel (matches DR's own
    /// percWindow title). First <see cref="IPluginHost.SetWindow"/> call creates it;
    /// open it via Window → Active Spells.</summary>
    private const string WindowName = "Active Spells";

    private bool _enabled = true;
    public bool Enabled
    {
        get => _enabled;
        set
        {
            if (_enabled == value) return;
            _enabled = value;
            if (!value) _host?.SetWindow(WindowName, "(Spell Timer plugin disabled)");
            else        _dirty = true;
        }
    }

    private IPluginHost _host = null!;
    private bool _dirty;

    /// <summary>Value object for one tracked spell. <c>Indefinite</c>/<c>OM</c> map to
    /// <see cref="Indefinite"/>; a fading spell is active with duration 0.</summary>
    private sealed class Spell
    {
        public required string Name;
        public bool Active;
        public int  Duration;   // roisaen remaining (Indefinite => 999)
        public int  Charge;     // Stellar Collector charge %
        public bool Fading;
    }

    private const int Indefinite = 999;

    // Every spell currently known, keyed by display name.
    private readonly Dictionary<string, Spell> _spells = new(StringComparer.Ordinal);
    // Names seen since the last <clearStream id="percWindow"/> — the current refresh.
    private readonly HashSet<string> _poppedThisRound = new(StringComparer.Ordinal);

    // Walk a raw chunk for percWindow events in wire order: either a clearStream
    // boundary, or a pushStream line carrying "Spell Name  (duration)".
    private static readonly Regex PercTokenRe = new(
        "<clearStream id=\"percWindow\"\\s*/>" +
        "|<pushStream id=\"percWindow\"\\s*/>([^<\\n]*)",
        RegexOptions.Compiled);

    // "Clear Vision  (18 roisaen)" -> name = "Clear Vision", inside = "18 roisaen".
    private static readonly Regex SpellLineRe = new(@"^(.+?)\s+\((.+)\)\s*$", RegexOptions.Compiled);
    // DR uses the singular "roisan" (no 'e') for a 1-roisaen duration; "roisae?n"
    // matches both "roisan" and "roisaen".
    private static readonly Regex RoisaenRe   = new(@"(\d+)\s+roisae?n", RegexOptions.Compiled);
    private static readonly Regex PercentRe    = new(@"(\d+)%", RegexOptions.Compiled);

    public void Initialize(IPluginHost host) => _host = host;

    public void Shutdown() { }

    public void OnXml(string xml)
    {
        if (xml.IndexOf("percWindow", StringComparison.Ordinal) < 0) return;

        var any = false;
        foreach (Match m in PercTokenRe.Matches(xml))
        {
            if (!m.Groups[1].Success)          // a clearStream boundary
            {
                FinishRound();                 // deactivate anything the last refresh dropped
            }
            else                                // a pushStream spell line
            {
                ApplySpellLine(m.Groups[1].Value);
                any = true;
            }
        }
        if (any) _dirty = true;
    }

    /// <summary>The percWindow content also arrives here as stream "percWindow";
    /// we drive everything from <see cref="OnXml"/> instead (see class remarks), so
    /// this hook is observe-only.</summary>
    public string? OnGameText(string text, string stream) => text;

    public void OnPrompt()
    {
        if (!_dirty) return;
        _dirty = false;
        _host.SetWindow(WindowName, Render());
    }

    public string? OnInput(string input)
    {
        var t = input.Trim();
        if (!t.StartsWith("/spelltimer", StringComparison.OrdinalIgnoreCase)) return input;

        var active   = _spells.Values.Where(s => s.Active).OrderBy(DurationSort).ToList();
        var inactive = _spells.Values.Where(s => !s.Active).OrderBy(s => s.Name, StringComparer.Ordinal).ToList();

        _host.Echo("Active spells:");
        if (active.Count == 0) _host.Echo("  (none)");
        foreach (var s in active) _host.Echo("  " + Line(s));

        if (inactive.Count > 0)
        {
            _host.Echo("Inactive (recently seen):");
            foreach (var s in inactive) _host.Echo("  " + s.Name);
        }
        return null;   // swallow — it's a plugin command, not a game command
    }

    public void OnCommandSent(string command)            { }
    public void OnVariableChanged(string name, string v) { }

    // ── parsing ─────────────────────────────────────────────────────────────────

    private void ApplySpellLine(string raw)
    {
        var text = raw.Trim();
        if (text.Length == 0) return;

        string name;
        var active   = true;
        var duration = 0;
        var charge   = 0;
        var fading   = false;

        var m = SpellLineRe.Match(text);
        if (m.Success)
        {
            name = m.Groups[1].Value.Trim();
            var inside = m.Groups[2].Value.Trim();

            if (name.Equals("Stellar Collector", StringComparison.Ordinal))
            {
                var pc = PercentRe.Match(inside);
                if (pc.Success) charge = int.Parse(pc.Groups[1].Value);
            }
            else if (name.Equals("Osrel Meraud", StringComparison.Ordinal))
            {
                var pc = PercentRe.Match(inside);
                if (pc.Success) duration = int.Parse(pc.Groups[1].Value);
            }
            else
            {
                var rs = RoisaenRe.Match(inside);
                if (rs.Success)
                    duration = int.Parse(rs.Groups[1].Value);
                else if (inside.Equals("OM", StringComparison.OrdinalIgnoreCase)
                      || inside.Equals("Indefinite", StringComparison.OrdinalIgnoreCase))
                    duration = Indefinite;
                else if (inside.Equals("Fading", StringComparison.OrdinalIgnoreCase))
                    fading = true;          // active, but about to expire (duration 0)
            }
        }
        else if (text.EndsWith("small orbiting slivers of lunar magic", StringComparison.Ordinal))
        {
            // Moonblade slivers report as a count phrase, not a (duration).
            if      (text.StartsWith("Many", StringComparison.Ordinal)) duration = 2;
            else if (text.StartsWith("No",   StringComparison.Ordinal)) { duration = 0; active = false; }
            else                                                          duration = 1;
            name = "Moonblade Slivers";
        }
        else
        {
            return;   // not a line we recognise
        }

        var spell = Get(name);
        spell.Active   = active;
        spell.Duration = duration;
        spell.Charge   = charge;
        spell.Fading   = fading;

        _poppedThisRound.Add(name);
        Publish(spell);
    }

    /// <summary>A <c>clearStream</c> closes the previous refresh: any spell we know
    /// about that the latest refresh did NOT list has dropped off — mark it inactive.
    /// Because DR sends the clear boundary <i>before</i> the spell lines of the new
    /// refresh, deactivation is observed one refresh late (the Genie 4 behaviour). DR
    /// re-sends the list every prompt, so a dropped spell clears within a second or
    /// two — acceptable, and never flickers a still-active spell off.</summary>
    private void FinishRound()
    {
        foreach (var spell in _spells.Values)
        {
            if (_poppedThisRound.Contains(spell.Name)) continue;
            if (!spell.Active && spell.Duration == 0 && spell.Charge == 0) continue;  // already clear
            spell.Active   = false;
            spell.Duration = 0;
            spell.Charge   = 0;
            spell.Fading   = false;
            Publish(spell);
        }
        _poppedThisRound.Clear();
    }

    private Spell Get(string name)
    {
        if (!_spells.TryGetValue(name, out var s))
            _spells[name] = s = new Spell { Name = name };
        return s;
    }

    /// <summary>Publish the Genie 4-compatible script globals for one spell. Only
    /// writes on change to avoid churning the variable store / OnVariableChanged.</summary>
    private void Publish(Spell s)
    {
        var v = Var(s.Name);
        Set($"SpellTimer.{v}.active",   s.Active ? "1" : "0");
        Set($"SpellTimer.{v}.duration", s.Duration.ToString());
        if (s.Name.Equals("Stellar Collector", StringComparison.Ordinal))
            Set($"SpellTimer.{v}.charge", s.Charge.ToString());
    }

    private void Set(string name, string value)
    {
        if (!string.Equals(_host.GetVariable(name), value, StringComparison.Ordinal))
            _host.SetVariable(name, value);
    }

    /// <summary>Spell name → variable token: strip spaces, apostrophes and hyphens,
    /// matching Genie 4's $SpellTimer.&lt;name&gt; convention.</summary>
    private static string Var(string name) =>
        name.Replace(" ", "").Replace("'", "").Replace("-", "");

    // ── rendering ───────────────────────────────────────────────────────────────

    private static int DurationSort(Spell s) =>
        s.Duration == Indefinite ? int.MaxValue : (s.Fading ? -1 : s.Duration);

    private static string Line(Spell s)
    {
        var when = s.Fading                 ? "fading"
                 : s.Duration == Indefinite ? "indefinite"
                 : $"{s.Duration} roisaen";
        if (s.Name.Equals("Stellar Collector", StringComparison.Ordinal) && s.Charge > 0)
            when = $"{s.Charge}% charged";
        return $"{s.Name,-22} {when}";
    }

    private string Render()
    {
        var active = _spells.Values.Where(s => s.Active).OrderBy(DurationSort).ToList();

        var sb = new StringBuilder();
        sb.Append("Active: ").Append(active.Count).Append('\n');
        sb.Append("──────────────────────────────────────\n");
        foreach (var s in active) sb.AppendLine(Line(s));

        if (active.Count == 0)
            sb.Append("(no active spells)");

        return sb.ToString().TrimEnd();
    }
}