MoonBridge/backend/src/main/java/dev/moonbridge/bukkit/MoonBridgeBackendPlugin.java

package dev.moonbridge.bukkit;

import dev.moonbridge.backendchannel.BackendChannelClient;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.server.PluginDisableEvent;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.ServicePriority;
import org.bukkit.plugin.java.JavaPlugin;

import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.UUID;
import java.util.concurrent.Executor;
import java.util.concurrent.RejectedExecutionException;

/** One process-level authenticated transport shared by all dependent plugins. */
public final class MoonBridgeBackendPlugin extends JavaPlugin implements Listener {
    private volatile boolean stopping;
    private BackendChannelClient client;
    private OwnedMessagingService service;
    private OwnedBukkitSessionService sessions;

    @Override public void onEnable() {
        stopping = false;
        saveDefaultConfig();
        byte[] secret = null;
        try {
            String secretText = getConfig().getString("secret", "");
            if (secretText.startsWith("replace-") || secretText.getBytes(StandardCharsets.UTF_8).length < 32) {
                throw new IllegalArgumentException("Configure a unique secret of at least 32 UTF-8 bytes");
            }
            secret = secretText.getBytes(StandardCharsets.UTF_8);
            client = new BackendChannelClient(
                    required("proxyHost"), getConfig().getInt("proxyPort", 28081),
                    required("instanceId"), required("backendName"), required("gameAddress"),
                    UUID.randomUUID().toString(), required("keyId"), secret);
            service = new OwnedMessagingService(client::messaging, this::mainThreadExecutor);
            sessions = new OwnedBukkitSessionService(required("backendName"), secret,
                    () -> client.isRegistered() ? client.getEpoch() : 0L,
                    () -> client.isRegistered() ? client.getProxyEpoch() : new UUID(0L, 0L));
            getServer().getServicesManager().register(BukkitMessagingService.class, service, this, ServicePriority.Normal);
            getServer().getServicesManager().register(BukkitSessionService.class, sessions, this, ServicePriority.Normal);
            getServer().getPluginManager().registerEvents(this, this);
            getServer().getPluginManager().registerEvents(sessions, this);
            getLogger().info("Shared MoonBridge messaging service started; registration runs asynchronously");
        } catch (IllegalArgumentException invalid) {
            // The configuration checks above and in BackendChannelClient name the key, never its value.
            getLogger().severe("Cannot start MoonBridge messaging: " + invalid.getMessage());
            getServer().getPluginManager().disablePlugin(this);
        } catch (RuntimeException failure) {
            // Do not include configuration values or authentication peer data.
            getLogger().severe("Cannot start MoonBridge messaging: " + failure.getClass().getSimpleName());
            getServer().getPluginManager().disablePlugin(this);
        } finally {
            if (secret != null) Arrays.fill(secret, (byte) 0);
        }
    }

    private String required(String key) {
        String value = getConfig().getString(key, "").trim();
        if (value.isEmpty()) throw new IllegalArgumentException("Missing configuration key: " + key);
        return value;
    }

    private Executor mainThreadExecutor(final Plugin owner) {
        return command -> {
            if (stopping || !owner.isEnabled()) throw new RejectedExecutionException("Message owner is disabled");
            try {
                getServer().getScheduler().runTask(owner, () -> {
                    if (!stopping && owner.isEnabled()) command.run();
                });
            } catch (RuntimeException rejected) {
                // A disable can race the enabled check. Preserve the Executor
                // rejection contract so the dispatcher releases its admission slot.
                throw new RejectedExecutionException("Bukkit scheduler rejected the message owner", rejected);
            }
        };
    }

    @EventHandler public void onPluginDisable(PluginDisableEvent event) {
        OwnedMessagingService active = service;
        if (active != null) active.release(event.getPlugin());
    }

    @Override public void onDisable() {
        stopping = true;
        getServer().getServicesManager().unregisterAll(this);
        if (sessions != null) { sessions.close(); sessions = null; }
        if (service != null) { service.close(); service = null; }
        if (client != null) { client.close(); client = null; }
    }
}