import com.google.common.base.Enums;
import org.brokenarrow.storage.NMS.UpdateTittleContainers;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.metadata.FixedMetadataValue;
import org.bukkit.plugin.Plugin;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;

public abstract class MenuHolderTest {


    /**
     * Create menu instance.
     *
     * @param clazz         from with class you crated your menu.
     * @param plugin        your main class.
     * @param inventorySize size if menu.
     */

    public MenuHolderTest(Class<?> clazz, Plugin plugin, int inventorySize) {
        this.clazz = clazz;
        this.inventorySize = inventorySize;
        this.plugin = plugin;
    }

    /**
     * Create menu instance.
     *
     * @param clazz           from with class you crated your menu.
     * @param plugin          your main class.
     * @param inventorySize   size if menu.
     * @param shallCacheItems if it shall cache items and slots in this class, other case use {@link #getMenuButtonsOwnCache()} ot cache it own class.
     */
    public MenuHolderTest(Class<?> clazz, Plugin plugin, int inventorySize, boolean shallCacheItems) {
        this.clazz = clazz;
        getFieldButton();
        this.inventorySize = inventorySize;
        this.itemsPerPage = inventorySize;
        this.plugin = plugin;
        this.shallCacheItems = shallCacheItems;
        if (shallCacheItems)
            generateInventories();

    }

    private final MenuCache menuCache = MenuCache.getInstance();
    private List<MenuButton> buttons = new ArrayList<>();
    private final Map<Integer, ItemStack> addedButtons = new HashMap<>();
    private final Plugin plugin;
    private final Class<?> clazz;
    private Inventory[] inventories;
    private int pageNumber;
    private boolean shallCacheItems;
    private boolean slotsYouCanAddItems;
    private int requiredPages;
    private List<Integer> fillSpace;
    private List<?> listOfFillItems;
    private int itemsPerPage = this.inventorySize;
    private Player player;
    private Sound menuOpenSound = Sound.BLOCK_NOTE_BLOCK_BASEDRUM;
    private int inventorySize;
    private String title;

    public ItemStack getItemAt(int slot) {
        return null;
    }

    public ItemStack getFillItemsAt(int slot) {
        return null;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public void setItemsPerPage(int itemsPerPage) {
        if (itemsPerPage <= 0)
            this.itemsPerPage = this.inventorySize;
        this.itemsPerPage = itemsPerPage;
    }

    public void setFillSpace(List<Integer> fillSpace) {
        this.fillSpace = fillSpace;
    }

    public void setMenuOpenSound(Sound sound) {
        this.menuOpenSound = sound;
    }

    public <T> void setListOfFillItems(List<T> listOfFillItems) {
        if (listOfFillItems instanceof ItemStack)
            this.listOfFillItems = listOfFillItems;
    }

    /**
     * set this to true if you whant players has option to add or remove items
     *
     * @param slotsYouCanAddItems true and it will give option to add and remove items on fill slots.
     */

    public void setSlotsYouCanAddItems(boolean slotsYouCanAddItems) {
        this.slotsYouCanAddItems = slotsYouCanAddItems;
    }

    /**
     * get if it this option will give you option add or remove items.
     *
     * @return true will you have option add items.
     */

    public boolean isSlotsYouCanAddItems() {
        return slotsYouCanAddItems;
    }

    public Map<Integer, ItemStack> getAddedButtons() {
        return addedButtons;
    }

    public List<MenuButton> getButtons() {
        return buttons;
    }

    public Player getViewer() {
        return this.player;
    }

    public Inventory getMenu() {
        if (this.inventories != null)
            return this.inventories[this.pageNumber];
        return null;
    }

    public int getPageNumber() {
        return pageNumber;
    }

    public int getRequiredPages() {
        return requiredPages;
    }

    public Map<Integer, ItemStack> getMenuButtonsOwnCache() {
        return generateInventories();
    }

    public List<Integer> getFillSpace() {
        return fillSpace;
    }

    public void onMenuClose(InventoryCloseEvent event, Class<?> metadata) {
        if (metadata != null)
            this.player.removeMetadata(metadata.toString(), plugin);
    }


    public void onMenuOpen(Player player, Location location, String setPlayerMetadata) {
        onMenuOpen(player, location, setPlayerMetadata, null);
    }

    public void onMenuOpen(Player player, String setPlayerMetadata, String setPlayerMetadataValue) {
        onMenuOpen(player, null, setPlayerMetadata, setPlayerMetadataValue);
    }

    public void onMenuOpen(Player player) {
        onMenuOpen(player, null, null, null);
    }

    private void onMenuOpen(Player player, Location location, String setPlayerMetadata, String setPlayerMetadataValue) {
        getFieldButton();
        generateInventories();
        this.player = player;
        System.out.println("menuCache.getMenuInCache(player) " + menuCache.getMenuInCache(player + "*__*" + this.clazz));
        player.openInventory((menuCache.getMenuInCache(player + "*__*" + this.clazz) != null ? menuCache.getMenuInCache(player + "*__*" + this.clazz).getMenu() : getMenu()));
        if (this.title != null && !this.title.equals(""))
            UpdateTittleContainers.update(player, this.title, Material.CHEST, getMenu().getSize());
        //PlayerUtil.updateInventoryTitle(player, GuiTempletsYaml.getGuiTitle("Settings_Menu"));
        onMenuOpenPlaySound();
        menuCache.setMenusChached(toMenuCache(player, location, setPlayerMetadataValue), this);
        if (location != null)
            setPlayermetadata(player, location, setPlayerMetadata);
        else
            setPlayermetadata(player, setPlayerMetadata, setPlayerMetadataValue);
    }

    private Object toMenuCache(Player player, Location location, String setPlayerMetadataValue) {
        String obj = null;

        if (location != null) {
            obj = String.valueOf(location);
            if (this.clazz != null)
                obj = location + "*__*" + this.clazz;
        }
        if (player != null) {
            obj = String.valueOf(player);
            if (this.clazz != null)
                obj = player + "*__*" + this.clazz;
        }
        if (player != null && setPlayerMetadataValue != null) {
            obj = player + "*__*" + setPlayerMetadataValue;
        }
        return obj;
    }

    private void setPlayermetadata(Player player, Location location, String setPlayerMetadata) {
        player.setMetadata(setPlayerMetadata, new FixedMetadataValue(plugin, location));

    }

    private void setPlayermetadata(Player player, String setPlayerMetadata, String setPlayerMetadataValue) {
        player.setMetadata(setPlayerMetadata, new FixedMetadataValue(plugin, setPlayerMetadataValue));
    }

    private void onMenuOpenPlaySound() {
        if (Enums.getIfPresent(Sound.class, menuOpenSound.name()).orNull() != null)
            this.player.playSound(player.getLocation(), menuOpenSound, 1, 1);
    }

    private void getFieldButton() {
        for (Field field : this.clazz.getDeclaredFields()) {
            field.setAccessible(true);
            if (MenuButton.class.isAssignableFrom(field.getType())) {
                try {
                    MenuButton fielddata = (MenuButton) field.get(this);
                    System.out.println("test " + this);
                    buttons.add(fielddata);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private int amountpages() {

        if (this.itemsPerPage > 0) {
            if (this.itemsPerPage >= this.inventorySize)
                plugin.getLogger().log(Level.SEVERE, "Items per page are biger an Inventory size", new Throwable().fillInStackTrace());
            return buttons.size() / this.itemsPerPage;
        } else {
            return buttons.size() / this.inventorySize;
        }
    }

    private Map<Integer, ItemStack> generateInventories() {
        Map<Integer, ItemStack> addedButtons = new HashMap<>();
        this.requiredPages = Math.max((int) Math.ceil(amountpages()), 1);
        //We need more pages if statically positioned players you add are placed at a higher page index an one page can hold.

        this.inventories = new Inventory[this.requiredPages];

        int slotIndex = 0;
        for (int i = 0; i < this.requiredPages; i++) {
            this.inventories[i] = createInventory();
            for (int slot = 0; slot < this.inventories[i].getSize(); slot++) {
                //for (int itemPos : this.fillSpace) {
                ItemStack result;
                if (fillSpace != null && fillSpace.contains(slot)) {
                    if (!this.listOfFillItems.isEmpty() && this.listOfFillItems.size() > slotIndex) {
                        result = (ItemStack) this.listOfFillItems.get(slotIndex);
                    } else
                        result = getFillItemsAt(slotIndex);
                    slotIndex++;
                } else {
                    result = getItemAt(slot);
                    System.out.println("result slottis" + getItemAt(slot));
                }

                if (result == null) continue;
                System.out.println("result " + result);
                this.inventories[i].setItem(slot, result);
                if (!this.shallCacheItems)
                    this.addedButtons.put(i * inventories[i].getSize() + slot, result);
                else
                    addedButtons.put(i * inventories[i].getSize() + slot, result);
            }
        }
        if (pageNumber >= this.inventories.length) {
            pageNumber = this.inventories.length - 1;
        }
        return addedButtons;
    }

    private Inventory createInventory() {
        if (!(this.inventorySize == 5 || this.inventorySize % 9 == 0))
            System.out.println("wrong inverntory size , you has put in " + this.inventorySize + "it need to be valid number.");
        if (this.inventorySize == 5)
            return Bukkit.createInventory(null, InventoryType.HOPPER, this.title);

        return Bukkit.createInventory(null, this.inventorySize, this.title != null ? this.title : "");
    }


}