package eu.th3game.chestkeeper;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;

import org.apache.commons.lang.Validate;
import org.bukkit.Material;
import org.bukkit.craftbukkit.inventory.InventoryIterator;
import org.bukkit.entity.HumanEntity;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;


public class MyInventory implements Inventory {

    private Map <Integer, ItemStack> inventory;
    private final String name;
    private final int size;
    private final String title;

    public MyInventory(String name, int size, String title) {
        Validate.isTrue(size > 0 && size <= 54, "Size out of bounds");
        Validate.isTrue(size % 9 == 0, "Size is not a multiple of 9");

        this.name = name;
        this.size = size;
        this.title = title;
        this.inventory = new HashMap<Integer, ItemStack>();
    }

    private int firstPartial(Material material) {
        Validate.notNull(material, "Material cannot be null");

        ItemStack[] inventory = getContents();
        for (int i = 0; i < inventory.length; i++) {
            ItemStack item = inventory[i];
            if (item != null && item.getType() == material && item.getAmount() < item.getMaxStackSize()) {
                return i;
            }
        }
        return -1;
    }

    private int firstPartial(ItemStack item) {
        ItemStack[] inventory = getContents();

        if (item == null) {
            return -1;
        }
        for (int i = 0; i < inventory.length; i++) {
            ItemStack cItem = inventory[i];
            if (cItem != null && cItem.getAmount() < cItem.getMaxStackSize() && cItem.isSimilar(item)) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public HashMap<Integer, ItemStack> addItem(ItemStack... items) {
        Validate.noNullElements(items, "Item cannot be null");
        HashMap<Integer, ItemStack> leftover = new HashMap<Integer, ItemStack>();

        ItemStack[] inv = getContents();
        for (int i = 0; i < inv.length; i++) {
            ItemStack item = inv[i];
            while (true) {
                // Do we already have a stack of it?
                int firstPartial = firstPartial(item);

                // Drat! no partial stack
                if (firstPartial == -1) {
                    // Find a free spot!
                    int firstFree = firstEmpty();

                    if (firstFree == -1) {
                        // No space at all!
                        leftover.put(i, item);
                        break;
                    } else {
                        // More than a single stack!
                        if (item.getAmount() > getMaxStackSize()) {
                            ItemStack stack = new ItemStack(item);
                            stack.setAmount(getMaxStackSize());
                            setItem(firstFree, stack);
                            item.setAmount(item.getAmount() - getMaxStackSize());
                        } else {
                            // Just store it
                            setItem(firstFree, item);
                            break;
                        }
                    }
                } else {
                    // So, apparently it might only partially fit, well lets do just that
                    ItemStack partialItem = getItem(firstPartial);

                    int amount = item.getAmount();
                    int partialAmount = partialItem.getAmount();
                    int maxAmount = partialItem.getMaxStackSize();

                    // Check if it fully fits
                    if (amount + partialAmount <= maxAmount) {
                        partialItem.setAmount(amount + partialAmount);
                        break;
                    }

                    // It fits partially
                    partialItem.setAmount(maxAmount);
                    item.setAmount(amount + partialAmount - maxAmount);
                }
            }
        }
        return leftover;
    }

    @Deprecated
    @Override
    public HashMap<Integer, ItemStack> all(int materialId) {
        return all(Material.getMaterial(materialId));
    }

    @Override
    public HashMap<Integer, ItemStack> all(Material material) {
        Validate.notNull(material, "Material cannot be null");
        HashMap<Integer, ItemStack> slots = new HashMap<Integer, ItemStack>();

        ItemStack[] inventory = getContents();
        for (int i = 0; i < inventory.length; i++) {
            ItemStack item = inventory[i];
            if (item != null && item.getType() == material) {
                slots.put(i, item);
            }
        }
        return slots;
    }

    @Override
    public HashMap<Integer, ItemStack> all(ItemStack item) {
        HashMap<Integer, ItemStack> slots = new HashMap<Integer, ItemStack>();
        if (item != null) {
            ItemStack[] inventory = getContents();
            for (int i = 0; i < inventory.length; i++) {
                if (item.equals(inventory[i])) {
                    slots.put(i, inventory[i]);
                }
            }
        }
        return slots;
    }

    @Override
    public void clear() {
        inventory.clear();
    }

    @Override
    public void clear(int index) {
        inventory.put(index, null);
    }

    @Deprecated
    @Override
    public boolean contains(int materialId) {
        return contains(Material.getMaterial(materialId));
    }

    @Override
    public boolean contains(Material material) throws IllegalArgumentException {
        if (material == null) {
            throw new IllegalArgumentException("Material cannot be null");
        }

        for (ItemStack item : getContents()) {
            if (item != null && item.getType() == material) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean contains(ItemStack item) {
        Validate.notNull(item, "Item cannot be null");

        for (ItemStack i : getContents()) {
            if (item.equals(i)) {
                return true;
            }
        }
        return false;
    }

    @Deprecated
    @Override
    public boolean contains(int materialId, int amount) {
        return contains(Material.getMaterial(materialId), amount);
    }

    @Override
    public boolean contains(Material material, int amount) throws IllegalArgumentException {
        Validate.notNull(material, "Material cannot be null");

        if (amount <= 0) {
            return true;
        }

        for (ItemStack item : getContents()) {
            if (item != null && item.getType() == material) {
                if ((amount -= item.getAmount()) <= 0)
                {
                    return true;
                }
            }
        }
        return false;
    }

    @Override
    public boolean contains(ItemStack item, int amount) {
        Validate.notNull(item, "Item cannot be null");

        if (amount <= 0) {
            return true;
        }

        for (ItemStack i : getContents()) {
            if (item.equals(i) && --amount <= 0) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean containsAtLeast(ItemStack item, int amount) {
        return contains(item.getType(), amount);
    }

    @Deprecated
    @Override
    public int first(int materialId) {
        return first(Material.getMaterial(materialId));
    }

    @Override
    public int first(Material material) throws IllegalArgumentException {
        Validate.notNull(material, "Material cannot be null");

        ItemStack[] inventory = getContents();
        for (int i = 0; i < inventory.length; i++) {
            if (inventory[i] != null && inventory[i].getType() == material) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public int first(ItemStack item) {
        return first(item, true);
    }

    private int first(ItemStack item, boolean withAmount) {
        Validate.notNull(item, "Item cannot be null");

        ItemStack[] inventory = getContents();
        for (int i = 0; i < inventory.length; i++) {
            ItemStack eitem = inventory[i];
            if (eitem != null && (withAmount ? item.equals(eitem) : item.isSimilar(eitem))) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public int firstEmpty() {
        ItemStack[] inventory = getContents();
        for (int i = 0; i < inventory.length; i++) {
            ItemStack item = inventory[i];
            if (item == null) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public ItemStack[] getContents() {
        ItemStack[] inv = new ItemStack[getSize()];

        for (Map.Entry<Integer, ItemStack> item : inventory.entrySet())
        {
            inv[item.getKey()] = item.getValue();
        }

        return inv;
    }

    @Override
    public InventoryHolder getHolder() {
        return new InventoryHolder() {
            private Inventory inventory;

            @Override
            public Inventory getInventory()
            {
                return inventory;
            }

            private InventoryHolder init(Inventory inventory)
            {
                this.inventory = inventory;
                return this;
            }
        }.init((Inventory) this);
    }

    @Override
    public ItemStack getItem(int index) {
        return inventory.get(index);
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public String getTitle() {
        return title;
    }

    @Override
    public InventoryType getType() {
        return InventoryType.CHEST;
    }

    @Override
    public List<HumanEntity> getViewers() {
        return new ArrayList<HumanEntity>();
    }

    @Override
    public ListIterator<ItemStack> iterator() {
        return iterator(0);
    }

    @Override
    public ListIterator<ItemStack> iterator(int index) {
        return new InventoryIterator(this, index);
    }

    @Deprecated
    @Override
    public void remove(int materialId) {
        remove(Material.getMaterial(materialId));
    }

    @Override
    public void remove(Material material) throws IllegalArgumentException {
        Validate.notNull(material, "Material cannot be null");

        ItemStack[] inv = getContents();
        for (int i = 0; i < inv.length; i++) {
            ItemStack item = inv[i];
            if (item != null && item.getType() == material) {
                clear(i);
            }
        }
    }

    @Override
    public void remove(ItemStack item) {
        Validate.notNull(item, "Item cannot be null");

        ItemStack[] inv = getContents();
        for (int i = 0; i < inv.length; i++) {
            ItemStack eitem = inv[i];
            if (eitem != null && eitem.equals(item)) {
                clear(i);
            }
        }
    }

    @Override
    public HashMap<Integer, ItemStack> removeItem(ItemStack... items) throws IllegalArgumentException {
        Validate.notNull(items, "Items cannot be null");
        HashMap<Integer, ItemStack> leftover = new HashMap<Integer, ItemStack>();

        for (int i = 0; i < items.length; i++) {
            ItemStack item = items[i];
            int toDelete = item.getAmount();

            while (true) {
                int first = first(item, false);

                // Drat! we don't have this type in the inventory
                if (first == -1) {
                    item.setAmount(toDelete);
                    leftover.put(i, item);
                    break;
                } else {
                    ItemStack itemStack = getItem(first);
                    int amount = itemStack.getAmount();

                    if (amount <= toDelete) {
                        toDelete -= amount;
                        // clear the slot, all used up
                        clear(first);
                    } else {
                        // split the stack and store
                        itemStack.setAmount(amount - toDelete);
                        setItem(first, itemStack);
                        toDelete = 0;
                    }
                }

                // Bail when done
                if (toDelete <= 0) {
                    break;
                }
            }
        }
        return leftover;
    }

    @Override
    public void setContents(ItemStack[] items) throws IllegalArgumentException {
        Validate.notNull(items, "Items cannot be null");
        Validate.isTrue(items.length < getSize(), "Items must be shorter than Inventory.getSize()");

        clear();

        int length = Math.min(getSize(), items.length);

        for (int i = 0; i < length; i++) {
            setItem(i, items[i]);
        }
    }

    @Override
    public void setItem(int index, ItemStack item) {
        inventory.put(index, item);
    }

    @Override
    public void setMaxStackSize(int size) {}

    @Override
    public int getMaxStackSize() {
        return 64;
    }

}