package com.alttd.cometskyblock.challenges;

import com.alttd.cometskyblock.CometSkyBlockPlugin;
import com.alttd.cometskyblock.api.challenges.ChallengeDifficulty;
import com.alttd.cometskyblock.api.challenges.ChallengeType;
import com.alttd.cometskyblock.gui.GUIButton;
import com.alttd.cometskyblock.gui.GUIInventory;
import com.alttd.cometskyblock.island.Island;
import com.alttd.cometskyblock.util.PlayerUtils;
import com.alttd.cometskyblock.util.StringUtil;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemFlag;
import org.bukkit.inventory.ItemStack;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Collectors;

public class ChallengesGUI extends GUIInventory {

    protected ChallengeDifficulty challengeDifficulty = ChallengeDifficulty.EASY;

    public ChallengesGUI(Island island) {
        super(island);
    }

    @Override
    protected Inventory createInventory() { // TODO - config
        return Bukkit.createInventory(this, 36, MiniMessage.miniMessage().deserialize("<yellow>Island - challenges menu"));
    }

    @Override
    public void decorate(Player player) {
        resetButtons();
        makeMenuBar(player);
        // Add buttons to change difficulty
        if (!challengeDifficulty.equals(ChallengeDifficulty.EASY))
            addButton(getInventory().getSize() - 5, createMenuButton(Material.WHITE_BANNER, "Easy Challenges", new ArrayList<>(), event -> {
                changeDifficulty(player, ChallengeDifficulty.EASY);
            }));
        if (!challengeDifficulty.equals(ChallengeDifficulty.MEDIUM))
            addButton(getInventory().getSize() - 4, createMenuButton(Material.GREEN_BANNER, "Medium Challenges", new ArrayList<>(), event -> {
                changeDifficulty(player, ChallengeDifficulty.MEDIUM);
            }));
        if (!challengeDifficulty.equals(ChallengeDifficulty.HARD))
            addButton(getInventory().getSize() - 3, createMenuButton(Material.BLUE_BANNER, "Hard Challenges", new ArrayList<>(), event -> {
                changeDifficulty(player, ChallengeDifficulty.HARD);
            }));
        if (!challengeDifficulty.equals(ChallengeDifficulty.LEGENDARY))
            addButton(getInventory().getSize() - 2, createMenuButton(Material.PURPLE_BANNER, "Legendary Challenges", new ArrayList<>(), event -> {
                changeDifficulty(player, ChallengeDifficulty.LEGENDARY);
            }));
        if (!challengeDifficulty.equals(ChallengeDifficulty.EXOTIC))
            addButton(getInventory().getSize() - 1, createMenuButton(Material.YELLOW_BANNER, "Exotic Challenges", new ArrayList<>(), event -> {
                changeDifficulty(player, ChallengeDifficulty.EXOTIC);
            }));

        currentSlot = 0;
        int startIndex = pageIndex * (getInventory().getSize() - 9);
        List<Challenge> challenges = CometSkyBlockPlugin.instance().challengeHandler().getChallengesList(challengeDifficulty);
        for (int i = startIndex; i < challenges.size(); i++) {
            Challenge challenge = challenges.get(i);
            int challengeCount = island.challengeCount(challenge.key());
            GUIButton guiButton = createChallengeButton(challenge, event -> {
                // TODO -- Clean up
                boolean repeat = challengeCount != 0;
                List<ItemStack> rewards = repeat ? challenge.repeatRewards() : challenge.rewards();
                boolean hasRequirements = false;
                boolean takeItems = false;
                switch (challenge.challengeType()) {
                    case ON_PLAYER -> {
                        hasRequirements = PlayerUtils.hasItems(player.getInventory(), challenge.requiredItems());
                        takeItems = true;
                    }
                    case ON_ISLAND -> {
                        if (repeat) {
                            return;
                        }
                        if (!player.getWorld().getUID().equals(island.islandUUID())) {
                            player.sendRichMessage(CometSkyBlockPlugin.instance().messagesConfiguration().get().island().notOnIsland());
                            return;
                        }
                        Object2IntMap<Material> blocks = PlayerUtils.getBlocks(player, challenge.radius());
                        for (ItemStack itemStack : challenge.requiredItems()) {
                            if (blocks.getInt(itemStack.getType()) < itemStack.getAmount()) {
                                hasRequirements = false;
                                break;
                            }

                            hasRequirements = true;
                        }
                    }
                    case ISLAND_LEVEL -> {
                        if (repeat) {
                            return;
                        }
                        hasRequirements = island.level() >= challenge.requiredLevel();
                        if (!hasRequirements) {
                            player.sendRichMessage("<red>You do no have the required island level.");
                            return;
                        }
                    }
                    default -> {
                        return;
                    }
                }
                if (!hasRequirements) {
                    player.sendRichMessage("<red>You do not have all the required items.");
                    return;
                }
                if (!PlayerUtils.hasRoom(player.getInventory(), rewards)) {
                    player.sendRichMessage("<red>You do not have room for the reward items.");
                    return;
                }
                island.challengeCount(challenge.key(), challengeCount + 1);
                TagResolver placeholders = TagResolver.resolver(
                        Placeholder.component("player", player.displayName()),
                        Placeholder.unparsed("challengename", challenge.challengeName())
                );
                island.broadCast("<player> has completed challenge <challengename>.", placeholders);
                PlayerUtils.giveItems(player.getInventory(), rewards);
                if (takeItems) {
                    PlayerUtils.takeItems(player.getInventory(), challenge.requiredItems());
                }
                this.decorate(player);
            }, challengeCount);
            if (!addItem(guiButton)) {
                createNextPageButton(player);
                break;
            }
        }
        if (pageIndex > 0) {
            createPrevPageButton(player);
        }
        super.decorate(player);
    }

    protected void changeDifficulty(Player player, ChallengeDifficulty challengeDifficulty) {
        int requiredLevel = CometSkyBlockPlugin.instance().challengeLoader().requiredLevel(challengeDifficulty);
        if (!(island.level() >= requiredLevel)) {
            TagResolver placeholders = TagResolver.resolver(
                    Placeholder.unparsed("requiredlevel", requiredLevel + ""),
                    Placeholder.unparsed("difficulty", challengeDifficulty.toString().toLowerCase())
            );
            player.sendRichMessage("<red>You need island level <requiredlevel> to access <difficulty> challenges", placeholders);
            return;
        }
        this.challengeDifficulty = challengeDifficulty;
        this.decorate(player);
    }

    private GUIButton createChallengeButton(Challenge challenge, Consumer<InventoryClickEvent> eventConsumer, int challengeCount) {
        return new GUIButton()
                .creator(player -> {
                    ItemStack itemStack = new ItemStack(challenge.shownItem(), Math.min(Math.max(1, challengeCount), 64));
                    itemStack.editMeta(meta -> {
                        MiniMessage miniMessage = MiniMessage.miniMessage();
                        meta.displayName(miniMessage.deserialize(challenge.challengeName()));
                        List<Component> lore = new ArrayList<>(StringUtil.splitMiniMessageString(challenge.description()).stream().map(miniMessage::deserialize).toList());
                        String prefix = switch (challenge.challengeType()) {
                            case ON_PLAYER -> "<yellow>Required items:</yellow>";
                            case ON_ISLAND -> "<yellow>Build:</yellow>";
                            case ISLAND_LEVEL -> "<yellow>Requires</yellow>";
                        };
                        lore.addAll(StringUtil.splitMiniMessageString(prefix + " " + challenge.requiredText()).stream().map(miniMessage::deserialize).toList());
                        lore.add(miniMessage.deserialize("<yellow>Reward: " + StringUtil.splitMiniMessageString(
                        (challenge.challengeType().equals(ChallengeType.ON_PLAYER) && challengeCount != 0) ?
                                challenge.repeatRewardText() : challenge.rewardText())));
                        if (challengeCount > 0) {
                            meta.addEnchant(Enchantment.MENDING, 1, true);
                        }
                        meta.addItemFlags(ItemFlag.values());

                        meta.lore(lore);
                    });
                    return itemStack;
                })
                .consumer(eventConsumer);
    }
}