package org.broken.cheststorage.menus;

import org.broken.cheststorage.ChestStorage;
import org.broken.cheststorage.data.ChestRegistry;
import org.broken.cheststorage.data.ChestRegistry.ChestData;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.Hopper;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.inventory.InventoryMoveItemEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.metadata.FixedMetadataValue;
import org.bukkit.scheduler.BukkitRunnable;
import org.mineacademy.fo.Common;
import org.mineacademy.fo.plugin.SimplePlugin;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public final class ChestInventoryListener extends ChestGuiInventory implements Listener {


    private final static String CHEST_METADATA = "SpecialChestLocation";

    @EventHandler(priority = EventPriority.LOW)
    public void onBlockClick(PlayerInteractEvent event) {

        Player player = event.getPlayer();
        Block clickedBlock = event.getClickedBlock();

        if (clickedBlock != null && clickedBlock.getType() == Material.CHEST
                && event.getAction() == Action.RIGHT_CLICK_BLOCK && !player.isSneaking()) {

            Location blockLocation = event.getClickedBlock().getLocation();
            ChestData chestData = ChestRegistry.getInstance().findChest(blockLocation);

            System.out.println("Attempted to load a chest inventory at " + Common.shortLocation(blockLocation) + " = " + chestData);

            if (chestData != null) {
                player.setMetadata(CHEST_METADATA, new FixedMetadataValue(SimplePlugin.getInstance(), blockLocation));

                onOpen(event);
                showMenus(player, chestData);
                event.setCancelled(true);
            }
        }
    }

    private void showMenu(Player player, ChestData chestData) {
        int size = 27;
        Inventory gui = Bukkit.createInventory(null, size, "Gui Chest");
        ItemStack[] items = chestData.getChestContents();

        if (items == null)
            items = new ItemStack[size];

        gui.setContents(items);
        player.openInventory(gui);
    }

    @EventHandler(priority = EventPriority.LOW)
    public void onInventoryClose(InventoryCloseEvent event) {
        Inventory inventory = event.getInventory();
        Player player = (Player) event.getPlayer();

        if (!player.hasMetadata(CHEST_METADATA)) {
            System.out.println("@RETURN DUE TO NO METADATA");

            return;
        }

        Location location = (Location) player.getMetadata("SpecialChestLocation").get(0).value();
        ChestRegistry registry = ChestRegistry.getInstance();
        ChestData chestData = registry.findChest(location);

        System.out.println("Attempted to save chest data at " + Common.shortLocation(location) + " and found: " + chestData);
        player.removeMetadata(CHEST_METADATA, ChestStorage.getInstance());

        if (chestData != null)
            registry.saveChestItems(location, player.getUniqueId(), inventory.getContents());

        viewers.remove(event.getPlayer().getUniqueId());
        onClose(event);

    }


    public void onInventoryMoveIn(InventoryMoveItemEvent event) {


        ArrayList<ItemStack> items = new ArrayList<>();
        Inventory destination = event.getDestination();
        Location destinationloc = event.getDestination().getLocation();
        Inventory source = event.getSource();
        Location sourceloc = event.getSource().getLocation();
        Inventory initiator = event.getInitiator();
        Location initiatorloc = event.getInitiator().getLocation();
        ItemStack item = event.getItem();
        items.add(item);

        ItemStack[] test = items.toArray(new ItemStack[0]);

        ChestRegistry registry = ChestRegistry.getInstance();
        ChestData chestData = registry.findChest(destinationloc);
        System.out.println("Destination " + test);
        if (chestData != null) {
            System.out.println("Destination " + destination + " " + destinationloc);
            event.setCancelled(true);
            //event.setItem();
            registry.saveChestItemsFromHopper(destinationloc, test);

        }
        /*System.out.println("source " + source + " " + sourceloc);
        System.out.println("Initiator " + initiator + " " + initiatorloc);
        System.out.println("item " + item);*/
    }

    /**
     * Detect if items are moved from hopper to chest or chest to hopper.
     *
     * @param event
     */

    @EventHandler(priority = EventPriority.NORMAL)
    public void fromHopperToContainer(InventoryMoveItemEvent event) {
        if (event.getInitiator().getHolder() instanceof Hopper) {
            ChestRegistry registry = ChestRegistry.getInstance();
            Location location = event.getDestination().getLocation();

            ChestData chestData = registry.findChest(location);
            //ItemStack[] itemStacks = chestData.getChestContents();
            chestData = registry.findChest(location);

            ArrayList<ItemStack> items = new ArrayList<>();
            ItemStack item = event.getItem();
            items.add(item);
            ItemStack[] test = items.toArray(new ItemStack[0]);

            //System.out.println("Items " + Arrays.toString(test));

            if (chestData != null) {
                if (!event.isCancelled()) {
                    event.setCancelled(true);
                    new BukkitRunnable() {
                        @Override
                        public void run() {
                            if (location != null) {
                                int hopperAmount = 1;
                                if (hopperMoveItemFromToChest(event.getSource(), hopperAmount, createMenu())) {
                                    //registry.saveChestItemsFromHopper(location, test);
                                }
                                /*if (event.getDestination().getHolder() != null)
                                    event.getDestination().getHolder().getInventory().clear();*/
                                //if (getInventory().getViewers().size() > 0) getInventory().setContents(itemStacks);
                            }
                        }
                    }.runTaskLater(ChestStorage.getInstance(), 1);
                }
            }
        }
    }

    public static ItemStack removeStackFromInventory(Inventory inventory, int amount, List filters) {
        ItemStack RemoveItemsFromContainerBefore;
        for (int i = 0; i < inventory.getContents().length; i++) {
            ItemStack stack = inventory.getItem(i);
            if ((stack != null)) {
                RemoveItemsFromContainerBefore = stack.clone();
                RemoveItemsFromContainerBefore.setAmount(Math.min(stack.getAmount(), amount));
                stack.setAmount(stack.getAmount() - RemoveItemsFromContainerBefore.getAmount());

                System.out.println("stack.getAmount " + stack.getAmount());
                System.out.println("Items before " + RemoveItemsFromContainerBefore);

                return RemoveItemsFromContainerBefore;
            }
        }
        return null;
    }

    public static boolean hopperMoveItemFromToChest(Inventory from, int amount, Inventory to, List filters) {
        ItemStack removed = removeStackFromInventory(from, amount, null);
        if (removed != null) {
            HashMap<Integer, ItemStack> leftOvers = to.addItem(removed);
            for (ItemStack leftOver : leftOvers.values()) {
                from.addItem(leftOver);

                System.out.println("Items leftOver " + leftOver);
                if (removed.equals(leftOver)) return false;
            }
            return true;
        }
        return false;
    }

    public static boolean hopperMoveItemFromToChest(Inventory from, int amount, Inventory to) {
        return hopperMoveItemFromToChest(from, amount, to, null);
    }

    public static boolean hopperMoveItemFromToChest(Inventory from, ItemStack stack, int amount, Inventory to) {
        if (stack != null) {
            ItemStack toRemoveFromHopper = stack.clone();
            toRemoveFromHopper.setAmount(Math.min(stack.getAmount(), amount));
            stack.setAmount(stack.getAmount() - toRemoveFromHopper.getAmount());

            HashMap<Integer, ItemStack> leftOvers = to.addItem(toRemoveFromHopper);
            for (ItemStack leftOver : leftOvers.values()) {
                from.addItem(leftOver);
                if (toRemoveFromHopper.equals(leftOver)) return false;
            }
            return true;
        }
        return false;
    }

}