XFEServerManager

package com.xfestudio.xfeservermanager.core.spi;

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

import com.xfestudio.xfeservermanager.api.command.CommandAnalysisRequest;
import com.xfestudio.xfeservermanager.api.command.InvocationAst;
import com.xfestudio.xfeservermanager.api.spi.CommandSemanticAdapter;
import com.xfestudio.xfeservermanager.api.spi.SemanticAnalysisException;
import com.xfestudio.xfeservermanager.api.spi.WorldStateCodecAdapter;
import com.xfestudio.xfeservermanager.api.world.WorldStateKind;
import com.xfestudio.xfeservermanager.api.world.WorldStatePayload;
import com.xfestudio.xfeservermanager.api.world.WorldStateView;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.junit.jupiter.api.Test;

class SpiRegistryTest {
    @Test
    void semanticRegistryUsesHighestPriorityAdapterAndChecksItsCommandId() throws Exception {
        CommandAnalysisRequest request = new CommandAnalysisRequest(
                "example:admin safe", "example:admin", List.of("safe"), Map.of(), List.of());
        CommandSemanticAdapter low = semanticAdapter(1, "low", "example:admin");
        CommandSemanticAdapter high = semanticAdapter(10, "high", "example:admin");

        InvocationAst analyzed = new CommandSemanticRegistry(List.of(low, high)).analyze(request).orElseThrow();

        assertEquals("high", analyzed.scalarArguments().get("adapter"));
        CommandSemanticAdapter invalid = semanticAdapter(20, "invalid", "example:different");
        assertThrows(SemanticAnalysisException.class,
                () -> new CommandSemanticRegistry(List.of(invalid)).analyze(request));
    }

    @Test
    void codecRegistryRoundTripsByStableCodecIdAndRejectsDuplicates() throws Exception {
        WorldStateCodecAdapter codec = codec("example:state");
        WorldStateCodecRegistry registry = new WorldStateCodecRegistry(List.of(codec));
        WorldStateView state = new WorldStateView(
                WorldStateKind.BLOCK_ENTITY, "example:machine", Map.of("facing", "north"), new byte[]{4, 2});

        WorldStatePayload encoded = registry.encode(state);
        assertEquals(state, registry.decode(encoded, WorldStateKind.BLOCK_ENTITY, "example:machine"));
        assertThrows(IllegalArgumentException.class,
                () -> new WorldStateCodecRegistry(List.of(codec, codec("example:state"))));
    }

    private static CommandSemanticAdapter semanticAdapter(int priority, String marker, String returnedCommandId) {
        return new CommandSemanticAdapter() {
            @Override
            public boolean supports(String canonicalCommandId) {
                return canonicalCommandId.equals("example:admin");
            }

            @Override
            public Optional<InvocationAst> analyze(CommandAnalysisRequest request) {
                return Optional.of(new InvocationAst(request.rawInput(), returnedCommandId, request.commandPath(),
                        Map.of("adapter", marker), List.of(), List.of(), List.of(), true));
            }

            @Override
            public int priority() {
                return priority;
            }
        };
    }

    private static WorldStateCodecAdapter codec(String codecId) {
        return new WorldStateCodecAdapter() {
            @Override
            public String codecId() {
                return codecId;
            }

            @Override
            public boolean supports(WorldStateKind kind, String resourceId) {
                return true;
            }

            @Override
            public WorldStatePayload encode(WorldStateView state) {
                return new WorldStatePayload(codecId, 1, "application/octet-stream", state.opaqueData(),
                        state.properties());
            }

            @Override
            public WorldStateView decode(
                    WorldStatePayload payload, WorldStateKind expectedKind, String expectedResourceId) {
                return new WorldStateView(expectedKind, expectedResourceId, payload.metadata(), payload.payload());
            }
        };
    }
}