public InventoryDragEvent(InventoryView what, ItemStack newCursor, ItemStack oldCursor, boolean right, Map<Integer, ItemStack> slots) {
    super(what);

    Validate.notNull(oldCursor);
    Validate.notNull(slots);

    type = right ? DragType.SINGLE : DragType.EVEN;
    this.newCursor = newCursor;
    this.oldCursor = oldCursor;
    this.addedItems = slots;
    ImmutableSet.Builder<Integer> b = ImmutableSet.builder();
    for (Integer slot : slots.keySet()) {
        b.add(what.convertSlot(slot));
    }
    this.containerSlots = b.build();
}
 

public CraftContainer(final Inventory inventory, final EntityPlayer player, int id) {
    this(new InventoryView() {
        @Override
        public Inventory getTopInventory() {
            return inventory;
        }

        @Override
        public Inventory getBottomInventory() {
            return getPlayer().getInventory();
        }

        @Override
        public HumanEntity getPlayer() {
            return player.getBukkitEntity();
        }

        @Override
        public InventoryType getType() {
            return inventory.getType();
        }
    }, player, id);
}
 

/**
 * Register the given {@link WindowListener} to receive notifications about the given {@link InventoryView}.
 */
public InventoryView registerWindow(WindowListener listener, InventoryView window) {
    final Player player = (Player) window.getPlayer();

    final View old = views.get(player);
    if(old == null || !old.window.equals(window)) {
        if(old != null) {
            old.notifyClose();
        }

        final View view = new View(player, window, listener);
        views.put(player, view);
        view.notifyOpen();
    }

    return window;
}
 

public static void openWarCrate(Player player, Crate crate, KeyType keyType, boolean checkHand) {
    String crateName = Methods.sanitizeColor(crate.getFile().getString(crateNameString));
    Inventory inv = Bukkit.createInventory(null, 9, crateName);
    setRandomPrizes(player, inv, crate, crateName);
    InventoryView inventoryView = player.openInventory(inv);
    canPick.put(player, false);
    canClose.put(player, false);
    if (!cc.takeKeys(1, player, crate, keyType, checkHand)) {
        Methods.failedToTakeKey(player, crate);
        cc.removePlayerFromOpeningList(player);
        canClose.remove(player);
        canPick.remove(player);
        return;
    }
    startWar(player, inv, crate, inventoryView.getTitle());
}
 

@Test
public void shouldAllowInventoryOpen() {
    // given
    HumanEntity player = mock(Player.class);
    InventoryView transaction = mock(InventoryView.class);
    InventoryOpenEvent event = new InventoryOpenEvent(transaction);
    given(event.getPlayer()).willReturn(player);
    given(listenerService.shouldCancelEvent(player)).willReturn(false);

    // when
    listener.onPlayerInventoryOpen(event);

    // then
    assertThat(event.isCancelled(), equalTo(false));
    verifyNoInteractions(bukkitService);
}
 

@EventHandler(priority=EventPriority.HIGH, ignoreCancelled=true)
public void onTag(PlayerTagEvent e) {
    Player player = e.getPlayer();
    InventoryView openView = player.getOpenInventory();
    if(openView == null) return;

    Inventory topInv = openView.getTopInventory();
    if(topInv == null) return;

    InventoryType type = openView.getType();
    if(type == InventoryType.CRAFTING) return;

    player.closeInventory();
    String message = this.plugin.getLanguageMessageColoredWithPrefix("cheat-prevention.inventory.force-closed");
    this.plugin.sendMessage(player, message);
}
 

public InventoryView openWorkbench(Location location, boolean force) {
    if (!force) {
        Block block = location.getBlock();
        if (block.getType() != Material.WORKBENCH) {
            return null;
        }
    }
    if (location == null) {
        location = getLocation();
    }
    getHandle().displayGUIWorkbench(location.getBlockX(), location.getBlockY(), location.getBlockZ());
    if (force) {
        getHandle().openContainer.checkReachable = false;
    }
    return getHandle().openContainer.getBukkitView();
}
 

public InventoryView openEnchanting(Location location, boolean force) {
    if (!force) {
        Block block = location.getBlock();
        if (block.getType() != Material.ENCHANTMENT_TABLE) {
            return null;
        }
    }
    if (location == null) {
        location = getLocation();
    }
    getHandle().displayGUIEnchantment(location.getBlockX(), location.getBlockY(), location.getBlockZ(), null);
    if (force) {
        getHandle().openContainer.checkReachable = false;
    }
    return getHandle().openContainer.getBukkitView();
}
 

public CraftContainer(final Inventory inventory, final HumanEntity player, int id) {
    this(new InventoryView() {
        @Override
        public Inventory getTopInventory() {
            return inventory;
        }

        @Override
        public Inventory getBottomInventory() {
            return player.getInventory();
        }

        @Override
        public HumanEntity getPlayer() {
            return player;
        }

        @Override
        public InventoryType getType() {
            return inventory.getType();
        }
    }, id);
}
 

@Test
public void shouldCancelInventoryOpen() {
    // given
    HumanEntity player = mock(Player.class);
    InventoryView transaction = mock(InventoryView.class);
    given(transaction.getTitle()).willReturn("Spawn");
    given(settings.getProperty(RestrictionSettings.UNRESTRICTED_INVENTORIES)).willReturn(Collections.emptySet());
    InventoryOpenEvent event = new InventoryOpenEvent(transaction);
    given(event.getPlayer()).willReturn(player);
    given(listenerService.shouldCancelEvent(player)).willReturn(true);
    setBukkitServiceToScheduleSyncDelayedTaskWithDelay(bukkitService);

    // when
    listener.onPlayerInventoryOpen(event);

    // then
    assertThat(event.isCancelled(), equalTo(true));
    verify(player).closeInventory();
}
 

@EventHandler 
  public void onInventoryClose(InventoryCloseEvent e) {
  	Inventory inv = e.getInventory();
InventoryView inView = e.getPlayer().getOpenInventory();
  	if (inView.getTitle().equals(new Messaging.MessageFormatter().format("event.crateInv"))) {
  		for (GameMap gMap: GameMap.getPlayableArenas(GameType.ALL)) {
  			for (Crate crate: gMap.getCrates()) {
  				if(crate.getInventory().equals(inv) && inv.getViewers().size() <= 1) {
				if (SkyWarsReloaded.getNMS().getVersion() < 9) {
					e.getPlayer().getWorld().playSound(e.getPlayer().getLocation(), Sound.valueOf("CHEST_CLOSE"), 1, 1);
				} else {
					e.getPlayer().getWorld().playSound(e.getPlayer().getLocation(), Sound.BLOCK_CHEST_CLOSE, 1, 1);
				}
  					SkyWarsReloaded.getNMS().playEnderChestAction(e.getPlayer().getWorld().getBlockAt(crate.getLocation()), false);
  					return;
  				}
  			}
  		}
  	} else if (inView.getTitle().contains("chest.yml")) {
  		SkyWarsReloaded.getCM().save(inView.getTitle());
}
  	
  }
 

private PrepareItemCraftEvent mockPreCraftingEvent(ItemStack item) {
    Player player = server.addPlayer();

    CraftingInventory inv = Mockito.mock(CraftingInventory.class);
    MutableObject result = new MutableObject(new ItemStack(Material.EMERALD));

    Mockito.doAnswer(invocation -> {
        ItemStack argument = invocation.getArgument(0);
        result.setValue(argument);
        return null;
    }).when(inv).setResult(Mockito.any());

    Mockito.when(inv.getResult()).thenAnswer(invocation -> result.getValue());
    Mockito.when(inv.getContents()).thenReturn(new ItemStack[] { null, null, item, null, null, null, null, null, null });

    InventoryView view = player.openInventory(inv);
    PrepareItemCraftEvent event = new PrepareItemCraftEvent(inv, view, false);

    listener.onPrepareCraft(event);
    return event;
}
 

/**
 * Sets whether or not player vaults are locked. If set to true, this will kick anyone who is currently using their
 * vaults out.
 *
 * @param locked true for locked, false otherwise
 */
public static void setLocked(boolean locked) {
    LOCKED.set(locked);

    if (locked) {
        for (Player player : PlayerVaults.getInstance().getServer().getOnlinePlayers()) {
            if (player.getOpenInventory() != null) {
                InventoryView view = player.getOpenInventory();
                if (view.getTopInventory().getHolder() instanceof VaultHolder) {
                    player.closeInventory();
                    player.sendMessage(Lang.TITLE + Lang.LOCKED.toString());
                }
            }
        }
    }
}
 

public InventoryClickEvent(InventoryView view, SlotType type, int slot, ClickType click, InventoryAction action) {
    super(view);
    this.slot_type = type;
    this.rawSlot = slot;
    if (slot < 0) {
        this.clickedInventory = null;
    } else if (view.getTopInventory() != null && slot < view.getTopInventory().getSize()) {
        this.clickedInventory = view.getTopInventory();
    } else {
        this.clickedInventory = view.getBottomInventory();
    }
    this.whichSlot = view.convertSlot(slot);
    this.click = click;
    this.action = action;
}
 

public PrepareItemEnchantEvent(final Player enchanter, InventoryView view, final Block table, final ItemStack item, final EnchantmentOffer[] offers, final int bonus) {
    super(view);
    this.enchanter = enchanter;
    this.table = table;
    this.item = item;
    this.offers = offers;
    this.bonus = bonus;
}
 

public EnchantItemEvent(final Player enchanter, final InventoryView view, final Block table, final ItemStack item, final int level, final Map<Enchantment, Integer> enchants, final int i) {
    super(view);
    this.enchanter = enchanter;
    this.table = table;
    this.item = item;
    this.level = level;
    this.enchants = new HashMap<Enchantment, Integer>(enchants);
    this.cancelled = false;
    this.button = i;
}
 

public CraftContainer(InventoryView view, EntityPlayer player, int id) {
    this.view = view;
    this.windowId = id;
    // TODO: Do we need to check that it really is a CraftInventory?
    IInventory top = ((CraftInventory) view.getTopInventory()).getInventory();
    InventoryPlayer bottom = (InventoryPlayer) ((CraftInventory) view.getBottomInventory()).getInventory();
    cachedType = view.getType();
    cachedTitle = view.getTitle();
    cachedSize = getSize();
    setupSlots(top, bottom, player);
}
 

public static ItemStack callPreCraftEvent(InventoryCrafting matrix, ItemStack result, InventoryView lastCraftView, boolean isRepair) {
    CraftInventoryCrafting inventory = new CraftInventoryCrafting(matrix, matrix.resultInventory);
    inventory.setResult(CraftItemStack.asCraftMirror(result));

    PrepareItemCraftEvent event = new PrepareItemCraftEvent(inventory, lastCraftView, isRepair);
    Bukkit.getPluginManager().callEvent(event);

    org.bukkit.inventory.ItemStack bitem = event.getInventory().getResult();

    return CraftItemStack.asNMSCopy(bitem);
}
 

/**
 * Handles clicks in inventories
 *
 * @param event the event fired
 * @since 0.5.4
 */
@EventHandler(ignoreCancelled = true)
public void onInventoryClick(@NotNull InventoryClickEvent event) {
    if (!(event.getInventory().getHolder() instanceof Gui)) {
        return;
    }

    Gui gui = (Gui) event.getInventory().getHolder();
    InventoryView view = event.getView();
    Inventory inventory = view.getInventory(event.getRawSlot());

    if (inventory == null) {
        gui.callOnOutsideClick(event);
        return;
    }

    gui.callOnGlobalClick(event);
    if (inventory.equals(view.getTopInventory())) {
        gui.callOnTopClick(event);
    } else {
        gui.callOnBottomClick(event);
    }

    if ((inventory.equals(view.getBottomInventory()) && gui.getState() == Gui.State.TOP) ||
        event.getCurrentItem() == null) {
        return;
    }

    List<Pane> panes = gui.getPanes();

    //loop through the panes reverse, because the pane with the highest priority (last in list) is most likely to have the correct item
    for (int i = panes.size() - 1; i >= 0; i--) {
        if (panes.get(i).click(gui, event, 0, 0, 9, gui.getRows() + 4))
            break;
    }
}
 

/**
 * Handles small drag events which are likely clicks instead. These small drags will be interpreted as clicks and
 * will fire a click event.
 *
 * @param event the event fired
 * @since 0.6.1
 */
@EventHandler
public void onInventoryDrag(@NotNull InventoryDragEvent event) {
    if (!(event.getInventory().getHolder() instanceof Gui)) {
        return;
    }

    Set<Integer> inventorySlots = event.getInventorySlots();

    if (inventorySlots.size() > 1) {
        return;
    }

    InventoryView view = event.getView();
    int index = inventorySlots.toArray(new Integer[0])[0];
    InventoryType.SlotType slotType = view.getSlotType(index);

    boolean even = event.getType() == DragType.EVEN;

    ClickType clickType = even ? ClickType.LEFT : ClickType.RIGHT;
    InventoryAction inventoryAction = even ? InventoryAction.PLACE_SOME : InventoryAction.PLACE_ONE;

    //this is a fake click event, firing this may cause other plugins to function incorrectly, so keep it local
    InventoryClickEvent inventoryClickEvent = new InventoryClickEvent(view, slotType, index, clickType,
        inventoryAction);

    onInventoryClick(inventoryClickEvent);

    event.setCancelled(inventoryClickEvent.isCancelled());
}
 

@Override
public boolean click(@NotNull Gui gui, @NotNull InventoryClickEvent event, int paneOffsetX, int paneOffsetY,
                     int maxLength, int maxHeight) {
    int length = Math.min(this.length, maxLength);
    int height = Math.min(this.height, maxHeight);

    int slot = event.getSlot();
    InventoryView view = event.getView();
    Inventory inventory = view.getInventory(event.getRawSlot());

    int x, y;

    if (inventory != null && inventory.equals(view.getBottomInventory())) {
        x = (slot % 9) - getX() - paneOffsetX;
        y = ((slot / 9) + gui.getRows() - 1) - getY() - paneOffsetY;

        if (slot / 9 == 0) {
            y = (gui.getRows() + 3) - getY() - paneOffsetY;
        }
    } else {
        x = (slot % 9) - getX() - paneOffsetX;
        y = (slot / 9) - getY() - paneOffsetY;
    }

    if (x < 0 || x >= length || y < 0 || y >= height)
        return false;

    callOnClick(event);

    boolean success = false;

    for (Pane pane : panes) {
        success = success || pane.click(gui, event, paneOffsetX + getX(),
            paneOffsetY + getY(), length, height);
    }

    return success;
}
 

@Override
public boolean click(@NotNull Gui gui, @NotNull InventoryClickEvent event, int paneOffsetX, int paneOffsetY,
                     int maxLength, int maxHeight) {
    int length = Math.min(this.length, maxLength);
    int height = Math.min(this.height, maxHeight);

    int slot = event.getSlot();
    InventoryView view = event.getView();
    Inventory inventory = view.getInventory(event.getRawSlot());

    int x, y;

    if (inventory != null && inventory.equals(view.getBottomInventory())) {
        x = (slot % 9) - getX() - paneOffsetX;
        y = ((slot / 9) + gui.getRows() - 1) - getY() - paneOffsetY;

        if (slot / 9 == 0) {
            y = (gui.getRows() + 3) - getY() - paneOffsetY;
        }
    } else {
        x = (slot % 9) - getX() - paneOffsetX;
        y = (slot / 9) - getY() - paneOffsetY;
    }

    if (x < 0 || x >= length || y < 0 || y >= height) {
        return false;
    }

    callOnClick(event);

    event.setCancelled(true);

    int newPaneOffsetX = paneOffsetX + getX();
    int newPaneOffsetY = paneOffsetY + getY();

    return this.fillPane.click(gui, event, newPaneOffsetX, newPaneOffsetY, length, height) ||
        this.backgroundPane.click(gui, event, newPaneOffsetX, newPaneOffsetY, length, height);
}
 

public void rate(final MatchPlayer player, final int score) {
    if(!this.checkCanRate(player)) return;

    final Integer oldScore = this.playerRatings.put(player, score);

    InventoryView inv = player.getBukkit().getOpenInventory();
    if(inv.getTopInventory().getType() == InventoryType.HOPPER) {
        this.updateScoreButtons(player, inv.getTopInventory());
    }

    if(oldScore != null && score == oldScore) {
        player.sendWarning(PGMTranslations.t("rating.sameRating", player, score));
        return;
    }

    player.facet(MatchPlayerExecutor.class).callback(mapService.rate(new MapRating(
        player.getPlayerId(),
        getMatch().getMap().getDocument(),
        score,
        null
    )), CommandFutureCallback.onSuccess(player.getBukkit(), result -> {
        if(result.first.isOnline()) {
            result.first.getBukkit().closeInventory();
        }
        notifyRating(result.first, score, oldScore);
    }));
}
 

public static InventorySlot<?> fromViewIndex(InventoryView view, int rawIndex) {
    final Slot slot = Slot.forViewIndex(view, rawIndex);
    if(slot == null) {
        throw new IllegalArgumentException("Could not determine slot at index " + rawIndex + " in view " + view);
    }
    final Inventory inventory = rawIndex == view.convertSlot(rawIndex) ? view.getTopInventory()
                                                                       : view.getBottomInventory();
    return new InventorySlot<>(inventory, slot);
}
 

/**
 * Called when an open window is clicked.
 */
default boolean windowClicked(InventoryView window,
                              Inventory inventory,
                              ClickType clickType,
                              InventoryType.SlotType slotType,
                              int slotIndex,
                              @Nullable ItemStack item) {
    return false;
}
 

@Test
public void regionShouldNotBeCreatedIfNotAllReqs() {
    loadRegionTypeCobble2();

    InventoryView transaction = mock(InventoryView.class);
    when(transaction.getPlayer()).thenReturn(TestUtil.player);
    InventoryCloseEvent inventoryCloseEvent = new InventoryCloseEvent(transaction);
    BlockPlaceEvent event3 = mock(BlockPlaceEvent.class);
    when(event3.getBlockPlaced()).thenReturn(TestUtil.block4);
    ItemStack cobbleStack = TestUtil.createItemStack(Material.COBBLESTONE);
    doReturn(cobbleStack).when(event3).getItemInHand();
    BlockPlaceEvent event2 = mock(BlockPlaceEvent.class);
    when(event2.getBlockPlaced()).thenReturn(TestUtil.block2);
    doReturn(cobbleStack).when(event2).getItemInHand();
    BlockPlaceEvent event1 = mock(BlockPlaceEvent.class);
    when(event1.getPlayer()).thenReturn(TestUtil.player);
    when(event1.getBlockPlaced()).thenReturn(TestUtil.blockUnique);
    doReturn(TestUtil.createUniqueItemStack(Material.CHEST, "Civs Cobble")).when(event1).getItemInHand();


    MenuManager.getInstance().onInventoryClose(inventoryCloseEvent);
    RegionListener regionListener = new RegionListener();
    regionListener.onBlockPlace(event2);
    regionListener.onBlockPlace(event3);
    regionListener.onBlockPlace(event1);
    assertNull(RegionManager.getInstance().getRegionAt(TestUtil.blockUnique.getLocation()));
}
 

public static void closeAll() {
        Collection<Player> openers = opened.values();
        for (Player p : openers) {
            InventoryView view = p.getOpenInventory();
            Inventory inventory = view.getTopInventory();
            if (inventory.getHolder() instanceof ExtraBackpackGUI) {
                ExtraBackpackGUI holder = (ExtraBackpackGUI) inventory.getHolder();
//                holder.saveAll(inventory);
                holder.saveAll(holder.extraBackpack);
                holder.close();
            }
        }
    }
 

public CraftContainer(InventoryView view, int id) {
    this.view = view;
    this.windowId = id;
    // TODO: Do we need to check that it really is a CraftInventory?
    net.minecraft.inventory.IInventory top = ((CraftInventory)view.getTopInventory()).getInventory();
    net.minecraft.inventory.IInventory bottom = ((CraftInventory)view.getBottomInventory()).getInventory();
    cachedType = view.getType();
    cachedTitle = view.getTitle();
    cachedSize = getSize();
    setupSlots(top, bottom);
}
 

private boolean isShulkerBox(InventoryView inv) {
    try {
        return inv.getType() == InventoryType.SHULKER_BOX;
    } catch (NoSuchFieldError e) {
        return false;
    }
}
 

/**
 * @param gui the gui
 * @return the announcer that has the GUI
 */
public Announcer getByGUI(InventoryView gui) {
    for (Announcer announcer : announcers) {
        if ((ChatColor.DARK_RED + announcer.getName()).equals(gui.getTitle())) {
            return announcer;
        }
    }

    return null;
}