import org.bukkit.Bukkit;
import org.bukkit.Location;
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.block.BlockBreakEvent;
import org.bukkit.event.inventory.*;
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.PlayerUtil;
import org.mineacademy.fo.SerializeUtil;
import org.mineacademy.fo.plugin.SimplePlugin;
import org.mineacademy.fo.remain.CompMetadata;
import org.mineacademy.fo.remain.CompSound;
import org.mineacademy.sharedinventory.InventoryHolder;
import org.mineacademy.sharedinventory.InventoryRegistry;
import org.mineacademy.sharedinventory.SharedInventoryPlugin;

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

public final class PlayerListener implements Listener {


    @EventHandler
    public void onBlockClick(PlayerInteractEvent event) {
        Player player = event.getPlayer();
        Block block = event.getClickedBlock();
        Action action = event.getAction();

        if (action == Action.RIGHT_CLICK_BLOCK && !player.isSneaking()) {
            Location location = block.getLocation();
            InventoryRegistry registry = InventoryRegistry.getInstance();


            if (registry.isRegistered(block.getLocation())) {
                //Inventory inventory = registry.findAndLoadInventory(location);
                InventoryHolder inventoryHolder = InventoryHolder.getInstance();
/*
                if (!registry.PlayerViwePageEmpty(player))
                    registry.playerViwePage(player, 0);

                int playerRegisted = registry.getPlayerViwePage(player);
                registry.playerViwePage(player, playerRegisted);*/

                //System.out.println("playerRegisted" + playerRegisted);
                inventoryHolder.setPlayerViwePage(player, 0);
                Inventory inventory = inventoryHolder.findAndLoadInventor(location, player);
                //Inventory inventory = registry.findAndLoadInventor(location, player);
                player.openInventory(inventory);
                PlayerUtil.updateInventoryTitle(player, "Chest page: " + inventoryHolder.getPlayerViwePage(player));

                player.setMetadata("SharedInventory", new FixedMetadataValue(SimplePlugin.getInstance(), SerializeUtil.serializeLoc(location)));

                CompSound.SUCCESSFUL_HIT.play(player);
                event.setCancelled(true);
            }
        }
    }

    @EventHandler
    public void onBlockBreak(BlockBreakEvent event) {
        InventoryRegistry.getInstance().handleBlockBreak(event.getBlock());
    }

    @EventHandler
    public void onInventoryClose(InventoryCloseEvent event) {
        Player player = (Player) event.getPlayer();
        Location chestLocation = SerializeUtil.deserializeLocation(CompMetadata.getMetadata(player, "SharedInventory"));

        if (CompMetadata.hasMetadata(player, "SharedInventory")) {
            //InventoryRegistry.getInstance().handleInventoryClose(player);
            InventoryHolder.getInstance().handleInventoryClose(player);
            InventoryHolder.getInstance().getContents(chestLocation);
            //InventoryRegistry.getInstance().getContents(chestLocation);
            //player.removeMetadata("SharedInventory", SharedInventoryPlugin.getInstance());
        }
    }

    @EventHandler
    public void onInteract(InventoryClickEvent event) {
        if (event.getSlotType() != InventoryType.SlotType.OUTSIDE)
            return;

        Player player = (Player) event.getWhoClicked();
        InventoryRegistry registerGui = InventoryRegistry.getInstance();
        Location chestLocation = SerializeUtil.deserializeLocation(CompMetadata.getMetadata(player, "SharedInventory"));

        if (registerGui.isRegistered(chestLocation)) {
            InventoryHolder inventoryHolder = InventoryHolder.getInstance();

            int inputNumber = inventoryHolder.getPageIndex(event.getWhoClicked().getOpenInventory().getTopInventory(), chestLocation); //registerGui.getPageIndex(event.getWhoClicked().getOpenInventory().getTopInventory(), chestLocation);
            System.out.println("inputNumber" + event.getClick());
            if (event.getClick() == ClickType.LEFT) {
                System.out.println("inputNumber" + inputNumber);
                if (inputNumber != 0) {
                    inputNumber--;

                    //registerGui.playerViwePage(player, inputNumber);
                    //Inventory inventory = registerGui.findAndLoadInventor(chestLocation, player);
                    inventoryHolder.playerViwesPage(player, inputNumber);
                    Inventory inventory = inventoryHolder.findAndLoadInventor(chestLocation, player);

                    player.openInventory(inventory);
                    PlayerUtil.updateInventoryTitle(player, "Chest page: " + inputNumber);


                }
            } else if (event.getClick() == ClickType.RIGHT) {
                if (inputNumber + 1 < registerGui.getPageIndex) {
                    inputNumber++;

                    //registerGui.playerViwePage(player, inputNumber);
                    //Inventory inventory = registerGui.findAndLoadInventor(chestLocation, player);
                    inventoryHolder.playerViwesPage(player, inputNumber);
                    Inventory inventory = inventoryHolder.findAndLoadInventor(chestLocation, player);

                    player.openInventory(inventory);
                    PlayerUtil.updateInventoryTitle(player, "Chest page: " + inputNumber);

                }
            }
        }

    }

    @EventHandler(priority = EventPriority.HIGH)
    public void onHopperMoveEvent(InventoryMoveItemEvent event) {
        System.out.println("test");
        if (event.getDestination().getHolder() instanceof Hopper) {
            InventoryRegistry registry = InventoryRegistry.getInstance();
            Location location = event.getSource().getLocation();
            if (event.getDestination().getLocation() != null) {
                // If the event is cancelled
                if (event.isCancelled()) return;
                if (event.getDestination().getLocation().getBlock().isBlockPowered()) return;
            }
            //event.setCancelled(!HopperFilter.isInFilter(event.getDestination().getLocation().getBlock(),event.getItem()));
            // Item shouldn't be moved/touched
            if (event.isCancelled() && registry.isRegistered(location)/* && ServerType.getType() == ServerType.Type.PAPER*/) {
                int index = event.getSource().first(event.getItem());

                ItemStack item;
                // Loop until next item is found, if no item found return.
                while ((item = event.getSource().getItem(++index)) == null) {
                    if (index >= event.getSource().getSize() - 1)
                        return;
                }

                InventoryMoveItemEvent newEvent =
                        new InventoryMoveItemEvent(event.getSource(), item, event.getDestination(), true);
                Bukkit.getPluginManager().callEvent(newEvent);

                if (!newEvent.isCancelled()) {
                    int hopperAmount = 1;
                    hopperMoveItemFromToChest(event.getSource(), hopperAmount, event.getDestination(), item);
                }
            }

        }
    }


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

            boolean chestRegisted = registry.isRegistered(location);

            if (chestRegisted) {
/*
                ArrayList<ItemStack[]> savedItems = registry.handleHopperMove(location);
                ItemStack item = event.getItem();*/

                if (!event.isCancelled()) {
                    event.setCancelled(true);
/*
                    for (int i = 0; i < savedItems.size(); i++) {
                        ItemStack[] savedItem = savedItems.get(i);
                        ItemStack itemsList = (ItemStack) Arrays.asList(savedItem);


                        if (itemsList == null || (itemsList.getAmount() < itemsList.getMaxStackSize() && itemsList.getType() == item.getType())) {
                            savedItems[i] = itemsList == null ? item : ItemCreator.of(itemsList).amount(itemsList.getAmount() + item.getAmount()).build().make();
                            //System.out.println(Arrays.toString(savedItems));

                            registry.AddItemsToChestold(location, savedItems);
                            break;
                        }

                    }*/
                    InventoryHolder inventoryHolder = InventoryHolder.getInstance();

                    int hopperAmount = 1;
                    new BukkitRunnable() {
                        @Override
                        public void run() {
                            if (location != null) {
                                if (!hopperMoveItemFromToChest(event.getSource(), hopperAmount, inventoryHolder.setPageHopper(location)/*registry.findAndLoadInventoryHopper(location)*/, location))
                                    cancel();
                                System.out.println("Test");

                            }
                        }
                    }.runTaskLater(SharedInventoryPlugin.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) {
        ItemStack removed = removeStackFromInventory(from, amount, null);
        if (removed != null) {
            HashMap<Integer, ItemStack> leftOvers = to.addItem(removed);
            for (ItemStack leftOver : leftOvers.values()) {
                from.addItem(leftOver);
                if (removed.equals(leftOver)) return false;
            }
            return true;
        }
        return false;
    }

    public static boolean hopperMoveItemFromToChest(Inventory from, int amount, Inventory to, Location location, List filters) {
        ItemStack removed = removeStackFromInventory(from, amount, null);
        InventoryRegistry registry = InventoryRegistry.getInstance();
        InventoryHolder inventoryHolder = InventoryHolder.getInstance();
        if (removed != null) {
            boolean inventoryHolder1 = inventoryHolder.checkIfChestFull(location, removed);
            //boolean test = registry.AddItemsToChest(0, location, removed, from);
            System.out.println("hoppermovefrom chest " + inventoryHolder1 + to);
            return inventoryHolder1;
        }
        return false;
    }

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

    public static boolean hopperMoveItemFromToChest(Inventory from, int amount, Inventory to, ItemStack stack) {
        if (stack != null) {
            System.out.println("from chest to hopper");
            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;
    }
}