InventoryBuilder.java

package net.theevilreaper.aves.inventory;

import net.kyori.adventure.text.Component;
import net.minestom.server.MinecraftServer;
import net.minestom.server.entity.Player;
import net.minestom.server.event.inventory.InventoryCloseEvent;
import net.minestom.server.event.inventory.InventoryOpenEvent;
import net.minestom.server.inventory.Inventory;
import net.minestom.server.inventory.InventoryType;
import net.minestom.server.inventory.click.Click;
import net.minestom.server.inventory.click.ClickType;
import net.minestom.server.item.ItemStack;
import net.theevilreaper.aves.inventory.click.ClickHolder;
import net.theevilreaper.aves.inventory.function.CloseFunction;
import net.theevilreaper.aves.inventory.function.InventoryClick;
import net.theevilreaper.aves.inventory.function.OpenFunction;
import net.theevilreaper.aves.inventory.layout.InventoryLayout;
import net.theevilreaper.aves.inventory.slot.EmptySlot;
import net.theevilreaper.aves.inventory.slot.ISlot;
import net.theevilreaper.aves.inventory.util.InventoryConstants;
import net.theevilreaper.aves.util.functional.ThrowingFunction;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Locale;
import java.util.function.Consumer;

/**
 * The {@link InventoryBuilder} is the base class which contains the necessary methods to create different context implementations for an inventory.
 *
 * @author Patrick Zdarsky / Rxcki
 * @version 1.3.1
 * @since 1.0.12
 */
@SuppressWarnings("java:S3252")
public abstract class InventoryBuilder {

    protected static final Logger LOGGER = LoggerFactory.getLogger(InventoryBuilder.class);
    protected final InventoryType type;
    protected volatile boolean inventoryLayoutValid = true;
    protected volatile boolean dataLayoutValid = false;
    protected volatile boolean dataLayoutPending = false;
    protected OpenFunction openFunction;
    protected CloseFunction closeFunction;
    protected ThrowingFunction<InventoryLayout, InventoryLayout> dataLayoutFunction;
    protected InventoryClick inventoryClick;

    private InventoryLayout inventoryLayout;
    private InventoryLayout dataLayout;

    /**
     * Creates a new instance from the inventory builder with the given size.
     *
     * @param type The type from the inventory to get the size from it
     */
    protected InventoryBuilder(@NotNull InventoryType type) {
        this.type = type;

        this.inventoryClick = (player, slot, clickType, stack, result) -> {
            if (slot == InventoryConstants.INVALID_SLOT_ID) {
                result.accept(ClickHolder.noClick());
                return;
            }

            ISlot clickedSlot = null;

            if (this.dataLayout != null) {
                clickedSlot = this.dataLayout.getSlot(slot);
            }

            if ((clickedSlot == null || clickedSlot instanceof EmptySlot) && this.inventoryLayout != null) {
                clickedSlot = this.inventoryLayout.getSlot(slot);
            }

            acceptClick(clickedSlot, player, clickType, slot, stack, result);
        };
    }

    /**
     * Handles the click request on a given slot.
     *
     * @param slot   the {@link ISlot} which is clicked
     * @param player the {@link Player} who is involved
     * @param click  the given {@link ClickType}
     * @param slotID the slot ID which is clicked
     * @param stack  the {@link ItemStack} which is clicked
     * @param result the consumer to accept the {@link ClickHolder} result
     */
    private void acceptClick(
            @Nullable ISlot slot,
            @NotNull Player player,
            @NotNull Click click,
            int slotID,
            @NotNull ItemStack stack,
            @NotNull Consumer<ClickHolder> result
    ) {
        if (slot == null || slot instanceof EmptySlot) {
            result.accept(ClickHolder.noClick());
            return;
        }
        slot.getClick().onClick(player, slotID, click, stack, result);
    }

    /**
     * Set a new reference to the data layout
     *
     * @param dataLayout The {@link InventoryLayout} to set
     */
    public void setDataLayoutFunction(ThrowingFunction<InventoryLayout, InventoryLayout> dataLayout) {
        this.dataLayoutFunction = dataLayout;
    }

    /**
     * Registers the underlying listeners into the event graph.
     */
    public abstract void register();

    /**
     * Removes the underlying listeners from the event graph.
     */
    public abstract void unregister();

    /**
     * Returns the inventory for the given locale.
     * If the locale is null, it indicates that the context is not translated and the non translated inventory will be returned.
     *
     * @param locale the locale to use
     * @return the inventory for the given locale
     */
    public abstract Inventory getInventory(@Nullable Locale locale);

    /**
     * Returns if the inventory is currently opened by a player.
     *
     * @return true if a player does the inventory currently opened otherwise false
     */
    protected abstract boolean isOpen();

    /**
     * Updates the underlying inventory.
     */
    protected abstract void updateInventory();

    /**
     * Apply the data layout to the inventory
     */
    protected abstract void applyDataLayout();

    /**
     * Marks the inventory layout as not valid an updates the inventory.
     */
    public void invalidateLayout() {
        if (!inventoryLayoutValid) return;
        inventoryLayoutValid = false;
        if (isOpen()) {
            updateInventory();
        }
    }

    /**
     * Invalidates the boolean for the data layout.
     */
    public void invalidateDataLayout() {
        if (isOpen()) {
            retrieveDataLayout();
            LOGGER.debug("DataLayout invalidated on open inv, requested data...");
        } else {
            LOGGER.debug("DataLayout invalidated on closed inv");
            dataLayoutValid = false;
        }
    }

    /**
     * Handles the open function when an inventory will be opened.
     *
     * @param event The instance from the inventory event
     */
    protected void handleOpen(@NotNull InventoryOpenEvent event) {
        if (this.openFunction == null) return;
        openFunction.onOpen(event);
    }

    /**
     * Handles the close function if a close event is called from the server
     *
     * @param event The instance from the close event
     */
    protected void handleClose(@NotNull InventoryCloseEvent event) {
        if (this.closeFunction == null) return;
        closeFunction.onClose(event);
    }

    /**
     * Updates the given inventory with the content.
     *
     * @param inventory   the inventory that should receive the update
     * @param locale      the locale for the inventory
     * @param applyLayout if the layout should be applied
     */
    protected void updateInventory(@NotNull Inventory inventory, Locale locale, boolean applyLayout){
        if (!applyLayout) return;
        if (this.inventoryLayout == null) {
            throw new IllegalStateException("Can't update content because the layout is null");
        }

        // Design
        ItemStack[] contents = inventory.getItemStacks();
        inventory.clear();
        this.inventoryLayout.applyLayout(contents, locale);
        this.setItemsInternal(inventory, contents);
        LOGGER.debug("UpdateInventory applied the InventoryLayout!");
        this.inventoryLayoutValid = true;

        synchronized (this) {
            if (!dataLayoutValid) {
                retrieveDataLayout();
            }
        }
    }

    /**
     * Set's the given array with the {@link ItemStack}'s into an inventory.
     *
     * @param inventory the inventory for the items
     * @param contents  the array itself that contains all items
     */
    private void setItemsInternal(@NotNull Inventory inventory, @NotNull ItemStack[] contents) {
        for (int i = 0; i < contents.length; i++) {
            var contentSlot = contents[i];
            if (contentSlot == null || contentSlot.isAir()) continue;
            inventory.setItemStack(i, contentSlot);
        }
    }

    /**
     * Executes the logic to retrieve the {@link InventoryLayout} which comes from the {@link ThrowingFunction}.
     */
    protected void retrieveDataLayout() {
        if (this.dataLayoutFunction == null) return;
        if (dataLayoutPending) return;
        synchronized (this) {
            this.dataLayoutPending = true;
            MinecraftServer.getSchedulerManager().scheduleNextTick(() -> {
                try {
                    this.dataLayout = this.dataLayoutFunction.acceptThrows(this.dataLayout);
                    applyDataLayout();
                } catch (Exception exception) {
                    MinecraftServer.getExceptionManager().handleException(exception);
                } finally {
                    this.dataLayoutPending = false;
                }
            });
        }
    }

    /**
     * Updates the title of an inventory.
     * Note that this method must be called from the developer
     *
     * @param inventory the {@link Inventory} to update the title
     * @param newTitle  the new title as {@link Component} to set
     */
    protected void updateTitle(@NotNull Inventory inventory, @NotNull Component newTitle) {
        inventory.setTitle(newTitle);
    }

    /**
     * Updates the inventory for all current viewers.
     *
     * @param inventory The inventory to update
     */
    protected void updateViewer(@NotNull Inventory inventory) {
        if (inventory.getViewers().isEmpty()) return;
        inventory.update();
    }

    /**
     * Returns the underlying inventory.
     * Please note this method ignores the translation context
     *
     * @return the given inventory
     */
    public Inventory getInventory() {
        return getInventory(null);
    }

    /**
     * Returns the given {@link InventoryType} for the inventory.
     *
     * @return the given type
     */
    public @NotNull InventoryType getType() {
        return type;
    }

    /**
     * Set the open function to the builder
     *
     * @param openFunction The function to set
     * @return the current instance of the builder
     */
    public InventoryBuilder setOpenFunction(OpenFunction openFunction) {
        this.openFunction = openFunction;
        return this;
    }

    /**
     * Set the close function to the builder.
     *
     * @param closeFunction the function to set
     * @return the current instance of the builder
     */
    public InventoryBuilder setCloseFunction(CloseFunction closeFunction) {
        this.closeFunction = closeFunction;
        return this;
    }

    /**
     * Set a new instance of the {@link InventoryLayout} to the builder
     *
     * @param inventoryLayoutImpl The layout to set
     * @return the current instance of the builder
     */
    public InventoryBuilder setLayout(@NotNull InventoryLayout inventoryLayoutImpl) {
        this.inventoryLayout = inventoryLayoutImpl;
        return this;
    }

    /**
     * Returns the underlying {@link InventoryLayout}.
     *
     * @return the given layout
     */
    public @Nullable InventoryLayout getLayout() {
        return inventoryLayout;
    }

    /**
     * Get underlying data {@link InventoryLayout}.
     *
     * @return the given layout
     */
    public @Nullable InventoryLayout getDataLayout() {
        return dataLayout;
    }
}