XFEServerManager

package com.xfestudio.xfeservermanager.platform.bridge;

import com.xfestudio.xfeservermanager.api.command.CommandSourceKind;
import com.xfestudio.xfeservermanager.api.policy.ActorContext;

import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.UUID;

/**
 * Narrow integration surface between Forge-owned objects and the platform-neutral runtime.
 * All providers are replaceable atomically during server startup and safe to read from HTTP threads.
 */
public final class PlatformServices {
    private static final ServerStatusPublisher STATUS = new ServerStatusPublisher();
    private static volatile ManagementStatusBridge managementStatus = ManagementStatusBridge.DISABLED;
    private static volatile LifecycleBridge lifecycle = LifecycleBridge.NO_OP;
    private static volatile ActorResolver actorResolver = PlatformServices::defaultActor;

    private PlatformServices() {
    }

    public static ServerStatusPublisher statusPublisher() {
        return STATUS;
    }

    public static ServerStatusBridge status() {
        return STATUS;
    }

    public static ManagementStatusBridge managementStatus() {
        return managementStatus;
    }

    public static void installManagementStatus(ManagementStatusBridge bridge) {
        managementStatus = Objects.requireNonNull(bridge, "bridge");
    }

    public static void installLifecycleBridge(LifecycleBridge bridge) {
        lifecycle = Objects.requireNonNull(bridge, "bridge");
    }

    public static LifecycleBridge lifecycle() {
        return lifecycle;
    }

    public static void installActorResolver(ActorResolver resolver) {
        actorResolver = Objects.requireNonNull(resolver, "resolver");
    }

    public static ActorContext resolveActor(NativeActor actor) {
        return Objects.requireNonNull(actorResolver.resolve(actor), "actorResolver result");
    }

    public static void resetRuntimeBridges() {
        managementStatus = ManagementStatusBridge.DISABLED;
        lifecycle = LifecycleBridge.NO_OP;
        actorResolver = PlatformServices::defaultActor;
        CommandPolicyBridge.reset();
        CommandAuditBridge.reset();
        CrashProtectionBridge.reset();
    }

    private static ActorContext defaultActor(NativeActor actor) {
        String role = switch (actor.opLevel()) {
            case 1 -> "observer";
            case 2 -> "helper";
            case 3 -> "moderator";
            case 4 -> "administrator";
            default -> null;
        };
        Set<String> roles = role == null ? Set.of() : Set.of(role);
        Map<String, Integer> weights = role == null ? Map.of() : Map.of(role, actor.opLevel() * 100);
        return new ActorContext(actor.actorId(), actor.displayName(), roles, weights, actor.opLevel(),
                actor.sourceKind(), actor.onlineMode());
    }

    public record NativeActor(UUID actorId, String displayName, int opLevel, CommandSourceKind sourceKind,
                              boolean onlineMode) {
        public NativeActor {
            Objects.requireNonNull(displayName, "displayName");
            Objects.requireNonNull(sourceKind, "sourceKind");
            if (opLevel < 0 || opLevel > 4) {
                throw new IllegalArgumentException("opLevel must be between 0 and 4");
            }
        }
    }

    @FunctionalInterface
    public interface ActorResolver {
        ActorContext resolve(NativeActor actor);
    }

    public interface LifecycleBridge {
        LifecycleBridge NO_OP = new LifecycleBridge() {
        };

        default void serverStarted(Object nativeServer) {
        }

        default void serverStopping(Object nativeServer) {
        }

        default void serverStopped(Object nativeServer) {
        }
    }

    public interface ManagementStatusBridge {
        ManagementStatusBridge DISABLED = new ManagementStatusBridge() {
        };

        default WebStatus web() {
            return new WebStatus(false, false, "http://127.0.0.1:8765/", "disabled");
        }

        default PolicyStatus policy() {
            return new PolicyStatus(0L, false, "pass-through");
        }
    }

    public record WebStatus(boolean enabled, boolean running, String endpoint, String detail) {
        public WebStatus {
            Objects.requireNonNull(endpoint, "endpoint");
            Objects.requireNonNull(detail, "detail");
        }
    }

    public record PolicyStatus(long activeVersion, boolean enforcementInstalled, String detail) {
        public PolicyStatus {
            if (activeVersion < 0) {
                throw new IllegalArgumentException("activeVersion must be non-negative");
            }
            Objects.requireNonNull(detail, "detail");
        }
    }
}