@EventHandler
public void handleWoolCrafting(PrepareItemCraftEvent event) {
  ItemStack result = event.getRecipe().getResult();
  InventoryHolder holder = event.getInventory().getHolder();

  if (holder instanceof Player) {
    MatchPlayer playerHolder = this.match.getPlayer((Player) holder);

    if (playerHolder != null && result != null && result.getType() == Material.WOOL) {
      for (MonumentWool wool : this.wools.values()) {
        if (wool.getDefinition().isObjectiveWool(result)) {
          if (!wool.getDefinition().isCraftable()) {
            playerHolder.sendWarning(
                TranslatableComponent.of("wool.craftingDisabled", wool.getComponentName()));
            event.getInventory().setResult(null);
          }
        }
      }
    }
  }
}
 

@EventHandler(ignoreCancelled = true)
public void showInventories(final ObserverInteractEvent event) {
  if (event.getClickType() != ClickType.RIGHT) return;
  if (event.getPlayer().isDead()) return;

  if (event.getClickedParticipant() != null) {
    event.setCancelled(true);
    if (canPreviewInventory(event.getPlayer(), event.getClickedParticipant())) {
      this.previewPlayerInventory(
          event.getPlayer().getBukkit(), event.getClickedParticipant().getInventory());
    }
  } else if (event.getClickedEntity() instanceof InventoryHolder
      && !(event.getClickedEntity() instanceof Player)) {
    event.setCancelled(true);
    this.previewInventory(
        event.getPlayer().getBukkit(),
        ((InventoryHolder) event.getClickedEntity()).getInventory());
  } else if (event.getClickedBlockState() instanceof InventoryHolder) {
    event.setCancelled(true);
    this.previewInventory(
        event.getPlayer().getBukkit(),
        ((InventoryHolder) event.getClickedBlockState()).getInventory());
  }
}
 

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void inventory(InventoryPickupItemEvent event) {
    ItemStack itemStack = event.getItem().getItemStack();
    if (DisplayItem.getNowUsing() != DisplayType.REALITEM) {
        return;
    }
    if (!DisplayItem.checkIsGuardItemStack(itemStack)) {
        return; // We didn't care that
    }
    @Nullable Location loc = event.getInventory().getLocation();
    @Nullable InventoryHolder holder = event.getInventory().getHolder();
    event.setCancelled(true);
    sendAlert(
            "[DisplayGuard] Something  "
                    + holder
                    + " at "
                    + loc
                    + " trying pickup the DisplayItem,  you should teleport to that location and to check detail..");
    Util.inventoryCheck(event.getInventory());
}
 

/**
 * Returns the chest attached to the given chest. The given block must be a chest.
 *
 * @param b The chest to check.
 * @return the block which is also a chest and connected to b.
 */
@Nullable
public static Block getSecondHalf(@NotNull Block b) {
    BlockState state = b.getState();
    if (!(state instanceof Chest)) {
        return null;
    }
    Chest oneSideOfChest = (Chest) state;
    InventoryHolder chestHolder = oneSideOfChest.getInventory().getHolder();
    if (chestHolder instanceof DoubleChest) {
        DoubleChest doubleChest = (DoubleChest) chestHolder;
        InventoryHolder left = doubleChest.getLeftSide();
        InventoryHolder right = doubleChest.getRightSide();
        Chest leftC = (Chest) left;
        Chest rightC = (Chest) right;
        if (equalsBlockStateLocation(oneSideOfChest.getLocation(), Objects.requireNonNull(rightC).getLocation())) {
            return Objects.requireNonNull(leftC).getBlock();
        }
        if (equalsBlockStateLocation(oneSideOfChest.getLocation(), Objects.requireNonNull(leftC).getLocation())) {
            return rightC.getBlock();
        }
    }
    return null;
}
 

/**
 * Merge inventories into one
 *
 * @param blocks
 * @return
 */
public ItemStack[] mergeInventories(List<Block> blocks) {
    ItemStack[] stacks = new ItemStack[54];
    int index = 0;

    try {
        for (Block block : blocks) {
            if (!(block.getState() instanceof InventoryHolder)) {
                continue;
            }

            InventoryHolder holder = (InventoryHolder) block.getState();
            Inventory inventory = holder.getInventory();

            // Add all the items from this inventory
            for (ItemStack stack : inventory.getContents()) {
                stacks[index] = stack;
                index++;
            }
        }
    } catch (Exception e) {
        return mergeInventories(blocks);
    }

    return stacks;
}
 

@EventHandler
public void handleWoolCrafting(PrepareItemCraftEvent event) {
    ItemStack result = event.getRecipe().getResult();
    InventoryHolder holder = event.getInventory().getHolder();

    if (holder instanceof Player) {
        MatchPlayer playerHolder = this.match.getPlayer((Player) holder);

        if (playerHolder != null && result != null && result.getType() == Material.WOOL) {
            for(MonumentWool wool : this.wools) {
                if(wool.getDefinition().isObjectiveWool(result)) {
                    if(!wool.getDefinition().isCraftable()) {
                        playerHolder.sendMessage(ChatColor.RED + PGMTranslations.t("match.wool.craftDisabled", playerHolder, BukkitUtils.woolMessage(wool.getDyeColor())));
                        event.getInventory().setResult(null);
                    }
                }
            }
        }
    }
}
 

/**
 * Return a predicate that applies a Filter to the given InventoryHolder,
 * or null if the InventoryHolder is not something that we should be filling.
 */
private static @Nullable Predicate<Filter> passesFilter(InventoryHolder holder) {
    if(holder instanceof DoubleChest) {
        final DoubleChest doubleChest = (DoubleChest) holder;
        return filter -> !filter.denies((Chest) doubleChest.getLeftSide()) ||
                         !filter.denies((Chest) doubleChest.getRightSide());
    } else if(holder instanceof BlockState) {
        return filter -> !filter.denies((BlockState) holder);
    } else if(holder instanceof Player) {
        // This happens with crafting inventories, and possibly other transient inventory types
        // Pretty sure we never want to fill an inventory held by the player
        return null;
    } else if(holder instanceof Entity) {
        return filter -> !filter.denies(new EntityQuery((Entity) holder));
    } else {
        // If we're not sure what it is, don't fill it
        return null;
    }
}
 

@EventHandler(ignoreCancelled = true)
public void showInventories(final ObserverInteractEvent event) {
    if(event.getClickType() != ClickType.RIGHT) return;
    if(event.getPlayer().isDead()) return;

    if(event.getClickedParticipant() != null) {
        event.setCancelled(true);
        if(canPreviewInventory(event.getPlayer(), event.getClickedParticipant())) {
            this.previewPlayerInventory(event.getPlayer().getBukkit(), event.getClickedParticipant().getInventory());
        }
    } else if(event.getClickedEntity() instanceof InventoryHolder && !(event.getClickedEntity() instanceof Player)) {
        event.setCancelled(true);
        this.previewInventory(event.getPlayer().getBukkit(), ((InventoryHolder) event.getClickedEntity()).getInventory());
    } else if(event.getClickedBlockState() instanceof InventoryHolder) {
        event.setCancelled(true);
        this.previewInventory(event.getPlayer().getBukkit(), ((InventoryHolder) event.getClickedBlockState()).getInventory());
    }
}
 

public void addChest(Chest chest, ChestPlacementType cpt) {
	ArrayList<CoordLoc> list;
	if (cpt == ChestPlacementType.NORMAL) {
		list = chests;
	} else {
		list = centerChests;
	}
	InventoryHolder ih = chest.getInventory().getHolder();
       if (ih instanceof DoubleChest) {
       	DoubleChest dc = (DoubleChest) ih;
		Chest left = (Chest) dc.getLeftSide();
		Chest right = (Chest) dc.getRightSide();
		CoordLoc locLeft = new CoordLoc(left.getX(), left.getY(), left.getZ());
		CoordLoc locRight = new CoordLoc(right.getX(), right.getY(), right.getZ());
		if (!(list.contains(locLeft) || list.contains(locRight))) {
			addChest(locLeft, cpt, true);
		}
       } else {
       	CoordLoc loc = new CoordLoc(chest.getX(), chest.getY(), chest.getZ());
           if (!list.contains(loc)){
			addChest(loc, cpt, true);
           }
       }
}
 

@Override
protected Object[] get(Event e, Inventory[] source) {

	switch (type) {
		case HOLDER:
			return get(source, inv -> {
				InventoryHolder holder = inv.getHolder();
				if (holder instanceof BlockState) {
					return new BlockInventoryHolder((BlockState) holder);
				}
				return holder;
			});
		case ROWS:
			return get(source, inv -> inv.getSize() / 9);
		case VIEWERS:
			List<HumanEntity> viewers = new ArrayList<>();
			for (Inventory inventory : source) {
				viewers.addAll(inventory.getViewers());
			}
			return viewers.toArray(new HumanEntity[0]);
		default:
			return new Object[0];
	}

}
 

@Override
    public InventoryHolder getOwner()
    {
//		int x = 0;
//		org.bukkit.block.Block b = this.world.getWorld().getBlockAt(x, 0, 0);
//		while(b != null && b.getType() != Material.AIR)
//			b = this.world.getWorld().getBlockAt(++x,0,0);
//		Furnace furnace = new CraftFurnace(b);
        org.bukkit.block.Furnace furnace = new CraftFurnace(this.world.getWorld().getBlockAt(0, 0, 0));
        try
        {
            ReflectionUtil.setValue(furnace, "furnace", this);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return furnace;
    }
 

@Override
	public InventoryHolder getOwner()
	{
		//Bukkit.getLogger().info("getOwner");
//		int x = 0;
//		org.bukkit.block.Block b = this.world.getWorld().getBlockAt(x, 0, 0);
//		while(b != null && b.getType() != Material.AIR)
//			b = this.world.getWorld().getBlockAt(++x,0,0);
//		Furnace furnace = new CraftFurnace(b);
		furnace = new CraftFurnace(this.world.getWorld().getBlockAt(0, 0, 0));
		try
		{
			ReflectionUtil.setValue(furnace, "furnace", this);
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
		return furnace;
	}
 

public void setHolder(InventoryHolder holder) throws CivException {
	if (holder instanceof Player) {
		Player player = (Player)holder;
		playerName = player.getName();
		blockLocation = null;
		return;
	} 
	
	if (holder instanceof Chest) {
		Chest chest = (Chest)holder;
		playerName = null;
		blockLocation = chest.getLocation();
		return;
	} 
	
	if (holder instanceof DoubleChest) {
		DoubleChest dchest = (DoubleChest)holder;
		playerName = null;
		blockLocation = dchest.getLocation();
		return;
	}
	
	throw new CivException("Invalid holder passed to set holder:"+holder.toString());
}
 

public void setHolder(InventoryHolder holder) throws CivException {
	if (holder == null) {
		return;
	}
	
	if (holderStore == null) {
		if (holder instanceof Chest) {
			holderStore = new InventoryHolderStorage(((Chest)holder).getLocation());
		} else if (holder instanceof Player){
			holderStore = new InventoryHolderStorage((Player)holder);
		} else {
			throw new CivException("Invalid holder.");
		}
	} else {
		holderStore.setHolder(holder);
	}
	
	// If we have a holder, we cannot be on the ground or in a item frame.
	this.frameStore = null;
	this.item = null;
	
}
 

@Override
public void setBlockFast(Block block, int blockId, byte data) {
    BlockState state = block.getState();
    if (state.getType().name().endsWith("AIR") && blockId == 0) return;
    if (state instanceof InventoryHolder) {
        ((InventoryHolder) state).getInventory().clear();
    }
    XMaterial material = XMaterial.requestOldXMaterial(blockId, (byte) 0);
    if (material != null && material.parseMaterial() != null) {
        block.setBlockData(IridiumSkyblock.getInstance().fromLegacy(material.parseMaterial(), data), false);
    }
}
 

@Override
public void setBlockFast(Block block, int blockId, byte data) {
    BlockState state = block.getState();
    if (state.getType().name().endsWith("AIR") && blockId == 0) return;
    if (state instanceof InventoryHolder) {
        ((InventoryHolder) state).getInventory().clear();
    }
    XMaterial material = XMaterial.requestOldXMaterial(blockId, (byte) 0);
    if (material != null && material.parseMaterial() != null) {
        block.setBlockData(IridiumSkyblock.getInstance().fromLegacy(material.parseMaterial(), data), false);
    }
}
 

@Override
public void setBlockFast(Block block, int blockId, byte data) {
    BlockState state = block.getState();
    if (state.getType().name().endsWith("AIR") && blockId == 0) return;
    if (state instanceof InventoryHolder) {
        ((InventoryHolder) state).getInventory().clear();
    }
    XMaterial material = XMaterial.requestOldXMaterial(blockId, (byte) 0);
    if (material != null && material.parseMaterial() != null) {
        block.setBlockData(IridiumSkyblock.getInstance().fromLegacy(material.parseMaterial(), data), false);
    }
}
 

@Override
public void setBlockFast(Block block, int blockId, byte data) {
    BlockState state = block.getState();
    if (state.getType().name().endsWith("AIR") && blockId == 0) return;
    if (state instanceof InventoryHolder) {
        ((InventoryHolder) state).getInventory().clear();
    }
    XMaterial material = XMaterial.requestOldXMaterial(blockId, (byte) 0);
    if (material != null && material.parseMaterial() != null) {
        block.setBlockData(IridiumSkyblock.getInstance().fromLegacy(material.parseMaterial(), data), false);
    }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onContainerPlace(BlockPlaceEvent event) {
  // Blacklist any placed container blocks
  if (event.getBlock().getState() instanceof InventoryHolder) {
    this.chests.put(((InventoryHolder) event.getBlock().getState()).getInventory(), false);
  }
}
 

/**
 * Get an inventory from file. Returns null if the inventory doesn't exist. SHOULD ONLY BE USED INTERNALLY
 *
 * @param playerFile the YamlConfiguration file.
 * @param size the size of the vault.
 * @param number the vault number.
 * @return inventory if exists, otherwise null.
 */
private Inventory getInventory(InventoryHolder owner, String ownerName, YamlConfiguration playerFile, int size, int number, String title) {
    Inventory inventory = Bukkit.createInventory(owner, size, title);

    String data = playerFile.getString(String.format(VAULTKEY, number));
    Inventory deserialized = Base64Serialization.fromBase64(data, ownerName);
    if (deserialized == null) {
        PlayerVaults.debug("Loaded vault as null");
        return inventory;
    }

    // Check if deserialized has more used slots than the limit here.
    // Happens on change of permission or if people used the broken version.
    // In this case, players will lose items.
    if (deserialized.getContents().length > size) {
        for (ItemStack stack : deserialized.getContents()) {
            if (stack != null) {
                inventory.addItem(stack);
            }
        }
    } else {
        inventory.setContents(deserialized.getContents());
    }

    PlayerVaults.debug("Loaded vault");
    return inventory;
}
 

public static InventoryHolder getOwner(TileEntity tileentity)
{
    org.bukkit.block.BlockState state = tileentity.worldObj.getWorld().getBlockAt(tileentity.xCoord, tileentity.yCoord, tileentity.zCoord).getState();

    if (state instanceof InventoryHolder)
    {
        return (InventoryHolder) state;
    }

    return null;
}
 

public MinecraftInventory(InventoryHolder owner, int size, String title) {
    Validate.notNull(title, "Title cannot be null");
    this.items = NonNullList.withSize(size, ItemStack.EMPTY);
    this.title = title;
    this.viewers = new ArrayList<HumanEntity>();
    this.owner = owner;
    this.type = InventoryType.CHEST;
}
 

public InventoryHolderStorage(InventoryHolder holder, Location holderLocation) {
	if (holder instanceof Player) {
		Player player = (Player)holder;
		playerName = player.getName();
		blockLocation = null;
	} else {
		blockLocation = holderLocation;
	}
}
 

@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
void onInventoryClick(InventoryClickEvent event) {
    InventoryHolder holder = event.getInventory().getHolder();
    if (holder instanceof Player && holder.equals(this.player)) {

        if (event.getInventory().equals(this.player.getOpenInventory().getTopInventory())) {
            event.setCancelled(true);

            if (event.getRawSlot() == 0) {
                setFlagValue(true);
                close(true);
                return;
            }

            if (event.getRawSlot() == 1) {
                setFlagValue(false);
                close(true);
                return;
            }

            ItemStack item = event.getCurrentItem();
            if (item != null && !item.equals(RedProtect.get().config.getGuiSeparator()) && !item.getType().equals(Material.AIR) && event.getRawSlot() >= 0 && event.getRawSlot() <= this.size - 1) {
                ItemMeta itemMeta = item.getItemMeta();
                List<String> lore = itemMeta.getLore();
                if (lore.get(0).equalsIgnoreCase(translateAlternateColorCodes('&', RedProtect.get().guiLang.getFlagString("value") + " " + RedProtect.get().guiLang.getFlagString("true")))) {
                    lore.set(0, translateAlternateColorCodes('&', RedProtect.get().guiLang.getFlagString("value") + " " + RedProtect.get().guiLang.getFlagString("false")));
                    item.setAmount(1);
                } else {
                    lore.set(0, translateAlternateColorCodes('&', RedProtect.get().guiLang.getFlagString("value") + " " + RedProtect.get().guiLang.getFlagString("true")));
                    item.setAmount(2);
                }
                itemMeta.setLore(lore);
                item.setItemMeta(itemMeta);
            }
        }
    }
}
 

/**
 * Remove the inventory from a block
 *
 * @param block
 */
private void removeInventory(Block block) {
    if (block == null) {
        return;
    }

    if (!(block.getState() instanceof InventoryHolder)) {
        return;
    }

    InventoryHolder holder = (InventoryHolder) block.getState();
    holder.getInventory().clear();
}
 

/**
 * Wrap a block in a restorableblock object
 *
 * @param block
 * @return
 */
public static RestorableBlock wrapBlock(Block block) {
    if (block == null) {
        return null;
    }

    BlockCache blockCache = BlockCache.getInstance();
    RestorableBlock rblock = new RestorableBlock();
    rblock.id = blockCache.getBlockId(block);
    rblock.world = block.getWorld().getName();
    rblock.x = block.getX();
    rblock.y = block.getY();
    rblock.z = block.getZ();
    rblock.data = block.getData();

    BlockState state = block.getState();

    // Does it have an inventory? ^^
    if (state instanceof InventoryHolder) {
        Inventory inventory = ((InventoryHolder) state).getInventory();
        ItemStack[] stacks = inventory.getContents();

        for (int slot = 0; slot < stacks.length; slot++) {
            ItemStack stack = stacks[slot];

            if (stack == null) {
                continue; // don't waste space!
            }

            rblock.setSlot(slot, stack);
        }
    }

    return rblock;
}
 

/**
 * Add a shop
 * @param shop Shop to add
 * @param addToDatabase Whether the shop should also be added to the database
 * @param callback Callback that - if succeeded - returns the ID the shop had or was given (as {@code int})
 */
public void addShop(Shop shop, boolean addToDatabase, Callback<Integer> callback) {
    InventoryHolder ih = shop.getInventoryHolder();
    plugin.debug("Adding shop... (#" + shop.getID() + ")");

    if (ih instanceof DoubleChest) {
        DoubleChest dc = (DoubleChest) ih;
        Chest r = (Chest) dc.getRightSide();
        Chest l = (Chest) dc.getLeftSide();

        plugin.debug("Added shop as double chest. (#" + shop.getID() + ")");

        shopLocation.put(r.getLocation(), shop);
        shopLocation.put(l.getLocation(), shop);
    } else {
        plugin.debug("Added shop as single chest. (#" + shop.getID() + ")");

        shopLocation.put(shop.getLocation(), shop);
    }

    if (addToDatabase) {
        if (shop.getShopType() != ShopType.ADMIN) {
            playerShopAmount.compute(shop.getVendor().getUniqueId(), (uuid, amount) -> amount == null ? new Counter(1) : amount.increment());
        }
        plugin.getShopDatabase().addShop(shop, callback);
    } else {
        if (callback != null) callback.callSyncResult(shop.getID());
    }

}
 

/**
 * Get the GUI registered to an InventoryHolder
 * @param holder    The InventoryHolder to get the GUI for
 * @return          The InventoryGui registered to it or <tt>null</tt> if none was registered to it
 */
public static InventoryGui get(InventoryHolder holder) {
    if (holder instanceof Entity) {
        return GUI_MAP.get(((Entity) holder).getUniqueId().toString());
    } else if (holder instanceof BlockState) {
        return GUI_MAP.get(((BlockState) holder).getLocation().toString());
    }
    return null;
}
 

/**
 * Handles users picking up items while their bottom inventory is in use.
 *
 * @param event the event fired when an entity picks up an item
 * @since 0.6.1
 */
@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onEntityPickupItem(@NotNull EntityPickupItemEvent event) {
    if (!(event.getEntity() instanceof HumanEntity)) {
        return;
    }

    InventoryHolder holder = ((HumanEntity) event.getEntity()).getOpenInventory().getTopInventory().getHolder();

    if (!(holder instanceof Gui)) {
        return;
    }

    Gui gui = (Gui) holder;

    if (gui.getState() != Gui.State.BOTTOM) {
        return;
    }

    int leftOver = gui.getHumanEntityCache().add((HumanEntity) event.getEntity(), event.getItem().getItemStack());

    if (leftOver == 0) {
        event.getItem().remove();
    } else {
        ItemStack itemStack = event.getItem().getItemStack();

        itemStack.setAmount(leftOver);

        event.getItem().setItemStack(itemStack);
    }

    event.setCancelled(true);
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onContainerPlace(BlockPlaceEvent event) {
    // Blacklist any placed container blocks
    if(event.getBlock().getState() instanceof InventoryHolder) {
        this.chests.put(((InventoryHolder) event.getBlock().getState()).getInventory(), false);
    }
}