package org.xfurkanadenia.xBlackMarket;

import net.citizensnpcs.api.CitizensAPI;
import net.citizensnpcs.api.npc.NPC;
import net.milkbowl.vault.economy.Economy;
import org.bukkit.Bukkit;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.plugin.RegisteredServiceProvider;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitTask;
import org.xfurkanadenia.xBlackMarket.commands.MainCommand;
import org.xfurkanadenia.xBlackMarket.files.DataFile;
import org.xfurkanadenia.xBlackMarket.files.Locale;
import org.xfurkanadenia.xBlackMarket.guis.BlackMarketGUI;
import org.xfurkanadenia.xBlackMarket.guis.EmptyMarket;
import org.xfurkanadenia.xBlackMarket.hooks.PlaceHolderAPI;
import org.xfurkanadenia.xBlackMarket.listeners.GUIListener;
import org.xfurkanadenia.xBlackMarket.managers.ChanceManager;
import org.xfurkanadenia.xBlackMarket.managers.GuiManager;
import org.xfurkanadenia.xBlackMarket.tasks.MarketRunnable;
import org.xfurkanadenia.xBlackMarket.utils.ConfigUtils;
import org.xfurkanadenia.xBlackMarket.utils.Utils;

import java.util.*;
import java.util.concurrent.ThreadLocalRandom;

public final class XBlackMarket extends JavaPlugin {
    private static XBlackMarket instance;

    BukkitTask marketTask;

    public enum blackMarketStartingModes { INTERVAL, TIME };
    public blackMarketStartingModes blackMarketStartingMode;
    public boolean blackMarketStarted = false;
    public long blackMarketStartedTime;
    public long blackMarketEndedTime;

    PlaceHolderAPI placeHolderAPI;

    NPC npc;

    public GuiManager guiManager;
    public Utils utils;
    public Locale locale;
    public DataFile data;
    public ConfigUtils configUtils;

    private static Economy economy = null;

    public Map<Integer, Map<String, Object>> marketListedItems = new HashMap<>();

    public HashMap<String, HashMap<String, Object>> BlackMarketGUIItems = new HashMap<>();
    public HashMap<String, HashMap<String, Object>> EmptyMarketGUIItems = new HashMap<>();
    public Map<String, Map<String,Object>> marketListableItems = new HashMap<>();
    public List<String> marketStartingTimes;

    private Inventory gui;

    @Override
    public void onEnable() {
        if(!setupEconomy()) {
            this.getLogger().severe("Economy can't setup.");
            this.getLogger().severe("Plugin Disabling!");
            this.getServer().getPluginManager().disablePlugin(this);
            return;
        }

        if(getServer().getPluginManager().getPlugin("Citizens") != null) {
            npc = CitizensAPI.getNPCRegistry().createNPC(EntityType.PLAYER, "fullwall");
        } else {
            getLogger().warning("If you want npc feature, please download \"Citizens\" plugin");
            getLogger().warning("Free Version of Citizens (Same as plugin in Spigot): https://ci.citizensnpcs.co/job/citizens2/");
        }

        instance = this;

        locale = new Locale(this);
        this.utils = new Utils();
        this.guiManager = new GuiManager(this);
        this.configUtils = new ConfigUtils();

        this.data = new DataFile("data.yml");


        this.getServer().getPluginManager().registerEvents(new GUIListener(guiManager), this);
        this.getCommand("blackmarket").setExecutor(new MainCommand());
        reloadPlugin();

        marketTask = new MarketRunnable(this).runTaskTimer(this, 0, 0);
    }

    private boolean setupEconomy() {
        if (getServer().getPluginManager().getPlugin("Vault") == null) {
            return false;
        }
        RegisteredServiceProvider<Economy> rsp = getServer().getServicesManager().getRegistration(Economy.class);
        if (rsp == null) {

            return false;
        }
        economy = rsp.getProvider();
        return economy != null;
    }

    public Economy getEconomy() {
        return economy;
    }

    public void reloadPlugin() {
        this.saveDefaultConfig();
        this.reloadConfig();

        data.saveDefaultConfig();
        data.reloadConfig();

        this.guiManager.loadGuis();
        locale.loadLocale(this.getConfig().getString("locale"));
        setGUIItems(EmptyMarketGUIItems, "emptyMarket.yml");
        setGUIItems(BlackMarketGUIItems, "blackMarket.yml");
        instance = this;

        String startingMode = this.getConfig().getString("blackMarketStartingMode", "interval");
        if(startingMode.equalsIgnoreCase("interval")) blackMarketStartingMode = blackMarketStartingModes.INTERVAL;
        else if(startingMode.equalsIgnoreCase("time")) blackMarketStartingMode = blackMarketStartingModes.TIME;

        if(blackMarketStartingMode == blackMarketStartingModes.TIME) {
            marketStartingTimes = new ArrayList<>(this.getConfig().getStringList("blackMarketStartingTimes"));
        }

        setupEconomy();
        setMarketListableItems();
        stopBlackMarket(false);

        if(this.getServer().getPluginManager().getPlugin("PlaceHolderAPI") != null) {
            if (placeHolderAPI == null) placeHolderAPI = new PlaceHolderAPI();
            if (!placeHolderAPI.isRegistered()) placeHolderAPI.register();
        }
    }

    @Override
    public void onDisable() {
        if(guiManager == null || marketListableItems == null) return;
        stopBlackMarket(false);
        guiManager.closeAllGUIs();
    }

    public void setGUIItems(HashMap<String, HashMap<String, Object>> map, String guiPath) {
        ConfigurationSection gui = new DataFile("guis/" + guiPath)
                .getConfig()
                .getConfigurationSection("items");

        if (gui == null) {
            getLogger().warning("blackMarket.yml içinde 'items' bulunamadı!");
            return;
        }

        for (String key : gui.getKeys(false)) {

           HashMap<String, Object> item = new HashMap<>();
           ConfigurationSection itemCfg = gui.getConfigurationSection(key);
           item.put("material", itemCfg.getString("material", ""));
           item.put("displayName", itemCfg.getString("displayName", ""));
            if(itemCfg.contains("slot")) item.put("slot", itemCfg.getInt("slot"));
           if(itemCfg.contains("slots")) item.put("slots", itemCfg.getIntegerList("slots"));
           if(itemCfg.contains("lore")) item.put("lore", itemCfg.getStringList("lore"));
           if(itemCfg.contains("customModelData")) item.put("customModelData", itemCfg.getInt("customModelData"));
           if(itemCfg.contains("lore")) item.put("lore", itemCfg.getStringList("lore"));



           map.put(key, item);
        }
    }

    public void setMarketListableItems() {
        FileConfiguration marketItems = new DataFile("marketItems.yml").getConfig();
        if(!marketListableItems.isEmpty()) marketListableItems.clear();
        for(String key : marketItems.getKeys(false)) {
            if(key.equals("nextValue")) continue;
            marketListableItems.put(key, configUtils.SectionToMap((ConfigurationSection) marketItems.get(key)));
        }

    }

    public void startBlackMarket(boolean sendMsg) {
        ChanceManager chance = new ChanceManager();

        if (!marketListedItems.isEmpty()) {
            marketListedItems.clear();
        }

        HashMap<String, Float> itemChances = new HashMap<>();
        ConfigurationSection marketItemsCfg = guiManager.guis.get("blackMarket.yml")
                .getConfigurationSection("items.marketItems");

        for (String item : marketListableItems.keySet()) {
            itemChances.put(item, Float.parseFloat(String.valueOf(
                    marketListableItems.get(item).get("chance")
            )));
        }

        if (marketItemsCfg.contains("slot")) {
            Map<String, Object> itemData = marketListableItems.entrySet().iterator().next().getValue();
            itemData.put("currentStock", ThreadLocalRandom.current().nextInt(
                    Integer.parseInt(String.valueOf(itemData.get("minStock"))),
                    Integer.parseInt(String.valueOf(itemData.get("maxStock")))
            ));
            marketListedItems.put(marketItemsCfg.getInt("slot"), itemData);
        } else if (marketItemsCfg.contains("slots")) {
            List<Integer> slots = marketItemsCfg.getIntegerList("slots");
            for (int slot : slots) {
                String itemName = chance.randomItem(itemChances);
                Map<String, Object> itemData = new HashMap<>(marketListableItems.get(itemName)); // Yeni bir kopya oluştur
                itemData.put("currentStock", ThreadLocalRandom.current().nextInt(
                        Integer.parseInt(String.valueOf(itemData.get("minStock"))),
                        Integer.parseInt(String.valueOf(itemData.get("maxStock")))
                ));
                marketListedItems.put(slot, itemData);
            }
        }

        data.getConfig().set("blackmarketStart", true);
        data.saveConfig();
        blackMarketStartedTime = System.currentTimeMillis() / 1000;
        blackMarketStarted = true;

        for (Player player : Bukkit.getOnlinePlayers()) {
            if (player.getOpenInventory().getTopInventory().equals(new BlackMarketGUI(this))) {
                new BlackMarketGUI(this).open(player);
            }
        }

        for(Player player : Bukkit.getOnlinePlayers()) {
            if(
                    guiManager.activeInventories.containsKey(player.getOpenInventory().getTopInventory())
                    && guiManager.activeInventories.get(player.getOpenInventory().getTopInventory()) instanceof EmptyMarket) {

                new BlackMarketGUI(this).open(player);
            }
            if(sendMsg) player.sendMessage(utils.translateColorCodes(utils.placeholders(locale.getMessage("blackMarket_start"), player, new HashMap<>())));
        }
    }




    public void stopBlackMarket(boolean sendMsg) {

        marketListedItems.clear();
        blackMarketStarted = false;


        for(Player player : Bukkit.getOnlinePlayers()) {
            if(guiManager.activeInventories.get(player.getOpenInventory().getTopInventory()) instanceof BlackMarketGUI) {
                player.closeInventory();

            }
            if(sendMsg) player.sendMessage(utils.translateColorCodes(utils.placeholders(locale.getMessage("blackMarket_finished"), player, new HashMap<>())));
        }

        blackMarketEndedTime = System.currentTimeMillis() / 1000;
        blackMarketStarted = false;
    }


    public Boolean stocksEmpty() {
        return marketListedItems.values().stream().filter((map)  -> (int) map.get("currentStock") > 0).count() < 1;
    }


    public static XBlackMarket getInstance() {
        return instance;
    }



}