DreamPlaceholderManager.java

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2025 Dreamfire Studio
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
package com.dreamfirestudios.dreamcore.DreamPlaceholder;
 
import me.clip.placeholderapi.expansion.PlaceholderExpansion;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
 
public class DreamPlaceholderManager extends PlaceholderExpansion {
 
    private final String identifier;
    private final String author;
    private final String version;
 
    // key -> provider
    private final Map<String, IDreamPlaceholder> placeholders = new ConcurrentHashMap<>();
 
    public DreamPlaceholderManager(@NotNull String identifier,
                                   @NotNull String author,
                                   @NotNull String version) {
        this.identifier = Objects.requireNonNull(identifier, "identifier").toLowerCase();
        this.author = Objects.requireNonNull(author, "author");
        this.version = Objects.requireNonNull(version, "version");
    }
 
    /* ----------------------------- Expansion meta ----------------------------- */
 
    @Override public @NotNull String getIdentifier() { return identifier; }
    @Override public @NotNull String getAuthor()     { return author; }
    @Override public @NotNull String getVersion()    { return version; }
    @Override public boolean canRegister()           { return true; }
    @Override public boolean persist()               { return true; } // survive /papi reload
 
    /* ----------------------------- Registration API ----------------------------- */
 
    public boolean register(@NotNull IDreamPlaceholder provider) {
        Objects.requireNonNull(provider, "provider");
        final String key = provider.key().toLowerCase();
        return placeholders.putIfAbsent(key, provider) == null;
    }
 
    public boolean unregister(@NotNull String key) {
        Objects.requireNonNull(key, "key");
        return placeholders.remove(key.toLowerCase()) != null;
    }
 
    public void clear() {
        placeholders.clear();
    }
 
    /* ----------------------------- Request handling ----------------------------- */
 
    @Override
    public @Nullable String onRequest(OfflinePlayer offlinePlayer, @NotNull String params) {
        return resolve(offlinePlayer, params);
    }
 
    @Override
    public @Nullable String onPlaceholderRequest(Player player, @NotNull String params) {
        return resolve(player, params);
    }
 
    private @NotNull String resolve(@Nullable OfflinePlayer offlinePlayer, @NotNull String rawParams) {
        final String params = rawParams.trim();
        if (params.isEmpty()) return "";
 
        // Split either by ':' or '_' (first token is the key, the rest are args)
        final String[] colonSplit = params.split(":");
        final String[] parts = (colonSplit.length > 1) ? colonSplit : params.split("_");
 
        final String key = parts[0].toLowerCase();
        final String[] args = (parts.length > 1) ? Arrays.copyOfRange(parts, 1, parts.length) : new String[0];
 
        final IDreamPlaceholder provider = placeholders.get(key);
        if (provider == null) {
            // Bukkit.getLogger().fine("[DreamPlaceholder] Unknown key: " + key + " (params=" + params + ")");
            return "";
        }
 
        try {
            return provider.resolve(offlinePlayer, args);
        } catch (Exception ex) {
            Bukkit.getLogger().warning("[DreamPlaceholder] Error resolving key '" + key + "' with args " +
                    Arrays.toString(args) + ": " + ex.getMessage());
            return "";
        }
    }
}