PlotSquared/Core/src/main/java/com/plotsquared/core/PlotPlatform.java

/*
 * PlotSquared, a land and world management plugin for Minecraft.
 * Copyright (C) IntellectualSites <https://intellectualsites.com>
 * Copyright (C) IntellectualSites team and contributors
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
package com.plotsquared.core;

import cloud.commandframework.services.ServicePipeline;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.TypeLiteral;
import com.plotsquared.core.backup.BackupManager;
import com.plotsquared.core.configuration.caption.LocaleHolder;
import com.plotsquared.core.generator.GeneratorWrapper;
import com.plotsquared.core.generator.HybridUtils;
import com.plotsquared.core.generator.IndependentPlotGenerator;
import com.plotsquared.core.inject.annotations.DefaultGenerator;
import com.plotsquared.core.location.World;
import com.plotsquared.core.permissions.PermissionHandler;
import com.plotsquared.core.player.PlotPlayer;
import com.plotsquared.core.plot.world.PlotAreaManager;
import com.plotsquared.core.queue.GlobalBlockQueue;
import com.plotsquared.core.util.AnnotationHelper;
import com.plotsquared.core.util.ChunkManager;
import com.plotsquared.core.util.EconHandler;
import com.plotsquared.core.util.PlatformWorldManager;
import com.plotsquared.core.util.PlayerManager;
import com.plotsquared.core.util.RegionManager;
import com.plotsquared.core.util.SetupUtils;
import com.plotsquared.core.util.WorldUtil;
import com.plotsquared.core.util.placeholders.PlaceholderRegistry;
import net.kyori.adventure.audience.Audience;
import net.kyori.adventure.text.Component;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;

import java.io.File;

/**
 * PlotSquared main utility class
 *
 * @param <P> Player type
 */
public interface PlotPlatform<P> extends LocaleHolder {

    /**
     * Gets the directory which contains PlotSquared files. The directory may not exist.
     *
     * @return the PlotSquared directory
     */
    @NonNull File getDirectory();

    /**
     * Gets the folder where all world data is stored.
     *
     * @return the world folder
     */
    @NonNull File worldContainer();

    /**
     * Completely shuts down the plugin.
     */
    void shutdown();

    /**
     * Get the name of the plugin
     *
     * @return Plugin name
     */
    default @NonNull String pluginName() {
        return "PlotSquared";
    }

    /**
     * Gets the version of Minecraft that is running
     *
     * @return server version as array of numbers
     */
    int[] serverVersion();

    /**
     * Gets the default minimum world height for the version of Minecraft that the server is running.
     *
     * @return minimum world height
     * @since 6.6.0
     */
    int versionMinHeight();

    /**
     * Gets the default maximum world height for the version of Minecraft that the server is running.
     *
     * @return maximum world height (inclusive)
     * @since 6.6.0
     */
    int versionMaxHeight();

    /**
     * Gets the server implementation name and version
     *
     * @return server implementation and version as string
     */
    @NonNull String serverImplementation();

    /**
     * Gets the native server code package prefix.
     *
     * @return The package prefix
     */
    @NonNull String serverNativePackage();

    /**
     * Start Metrics.
     */
    void startMetrics();

    /**
     * If a world is already loaded, set the generator (use NMS if required).
     *
     * @param world The world to set the generator
     */
    void setGenerator(@NonNull String world);

    /**
     * Unregisters a {@link PlotPlayer} from cache e.g. if they have logged off.
     *
     * @param player the player to remove
     */
    void unregister(@NonNull PlotPlayer<?> player);

    /**
     * Gets the generator wrapper for a world (world) and generator (name).
     *
     * @param world The world to get the generator from
     * @param name  The name of the generator
     * @return The generator being used for the provided world
     */
    @Nullable GeneratorWrapper<?> getGenerator(
            @NonNull String world,
            @Nullable String name
    );

    /**
     * Create a platform generator from a plot generator
     *
     * @param world     World name
     * @param generator Plot generator
     * @return Platform generator wrapper
     */
    @NonNull GeneratorWrapper<?> wrapPlotGenerator(
            @NonNull String world,
            @NonNull IndependentPlotGenerator generator
    );

    /**
     * Usually HybridGen
     *
     * @return Default implementation generator
     */
    default @NonNull IndependentPlotGenerator defaultGenerator() {
        return injector().getInstance(Key.get(IndependentPlotGenerator.class, DefaultGenerator.class));
    }

    /**
     * Get the backup manager instance
     *
     * @return Backup manager
     */
    default @NonNull BackupManager backupManager() {
        return injector().getInstance(BackupManager.class);
    }

    /**
     * Get the platform specific world manager
     *
     * @return World manager
     */
    default @NonNull PlatformWorldManager<?> worldManager() {
        return injector().getInstance(PlatformWorldManager.class);
    }

    /**
     * Get the player manager implementation for the platform
     *
     * @return Player manager
     */
    default @NonNull PlayerManager<? extends PlotPlayer<P>, ? extends P> playerManager() {
        return injector().getInstance(Key.get(new TypeLiteral<PlayerManager<? extends PlotPlayer<P>, ? extends P>>() {
        }));
    }

    /**
     * Get a platform world wrapper from a world name
     *
     * @param worldName World name
     * @return Platform world wrapper
     */
    @Nullable World<?> getPlatformWorld(@NonNull String worldName);

    /**
     * Get the {@link com.google.inject.Injector} instance used by PlotSquared
     *
     * @return Injector instance
     */
    @NonNull Injector injector();

    /**
     * Get the world utility implementation
     *
     * @return World utility
     */
    default @NonNull WorldUtil worldUtil() {
        return injector().getInstance(WorldUtil.class);
    }

    /**
     * Get the global block queue implementation
     *
     * @return Global block queue implementation
     */
    default @NonNull GlobalBlockQueue globalBlockQueue() {
        return injector().getInstance(GlobalBlockQueue.class);
    }

    /**
     * Get the {@link HybridUtils} implementation for the platform
     *
     * @return Hybrid utils
     */
    default @NonNull HybridUtils hybridUtils() {
        return injector().getInstance(HybridUtils.class);
    }

    /**
     * Get the {@link SetupUtils} implementation for the platform
     *
     * @return Setup utils
     */
    default @NonNull SetupUtils setupUtils() {
        return injector().getInstance(SetupUtils.class);
    }

    /**
     * Get the {@link EconHandler} implementation for the platform
     *
     * @return Econ handler
     */
    default @NonNull EconHandler econHandler() {
        return injector().getInstance(EconHandler.class);
    }

    /**
     * Get the {@link RegionManager} implementation for the platform
     *
     * @return Region manager
     */
    default @NonNull RegionManager regionManager() {
        return injector().getInstance(RegionManager.class);
    }

    /**
     * Get the {@link ChunkManager} implementation for the platform
     *
     * @return Region manager
     */
    default @NonNull ChunkManager chunkManager() {
        return injector().getInstance(ChunkManager.class);
    }

    /**
     * Get the {@link PlotAreaManager} implementation.
     *
     * @return the PlotAreaManager
     * @since 6.1.4
     */
    @NonNull PlotAreaManager plotAreaManager();

    /**
     * Get the platform specific console {@link Audience}
     *
     * @return Console audience
     */
    @NonNull Audience consoleAudience();

    /**
     * Get a formatted string containing all plugins on the server together
     * with plugin metadata. Mainly for use in debug pastes
     *
     * @return Formatted string
     */
    @NonNull String pluginsFormatted();

    /**
     * Get the kind of WorldEdit implementation
     *
     * @return worldedit implementations
     * @since 6.3.0
     */
    @AnnotationHelper.ApiDescription(info = "Internal use only")
    @NonNull String worldEditImplementations();

    /**
     * Load the caption maps
     */
    void copyCaptionMaps();

    /**
     * Get the {@link PermissionHandler} implementation for the platform
     *
     * @return Permission handler
     */
    default @NonNull PermissionHandler permissionHandler() {
        return injector().getInstance(PermissionHandler.class);
    }

    /**
     * Get the {@link ServicePipeline} implementation
     *
     * @return Service pipeline
     */
    default @NonNull ServicePipeline servicePipeline() {
        return injector().getInstance(ServicePipeline.class);
    }

    /**
     * Get the {@link PlaceholderRegistry} implementation
     *
     * @return Placeholder registry
     */
    default @NonNull PlaceholderRegistry placeholderRegistry() {
        return injector().getInstance(PlaceholderRegistry.class);
    }

    /**
     * Convert a component to a legacy string
     *
     * @param component Component to convert
     * @return Converted string
     */
    @NonNull String toLegacyPlatformString(@NonNull Component component);

    /**
     * Returns if the FastAsyncWorldEdit-PlotSquared hook is active/enabled
     *
     * @return status of FastAsyncWorldEdit-PlotSquared hook
     */
    default boolean isFaweHooking() {
        return false;
    }

}