// 1. 单例模式（Singleton）
public class EconomyManager {
    private static EconomyManager instance;

    public static EconomyManager getInstance() {
        if (instance == null) {
            instance = new EconomyManager();
        }
        return instance;
    }
}

// 2. 建造者模式（Builder）
public class ItemBuilder {
    private final ItemStack item;
    private final ItemMeta meta;

    public ItemBuilder(Material material) {
        this.item = new ItemStack(material);
        this.meta = item.getItemMeta();
    }

    public ItemBuilder name(String name) {
        meta.displayName(Component.text(name));
        return this;
    }

    public ItemBuilder lore(String... lines) {
        meta.lore(Arrays.stream(lines)
            .map(Component::text)
            .collect(Collectors.toList()));
        return this;
    }

    public ItemStack build() {
        item.setItemMeta(meta);
        return item;
    }
}

// 使用
ItemStack sword = new ItemBuilder(Material.DIAMOND_SWORD)
    .name("§6传说之剑")
    .lore("§7攻击 +100", "§7速度 +20%")
    .build();

// 不好：每次移动都处理
@EventHandler
public void onMove(PlayerMoveEvent event) {
    checkRegion(event.getPlayer());
}

// 好：只在跨越区块时处理
@EventHandler(ignoreCancelled = true)
public void onMove(PlayerMoveEvent event) {
    Location from = event.getFrom();
    Location to = event.getTo();

    if (to == null) return;
    if (from.getBlockX() >> 4 == to.getBlockX() >> 4
        && from.getBlockZ() >> 4 == to.getBlockZ() >> 4) {
        return; // 同一区块，跳过
    }

    checkRegion(event.getPlayer());
}

// 不好：循环中拼接
String result = "";
for (String s : list) {
    result += s + ", "; // 每次创建新 String 对象
}

// 好：使用 StringBuilder
StringBuilder sb = new StringBuilder();
for (String s : list) {
    if (!sb.isEmpty()) sb.append(", ");
    sb.append(s);
}
String result = sb.toString();

// 更好：使用 Stream
String result = String.join(", ", list);

public class CacheManager<K, V> {

    private final Map<K, CacheEntry<V>> cache = new HashMap<>();
    private final long ttl; // 缓存过期时间（毫秒）

    public CacheManager(long ttlMillis) {
        this.ttl = ttlMillis;
    }

    public void put(K key, V value) {
        cache.put(key, new CacheEntry<>(value, System.currentTimeMillis()));
    }

    public V get(K key) {
        CacheEntry<V> entry = cache.get(key);
        if (entry == null) return null;

        if (System.currentTimeMillis() - entry.timestamp() > ttl) {
            cache.remove(key); // 过期移除
            return null;
        }

        return entry.value();
    }

    public void clear() {
        cache.clear();
    }

    private record CacheEntry<V>(V value, long timestamp) {}
}

// 限制实体数量
public void spawnMobSafely(Location loc, EntityType type, int maxNearby) {
    long count = loc.getWorld().getNearbyEntities(loc, 32, 32, 32).stream()
        .filter(e -> e.getType() == type)
        .count();

    if (count < maxNearby) {
        loc.getWorld().spawnEntity(loc, type);
    }
}

// 定期清理
Bukkit.getScheduler().runTaskTimer(plugin, () -> {
    for (World world : Bukkit.getWorlds()) {
        int removed = cleanupEntities(world, EntityType.DROPPED_ITEM, 100);
        if (removed > 0) {
            plugin.getLogger().info("清理了 " + removed + " 个掉落物");
        }
    }
}, 6000L, 6000L); // 每 5 分钟

public class PlayerDataManager {

    // 不好：玩家退出后数据仍在内存
    private final Map<UUID, PlayerData> data = new HashMap<>();

    // 好：玩家退出时清理
    @EventHandler
    public void onQuit(PlayerQuitEvent event) {
        UUID uuid = event.getPlayer().getUniqueId();
        PlayerData playerData = data.remove(uuid); // 移除并获取
        if (playerData != null) {
            saveToDatabase(playerData); // 持久化
        }
    }
}

public class MyPlugin extends JavaPlugin {

    private final List<BukkitTask> tasks = new ArrayList<>();

    @Override
    public void onDisable() {
        // 取消所有任务
        tasks.forEach(BukkitTask::cancel);
        tasks.clear();

        // 或者一次性取消所有
        Bukkit.getScheduler().cancelTasks(this);
    }

    private void startTask() {
        BukkitTask task = Bukkit.getScheduler().runTaskTimer(this, () -> {
            // 逻辑
        }, 0L, 20L);
        tasks.add(task);
    }
}

public class InputValidator {

    /**
     * 验证玩家名
     */
    public static boolean isValidPlayerName(String name) {
        return name != null
            && name.length() >= 3
            && name.length() <= 16
            && name.matches("[a-zA-Z0-9_]+");
    }

    /**
     * 验证数值范围
     */
    public static boolean isInRange(double value, double min, double max) {
        return value >= min && value <= max;
    }

    /**
     * 清理聊天消息（防注入）
     */
    public static String sanitize(String input) {
        if (input == null) return "";
        return input.replaceAll("[§&][0-9a-fk-or]", "") // 移除颜色代码
                    .trim();
    }

    /**
     * 验证配置文件路径（防路径遍历）
     */
    public static boolean isSafePath(String path) {
        return path != null
            && !path.contains("..")
            && !path.startsWith("/");
    }
}

// 始终在执行操作前检查权限
public void handleCommand(CommandSender sender, String[] args) {
    // 不好：先执行后检查
    // executeAction();
    // if (!sender.hasPermission("perm")) { return; }

    // 好：先检查后执行
    if (!sender.hasPermission("myplugin.admin")) {
        sender.sendMessage("§c没有权限！");
        return;
    }
    executeAction();
}

// 敏感数据加密
public class DataEncryptor {

    private static final String SECRET_KEY = getConfigSecretKey();

    public static String encrypt(String data) {
        try {
            Cipher cipher = Cipher.getInstance("AES");
            SecretKeySpec key = new SecretKeySpec(
                SECRET_KEY.getBytes(), "AES");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] encrypted = cipher.doFinal(data.getBytes());
            return Base64.getEncoder().encodeToString(encrypted);
        } catch (Exception e) {
            throw new RuntimeException("加密失败", e);
        }
    }

    public static String decrypt(String encrypted) {
        try {
            Cipher cipher = Cipher.getInstance("AES");
            SecretKeySpec key = new SecretKeySpec(
                SECRET_KEY.getBytes(), "AES");
            cipher.init(Cipher.DECRYPT_MODE, key);
            byte[] decoded = Base64.getDecoder().decode(encrypted);
            return new String(cipher.doFinal(decoded));
        } catch (Exception e) {
            throw new RuntimeException("解密失败", e);
        }
    }
}

// 不好：字符串拼接 SQL
String sql = "SELECT * FROM players WHERE name = '" + playerName + "'";

// 好：参数化查询
String sql = "SELECT * FROM players WHERE name = ?";
PreparedStatement pstmt = connection.prepareStatement(sql);
pstmt.setString(1, playerName);

public class VersionCompat {

    private static final int CURRENT_VERSION = getMinecraftVersion();

    private static int getMinecraftVersion() {
        String version = Bukkit.getBukkitVersion(); // "1.21.4-R0.1-SNAPSHOT"
        String[] parts = version.split("-")[0].split("\\.");
        return Integer.parseInt(parts[0]) * 100 + Integer.parseInt(parts[1]);
    }

    /**
     * 根据版本使用不同 API
     */
    public static void sendActionBar(Player player, String message) {
        if (CURRENT_VERSION >= 1210) {
            // Paper 1.21+ Adventure API
            player.sendActionBar(Component.text(message));
        } else {
            // 旧版兼容
            player.spigot().sendMessage(
                ChatMessageType.ACTION_BAR,
                TextComponent.fromLegacyText(message)
            );
        }
    }
}

public class FeatureManager {

    private boolean papiEnabled = false;
    private boolean vaultEnabled = false;

    public void initialize(MyPlugin plugin) {
        // PlaceholderAPI
        if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) {
            papiEnabled = true;
            new MyPluginExpansion(plugin).register();
            plugin.getLogger().info("PlaceholderAPI 已集成");
        } else {
            plugin.getLogger().info("PlaceholderAPI 未安装，跳过集成");
        }

        // Vault
        if (Bukkit.getPluginManager().getPlugin("Vault") != null) {
            vaultEnabled = true;
            setupEconomy();
            plugin.getLogger().info("Vault 经济已集成");
        }
    }

    public boolean isPAPIEnabled() { return papiEnabled; }
    public boolean isVaultEnabled() { return vaultEnabled; }
}

public class PluginLogger {

    private final Logger logger;
    private boolean debug = false;

    public void info(String message) {
        logger.info(message);
    }

    public void warning(String message) {
        logger.warning(message);
    }

    public void severe(String message) {
        logger.severe(message);
    }

    public void debug(String message) {
        if (debug) {
            logger.info("[DEBUG] " + message);
        }
    }

    public void setDebug(boolean debug) {
        this.debug = debug;
    }
}

public class PerformanceMonitor {

    /**
     * 测量方法执行时间
     */
    public static <T> T measure(String name, Supplier<T> supplier) {
        long start = System.nanoTime();
        T result = supplier.get();
        long elapsed = (System.nanoTime() - start) / 1_000_000; // 毫秒

        if (elapsed > 50) { // 超过 50ms 警告
            Bukkit.getLogger().warning(String.format(
                "[Performance] %s 耗时 %dms", name, elapsed));
        }

        return result;
    }
}

public class SafeExecutor {

    /**
     * 安全执行任务（捕获异常不影响服务器）
     */
    public static void safeRun(Runnable task) {
        try {
            task.run();
        } catch (Exception e) {
            Bukkit.getLogger().severe("任务执行失败: " + e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 带返回值的安全执行
     */
    public static <T> Optional<T> safeGet(Supplier<T> supplier) {
        try {
            return Optional.ofNullable(supplier.get());
        } catch (Exception e) {
            Bukkit.getLogger().warning("获取数据失败: " + e.getMessage());
            return Optional.empty();
        }
    }
}

@EventHandler
public void onCommand(PlayerCommandPreprocessEvent event) {
    try {
        // 处理命令
        handleCommand(event);
    } catch (Exception e) {
        event.setCancelled(true);
        event.getPlayer().sendMessage("§c执行命令时出错，请联系管理员。");
        plugin.getLogger().severe("命令执行失败: " + e.getMessage());
        e.printStackTrace();
    }
}

public class ConfigManager {

    private FileConfiguration config;
    private final JavaPlugin plugin;

    public ConfigManager(JavaPlugin plugin) {
        this.plugin = plugin;
        reload();
    }

    public void reload() {
        plugin.saveDefaultConfig();
        plugin.reloadConfig();
        config = plugin.getConfig();
    }

    public String getString(String path, String def) {
        return config.getString(path, def);
    }

    public int getInt(String path, int def) {
        return config.getInt(path, def);
    }

    public boolean getBoolean(String path, boolean def) {
        return config.getBoolean(path, def);
    }

    public List<String> getStringList(String path) {
        return config.getStringList(path);
    }
}

public class UpdateChecker {

    private final JavaPlugin plugin;
    private final String resourceId; // SpigotMC 资源 ID

    public UpdateChecker(JavaPlugin plugin, String resourceId) {
        this.plugin = plugin;
        this.resourceId = resourceId;
    }

    /**
     * 异步检查更新
     */
    public void check(Consumer<String> callback) {
        Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
            try {
                HttpClient client = HttpClient.newHttpClient();
                HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create(
                        "https://api.spigotmc.org/legacy/resource.php?"
                        + resourceId + "&command=getversion"))
                    .build();

                HttpResponse<String> response = client.send(
                    request, HttpResponse.BodyHandlers.ofString());

                String latest = response.body().trim();
                String current = plugin.getDescription().getVersion();

                if (!current.equals(latest)) {
                    Bukkit.getScheduler().runTask(plugin, () ->
                        callback.accept(latest));
                }
            } catch (Exception e) {
                plugin.getLogger().warning("检查更新失败: " + e.getMessage());
            }
        });
    }
}