using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using AcDream.App.UI;
using AcDream.App.UI.Layout;
using AcDream.Content;
using DatReaderWriter;
using DatReaderWriter.DBObjs;
using DatReaderWriter.Options;

namespace AcDream.App.Tests.UI.Layout;

/// <summary>
/// #409 (client-wide retail tooltip system) installed-DAT acceptance gate.
/// Opt in with <c>ACDREAM_PROBE_LIVE_MOUNT=1</c>; <c>ACDREAM_DAT_DIR</c> can
/// override the ordinary Documents/Asheron's Call location. Pins retail's
/// tooltip popup LayoutDesc <c>0x21000041</c> structure and a client-wide
/// sweep landmark, mirroring <see cref="CharacterManagementLiveDatTests"/>'s
/// pattern.
/// </summary>
public sealed class TooltipLiveDatTests
{
    private static string DatDirectory =>
        System.Environment.GetEnvironmentVariable("ACDREAM_DAT_DIR")
        ?? Path.Combine(
            System.Environment.GetFolderPath(System.Environment.SpecialFolder.UserProfile),
            "Documents",
            "Asheron's Call");

    /// <summary>The tooltip popup catalog LayoutDesc — every probed
    /// tooltip-bearing element's P0x48 resolves here (with one exception,
    /// 0x21000026, an alternate skin used by a handful of elements —
    /// RetailTooltipPresenter is data-driven off each element's OWN P0x48
    /// so neither this constant nor 0x21000026 is hardcoded in production
    /// code; it is cited here only to pin the probe's own finding).</summary>
    private const uint TooltipCatalogLayoutId = 0x21000041u;

    /// <summary>The four popup "skin" root element ids live-DAT-probed inside
    /// <see cref="TooltipCatalogLayoutId"/>. Each is a 30x30 four-piece bevel
    /// frame around the SAME text child id (<see cref="TooltipTextChildId"/>).</summary>
    private static readonly uint[] PopupSkinRootIds =
        [0x10000487u, 0x10000395u, 0x10000397u, 0x10000398u];

    private const uint TooltipTextChildId = 0x10000396u;

    [InstalledDatFact]
    public void TooltipCatalog_EveryPopupSkin_SharesTheSameTextChild()
    {
        using var dats = new DatCollection(DatDirectory, DatAccessType.Read);

        ElementInfo? root = LayoutImporter.ImportInfos(dats, TooltipCatalogLayoutId);
        Assert.NotNull(root);
        Assert.Equal(0u, root!.Id);
        Assert.Equal(800f, root.Width);
        Assert.Equal(600f, root.Height);

        foreach (uint skinRootId in PopupSkinRootIds)
        {
            ElementInfo skin = Assert.Single(root.Children, c => c.Id == skinRootId);
            // UIElementManager::StartTooltip @0x0045DE90's own fallback read:
            // GetAttribute_Enum(tooltipRootElement, 0x4a, &textChildId) off the
            // freshly-instantiated POPUP root itself.
            Assert.Equal(TooltipTextChildId, skin.TooltipTextChildElementId);

            ElementInfo textChild = Assert.Single(
                AllDescendants(skin), e => e.Id == TooltipTextChildId);
            Assert.Equal(12u, textChild.Type); // UIElement_Text
        }
    }

    [InstalledDatFact]
    public void TooltipCatalog_ImportsThroughLayoutImporter_WithTextChildResolvable()
    {
        using var dats = new DatCollection(DatDirectory, DatAccessType.Read);

        ImportedLayout? popup = LayoutImporter.Import(
            dats,
            TooltipCatalogLayoutId,
            0x10000487u,
            _ => (0u, 0, 0),
            null);
        Assert.NotNull(popup);
        Assert.Equal(30f, popup!.Root.Width);
        Assert.Equal(30f, popup.Root.Height);
        Assert.Equal(TooltipTextChildId, popup.Root.AuthoredTooltipTextChildElementId);

        UiElement? textChild = popup.FindElement(TooltipTextChildId);
        Assert.IsType<UiText>(textChild);
    }

    /// <summary>
    /// A known tooltip-bearing element (the Appearance page's left rotate
    /// button, live-DAT-probed) authors all five trigger properties with
    /// literal StringInfo text — the "core" case
    /// <see cref="RetailTooltipPresenter"/> can show end to end.
    /// </summary>
    [InstalledDatFact]
    public void KnownElement_AuthorsAllFiveTooltipProperties_WithResolvableText()
    {
        using var dats = new DatCollection(DatDirectory, DatAccessType.Read);

        ElementInfo? tree = LayoutImporter.ImportInfos(dats, 0x21000005u);
        Assert.NotNull(tree);
        ElementInfo rotateLeft = Assert.Single(AllDescendants(tree!), e => e.Id == 0x100005A4u);

        Assert.True(rotateLeft.TooltipEnabled);
        Assert.Equal(0x10000487u, rotateLeft.TooltipRootElementId);
        Assert.Equal(TooltipCatalogLayoutId, rotateLeft.TooltipLayoutDid);
        Assert.NotNull(rotateLeft.TooltipText);

        var strings = new DatStringResolver(dats);
        string? resolved = DatWidgetFactory.ResolveTooltipText(rotateLeft, strings.Resolve);
        Assert.Equal("Rotate left.", resolved);
    }

    /// <summary>
    /// Landmark client-wide sweep (mirrors
    /// <see cref="LayoutImporterMediaBearingChildSweepTests"/>'s own shape):
    /// every installed LayoutDesc, counting elements authoring at least one
    /// of the five tooltip-trigger properties. Asserts landmarks + a floor,
    /// not a brittle exact total, so the gate survives a future DAT
    /// revision.
    /// </summary>
    [InstalledDatFact]
    public void ClientWideSweep_FindsKnownLandmarksAndAFloorCount()
    {
        using var dats = new DatCollection(DatDirectory, DatAccessType.Read);

        var withProperties = new List<(uint LayoutId, uint ElementId, bool HasText, bool Showable)>();
        foreach (uint layoutId in dats.GetAllIdsOfType<LayoutDesc>())
        {
            ElementInfo? tree;
            try { tree = LayoutImporter.ImportInfos(dats, layoutId); }
            catch { continue; }
            if (tree is null) continue;

            foreach (ElementInfo e in AllDescendants(tree))
            {
                bool any = e.TooltipRootElementId != 0 || e.TooltipLayoutDid != 0
                    || e.TooltipText.HasValue || e.TooltipEnabled
                    || e.TooltipDelaySeconds.HasValue;
                if (any)
                {
                    // F9 (2026-08-16 review round): "with literal text" alone
                    // over-counts what RetailTooltipPresenter.OnTooltipShow
                    // actually shows — that gate is a FULL AND across
                    // TooltipEnabled (P0x4B) AND non-null text (P0x49) AND
                    // both popup-locator ids (P0x47/P0x48), not just text
                    // presence. Measure the real intersection instead of
                    // assuming "243 with text" == "243 showable".
                    bool showable = e.TooltipEnabled && e.TooltipText.HasValue
                        && e.TooltipLayoutDid != 0 && e.TooltipRootElementId != 0;
                    withProperties.Add((layoutId, e.Id, e.TooltipText.HasValue, showable));
                }
            }
        }

        Console.WriteLine($"[409-DAT] {withProperties.Count} elements author >=1 tooltip property "
            + $"({withProperties.Count(f => f.HasText)} with literal StringInfo text, "
            + $"{withProperties.Count(f => f.Showable)} pass the full OnTooltipShow gate).");

        // #409 investigation landmark (main game UI, Appearance rotate button).
        Assert.Contains(withProperties, f => f.LayoutId == 0x21000005u && f.ElementId == 0x100005A4u);
        // Floor: the live-DAT sweep found 430 total / 243 with literal text /
        // 243 fully showable (2026-08-16, both post-F9 measurements) —
        // assert comfortably below all three so a future content patch that
        // only ADDS tooltip authoring cannot flake this gate.
        Assert.True(withProperties.Count >= 400,
            $"expected at least 400 tooltip-property-authoring elements, found {withProperties.Count}.");
        Assert.True(withProperties.Count(f => f.HasText) >= 200,
            $"expected at least 200 elements with literal tooltip text, found {withProperties.Count(f => f.HasText)}.");
        Assert.True(withProperties.Count(f => f.Showable) >= 200,
            $"expected at least 200 fully showable elements, found {withProperties.Count(f => f.Showable)}.");
    }

    /// <summary>
    /// #409 live-failure round, the pin that protects the runtime-text fix.
    /// The Options panel's authored toggle-row TEMPLATE (LayoutDesc
    /// <c>0x2100002B</c>, row root <c>0x10000218</c>, checkbox leaf
    /// <c>0x10000219</c>) carries the full tooltip POPUP LOCATOR
    /// (<c>P0x47</c>/<c>P0x48</c>) and the <c>P0x4B</c> on-bit, but authors NO
    /// <c>P0x49</c> text — its help string arrives at runtime, exactly as
    /// retail's <c>UIOption_CheckboxBitfield64::CreateChildren @0x00485E65</c>
    /// stamps its <c>siTooltip</c> array. This is why reading only
    /// <c>AuthoredTooltipText</c> showed nothing anywhere in-world; see
    /// <c>RetailTooltipPresenter.ResolveTooltipText</c>.
    ///
    /// <para>The row template is template-list referenced, so
    /// <see cref="LayoutImporter.ImportInfos"/>'s client-wide walk deliberately
    /// filters it out (#375) — it has to be imported by its own root id.</para>
    /// </summary>
    [InstalledDatFact]
    public void OptionsToggleRowTemplate_AuthorsThePopupLocatorButNoLiteralText()
    {
        using var dats = new DatCollection(DatDirectory, DatAccessType.Read);

        ImportedLayout? row = LayoutImporter.Import(
            dats, OptionsPanelLayoutId, OptionsToggleRowTemplateId, _ => (0u, 0, 0), null);
        Assert.NotNull(row);

        UiElement checkbox = Assert.Single(
            AllWidgets(row!.Root), w => w.DatElementId == OptionsToggleCheckboxId);

        Assert.Equal(0x10000397u, checkbox.AuthoredTooltipRootElementId);   // P0x47
        Assert.Equal(TooltipCatalogLayoutId, checkbox.AuthoredTooltipLayoutDid); // P0x48
        Assert.True(checkbox.AuthoredTooltipEnabled);                        // P0x4B
        Assert.True(string.IsNullOrEmpty(checkbox.AuthoredTooltipText));     // no P0x49
        // ...and it is a real hover target, so UiRoot.UpdateHover can select it.
        Assert.False(checkbox.ClickThrough);
        // StartTooltipAtMouse @0x00460E7E's fallback source, stamped by the
        // importer's dat shell.
        Assert.Equal(OptionsPanelLayoutId, checkbox.SourceLayoutDid);
    }

    private const uint OptionsPanelLayoutId = 0x2100002Bu;
    private const uint OptionsToggleRowTemplateId = 0x10000218u;
    private const uint OptionsToggleCheckboxId = 0x10000219u;

    private static IEnumerable<UiElement> AllWidgets(UiElement root)
    {
        yield return root;
        foreach (UiElement child in root.Children)
            foreach (UiElement descendant in AllWidgets(child))
                yield return descendant;
    }

    private static IEnumerable<ElementInfo> AllDescendants(ElementInfo root)
    {
        yield return root;
        foreach (ElementInfo child in root.Children)
            foreach (ElementInfo descendant in AllDescendants(child))
                yield return descendant;
    }
}