main :
package com.no6we.mctiers;

import org.bukkit.plugin.java.JavaPlugin;

public class Main extends JavaPlugin {

    private TierService tierService;

    @Override
    public void onEnable() {
        this.tierService = new TierService(this);

        // Listeners
        getServer().getPluginManager().registerEvents(new PlayerJoinListener(tierService), this);
        getServer().getPluginManager().registerEvents(new ChatListener(tierService), this);
        getServer().getPluginManager().registerEvents(new TablistUpdater(tierService), this);

        // Command
        this.getCommand("checktier").setExecutor(new CheckTierCommand(tierService));

        getLogger().info("MC-Tiers Plugin Enabled!");
    }

    @Override
    public void onDisable() {
        getLogger().info("MC-Tiers Plugin Disabled!");
    }
}
chat listenter: 
package com.no6we.mctiers;

import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.entity.Player;

import java.util.Map;

public class ChatListener implements Listener {

    private final TierService tierService;

    public ChatListener(TierService tierService) {
        this.tierService = tierService;
    }

    @EventHandler
    public void onPlayerChat(AsyncPlayerChatEvent event) {
        Player player = event.getPlayer();

        Map<String, String> tiers = tierService.getAllTiers(
                tierService.getPlayerData(player.getUniqueId(), player.getName())
        );

        String bestTier = tierService.getBestTier(tiers);

        // Prefix chat with tier
        event.setFormat("[" + bestTier + "] " + player.getName() + ": %2$s");
    }
}
checktiercommand:
package com.no6we.mctiers;

import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

import java.util.Map;

public class CheckTierCommand implements CommandExecutor {

    private final TierService tierService;

    public CheckTierCommand(TierService tierService) {
        this.tierService = tierService;
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (args.length != 1) {
            sender.sendMessage("Usage: /checktier <player>");
            return true;
        }

        Player target = Bukkit.getPlayer(args[0]);
        if (target == null) {
            sender.sendMessage("Player not online or does not exist.");
            return true;
        }

        Map<String, String> tiers = tierService.getAllTiers(tierService.getPlayerData(target.getUniqueId(), target.getName()));
        String best = tierService.getBestTier(tiers);

        sender.sendMessage(target.getName() + "'s tiers:");
        for (String gm : tiers.keySet()) {
            String t = tiers.get(gm);
            if (t.equals(best)) t = "**" + t + "**"; // bold best tier
            sender.sendMessage(tierService.getGamemodeShort(gm) + ": " + t);
        }

        return true;
    }
}
Playerjoinlistener : 
package com.no6we.mctiers;

import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.entity.Player;
import java.util.Map;

public class PlayerJoinListener implements Listener {

    private final TierService tierService;

    public PlayerJoinListener(TierService tierService) {
        this.tierService = tierService;
    }

    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent event) {
        Player player = event.getPlayer();
        Map<String, String> tiers = tierService.getAllTiers(
                tierService.getPlayerData(player.getUniqueId(), player.getName())
        );

        String bestTier = tierService.getBestTier(tiers);

        // NameTag above head (simplest version)
        player.setPlayerListName(bestTier);

        // Update TABLIST
        TablistUpdater.updatePlayerTab(player, tiers, tierService);
    }
}
tablist updater: 
package com.no6we.mctiers;

import org.bukkit.entity.Player;

import java.util.Map;

public class TablistUpdater {

    public static void updatePlayerTab(Player player, Map<String, String> tiers, TierService tierService) {
        String bestTier = tierService.getBestTier(tiers);
        String bestGamemode = "";

        for (Map.Entry<String, String> entry : tiers.entrySet()) {
            if (entry.getValue().equals(bestTier)) {
                bestGamemode = tierService.getGamemodeShort(entry.getKey());
                break;
            }
        }

        // Display in TABLIST
        player.setPlayerListName(bestGamemode + bestTier + " " + player.getName());
    }
}
tierservice : 
package com.no6we.mctiers;

import org.bukkit.Bukkit;
import org.bukkit.scheduler.BukkitRunnable;
import org.json.JSONObject;

import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.*;

public class TierService {

    private final Main plugin;
    private final Map<UUID, JSONObject> cache = new HashMap<>();
    private final long CACHE_TIME = 30 * 60 * 1000; // 30 minutes
    private final Map<UUID, Long> cacheTimestamps = new HashMap<>();

    public TierService(Main plugin) {
        this.plugin = plugin;
    }

    public JSONObject getPlayerData(UUID uuid, String username) {
        if (cache.containsKey(uuid) && (System.currentTimeMillis() - cacheTimestamps.get(uuid)) < CACHE_TIME) {
            return cache.get(uuid);
        }

        try {
            URL url = new URL("https://mctiers.com/api/search_profile/" + username);
            HttpURLConnection con = (HttpURLConnection) url.openConnection();
            con.setConnectTimeout(10000);
            con.setReadTimeout(10000);
            con.setRequestMethod("GET");

            InputStreamReader reader = new InputStreamReader(con.getInputStream());
            StringBuilder sb = new StringBuilder();
            int c;
            while ((c = reader.read()) != -1) sb.append((char) c);
            reader.close();

            JSONObject json = new JSONObject(sb.toString());
            cache.put(uuid, json);
            cacheTimestamps.put(uuid, System.currentTimeMillis());
            return json;
        } catch (Exception e) {
            plugin.getLogger().warning("Failed to fetch MC-Tiers API for " + username);
            return null;
        }
    }

    public Map<String, String> getAllTiers(JSONObject data) {
        Map<String, String> result = new HashMap<>();
        if (data == null || !data.has("rankings")) return result;

        JSONObject rankings = data.getJSONObject("rankings");

        for (String mode : rankings.keySet()) {
            JSONObject modeData = rankings.getJSONObject(mode);
            String tier = modeData.getString("tier").toUpperCase();
            String pos = modeData.get("pos").toString();
            boolean retired = modeData.getBoolean("retired");
            String display = (retired ? "R" : "") + "HT" + tier; // simplified, can customize
            result.put(mode.toUpperCase(), display);
        }

        return result;
    }

    public String getBestTier(Map<String, String> tiers) {
        // Use order: HT1 > LT1 > HT2 > LT2 > HT3 > LT3 > HT4 > LT4 > HT5 > LT5
        List<String> tierOrder = Arrays.asList(
                "HT1","LT1",
                "HT2","LT2",
                "HT3","LT3",
                "HT4","LT4",
                "HT5","LT5"
        );

        String best = null;
        int bestIndex = Integer.MAX_VALUE;

        for (String tier : tiers.values()) {
            int idx = tierOrder.indexOf(tier);
            if (idx != -1 && idx < bestIndex) {
                bestIndex = idx;
                best = tier;
            }
        }

        return best;
    }

    public String getGamemodeShort(String gamemode) {
        switch (gamemode.toUpperCase()) {
            case "VANILLA": case "SWORD": case "CRYSTAL": return "CPVP";
            case "POT": return "POT";
            case "AXE": return "AXE";
            case "UHC": return "UHC";
            case "MACE": return "MACE";
            case "SMP": return "SMP";
            case "NETHOP": return "NETP";
            default: return gamemode.toUpperCase();
        }
    }

}