spigot-base/src/test/java/games/dmg/spigotbase/BaseSettingsDialogFactoryTest.java

package games.dmg.spigotbase;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import net.kyori.adventure.text.event.ClickEvent;
import org.junit.jupiter.api.Test;

final class BaseSettingsDialogFactoryTest {
    @Test
    void createsStaticRunCommandActionWithoutMacroVariables() {
        ClickEvent<ClickEvent.Payload.Text> action = BaseSettingsDialogFactory.commandClick(
            "/basesettings status"
        );

        assertEquals(ClickEvent.Action.RUN_COMMAND, action.action());
        ClickEvent.Payload.Text payload = assertInstanceOf(
            ClickEvent.Payload.Text.class,
            action.payload()
        );
        assertEquals("/basesettings status", payload.value());
    }

    @Test
    void createsBackButtonThatReturnsToMainSettingsDashboard() {
        BaseSettingsDialogFactory.ButtonSpec back =
            BaseSettingsDialogFactory.backButtonSpec();

        assertEquals("Back", back.label());
        assertEquals("/basesettings ui", back.command());
    }

    @Test
    void createsControlsForEveryBaseSettingAndConfirmedPurchase() {
        UUID playerId = UUID.randomUUID();
        PlayerState owner = PlayerState.newPlayer(playerId, "Builder")
            .withAdministrativeLevels(4, 2, 2, 1, 1, true, true, true)
            .withBase(
                new BaseLocation(UUID.randomUUID(), "world", 10, 64, 20, 10, 20),
                Instant.EPOCH
            )
            .withBorderEnabled(true)
            .withTotalBlocksPlaced(250)
            .withSpawnableOverlayEnabled(true);
        PocketBaseState pocket = new PocketBaseState(
            playerId,
            1,
            Optional.empty(),
            Optional.empty(),
            true,
            false,
            PocketBaseBiome.PLAINS,
            true
        );

        BaseSettingsDialogFactory.DialogSpec specification =
            new BaseSettingsDialogFactory(PluginSettings.from(Map.of()))
                .specification(owner, pocket);

        BaseSettingsDialogFactory.ListSpec root = assertInstanceOf(
            BaseSettingsDialogFactory.ListSpec.class,
            specification
        );
        assertTrue(root.content().message().contains("Base 4/4"));
        BaseSettingsDialogFactory.ListSpec pocketSettings = assertInstanceOf(
            BaseSettingsDialogFactory.ListSpec.class,
            root.dialogs().get(3)
        );
        assertTrue(pocketSettings.content().message().contains(
            "Flight: Enabled"
        ));
        List<String> commands = commands(root);
        assertTrue(commands.contains("/basesettings status"));
        assertTrue(commands.contains("/basesettings visitors blocked"));
        assertTrue(commands.contains("/basesettings navigation disable"));
        assertTrue(commands.contains("/basesettings flight disable"));
        assertTrue(commands.contains("/basesettings border disable"));
        assertTrue(commands.contains("/basesettings spawnable disable"));
        assertTrue(commands.contains("/basesettings bossbar disable"));
        assertTrue(commands.contains("/basesettings pocket upgrade"));
        assertTrue(commands.contains("/basesettings pocket flight disable"));
        assertTrue(commands.contains("/basesettings pocket mobs hostile disable"));
        assertTrue(commands.contains("/basesettings pocket mobs passive enable"));
        assertTrue(commands.contains("/basesettings pocket type nether crimson_forest"));
    }

    @Test
    void requiresConfirmationForBaseIvPurchase() {
        UUID playerId = UUID.randomUUID();
        PlayerState owner = PlayerState.newPlayer(playerId, "Builder")
            .withAdministrativeLevels(3, 0, 0, 0, 0, false, false, false)
            .withBase(
                new BaseLocation(UUID.randomUUID(), "world", 0, 64, 0, 0, 0),
                Instant.EPOCH
            );

        BaseSettingsDialogFactory.ListSpec root = assertInstanceOf(
            BaseSettingsDialogFactory.ListSpec.class,
            new BaseSettingsDialogFactory(PluginSettings.from(Map.of())).specification(
                owner,
                PocketBaseState.locked(playerId)
            )
        );
        BaseSettingsDialogFactory.ConfirmationSpec upgrade = assertInstanceOf(
            BaseSettingsDialogFactory.ConfirmationSpec.class,
            root.dialogs().get(2)
        );

        assertEquals("/basesettings upgrade", upgrade.confirm().command());
    }

    @Test
    void marksUnavailableControlsAsLocked() {
        UUID playerId = UUID.randomUUID();
        PlayerState owner = PlayerState.newPlayer(playerId, "Newcomer");

        BaseSettingsDialogFactory.ListSpec root = assertInstanceOf(
            BaseSettingsDialogFactory.ListSpec.class,
            new BaseSettingsDialogFactory(PluginSettings.from(Map.of())).specification(
                owner,
                PocketBaseState.locked(playerId)
            )
        );
        BaseSettingsDialogFactory.MultiSpec controls = assertInstanceOf(
            BaseSettingsDialogFactory.MultiSpec.class,
            root.dialogs().get(0)
        );
        List<String> labels = controls.actions().stream()
            .map(BaseSettingsDialogFactory.ButtonSpec::label)
            .toList();

        assertTrue(labels.stream().anyMatch(label -> label.contains("Visitors: Locked")));
        assertTrue(labels.stream().anyMatch(label -> label.contains("Navigation: Locked")));
        assertTrue(labels.stream().anyMatch(label -> label.contains("Flight: Locked")));
        assertTrue(labels.stream().anyMatch(label -> label.contains("Border: Locked")));
        assertTrue(labels.stream().anyMatch(label -> label.contains("Spawnable Overlay: Locked")));
    }

    private static List<String> commands(
        BaseSettingsDialogFactory.DialogSpec specification
    ) {
        List<String> commands = new ArrayList<>();
        collect(specification, commands);
        return commands;
    }

    private static void collect(
        BaseSettingsDialogFactory.DialogSpec specification,
        List<String> commands
    ) {
        if (specification instanceof BaseSettingsDialogFactory.ListSpec list) {
            list.dialogs().forEach(child -> collect(child, commands));
        } else if (specification instanceof BaseSettingsDialogFactory.MultiSpec multi) {
            multi.actions().forEach(button -> commands.add(button.command()));
        } else if (specification
                instanceof BaseSettingsDialogFactory.ConfirmationSpec confirmation) {
            commands.add(confirmation.confirm().command());
        } else if (specification instanceof BaseSettingsDialogFactory.NoticeSpec notice
                && notice.action() != null) {
            commands.add(notice.action().command());
        }
    }
}