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));

				/*List<HumanEntity> players = getInventory().getViewers();
				System.out.println(players);
				HumanEntity playerres = players.get(players.size());
				System.out.println(playerres);
				if (playerres != null)
					playerres.openInventory(getInventory());*/
				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());
		event.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;
	}
}