ItemContainer.java

package com.osroyale.game.world.items.containers;
 
import com.google.common.base.Preconditions;
import com.osroyale.game.world.entity.mob.player.Player;
import com.osroyale.game.world.items.Item;
import com.osroyale.game.world.items.ItemDefinition;
import com.osroyale.game.world.items.containers.pricechecker.PriceType;
import com.osroyale.net.packet.out.SendItemOnInterface;
 
import java.util.*;
import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
 
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
 

 
public class ItemContainer implements Iterable<Item> {
 
    // TODO: Unit tests for various functions

    private static final class ItemContainerIterator implements Iterator<Item> {

        private final ItemContainer container;

        private int index;

        private int lastIndex = -1;

        ItemContainerIterator(ItemContainer container) {
            this.container = container;
        }
 
        @Override
        public boolean hasNext() {
            return (index + 1) <= container.capacity;
        }
 
        @Override
        public Item next() {
            checkState(index < container.capacity, "no more elements left to iterate");
 
            lastIndex = index;
            index++;
            return container.items[lastIndex];
        }
 
        @Override
        public void remove() {
            checkState(lastIndex != -1, "can only be called once after 'next'");
 
            Item oldItem = container.items[lastIndex];
            container.items[lastIndex] = null;
            container.fireItemUpdatedEvent(oldItem, null, lastIndex, true);
 
            index = lastIndex;
            lastIndex = -1;
        }
    }

public enum StackPolicy {

        STANDARD,

        ALWAYS,

        NEVER
    }

    private final List<ItemContainerListener> listeners = new ArrayList<>();

    private final int capacity;

    private final StackPolicy policy;

    private Item[] items;

    private boolean firingEvents = true;

    public ItemContainer(int capacity, StackPolicy policy, Item[] items) {
        this.capacity = capacity;
        this.policy = policy;
        this.items = items;
    }

    public ItemContainer(int capacity, StackPolicy policy) {
        this(capacity, policy, new Item[capacity]);
    }

    @Override
    public final void forEach(Consumer<? super Item> action) {
        Objects.requireNonNull(action);
        for (Item item : items) {
            if (item != null) {
                action.accept(item);
            }
        }
    }
 
    @Override
    public final Spliterator<Item> spliterator() {
        return Spliterators.spliterator(items, Spliterator.ORDERED);
    }
 
    @Override
    public final Iterator<Item> iterator() {
        return new ItemContainerIterator(this);
    }

    public final Stream<Item> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    public boolean add(Item item) {
        return add(item, -1, true);
    }

    public boolean add(Item item, int slot) {
        return add(item, slot, true);
    }

    public boolean add(int id, int amount) {
        return add(new Item(id, amount));
    }
 
    public boolean add(Item item, boolean refresh, boolean stack) {
        return add(item, -1, refresh, stack);
    }
 
    public boolean add(Item item, int preferredIndex, boolean refresh) {
        return add(item, preferredIndex, refresh, false);
    }

    public boolean add(Item item, int preferredIndex, boolean refresh, boolean stack) {
        checkArgument(preferredIndex >= -1, "invalid index identifier");
 
        item = item.copy();
 
        boolean stackable = stack || (policy.equals(StackPolicy.STANDARD) && item.isStackable()) || policy.equals(StackPolicy.ALWAYS);
 
        if (stackable && !stack) {
            preferredIndex = computeIndexForId(item.getId());
        } else if (preferredIndex != -1) {
            preferredIndex = items[preferredIndex] != null ? -1 : preferredIndex;
        }
 
        preferredIndex = preferredIndex == -1 ? computeFreeIndex() : preferredIndex;
 
        if (preferredIndex == -1) { // Not enough space in container.
            fireCapacityExceededEvent();
            return false;
        }
 
        if (stackable) {
            Item current = items[preferredIndex];
            items[preferredIndex] = (current == null) ? item : current.createAndIncrement(item.getAmount());
            fireItemUpdatedEvent(current, items[preferredIndex], preferredIndex, refresh);
        } else {
            int remaining = remaining();
            int until = (remaining > item.getAmount()) ? item.getAmount() : remaining;
 
            for (int index = 0; index < until; index++) {
                preferredIndex = (preferredIndex > capacity || preferredIndex < 0 || items[preferredIndex] == null) ? preferredIndex : computeFreeIndex();
                if (preferredIndex == -1) {//Couldn't find an empty spot.
                    fireCapacityExceededEvent();
                    return false;
                }
                item.setAmount(1);
                items[preferredIndex] = item;
 
                fireItemUpdatedEvent(null, item, preferredIndex++, refresh);
            }
        }
        return true;
    }

    public boolean addAll(Collection<? extends Item> items) {
        if (items.size() == 1) { // Bulk operation on singleton list? No thanks..
            Optional<? extends Item> item = items.stream().
                    filter(Objects::nonNull).
                    findFirst();
            return item.isPresent() && add(item.get());
        }
 
        firingEvents = false;
 
        boolean added = false;
        try {
            for (Item item : items) {
                if (item == null) {
                    continue;
                }
                if (add(item, -1, false)) {
                    added = true;
                }
            }
        } finally {
            firingEvents = true;
        }
        fireBulkItemsUpdatedEvent();
        return added;
    }

    public boolean addAll(Item... items) {
        return addAll(Arrays.asList(items));
    }

    public boolean addAll(ItemContainer items) {
        return addAll(items.items);
    }

    public boolean remove(Item item) {
        return remove(item, -1, true);
    }

    public boolean remove(Item item, int preferredIndex) {
        return remove(item, preferredIndex, true);
    }
 
    public boolean remove(int id) {
        return remove(new Item(id, 1));
    }
 
    public boolean remove(int id, int amount) {
        return remove(new Item(id, amount));
    }
 
    public boolean remove(Item item, int preferredIndex, boolean refresh) {
        return remove(item, preferredIndex, refresh, true);
    }

    public boolean remove(Item item, int preferredIndex, boolean refresh, boolean removeAll) {
        checkArgument(preferredIndex >= -1, "invalid index identifier");
 
        item = item.copy();
 
        boolean stackable = (policy.equals(StackPolicy.STANDARD) && item.isStackable()) || policy.equals(StackPolicy.ALWAYS);
 
        if (stackable) {
            //todo fix dupe
            /*
            because stackable is true (due to the coins being stackable). it will compute the first index.
            being the 1 coin, so when you drop. amount is 260. removes 1coin but drops 260k.
             */
            preferredIndex = computeIndexForId(item.getId());
        } else {
            preferredIndex = preferredIndex == -1 ? computeIndexForId(item.getId()) : preferredIndex;
 
            if (preferredIndex != -1 && items[preferredIndex] == null) {
                preferredIndex = -1;
            }
 
        }
 
        if (preferredIndex == -1) { // Item isn't present within this container.
            return false;
        }
 
        if (stackable) {
            Item current = items[preferredIndex];
            if (current.getAmount() > item.getAmount()) {
                items[preferredIndex] = current.createAndDecrement(item.getAmount());
            } else {
                if (allowZero()) {
                    items[preferredIndex] = current.createWithAmount(0);
                } else {
                    items[preferredIndex] = null;
                }
            }
 
            fireItemUpdatedEvent(current, items[preferredIndex], preferredIndex, refresh);
        } else {
            int until = removeAll ? computeAmountForId(item.getId()) : items[preferredIndex].getAmount();
            until = (item.getAmount() > until) ? until : item.getAmount();
 
            for (int index = 0; index < until && index < capacity; index++) {
                if (removeAll) {
                    if (preferredIndex < 0 || preferredIndex >= capacity) {
                        preferredIndex = computeIndexForId(item.getId());
                    } else if (items[preferredIndex] == null) {
                        preferredIndex = computeIndexForId(item.getId());
                    } else if (items[preferredIndex].getId() != item.getId()) {
                        preferredIndex = computeIndexForId(item.getId());
                    }
                    if (preferredIndex == -1) {
                        break;
                    }
                }
                Item oldItem = items[preferredIndex];
                if (allowZero()) {
                    items[preferredIndex] = oldItem.createWithAmount(0);
                } else {
                    items[preferredIndex] = null;
                }
                fireItemUpdatedEvent(oldItem, null, preferredIndex++, refresh);
            }
        }
        return true;
    }

    public boolean removeAll(Collection<? extends Item> items) {
        if (items.size() == 1) { // Bulk operation on singleton list? No thanks..
            Optional<? extends Item> item = items.stream().
                    filter(Objects::nonNull).
                    findFirst();
            return item.isPresent() && remove(item.get());
        }
 
        firingEvents = false;
        boolean removed = false;
        try {
            for (Item item : items) {
                if (item == null) {
                    continue;
                }
                if (remove(item, -1, false)) {
                    removed = true;
                }
            }
        } finally {
            firingEvents = true;
        }
        fireBulkItemsUpdatedEvent();
        return removed;
    }

    public boolean removeAll(Item... items) {
        return removeAll(Arrays.asList(items));
    }

    public boolean removeAll(ItemContainer items) {
        return removeAll(items.items);
    }

    public long containerValue(PriceType type) {
        long value = 0;
 
        for (final Item item : items) {
            if (item == null) {
                continue;
            }
 
            int price = item.getValue(type);
 
            if (value >= Long.MAX_VALUE - price * item.getAmount()) {
                return Long.MAX_VALUE;
            }
 
            value += price * item.getAmount();
        }
 
        return value;
    }

    public final int computeFreeIndex() {
        for (int index = 0; index < capacity; index++) {
            if (items[index] == null) {
                return index;
            }
        }
        return -1;
    }

    public final int computeIndexForId(int id) {
        for (int index = 0; index < capacity; index++) {
            if (items[index] != null && items[index].getId() == id) {
                return index;
            }
        }
        return -1;
    }

    public final int computeAmountForId(int id) {
        int amount = 0;
        for (Item item : items) {
            if (item == null || item.getId() != id)
                continue;
            amount += item.getAmount();
        }
        return amount;
    }

    public final Optional<Integer> computeIdForIndex(int index) {
        return retrieve(index).map(Item::getId);
    }

    public final boolean replace(int oldId, int newId, int index, boolean refresh) {
        Item oldItem = items[index];
 
        if (oldItem == null || !oldItem.matchesId(oldId))
            return false;
 
        Item newItem = oldItem.createWithId(newId);
        return remove(oldItem, index, refresh) && add(newItem, index, refresh);
    }

    public final boolean replace(int oldId, int newId, boolean refresh) {
        int index = computeIndexForId(oldId);
        if (index == -1) {
            return false;
        }
 
        Item oldItem = items[index];
 
        if (oldItem == null || !oldItem.matchesId(oldId))
            return false;
 
        Item newItem = oldItem.createWithId(newId);
        return remove(oldItem, index, refresh) && add(newItem, index, refresh);
    }

    public final boolean replace(Item first, Item second, boolean refresh) {
        int index = computeIndexForId(first.getId());
 
        if (index == -1) {
            return false;
        }
 
        Item oldItem = items[index];
 
        if (oldItem == null || !oldItem.matchesId(first.getId()))
            return false;
 
        return remove(oldItem, index, refresh) && add(second, index, refresh);
    }

    public final boolean replaceAll(int oldId, int newId) {
        boolean replaced = false;
 
        firingEvents = false;
        try {
            while (replace(oldId, newId, false)) {
                replaced = true;
            }
        } finally {
            firingEvents = true;
        }
        fireBulkItemsUpdatedEvent();
        return replaced;
    }

    public final int computeIndexCount(Item... forItems) {
        int indexCount = 0;
        for (Item item : forItems) {
            if (item == null)
                continue;
            boolean stackable = (policy.equals(StackPolicy.STANDARD) && item.isStackable()) || policy.equals(StackPolicy.ALWAYS);
 
            if (stackable) {
                int index = computeIndexForId(item.getId());
                if (index == -1) {
                    indexCount++;
                    continue;
                }
 
                Item existing = items[index];
                if ((existing.getAmount() + item.getAmount()) <= 0) {
                    indexCount++;
                }
            } else {
                indexCount += item.getAmount();
            }
        }
        return indexCount;
    }

    public final boolean hasCapacityFor(Item... item) {
        int indexCount = computeIndexCount(item);
        return remaining() >= indexCount;
    }

    public final boolean hasCapacityAfter(Item[] add, Item... remove) {
        ItemContainer container = new ItemContainer(capacity, policy, toArray());
        container.removeAll(Arrays.copyOf(remove, remove.length));
        return container.hasCapacityFor(add);
    }

    public boolean contains(int id) {
        for (Item item : items) {
            if (item != null && id == item.getId()) {
                return true;
            }
        }
        return false;
    }

    public final boolean containsAll(int... identifiers) {
        for (int id : identifiers) {
            if (!contains(id)) {
                return false;
            }
        }
        return true;
    }

    public final boolean containsAny(int... identifiers) {
        for (int id : identifiers) {
            if (contains(id)) {
                return true;
            }
        }
        return false;
    }

    public final boolean contains(Item item) {
        return item != null && contains(item.getId(), item.getAmount());
    }

    public final boolean contains(int id, int amount) {
        for (Item item : items) {
            if (item != null && id == item.getId()) {
                amount -= item.getAmount();
                if (amount <= 0) return true;
            }
        }
        return false;
    }

    public final boolean containsAll(Item... items) {
        for (Item item : items) {
            if (!contains(item)) {
                return false;
            }
        }
        return true;
    }

    public final boolean containsAll(Collection<Item> items) {
        for (Item item : items) {
            if (!contains(item)) {
                return false;
            }
        }
        return true;
    }

    public final boolean containsAny(Item... items) {
        for (Item item : items) {
            if (contains(item)) {
                return true;
            }
        }
        return false;
    }

    public final boolean containsAny(Collection<Item> items) {
        for (Item item : items) {
            if (contains(item)) {
                return true;
            }
        }
        return false;
    }

    public void refresh(Player player, int widget) {
        player.send(new SendItemOnInterface(widget, items));
        onRefresh();
    }

    public void onRefresh() {
        /* can be overriden */
    }

    public final void swap(int oldIndex, int newIndex) {
        swap(false, oldIndex, newIndex, true);
    }

    public final void swap(boolean insert, int oldIndex, int newIndex, boolean refresh) {
        if (insert) {
            insert(oldIndex, newIndex, refresh);
        } else {
            swap(oldIndex, newIndex, refresh);
        }
    }
 
    public final void swap(int oldIndex, int newIndex, boolean refresh) {
        checkArgument(oldIndex >= 0 && oldIndex < capacity, "[swap] oldIndex out of range - [old=" + oldIndex + ", new=" + newIndex + ", refresh=" + refresh + ", size=" + size() + ", capacity=" + capacity + "]");
        checkArgument(newIndex >= 0 && newIndex < capacity, "[swap] newIndex out of range - [old=" + oldIndex + ", new=" + newIndex + ", refresh=" + refresh + ", size=" + size() + ", capacity=" + capacity + "]");
 
        Item itemOld = items[oldIndex];
        Item itemNew = items[newIndex];
 
        items[oldIndex] = itemNew;
        items[newIndex] = itemOld;
 
        fireItemUpdatedEvent(itemOld, items[oldIndex], oldIndex, refresh);
        fireItemUpdatedEvent(itemNew, items[newIndex], newIndex, refresh);
    }
 
    public final void insert(int oldIndex, int newIndex, boolean refresh) {
        checkArgument(oldIndex >= 0 && oldIndex < capacity, "[insert] oldIndex out of range - [old=" + oldIndex + ", new=" + newIndex + ", refresh=" + refresh + ", size=" + size() + ", capacity=" + capacity + "]");
        checkArgument(newIndex >= 0 && newIndex < capacity, "[insert] newIndex out of range - [old=" + oldIndex + ", new=" + newIndex + ", refresh=" + refresh + ", size=" + size() + ", capacity=" + capacity + "]");
 
        if (newIndex > oldIndex) {
            for (int index = oldIndex; index < newIndex; index++) {
                swap(index, index + 1, refresh);
            }
        } else if (oldIndex > newIndex) {
            for (int index = oldIndex; index > newIndex; index--) {
                swap(index, index - 1, refresh);
            }
        }
    }
 
    public final void transfer(int firstIndex, int secondIndex, ItemContainer other, boolean refresh) {
        checkArgument(firstIndex >= 0 && firstIndex < capacity, "[transfer] firstIndex out of range - [first=" + firstIndex + ", second=" + secondIndex + ", refresh=" + refresh + "]");
        checkArgument(secondIndex >= 0 && secondIndex < other.capacity, "[transfer] secondIndex out of range - [first=" + firstIndex + ", second=" + secondIndex + ", refresh=" + refresh + "]");
        Item first = get(firstIndex);
        Item second = other.get(secondIndex);
        set(firstIndex, second, true);
        other.set(secondIndex, first, true);
    }

    public void shift() {
        Item[] newItems = new Item[capacity];
        int newIndex = 0;
 
        for (Item item : items) {
            if (item == null) {
                continue;
            }
            newItems[newIndex++] = item;
        }
 
        setItems(newItems);
    }

    public final void setItems(Item[] items, boolean copy) {
        Preconditions.checkArgument(items.length <= capacity);
        clear();
        for (int i = 0; i < items.length; i++) {
            this.items[i] = items[i] == null ? null : copy ? items[i].copy() : items[i];
        }
        fireBulkItemsUpdatedEvent();
    }
 
    public final void setItems(Item[] items) {
        setItems(items, true);
    }
 
    public final void set(Item[] toSet) {
        items = toSet;
    }

    public final Item[] toArray() {
        return Arrays.copyOf(items, items.length);
    }
 
    public final Item[] toNonNullArray() {
        if (size() == 0) {
            return new Item[0];
        }
 
        final List<Item> items = new ArrayList<>(size());
 
        for (Item item : getItems()) {
            if (item == null) {
                continue;
            }
 
            items.add(item);
        }
 
        return items.toArray(new Item[items.size()]);
    }

    public double getWeight() {
        double weight = 0;
        for (Item item : toArray()) {
            if (item == null)
                continue;
            weight += item.getWeight();
        }
        return weight;
    }

    public void set(int index, Item item, boolean refresh) {
        Item oldItem = items[index];
        items[index] = item;
        fireItemUpdatedEvent(oldItem, items[index], index, refresh);
    }

    public final Optional<Item> retrieve(int index) {
        if (index >= 0 && index < items.length)
            return Optional.ofNullable(items[index]);
        return Optional.empty();
    }

    public final void ifPresent(int index, Consumer<Item> action) {
        if (index >= 0 && index < items.length)
            action.accept(items[index]);
    }

    public final Item get(int index) {
        if (index >= 0 && index < items.length)
            return items[index];
        return null;
    }

    public final int getId(int index) {
        if (items[index] == null) {
            return -1;
        }
        return items[index].getId();
    }

    public Optional<Item> search(int id) {
        return stream().filter(i -> i != null && id == i.getId()).findFirst();
    }

    public Optional<Item> search(Item item) {
        return stream().filter(i -> i != null && item.getId() == i.getId() && item.getAmount() == i.getAmount()).findFirst();
    }

    public final boolean indexOccupied(int index) {
        return retrieve(index).isPresent();
    }

    public final boolean indexFree(int index) {
        return !indexOccupied(index);
    }

    public final ItemContainer copy() {
        ItemContainer container = new ItemContainer(this.capacity, this.policy, this.toArray());
        this.listeners.forEach(container::addListener);
        return container;
    }

    public void clear() {
        clear(true);
    }

    public final void clear(boolean refresh) {
        Arrays.fill(items, null);
        if (refresh)
            fireBulkItemsUpdatedEvent();
    }

    public final boolean isEmpty() {
        return size() == 0;
    }
 
    public final boolean isFull() {
        return getFreeSlots() == 0;
    }

    public final boolean addListener(ItemContainerListener listener) {
        return listeners.add(listener);
    }

    public final boolean removeListener(ItemContainerListener listener) {
        return listeners.remove(listener);
    }

 
    public final void fireItemUpdatedEvent(Item oldItem, Item newItem, int index, boolean refresh) {
        fireItemUpdatedEvent(oldItem, newItem, index, refresh, false);
    }
 
    public final void fireItemUpdatedEvent(Item oldItem, Item newItem, int index, boolean refresh, boolean login) {
        if (firingEvents) {
            listeners.forEach(evt -> evt.itemUpdated(this, Optional.ofNullable(oldItem), Optional.ofNullable(newItem), index, refresh, login));
        }
    }

    public final void fireBulkItemsUpdatedEvent() {
        if (firingEvents) {
            listeners.forEach(evt -> evt.bulkItemsUpdated(this));
        }
    }

    public final void fireCapacityExceededEvent() {
        if (firingEvents) {
            listeners.forEach(evt -> evt.capacityExceeded(this));
        }
    }

    public Item[] getItems() {
        return items;
    }

    public void setFiringEvents(boolean firingEvents) {
        this.firingEvents = firingEvents;
    }

    public final int remaining() {
        return capacity - size();
    }

    public int getFreeSlots() {
        return capacity() - size();
    }

    public final int size() {
        return (int) Arrays.stream(items).filter(Objects::nonNull).count();
    }

    public final int capacity() {
        return capacity;
    }

    public final StackPolicy policy() {
        return policy;
    }

    public boolean allowZero() {
        return false;
    }

    public int getSlotById(int id) {
        for (int i = 0; i < items.length; i++) {
            if (items[i] == null) {
                continue;
            }
            if (items[i].getId() == id) {
                return i;
            }
        }
        return -1;
    }
 
//    public boolean isFull() {
//        return size() == capacity();
//    }
}