using System.Collections.Generic;
using AcDream.App.UI.Layout;

namespace AcDream.App.UI;

/// <summary>
/// Retail <c>UIElement_TabControl</c> (Type 8) — the Options panel's tab strip +
/// mounted-page switcher. Owns the authored tab table (dat property <c>0x2E</c>,
/// see <see cref="UiTabTableEntry"/>): activating a tab shows exactly ONE page-slot
/// child and hides the rest, and updates the corresponding tab button's Open/Closed
/// visual state.
///
/// <para>
/// The tab buttons and page-slot children are ORDINARY imported dat elements — this
/// widget does <b>not</b> set <see cref="UiElement.ConsumesDatChildren"/>, so
/// <c>LayoutImporter</c> builds them the normal recursive way (buttons build as
/// <see cref="UiText"/> with Open/Closed states — retail's tab buttons are Type 0xC
/// text elements, not Type-1 buttons; page slots build as generic containers whose
/// OWN children are the mounted page's content via <c>BaseLayoutId</c>/
/// <c>BaseElement</c> inheritance). This widget only wires cross-references the tab
/// table names by id, which it can only resolve once that subtree exists — see
/// <see cref="IUiChildrenAttachedListener"/>.
/// </para>
///
/// <para>
/// Retail anchors: <c>docs/research/2026-08-10-options-panel-structure.md</c> §1.3
/// (the tab table property <c>0x2E</c> struct shape), §10.1 (structural inventory —
/// tab buttons `0x1000020D..0x1000020F`/`0x1000050B`, page slots
/// `0x10000211..0x10000213`/`0x1000050C`, Gameplay the authored default). Verified
/// byte-for-byte against the regenerated <c>options_2100002B.json</c> fixture: four
/// entries, Gameplay (`0x1000020D`/`0x10000212`) is the sole <c>IsDefault</c> row.
/// </para>
///
/// <para>
/// Retail's <c>OnVisibilityChanged</c> auto-apply/auto-revert semantics (research doc
/// §3.6 — hiding a page reverts uncommitted edits, showing one applies + commits) are
/// OUT of this widget's scope: they belong to the <c>OptionPage</c>/
/// <c>PlayerOptionPage</c> model a page controller owns (Campaign OP slice OP3+).
/// This widget only switches which page slot is <see cref="UiElement.Visible"/>.
/// </para>
/// </summary>
public sealed class UiTabControl : UiElement, IUiChildrenAttachedListener
{
    private readonly IReadOnlyList<UiTabTableEntry> _tabs;

    public UiTabControl(IReadOnlyList<UiTabTableEntry> tabs)
    {
        _tabs = tabs;
    }

    /// <summary>The authored tab table this control was built from, in authored array order.</summary>
    public IReadOnlyList<UiTabTableEntry> Tabs => _tabs;

    /// <summary>Dat element id of the currently active page slot. 0 before the first mount.</summary>
    public uint ActivePageElementId { get; private set; }

    /// <summary>
    /// Retail wires the tab table's cross-references (button ↔ page ↔ default) once
    /// the imported subtree exists — see <see cref="IUiChildrenAttachedListener"/>'s
    /// doc for why this can't happen during <c>DatWidgetFactory.Create</c>. Every tab
    /// button's click is bound to switch to its paired page, then the authored
    /// default tab (the entry with <see cref="UiTabTableEntry.IsDefault"/> true, or
    /// the first entry if the dat authored none) is activated.
    /// </summary>
    public void OnChildrenAttached()
    {
        UiTabTableEntry? defaultEntry = null;
        foreach (UiTabTableEntry entry in _tabs)
        {
            UiElement? button = FindDirectChild(entry.ButtonElementId);
            uint pageId = entry.PageElementId;
            RetailTabBinding.SetClick(button, () => SwitchTo(pageId));

            if (entry.IsDefault)
                defaultEntry = entry;
        }

        defaultEntry ??= _tabs.Count > 0 ? _tabs[0] : null;
        if (defaultEntry is { } def)
            SwitchTo(def.PageElementId);
    }

    /// <summary>
    /// Activates the page slot named <paramref name="pageElementId"/>: shows it, hides
    /// every other authored page slot, and sets each tab button's Open/Closed state to
    /// match (<see cref="RetailTabBinding.SetOpen"/>). No-op if the page is already active.
    /// </summary>
    public void SwitchTo(uint pageElementId)
    {
        if (ActivePageElementId == pageElementId) return;

        foreach (UiTabTableEntry entry in _tabs)
        {
            bool active = entry.PageElementId == pageElementId;
            UiElement? page = FindDirectChild(entry.PageElementId);
            if (page is not null) page.Visible = active;

            UiElement? button = FindDirectChild(entry.ButtonElementId);
            RetailTabBinding.SetOpen(button, active);
        }

        ActivePageElementId = pageElementId;
    }

    private UiElement? FindDirectChild(uint datElementId)
    {
        foreach (UiElement child in Children)
            if (child.DatElementId == datElementId)
                return child;
        return null;
    }
}