acdream/src/AcDream.App/UI/Layout/UiDatElement.cs

using System;
using System.Numerics;

namespace AcDream.App.UI.Layout;

/// <summary>
/// Generic dat element: draws its active state's media by DrawMode (Normal=tile,
/// Alphablend/Overlay=blended overlay). The fallback renderer for every element type
/// without a dedicated behavioral widget (chrome corners/edges, drag bars, resize grips);
/// faithful because retail's base element render is exactly "stamp the media per draw-mode".
///
/// <para>
/// For Plan 1, all observed draw modes produce the same alpha-blended tiled quad — the
/// sprite shader already alpha-blends, so no per-mode branch is needed here. The named
/// constants document the real enum for Plan 2.
/// </para>
///
/// <para>
/// DrawModeType (DatReaderWriter.Enums), stored as int in <see cref="ElementInfo"/> to
/// keep this dat-free. See docs/research/2026-06-15-layoutdesc-format.md §6:
/// <c>Undefined=0, Normal=1, Overlay=2, Alphablend=3</c>. There is no Stretch mode.
/// </para>
///
/// <para>
/// Tiling uses UV-repeat on BOTH axes (<c>Width/tw</c>, <c>Height/th</c>) so vertical
/// chrome edges (e.g. a 5×10 sprite drawn over a 5×48 rect) tile vertically too.
/// <see cref="AcDream.App.Rendering.TextureCache.UploadRgba8"/> sets
/// <c>GL_REPEAT</c> on both S and T, so vertical tiling is always active.
/// </para>
/// </summary>
public sealed class UiDatElement : UiElement, IUiDatStateful
{
    // DrawModeType enum values from DatReaderWriter.Enums.
    // See docs/research/2026-06-15-layoutdesc-format.md §6.
#pragma warning disable IDE0051 // private constants kept for documentation / Plan 2
    private const int DrawUndefined   = 0;
    private const int DrawNormal      = 1;
    private const int DrawOverlay     = 2;
    private const int DrawAlphablend  = 3;
#pragma warning restore IDE0051

    private readonly ElementInfo _info;
    private readonly Func<uint, (uint tex, int w, int h)> _resolve;

    /// <summary>The dat element id from <see cref="ElementInfo.Id"/>. Exposed so controllers
    /// can identify which logical element a UiDatElement represents when walking subtrees
    /// (e.g. footer state groups that appear once per tab page but share the same dat id).</summary>
    public uint ElementId => _info.Id;

    /// <summary>Which state name to render. <c>""</c> = the unnamed DirectState.
    /// Falls back to DirectState if the named state is absent.</summary>
    public string ActiveState { get; set; } = "";

    public uint ActiveRetailStateId
    {
        get
        {
            if (string.IsNullOrEmpty(ActiveState))
                return UiStateInfo.DirectStateId;
            foreach (var (id, state) in _info.States)
                if (string.Equals(state.Name, ActiveState, StringComparison.Ordinal))
                    return id;
            return UiButtonStateMachine.TryStateId(ActiveState, out uint standard)
                ? standard
                : RetailUiStateIds.TryStateId(ActiveState, out uint custom) ? custom : 0u;
        }
    }

    public override string ActiveCursorStateName => ActiveState;

    public bool TrySetRetailState(uint stateId)
    {
        UiStateInfo? selectedState = null;
        if (stateId == UiStateInfo.DirectStateId)
        {
            if (!_info.States.TryGetValue(stateId, out selectedState)
                && !_info.StateMedia.ContainsKey(""))
                return false;
            ActiveState = "";
        }
        else if (_info.States.TryGetValue(stateId, out selectedState))
        {
            ActiveState = selectedState.Name;
        }
        else
        {
            string stateName = UiButtonStateMachine.StateName(stateId);
            if (string.IsNullOrEmpty(stateName))
                stateName = RetailUiStateIds.StateName(stateId);
            if (string.IsNullOrEmpty(stateName) || !_info.StateMedia.ContainsKey(stateName))
                return false;
            ActiveState = stateName;
        }

        if (selectedState?.PassToChildren == true)
        {
            foreach (UiElement child in Children)
                if (child is IUiDatStateful stateful)
                    stateful.TrySetRetailState(stateId);
        }
        return true;
    }

    /// <param name="info">Merged <see cref="ElementInfo"/> for this element.</param>
    /// <param name="resolve">Dat file-id → (GL texture handle, native px width, native px height).
    /// Returns (0,0,0) when the texture is not yet uploaded.</param>
    public UiDatElement(ElementInfo info, Func<uint, (uint tex, int w, int h)> resolve)
    {
        _info = info;
        _resolve = resolve;
        ClickThrough = true; // generic decoration; behavioral widgets opt back in

        // Pick the initial active state: retail applies DefaultState when set; falls back
        // to "Normal" when the element has a Normal-state sprite (retail's implicit default
        // for stateful elements like tabs and buttons); else the unnamed DirectState ("").
        if (!string.IsNullOrEmpty(info.DefaultStateName))
            ActiveState = info.DefaultStateName;
        else if (info.StateMedia.ContainsKey("Normal"))
            ActiveState = "Normal";
        // else ActiveState stays "" (DirectState)
    }

    /// <summary>
    /// Returns the (File, DrawMode) for the current <see cref="ActiveState"/>,
    /// falling back to the DirectState (<c>""</c> key) if the named state is absent.
    /// Returns (0, 0) if neither exists.
    /// </summary>
    // exposed for unit testing
    public (uint File, int DrawMode) ActiveMedia()
        => _info.StateMedia.TryGetValue(ActiveState, out var m) ? m
         : _info.StateMedia.TryGetValue("", out var d) ? d
         : (0u, 0);

    /// <summary>Optional click handler. Set by a controller for interactive dat
    /// elements (e.g. the chat Send / max-min buttons). Requires
    /// <see cref="UiElement.ClickThrough"/> = false to receive click events.</summary>
    public Action? OnClick { get; set; }
    public Action<int, int>? OnClickAt { get; set; }

    public override bool HandlesClick => OnClick is not null || OnClickAt is not null;

    public override bool OnEvent(in UiEvent e)
    {
        if (e.Type == UiEventType.Click && (OnClick is not null || OnClickAt is not null))
        {
            OnClick?.Invoke();
            OnClickAt?.Invoke(e.Data1, e.Data2);
            return true;
        }
        return false;
    }

    /// <summary>Optional centered text label drawn over the sprite (e.g. the "Send"
    /// button face whose dat sprite is a blank frame). Null = sprite only.</summary>
    public string? Label { get; set; }
    /// <summary>Dat font for <see cref="Label"/>. Required for the label to draw.</summary>
    public UiDatFont? LabelFont { get; set; }
    /// <summary>Label color (default white).</summary>
    public Vector4 LabelColor { get; set; } = Vector4.One;

    /// <summary>
    /// Controls only this element's authored media. Descendants still draw.
    /// Layered retail composites use this to place a template's chrome behind a
    /// viewport while retaining its text descendants above that viewport.
    /// </summary>
    public bool MediaVisible { get; set; } = true;

    /// <summary>
    /// Runtime image installed on this region in place of its authored state media.
    /// A non-null value mirrors retail <c>UIRegion::ClearImage</c> followed by
    /// <c>UIRegion::SetImage</c>; zero deliberately leaves the region image-less.
    /// The image remains this element's own media, so authored descendants retain
    /// their normal foreground relationship.
    /// </summary>
    public uint? RuntimeImageTexture { get; set; }

    protected override void OnDraw(UiRenderContext ctx)
    {
        if (MediaVisible && RuntimeImageTexture is uint runtimeTexture)
        {
            if (runtimeTexture != 0u)
            {
                ctx.DrawSprite(
                    runtimeTexture,
                    0f,
                    0f,
                    Width,
                    Height,
                    0f,
                    0f,
                    1f,
                    1f,
                    Vector4.One);
            }
            DrawLabel(ctx);
            return;
        }

        var (file, _) = ActiveMedia();
        if (MediaVisible && file != 0)
        {
            var (tex, tw, th) = _resolve(file);
            if (tex != 0 && tw != 0 && th != 0)
            {
                // Normal → TILE at native size on both axes (UV-repeat; GL_REPEAT-wrapped UI
                // texture), matching ImgTex::TileCSI. Overlay/Alphablend use the same blit (the
                // sprite shader already alpha-blends). No Stretch mode exists in DrawModeType.
                ctx.DrawSprite(tex, 0, 0, Width, Height, 0, 0, Width / tw, Height / th, Vector4.One);
            }
        }

        DrawLabel(ctx);
    }

    private void DrawLabel(UiRenderContext ctx)
    {
        // Centered text label over the sprite (retail draws button captions as text;
        // their dat sprites are blank frames).
        if (Label is { Length: > 0 } label && LabelFont is { } lf)
        {
            float tx = (Width - lf.MeasureWidth(label)) * 0.5f;
            float ty = (Height - lf.LineHeight) * 0.5f;
            ctx.DrawStringDat(lf, label, tx, ty, LabelColor);
        }
    }
}