package org.brokenarrow.storage.menus.redone;

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.*;
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;
        this.inventorySize = inventorySize;
        this.itemsPerPage = inventorySize;
        this.plugin = plugin;
        this.shallCacheItems = shallCacheItems;
    }

    private final MenuCache menuCache = MenuCache.getInstance();
    private final 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 boolean startLoadMenuButtons;
    private boolean hasLoadMenuButtons;
    private int pageNumber;
    private ItemStack itemStack;
    private boolean shallCacheItems;
    private boolean slotsYouCanAddItems;
    private int slotIndex = 0;
    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 ItemStack getFillItemsAt() {
        return null;
    }

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

    public void setPageNumber(int pageNumber) {
        this.pageNumber = pageNumber;
    }

    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) {
        this.listOfFillItems = listOfFillItems;
    }

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

    /**
     * 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 Inventory[] getInventories() {
        return inventories;
    }

    public List<?> getListOfFillItems() {
        return listOfFillItems;
    }

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

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

    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) {
        System.out.println("has loded " + hasLoadMenuButtons);
        Inventory menu;
        this.player = player;
        if (!hasLoadMenuButtons) {
            registerMenuButtons();
            if (!shallCacheItems) {
                generateInventories();
            }
            hasLoadMenuButtons = true;
        }

        if (menuCache.getMenuInCache(player + "*__*" + this.clazz) != null && menuCache.getMenuInCache(player + "*__*" + this.clazz).getMenu() != null) {
            menu = menuCache.getMenuInCache(player + "*__*" + this.clazz).getMenu();
        } else {
            menu = getMenu();
        }

        if (menu == null) return;
        System.out.println(" menu result in cache " + menu);
        System.out.println("test all menus " + Arrays.toString(inventories));
        player.openInventory(menu);

        System.out.println("this clazz " + menu.equals(getMenu()));
        if (this.title != null && !this.title.equals(""))
            UpdateTittleContainers.update(player, this.title, Material.CHEST, menu.getSize());
        //PlayerUtil.updateInventoryTitle(player, GuiTempletsYaml.getGuiTitle("Settings_Menu"));
        onMenuOpenPlaySound();
        if (location != null)
            setPlayermetadata(player, location, setPlayerMetadata);
        else
            setPlayermetadata(player, setPlayerMetadata, setPlayerMetadataValue);

        if (menuCache.getMenuInCache(player + "*__*" + this.clazz) == null || menuCache.getMenuInCache(player + "*__*" + this.clazz).getMenu() == null)
            menuCache.setMenusChached(toMenuCache(player, location, setPlayerMetadataValue), this);
        System.out.println("has loded after " + hasLoadMenuButtons);
    }

    public boolean isStartLoadMenuButtons() {
        return startLoadMenuButtons;
    }

    public int getSlotIndex() {
        return slotIndex;
    }

    /**
     * get previous page if this menu has several pages
     */
    public void previousPage() {
        int pageNumber = this.pageNumber;

        pageNumber -= 1;
        if (pageNumber < 0) {
            pageNumber = inventories.length - 1;
        } else if (pageNumber >= inventories.length) {
            pageNumber = 0;
        }
        if (pageNumber == -1) {
            pageNumber = 0;
        }
        this.pageNumber = pageNumber;
    }

    /**
     * get next page if this menu has several pages
     */
    public void nextPage() {
        int pageNumber = this.pageNumber;

        pageNumber += 1;
        if (pageNumber < 0) {
            pageNumber = inventories.length - 1;
        } else if (pageNumber >= inventories.length) {
            pageNumber = 0;
        }
        if (pageNumber == -1) {
            pageNumber = 0;
        }
        this.pageNumber = pageNumber;
    }

    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 setPlayerMetadataKey) {
        player.setMetadata(setPlayerMetadataKey, new FixedMetadataValue(plugin, location));

    }

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

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

    public void updateButtons() {
        registerMenuButtons();
        generateInventories();
    }

    private void registerMenuButtons() {
        this.buttons.clear();
        startLoadMenuButtons = true;
        try {
            for (Field field : this.clazz.getDeclaredFields()) {
                field.setAccessible(true);
                if (MenuButton.class.isAssignableFrom(field.getType())) {
                    try {
                        MenuButton fielddata = (MenuButton) field.get(this);
                        this.buttons.add(fielddata);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        } finally {
            startLoadMenuButtons = false;
        }
    }

    private double amountpages() {

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

        }
        if (this.listOfFillItems != null && !this.listOfFillItems.isEmpty()) {
            System.out.println("test ");
            return (double) this.listOfFillItems.size() / this.fillSpace.size();
        } else {
            return (double) this.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 object you add are placed at a higher page index an one page can hold.
        if (this.inventories == null || (this.inventories.length < this.requiredPages)) {
            this.inventories = new Inventory[this.requiredPages];
        }
        System.out.println("pges " + this.requiredPages);
        for (int i = 0; i < this.requiredPages; i++) {
            if (this.inventories[i] == null) {
                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)) {
                    result = getFillItemsAt(this.slotIndex);
                    this.slotIndex++;
                } else {
                    result = getItemAt(slot);
                }

                if (result == null) continue;
                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);
            }
        }
        this.slotIndex = 0;
        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 : "");
    }


}