package ru.lisenochek.mcrust.objects.blockMechanic;

import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.entity.HumanEntity;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.scheduler.BukkitRunnable;
import ru.lisenochek.mcrust.Items;
import ru.lisenochek.mcrust.Main;
import ru.lisenochek.mcrust.objects.misc.Sounds;
import ru.lisenochek.mcrust.objects.player.craft.Craft;
import ru.lisenochek.mcrust.sql.SQLManager;
import ru.lisenochek.mcrust.utils.ISBuilder;
import ru.lisenochek.mcrust.utils.Utils;

import java.util.*;

public class Recycler {

    private static HashMap<Location, Recycler> recyclersMap = new HashMap<>();
    private static List<Integer> recyclerSlots = Arrays.asList(10, 11, 12, 13, 14);

    private Location location;
    private boolean isWork;
    private int taskID;
    private Inventory inventory;

    private Recycler(Location location) {
        this.location = location;
        this.inventory = Bukkit.createInventory(null, 27, Utils.stripColor("&2&lПереработчик"));
        recyclersMap.put(location, this);
    }

    private Recycler(Location location, String data) {
        this.location = location;
        this.inventory = Bukkit.createInventory(null, 27, Utils.stripColor("&2&lПереработчик"));
        for (String s : data.split(" ")) {
            String[] s1 = s.split("-");
            inventory.setItem(Integer.parseInt(s1[0]), ISBuilder.deserialiseStack(s1[1]));
        }
        recyclersMap.put(location, this);
    }

    public static Recycler create(Location location) {
        return new Recycler(location);
    }

    public static Recycler create(Location location, String data) {
        return new Recycler(location, data);
    }

    public static Recycler fromLocation(Location location) {
        return recyclersMap.get(location);
    }

    public Location getLocation() {
        return location;
    }

    public static List<Integer> getRecyclerSlots() {
        return recyclerSlots;
    }

    public static void save() {
        for (Recycler recycler : recyclersMap.values()) {
            recycler.stopWork();
            SQLManager.getManager().updateRecyclerData(recycler);
        }
    }

    public void remove() {
        stopWork();
        Recycler.recyclersMap.remove(location);
        SQLManager.getManager().deleteRecyclerData(this);
    }

    public void openGUI(Player player) {

        inventory.setItem(16, (isWork
                ?
                ISBuilder.getBuilder(Material.BOOK, 0, 1, "&a&l» &e&lПереработчик запущен",
                        "",
                        "&7Нажмите, чтобы &aостановить",
                        "&7переработчик"
                )
                :
                ISBuilder.getBuilder(Material.BOOK, 0, 1, "&a&l» &e&lПереработчик остановлен",
                        "",
                        "&7Нажмите, чтобы &aвключить",
                        "&7переработчик"
                )).setTag("location", Utils.serialiseLocation(location)).getStack()
        );

        inventory.setItem(18, ISBuilder.getBuilder(Material.BOOK, 0, 1, "&a&l» &e&lРабота переработчика",
                "",
                "&7&l&nМатериалы для переработки&7&l:",
                "",
                "&7Положите предметы для &aпереработки &7в любые &a5 &7слотов. Предметы, которые",
                "&aнельзя &7создать и &aнекоторые &7создаваемые &aнельзя &7переработать. Предметы",
                "&7перерабатываются &aслева-направо &7и их составляющие &aпоявляются &7в &aсвободных",
                "&7слотах",
                "",
                "&7&l&nРабота переработчика&7&l:",
                "",
                "&7Нажмите по иконке &aсправа&7, чтобы &aвключить &7переработчик.",
                "&7Переработчик &aостановится&7, если он будет &aпереполнен &7ресурсами или",
                "&7если в нем &aне &7будет предметов для &aпереработки"
        ).getStack());

        for (int freeSlot = 0; freeSlot < inventory.getSize(); freeSlot++) if (!recyclerSlots.contains(freeSlot) && inventory.getItem(freeSlot) == null) inventory.setItem(freeSlot, ISBuilder.getBuilder(Material.STAINED_GLASS_PANE, 0, 1, " ").getStack());
        player.openInventory(inventory);
    }

    public void startWork() {

        if (isWork) return;
        if (isFull() || isEmpty()) return;

        isWork = true;
        for (HumanEntity entity : new ArrayList<>(inventory.getViewers())) openGUI((Player) entity);
        location.getWorld().playSound(location, Sounds.RECYCLER_START_WORK.getSoundName(), 1, 1);

        BukkitRunnable runnable = new BukkitRunnable() {

            int milsec = 0;

            @Override
            public void run() {

                if (!recyclersMap.containsKey(location)) {
                    cancel();
                    return;
                }

                if (isFull() || isEmpty()) {
                    stopWork();
                    return;
                }

                milsec++;

                if (milsec % 20 == 0) location.getWorld().playSound(location, Sounds.RECYCLER_WORK.getSoundName(), 1, 1);
                if (milsec % (20 * 5) != 0) return;

                for (int slot : recyclerSlots) {

                    boolean resFound = false;
                    ItemStack material = inventory.getItem(slot);

                    if (material == null) continue;

                    HashMap<ItemStack, List<ItemStack>> map = getItems();

                    for (Map.Entry<ItemStack, List<ItemStack>> entry : map.entrySet()) {

                        if (!Utils.checkItem(material, entry.getKey())) continue;

                        inventory.setItem(slot, ISBuilder.getBuilder(material).setAmount(material.getAmount() - 1).getStack());

                        for (ItemStack stack : entry.getValue()) {

                            Collection<ItemStack> dropList = inventory.addItem(stack).values();

                            if (dropList.size() != 0) stopWork();
                            for (ItemStack drops : dropList) location.getWorld().dropItemNaturally(location.clone().add(0.5D, 1, 0.5D), drops);
                        }

                        resFound = true;
                        break;
                    }

                    if (resFound) break;
                }
            }
        };
        runnable.runTaskTimer(Main.plugin, 1, 1);
        taskID = runnable.getTaskId();
    }

    public void stopWork() {

        if (!isWork) return;

        isWork = false;
        for (HumanEntity entity : new ArrayList<>(inventory.getViewers())) openGUI((Player) entity);
        Sounds.stopSounds(location, Sounds.RECYCLER_START_WORK.getSoundName(), Sounds.RECYCLER_WORK.getSoundName());
        location.getWorld().playSound(location, Sounds.RECYCLER_STOP_WORK.getSoundName(), 1, 1);
        Bukkit.getScheduler().cancelTask(taskID);
    }

    private boolean isFull() {

        boolean isFull = true;

        for (int slot : recyclerSlots) {

            ItemStack stack = inventory.getItem(slot);

            if (stack == null) {
                isFull = false;
                break;
            }

            for (Map.Entry<ItemStack, List<ItemStack>> entry : getItems().entrySet()) {

                if (!Utils.checkItem(entry.getKey(), stack)) continue;

                for (ItemStack result : entry.getValue()) {

                    if (!Utils.checkItem(result, stack)) continue;
                    if (stack.getAmount() == stack.getMaxStackSize()) continue;

                    isFull = false;
                    break;
                }
            }
        }

        return isFull;
    }

    private boolean isEmpty() {

        boolean isEmpty = true;

        for (int slot : recyclerSlots) {
            ItemStack stack = inventory.getItem(slot);
            if (stack == null) continue;
            for (ItemStack recycleItem : getItems().keySet()) {
                if (!Utils.checkItem(recycleItem, stack)) continue;
                isEmpty = false;
                break;
            }
        }

        return isEmpty;
    }

    private HashMap<ItemStack, List<ItemStack>> getItems() {

        HashMap<ItemStack, List<ItemStack>> map = new HashMap<>();

        for (Craft.CraftItems categoryItems : Craft.CraftItems.values()) {
            if (categoryItems.isNotRecycling()) continue;
            List<ItemStack> list = new ArrayList<>();
            for (ItemStack stack : categoryItems.getNeedItems()) list.add(ISBuilder.getBuilder(stack.clone()).setAmount(stack.getAmount() / 2).getStack());
            map.put(categoryItems.getResult(), list);
        }

        for (I i : I.values()) map.put(i.getStack(), Arrays.asList(i.getResult()));
        return map;
    }

    public String serialize() {

        StringBuilder builder = new StringBuilder();
        boolean isEmpty = true;

        for (int slot : recyclerSlots) {
            ItemStack stack = inventory.getItem(slot);
            if (stack == null) continue;
            isEmpty = false;
            break;
        }

        if (isEmpty) return null;

        for (int slot : recyclerSlots) {
            ItemStack stack = inventory.getItem(slot);
            if (stack == null) continue;
            builder.append(slot).append("-").append(ISBuilder.serialise(stack)).append(" ");
        }

        return builder.toString();
    }

    public enum I {

        SEMI_RIFLE_BODY(Items.SEMI_RIFLE_BODY.getStack(),
                ISBuilder.getBuilder(Items.SCRAP.getStack()).setAmount(5).getStack(),
                Items.HQM.getStack(),
                ISBuilder.getBuilder(Items.METAL_FRAGMENTS.getStack()).setAmount(20).getStack()
        ),

        SMG_BODY(Items.SMG_BODY.getStack(),
                ISBuilder.getBuilder(Items.SCRAP.getStack()).setAmount(15).getStack(),
                ISBuilder.getBuilder(Items.HQM.getStack()).setAmount(4).getStack()
        ),

        RIFLE_BODY(Items.RIFLE_BODY.getStack(),
                ISBuilder.getBuilder(Items.SCRAP.getStack()).setAmount(25).getStack(),
                ISBuilder.getBuilder(Items.HQM.getStack()).setAmount(4).getStack()
        ),

        ROPE(Items.RIFLE_BODY.getStack(),
                ISBuilder.getBuilder(Items.SCRAP.getStack()).setAmount(25).getStack(),
                ISBuilder.getBuilder(Items.HQM.getStack()).setAmount(4).getStack()
        );

        private ItemStack stack;
        private ItemStack[] result;

        I(ItemStack stack, ItemStack... result) {
            this.stack = stack;
            this.result = result;
        }

        public ItemStack getStack() {
            return stack;
        }

        public ItemStack[] getResult() {
            return result;
        }
    }
}