Untitled

package net.thebridgemc.dynamicpricingsellgui;

import java.text.DecimalFormat;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;

import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemFlag;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.EnchantmentStorageMeta;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.plugin.RegisteredServiceProvider;
import org.bukkit.plugin.java.JavaPlugin;

import net.kyori.adventure.text.Component;
import net.milkbowl.vault.economy.Economy;

public class Main extends JavaPlugin implements Listener {

    private static Economy economy = null;
    private final Map<String, Double> itemPrices = new ConcurrentHashMap<>();
    private final Map<Enchantment, Map<Integer, Double>> enchantedBookPrices = new ConcurrentHashMap<>();
    private final Random random = new Random();
    private final Sound[] sounds = { Sound.ENTITY_PLAYER_LEVELUP };
    private final ThreadLocal<DecimalFormat> decimalFormat = ThreadLocal.withInitial(() -> new DecimalFormat("#0.00"));

    @Override
    public void onEnable() {
        Bukkit.getServer().getPluginManager().registerEvents(this, this);
        saveDefaultConfig();
        
        // Setup Vault economy
        if (!setupEconomy()) {
            getLogger().severe("Vault setup failed! Disabling plugin.");
            getServer().getPluginManager().disablePlugin(this);
            return;
        }
        
        // Load item prices from config
        FileConfiguration config = getConfig();
        for (String key : config.getConfigurationSection("items").getKeys(false)) {
            itemPrices.put(key.toUpperCase(), config.getDouble("items." + key));
        }
        
        // Load enchanted book prices from config
        for (String enchantment : config.getConfigurationSection("enchanted_books").getKeys(false)) {
            Enchantment ench = Enchantment.getByKey(org.bukkit.NamespacedKey.minecraft(enchantment.toLowerCase()));
            if (ench != null) {
                Map<Integer, Double> levels = new ConcurrentHashMap<>();
                for (String level : config.getConfigurationSection("enchanted_books." + enchantment).getKeys(false)) {
                    levels.put(Integer.parseInt(level.split("_")[1]), config.getDouble("enchanted_books." + enchantment + "." + level));
                }
                enchantedBookPrices.put(ench, levels);
            } else {
                getLogger().warning("Invalid enchantment: " + enchantment);
            }
        }
    }

    @Override
    public void onDisable() {
        // Save item prices to config
        FileConfiguration config = getConfig();
        for (Map.Entry<String, Double> entry : itemPrices.entrySet()) {
            config.set("items." + entry.getKey().toLowerCase(), entry.getValue());
        }

        for (Enchantment enchantment : enchantedBookPrices.keySet()) {
            String enchantmentKey = enchantment.getKey().getKey();
            for (Map.Entry<Integer, Double> levelEntry : enchantedBookPrices.get(enchantment).entrySet()) {
                config.set("enchanted_books." + enchantmentKey + ".level_" + levelEntry.getKey(), levelEntry.getValue());
            }
        }

        saveConfig();
        getLogger().info("Current item prices have been saved to config.");
    }

    public static boolean setupEconomy() {
        if (Bukkit.getServer().getPluginManager().getPlugin("Vault") == null) {
            return false;
        }
        RegisteredServiceProvider<Economy> rsp = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
        if (rsp == null) {
            return false;
        }
        economy = rsp.getProvider();
        return economy != null;
    }

    public static Economy getEconomy() {
        return economy;
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (command.getName().equalsIgnoreCase("sell")) {
            if (sender instanceof Player) {
                Player player = (Player) sender;
                openSellGUI(player);
                return true;
            }
        }
        return false;
    }

    public void openSellGUI(Player player) {
        Inventory inventory = Bukkit.createInventory(player, 54, Component.text("§3§lsᴇʟʟ ɢᴜɪ"));

        ItemStack blank = new ItemStack(Material.BLACK_STAINED_GLASS_PANE);
        ItemMeta blankMeta = blank.getItemMeta();
        blankMeta.displayName(Component.text("§r"));
        blankMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
        blank.setItemMeta(blankMeta);

        for (int i = 45; i < 54; i++) {
            if (i == 49) {
                ItemStack emerald = new ItemStack(Material.EMERALD);
                ItemMeta emeraldMeta = emerald.getItemMeta();
                emeraldMeta.displayName(Component.text("§aTotal: 0.00"));
                emeraldMeta.lore(List.of(Component.text("§7Close GUI to confirm sell")));
                emerald.setItemMeta(emeraldMeta);
                inventory.setItem(i, emerald);
            } else {
                inventory.setItem(i, blank);
            }
        }
        player.openInventory(inventory);
    }

    @EventHandler
    public void onInventoryClick(InventoryClickEvent event) {
        if (event.getView().title().equals(Component.text("§3§lsᴇʟʟ ɢᴜɪ"))) {
            if (event.getRawSlot() >= 45 && event.getRawSlot() < 54) {
                event.setCancelled(true);
            } else {
                Bukkit.getScheduler().runTaskLater(this, () -> updateTotalPrice(event.getInventory()), 1L);
            }
        } else if (event.getClickedInventory() != null && event.getClickedInventory().getType() == InventoryType.PLAYER) {
            if (event.isShiftClick() && event.getView().title().equals(Component.text("§7§lsᴇʟʟ ɢᴜɪ"))) {
                Bukkit.getScheduler().runTaskLater(this, () -> updateTotalPrice(event.getView().getTopInventory()), 1L);
            }
        }
    }

    @EventHandler
    public void onInventoryClose(InventoryCloseEvent event) {
        if (event.getView().title().equals(Component.text("§3§lsᴇʟʟ ɢᴜɪ"))) {
            Inventory inventory = event.getInventory();
            double totalPrice = 0.0;
            for (int i = 0; i < 45; i++) {
                ItemStack item = inventory.getItem(i);
                if (item != null) {
                    double itemPrice = calculateItemPrice(item);
                    totalPrice += itemPrice * item.getAmount();
                }
            }

            if (totalPrice > 0 && economy != null) {
                Player player = (Player) event.getPlayer();
                economy.depositPlayer(player, totalPrice);
                sendActionBarMessage(player, "§aɪᴛᴇᴍs sᴏʟᴅ ғᴏʀ $" + decimalFormat.get().format(totalPrice));
                playRandomSound(player);
            }
        }
    }

    private void updateTotalPrice(Inventory inventory) {
        double totalPrice = 0.0;
        for (int i = 0; i < 45; i++) {
            ItemStack item = inventory.getItem(i);
            if (item != null) {
                double itemPrice = calculateItemPrice(item);
                totalPrice += itemPrice * item.getAmount();
            }
        }

        ItemStack emerald = inventory.getItem(49);
        if (emerald != null && emerald.getType() == Material.EMERALD) {
            ItemMeta emeraldMeta = emerald.getItemMeta();
            emeraldMeta.displayName(Component.text("§aTotal: " + decimalFormat.get().format(totalPrice)));
            emerald.setItemMeta(emeraldMeta);
        }
    }

    private double calculateItemPrice(ItemStack item) {
        double itemPrice = 0.0;
        if (item.getType() == Material.ENCHANTED_BOOK && item.getItemMeta() instanceof EnchantmentStorageMeta) {
            EnchantmentStorageMeta meta = (EnchantmentStorageMeta) item.getItemMeta();
            for (Map.Entry<Enchantment, Integer> enchantment : meta.getStoredEnchants().entrySet()) {
                if (enchantedBookPrices.containsKey(enchantment.getKey())) {
                    itemPrice += enchantedBookPrices.get(enchantment.getKey()).get(enchantment.getValue());
                }
            }
        } else if (itemPrices.containsKey(item.getType().name())) {
            itemPrice = itemPrices.get(item.getType().name());
        }
        if (item.getEnchantments().size() > 0) {
            for (Map.Entry<Enchantment, Integer> enchantment : item.getEnchantments().entrySet()) {
                if (enchantedBookPrices.containsKey(enchantment.getKey())) {
                    itemPrice += enchantedBookPrices.get(enchantment.getKey()).get(enchantment.getValue());
                }
            }
        }
        return itemPrice;
    }

    private void sendActionBarMessage(Player player, String message) {
        player.sendActionBar(Component.text(message));
    }

    private void playRandomSound(Player player) {
        Sound sound = sounds[random.nextInt(sounds.length)];
        player.playSound(player.getLocation(), sound, 1.0f, 1.0f);
    }
}