spigot-tyrant/src/test/java/games/dmg/spigottyrant/TyrantProgressionServiceTest.java

package games.dmg.spigottyrant;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.time.Duration;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import org.junit.jupiter.api.Test;

final class TyrantProgressionServiceTest {
    private static final UUID TYRANT = UUID.fromString("11111111-1111-1111-1111-111111111111");
    private static final UUID VIGILANTE = UUID.fromString("22222222-2222-2222-2222-222222222222");
    private static final UUID OTHER = UUID.fromString("33333333-3333-3333-3333-333333333333");
    private final TyrantProgressionService service = new TyrantProgressionService();

    @Test
    void tyrantPersonallyKillingCurrentVigilanteEarnsOneLevelAndChoice() {
        GameState before = runningState(0, 1, Set.of());

        GameState after = service.recordVigilanteDeath(before, Optional.of(TYRANT));

        assertEquals(1, after.tyrantLevel());
        assertEquals(2, after.unspentChoices());
    }

    @Test
    void otherEnvironmentalAndPausedDeathsDoNotEarnProgress() {
        GameState running = runningState(2, 0, Set.of());
        GameState paused = new GameState(
            GameLifecycle.PAUSED,
            running.tyrantId(),
            running.vigilanteId(),
            running.pendingTyrant(),
            running.pendingVigilante(),
            Optional.of(java.time.Instant.parse("2026-08-14T12:00:00Z")),
            Duration.ZERO,
            2,
            0,
            Set.of()
        );

        assertEquals(running, service.recordVigilanteDeath(running, Optional.of(OTHER)));
        assertEquals(running, service.recordVigilanteDeath(running, Optional.empty()));
        assertEquals(paused, service.recordVigilanteDeath(paused, Optional.of(TYRANT)));
    }

    @Test
    void administrativePointGrantAddsOneLevelAndChoicePerInvocation() {
        GameState base = runningState(2, 1, Set.of(TyrantUnlock.ASSASSIN));
        GameState before = new GameState(
            base.lifecycle(), base.tyrantId(), base.vigilanteId(), base.pendingTyrant(),
            base.pendingVigilante(), base.pausedAt(), base.accumulatedPausedTime(),
            base.tyrantLevel(), base.unspentChoices(), base.purchases(),
            Set.of(TyrantArmorPiece.HELMET)
        );

        GameState first = service.grantPoint(before);
        GameState second = service.grantPoint(first);

        assertEquals(4, second.tyrantLevel());
        assertEquals(3, second.unspentChoices());
        assertEquals(before.purchases(), second.purchases());
        assertEquals(before.tyrantId(), second.tyrantId());
        assertEquals(before.vigilanteId(), second.vigilanteId());
        assertEquals(before.claimedArmor(), second.claimedArmor());
    }

    @Test
    void administrativePointGrantRequiresRunningGameAndCurrentTyrant() {
        GameState running = runningState(0, 1, Set.of());
        GameState paused = new GameState(
            GameLifecycle.PAUSED, running.tyrantId(), running.vigilanteId(),
            running.pendingTyrant(), running.pendingVigilante(),
            Optional.of(java.time.Instant.parse("2026-08-14T12:00:00Z")),
            Duration.ZERO, 0, 1, Set.of()
        );
        GameState vacant = new GameState(
            GameLifecycle.RUNNING, Optional.empty(), Optional.empty(), Optional.empty(),
            Optional.empty(), Optional.empty(), Duration.ZERO, 0, 0, Set.of()
        );

        assertThrows(IllegalStateException.class, () -> service.grantPoint(paused));
        assertThrows(IllegalStateException.class, () -> service.grantPoint(vacant));
    }

    @Test
    void purchaseConsumesOneChoiceAndCannotBeBoughtTwice() {
        GameState before = runningState(1, 2, Set.of());

        PurchaseResult first = service.purchase(before, TYRANT, TyrantUnlock.ASSASSIN);
        PurchaseResult duplicate = service.purchase(
            first.state(), TYRANT, TyrantUnlock.ASSASSIN
        );

        assertEquals(PurchaseStatus.PURCHASED, first.status());
        assertEquals(1, first.state().unspentChoices());
        assertTrue(first.state().purchases().contains(TyrantUnlock.ASSASSIN));
        assertEquals(PurchaseStatus.ALREADY_PURCHASED, duplicate.status());
        assertEquals(first.state(), duplicate.state());
    }

    @Test
    void nonTyrantPausedAndNoChoicePurchasesAreRejected() {
        GameState noChoices = runningState(0, 0, Set.of());
        GameState paused = new GameState(
            GameLifecycle.PAUSED,
            noChoices.tyrantId(),
            noChoices.vigilanteId(),
            noChoices.pendingTyrant(),
            noChoices.pendingVigilante(),
            Optional.of(java.time.Instant.parse("2026-08-14T12:00:00Z")),
            Duration.ZERO,
            0,
            1,
            Set.of()
        );

        assertEquals(PurchaseStatus.NO_CHOICES,
            service.purchase(noChoices, TYRANT, TyrantUnlock.FIXER).status());
        assertEquals(PurchaseStatus.NOT_TYRANT,
            service.purchase(runningState(0, 1, Set.of()), OTHER, TyrantUnlock.FIXER).status());
        PurchaseResult pausedResult = service.purchase(paused, TYRANT, TyrantUnlock.FIXER);
        assertEquals(PurchaseStatus.GAME_NOT_RUNNING, pausedResult.status());
        assertFalse(pausedResult.state().purchases().contains(TyrantUnlock.FIXER));
    }

    @Test
    void endingReignClearsLevelChoicesAndPurchases() {
        GameState base = runningState(
            4,
            2,
            Set.of(TyrantUnlock.ASSASSIN, TyrantUnlock.STRENGTH)
        );
        GameState progressed = new GameState(
            base.lifecycle(), base.tyrantId(), base.vigilanteId(), base.pendingTyrant(),
            base.pendingVigilante(), base.pausedAt(), base.accumulatedPausedTime(),
            base.tyrantLevel(), base.unspentChoices(), base.purchases(),
            Set.of(TyrantArmorPiece.BOOTS)
        );

        GameState reset = service.resetReignProgression(progressed);

        assertEquals(0, reset.tyrantLevel());
        assertEquals(0, reset.unspentChoices());
        assertEquals(Set.of(), reset.purchases());
        assertEquals(Set.of(), reset.claimedArmor());
    }

    private static GameState runningState(
        int level,
        int choices,
        Set<TyrantUnlock> purchases
    ) {
        return new GameState(
            GameLifecycle.RUNNING,
            Optional.of(TYRANT),
            Optional.of(VIGILANTE),
            Optional.empty(),
            Optional.empty(),
            Optional.empty(),
            Duration.ZERO,
            level,
            choices,
            purchases
        );
    }
}