package com.ghostchu.storageproxy;

import org.brokenarrow.storage.CustomContainersMainClass;
import org.brokenarrow.storage.api.ContainerRegistryAPI;
import org.brokenarrow.storage.api.containerholders.InventoryHolders;
import org.brokenarrow.storage.util.TypeOfContainers;
import org.brokenarrow.storage.util.builderclass.ContainerData;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.maxgamer.quickshop.QuickShop;
import org.maxgamer.quickshop.api.shop.Shop;
import org.maxgamer.quickshop.api.shop.inventory.InventoryWrapper;
import org.maxgamer.quickshop.api.shop.inventory.InventoryWrapperManager;
import org.maxgamer.quickshop.api.shop.inventory.InventoryWrapperType;

import java.util.Arrays;
import java.util.Map;

public class CCHWrapper implements InventoryWrapper {
    private final Location cchBindingLocation;
    private final ContainerData data;

    private final InventoryHolders holders;
    private final Inventory inventory;

    public CCHWrapper(Location loc) {
        this.cchBindingLocation = loc;
        this.data = ContainerRegistryAPI.getInstance().findChest(loc);
        if (this.data == null)
            this.inventory = Bukkit.createInventory(null, 27);
            //throw new IllegalArgumentException("Target chest not a CCH container");
        else {
            this.inventory = null;
            if (this.data.getTypeOfContainer() != TypeOfContainers.TypeOfContainer.PAGEDCONTAINER)
                throw new IllegalArgumentException("Target chest not a CCH paged container");
        }
        this.holders = CustomContainersMainClass.getInstance().getInventoryHoldersCached().getInventoryHolder(cchBindingLocation);

    }

    @Override
    public int getSize() {
        if (this.inventory != null)
            return this.inventory.getSize();
        else
            return holders.getguiSize();
    }

    public Inventory getInventory() {
        Inventory inventory = this.holders.getFirstPageWithItems(QuickShop.getInstance().getShopManager().getShop(cchBindingLocation).getItem());
        if (inventory == null)
            this.holders.setInventoryHopper();

        return inventory;
    }

    @Override
    public @Nullable ItemStack getItem(int i) {
        System.out.println("getItem   ###############");
        if (this.inventory != null)
            return this.inventory.getItem(i);
        else
            return this.holders.getContents()[i];
        // TODO
    }

    @Override
    public void setItem(int i, @Nullable ItemStack itemStack) throws IllegalArgumentException {
        System.out.println("setItem    ###############");
        if (this.inventory != null)
            this.inventory.setItem(i, itemStack);
        else
            this.holders.addItems(itemStack);
        //getInventory().setItem(i, itemStack);
        // TODO
    }

    @Override
    public @NotNull ItemStack[] getContents() {
        System.out.println("getContents    ###############");
        if (this.inventory != null)
            return this.inventory.getContents();
        else
            return this.holders.getContents();
        //return    getInventory().getContents();
        // TODO
    }

    @Override
    public void setContents(@NotNull ItemStack[] itemStacks) throws IllegalArgumentException {
        //System.out.println("setContents    ###############");
        System.out.println("setContents     ############### " + Arrays.toString(itemStacks));
        if (this.inventory != null)
            this.inventory.setContents(itemStacks);
        else
            holders.setContents(itemStacks);
        //getInventory().setContents(itemStacks);
        // TODO
    }

    @Override
    public @NotNull ItemStack[] getStorageContents() {
        System.out.println("getStorageContents     ############### ");
        if (this.inventory != null)
            return this.inventory.getStorageContents();
        else
            return this.holders.getContents();
        //return getInventory().getStorageContents();
        // TODO
    }

    @Override
    public void setStorageContents(@NotNull ItemStack[] itemStacks) throws IllegalArgumentException {
        System.out.println("setStorageContents     ############### " + Arrays.toString(itemStacks));
        if (this.inventory != null)
            this.inventory.setStorageContents(itemStacks);
        else
            holders.setContents(itemStacks);
        //getInventory().setContents(itemStacks);
        // TODO
    }

    @Override
    public @Nullable InventoryHolder getHolder() {
        if (this.inventory != null)
            this.inventory.getHolder();
        else
            getInventory().getHolder();
        return null;
    }

    @Override
    public @Nullable Location getLocation() {
        return cchBindingLocation;
    }

    @Override
    public int countItems(@NotNull ItemStack stack) {
        System.out.println("countItems inside count items" + this.holders);
        if (this.inventory != null)
            return this.inventory.getContents().length;
        else
            return this.holders.getAmountOfOneItem(stack);
    }

    @Override
    public int countSpace(@NotNull ItemStack stack) {
        System.out.println("countSpaces     ###############");
        return -1;
    }

    @Override
    public int countItems(@NotNull Shop shop) {
        System.out.println("countItems " + this.holders);
        if (this.inventory != null)
            return 0;
        else
            return this.holders.getAmountOfOneItem(shop.getItem());
    }

    @Override
    public @NotNull Map<Integer, ItemStack> removeItem(@NotNull ItemStack... items) throws IllegalArgumentException {
        System.out.println("test removeItem ");
        return InventoryWrapper.super.removeItem(items);
    }

    @Override
    public void remove(@NotNull ItemStack item) {
        System.out.println("test remove ");
        InventoryWrapper.super.remove(item);
    }

    @Override
    public @NotNull InventoryWrapperType getInventoryType() {
        return InventoryWrapperType.PLUGIN;
    }

    @Override
    public @NotNull InventoryWrapperManager getWrapperManager() {
        return StorageProxy.getInstance().getManager();
    }
}