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.*;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
import org.bukkit.metadata.FixedMetadataValue;
import org.bukkit.scheduler.BukkitRunnable;
import org.mineacademy.fo.plugin.SimplePlugin;

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

public final class ChestInventoryListener extends ChestGuiInventory implements Listener {

    public static final Map<Player, Object> viewers = new HashMap<>();
    private final static String CHEST_METADATA = "SpecialChestLocation";

    @EventHandler(priority = EventPriority.LOWEST)
    public void onInventoryPlayerUpdate(InventoryClickEvent event) {
        inventoryUpdates(event);
    }

    @EventHandler(priority = EventPriority.LOWEST)
    public void onInventoryPlayerUpdate(InventoryDragEvent event) {
        inventoryUpdates(event);
        //craftingUpdate(event);
    }

    @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));
                Inventory inventory = createMenu();

                onOpen(event);
                player.openInventory(getInventory());

                System.out.println(ChestGuiInventory.viewers.get(player.getUniqueId()));
                //showMenus(player, chestData);
                event.setCancelled(true);
                getInventory().getViewers().remove(event.getPlayer());
                //ItemStack[] itemStacks = chestData.getChestContents();
                //getInventory().setContents(itemStacks);
                System.out.println("Inventory  " + getInventory());
                //System.out.println("createMenu" + createMenu());
            }
        }
    }


    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
    public void inventoryUpdates(InventoryInteractEvent event) {
        InventoryHolder holder = event.getInventory().getHolder();
        Location locations = event.getInventory().getLocation();
        System.out.println("if InventoryInteractEvent ");
        Player player = (Player) event.getWhoClicked();

        if (!player.hasMetadata(CHEST_METADATA)) return;

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

        System.out.println("chest loc" + location);
        if (chestData != null) {

            System.out.println("if Inventory ");
            Bukkit.getScheduler().scheduleSyncDelayedTask(ChestStorage.getInstance(), () -> {
                ItemStack[] items = chestData.getChestContents();
                if (getInventory().getHolder() != null)
                    getInventory().setContents(items);
                ItemStack[] item = getInventory().getContents();
                registry.saveChestItemsFromHopper(location, item);
            }, 1);
        }
    }

    @EventHandler
    public void onInventoryclick(InventoryClickEvent event) {

    /*  ChestStorage.getInstance().getServer().getScheduler().scheduleSyncDelayedTask(ChestStorage.getInstance(), () -> {
            List<HumanEntity> plyers = event.getInventory().getViewers();

            for (Map.Entry<Player, Object> entry : viewers.entrySet()) {
                Player p = entry.getKey();
                //Player p = (Player) he;
                p.updateInventory();
                System.out.println("player fun " + p);
            }
        }, 1L);*/
    }

    @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());
            onClose(event);
        getInventory().getViewers().remove(event.getPlayer());
    }


    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, getInventory())) {
                                    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;
    }

}