acdream/tests/AcDream.App.Tests/UI/Layout/EffectsUiControllerTests.cs

using AcDream.App.UI;
using AcDream.App.UI.Layout;
using AcDream.Core.Spells;

namespace AcDream.App.Tests.UI.Layout;

public sealed class EffectsUiControllerTests
{
    private static (uint, int, int) NoTex(uint _) => (0u, 0, 0);

    [Fact]
    public void Rebuild_DoesNotAutoSelectFirstEffect_AndClearsRemovedSelection()
    {
        var table = SpellTable.LoadFromReader(new StringReader(
            "Spell ID,Name,Flags [Hex]\n42,Boon,0x4\n"));
        var spellbook = new Spellbook(table);
        var root = new UiPanel { Width = 160f, Height = 100f };
        var list = new UiItemList(NoTex) { Width = 160f, Height = 64f };
        var info = new UiText { Width = 160f, Height = 32f };
        root.AddChild(list);
        root.AddChild(info);
        var layout = new ImportedLayout(root, new Dictionary<uint, UiElement>
        {
            [EffectsUiController.ListId] = list,
            [EffectsUiController.InfoTextId] = info,
        });
        using EffectsUiController controller = EffectsUiController.Bind(
            layout, spellbook, positive: true, () => 0d, NoTex, id => id)!;

        spellbook.OnEnchantmentAdded(new ActiveEnchantmentRecord(
            42u, 1u, 60f, 1u, Bucket: 1u, SpellCategory: 42u));
        spellbook.OnEnchantmentAdded(new ActiveEnchantmentRecord(
            42u, 2u, 60f, 1u, Bucket: 4u, SpellCategory: 42u));
        spellbook.OnEnchantmentAdded(new ActiveEnchantmentRecord(
            42u, 3u, 60f, 1u, Bucket: 8u, SpellCategory: 42u));
        Assert.Null(controller.SelectedSpellId);
        Assert.Equal(1, list.GetNumUIItems());
        UiCatalogSlot row = Assert.IsType<UiCatalogSlot>(list.GetItem(0));
        row.OnEvent(new UiEvent(0, row, UiEventType.Click));
        Assert.Equal(42u, controller.SelectedSpellId);

        spellbook.OnEnchantmentRemoved(1u, 42u);
        Assert.Null(controller.SelectedSpellId);
    }

    [Fact]
    public void DuplicateLayersOfSameSpell_ShareRetailSelection()
    {
        var table = SpellTable.LoadFromReader(new StringReader(
            "Spell ID,Name,Flags [Hex]\n42,Boon,0x4\n"));
        var spellbook = new Spellbook(table);
        var root = new UiPanel { Width = 160f, Height = 100f };
        var list = new UiItemList(NoTex) { Width = 160f, Height = 64f };
        root.AddChild(list);
        var layout = new ImportedLayout(root, new Dictionary<uint, UiElement>
        {
            [EffectsUiController.ListId] = list,
        });
        using EffectsUiController controller = EffectsUiController.Bind(
            layout, spellbook, positive: true, () => 0d, NoTex, id => id)!;
        spellbook.OnEnchantmentAdded(new ActiveEnchantmentRecord(
            42u, 1u, 60f, 1u, Bucket: 1u, SpellCategory: 100u));
        spellbook.OnEnchantmentAdded(new ActiveEnchantmentRecord(
            42u, 2u, 60f, 2u, Bucket: 2u, SpellCategory: 101u));

        UiCatalogSlot first = Assert.IsType<UiCatalogSlot>(list.GetItem(0));
        UiCatalogSlot second = Assert.IsType<UiCatalogSlot>(list.GetItem(1));
        first.OnEvent(new UiEvent(0, first, UiEventType.Click));

        Assert.Equal(42u, controller.SelectedSpellId);
        Assert.True(first.Selected);
        Assert.True(second.Selected);

        second.OnEvent(new UiEvent(0, second, UiEventType.Click));
        Assert.Null(controller.SelectedSpellId);
        Assert.False(first.Selected);
        Assert.False(second.Selected);
    }

    [Theory]
    [InlineData(true)]
    [InlineData(false)]
    public void AuthoredEffectsFixture_InheritsListAndInfo_AndBinds(bool positive)
    {
        ElementInfo info = positive
            ? FixtureLoader.LoadPositiveEffectsInfos()
            : FixtureLoader.LoadNegativeEffectsInfos();
        uint expectedRoot = positive
            ? EffectsUiController.PositiveRootId
            : EffectsUiController.NegativeRootId;
        Assert.Equal(expectedRoot, info.Id);
        Assert.Equal(0x1000001Bu, info.Type);
        Assert.Equal(300f, info.Width);
        Assert.Equal(362f, info.Height);
        Assert.True(info.TryGetEffectiveProperty(0x1000000Cu, out UiPropertyValue effectType));
        Assert.Equal(UiPropertyKind.Enum, effectType.Kind);
        Assert.Equal(positive ? 1u : 2u, effectType.UnsignedValue);
        Assert.Equal(
            positive,
            info.TryGetEffectiveBool(0x10000049u, out bool restorePrevious)
                && restorePrevious);

        ElementInfo[] children = info.Children.OrderBy(child => child.ReadOrder).ToArray();
        Assert.Equal(
            [0x100000FCu, 0x10000120u, 0x10000123u, 0x10000124u, 0x10000125u],
            children.Select(child => child.Id));
        Assert.Equal([1u, 2u, 3u, 4u, 5u], children.Select(child => child.ReadOrder));
        Assert.Equal(children.Length, children.Select(child => child.Id).Distinct().Count());
        ElementInfo listInfo = Assert.Single(children, child => child.Id == EffectsUiController.ListId);
        Assert.Equal(5u, listInfo.Type);
        Assert.Equal(300f, listInfo.Width);
        Assert.Equal(249f, listInfo.Height);
        Assert.Equal(12u, FindInfo(info, EffectsUiController.InfoTextId)?.Type);

        ImportedLayout layout = LayoutImporter.Build(info, NoTex, datFont: null);
        var spellbook = new Spellbook();
        int closes = 0;

        using EffectsUiController? controller = EffectsUiController.Bind(
            layout, spellbook, positive, () => 0d, NoTex, id => id, () => closes++);

        Assert.NotNull(controller);
        Assert.NotNull(layout.FindElement(EffectsUiController.ListId));
        Assert.IsType<UiText>(layout.FindElement(EffectsUiController.InfoTextId));
        Assert.Equal(expectedRoot, layout.Root.DatElementId);
        UiButton close = Assert.IsType<UiButton>(layout.FindElement(EffectsUiController.CloseId));
        close.OnEvent(new UiEvent(0, close, UiEventType.Click));
        Assert.Equal(1, closes);

        uint panelId = positive
            ? RetailPanelCatalog.PositiveEffects
            : RetailPanelCatalog.NegativeEffects;
        Assert.True(RetailPanelCatalog.TryGetWindowName(panelId, out string windowName));
        Assert.Equal(
            positive ? WindowNames.PositiveEffects : WindowNames.NegativeEffects,
            windowName);
        Assert.DoesNotContain(
            RetailPanelCatalog.ToolbarPanels,
            entry => entry.PanelId == panelId);
    }

    [Theory]
    [InlineData(true)]
    [InlineData(false)]
    public void AuthoredRestorePreviousProperty_DrivesRetailPanelLifecycle(bool positive)
    {
        ElementInfo info = positive
            ? FixtureLoader.LoadPositiveEffectsInfos()
            : FixtureLoader.LoadNegativeEffectsInfos();
        var visible = new Dictionary<string, bool>(StringComparer.Ordinal)
        {
            [WindowNames.Inventory] = false,
            [positive ? WindowNames.PositiveEffects : WindowNames.NegativeEffects] = false,
        };
        var panelUi = new RetailPanelUiController(
            name => visible[name],
            name =>
            {
                visible[name] = true;
                return true;
            },
            name =>
            {
                visible[name] = false;
                return true;
            });
        uint effectsPanel = positive
            ? RetailPanelCatalog.PositiveEffects
            : RetailPanelCatalog.NegativeEffects;
        string effectsWindow = positive
            ? WindowNames.PositiveEffects
            : WindowNames.NegativeEffects;
        panelUi.Register(RetailPanelCatalog.Inventory, WindowNames.Inventory);
        panelUi.Register(
            effectsPanel,
            effectsWindow,
            info);

        panelUi.SetPanelVisibility(RetailPanelCatalog.Inventory, visible: true);
        panelUi.SetPanelVisibility(effectsPanel, visible: true);
        panelUi.SetPanelVisibility(effectsPanel, visible: false);

        Assert.Equal(positive, visible[WindowNames.Inventory]);
        Assert.False(visible[effectsWindow]);
        Assert.Equal(
            positive ? RetailPanelCatalog.Inventory : null,
            panelUi.ActivePanelId);
    }

    private static ElementInfo? FindInfo(ElementInfo root, uint id)
    {
        if (root.Id == id) return root;
        foreach (ElementInfo child in root.Children)
            if (FindInfo(child, id) is { } found)
                return found;
        return null;
    }
}