package world.bentobox.bentobox.api.flags;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Locale;
import java.util.Optional;
import java.util.Set;

import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.event.Listener;
import org.bukkit.inventory.ItemStack;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;

import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.addons.Addon;
import world.bentobox.bentobox.api.addons.GameModeAddon;
import world.bentobox.bentobox.api.configuration.WorldSettings;
import world.bentobox.bentobox.api.flags.clicklisteners.CycleClick;
import world.bentobox.bentobox.api.flags.clicklisteners.IslandToggleClick;
import world.bentobox.bentobox.api.flags.clicklisteners.WorldToggleClick;
import world.bentobox.bentobox.api.localization.TextVariables;
import world.bentobox.bentobox.api.panels.PanelItem;
import world.bentobox.bentobox.api.panels.builders.PanelItemBuilder;
import world.bentobox.bentobox.api.user.User;
import world.bentobox.bentobox.database.objects.Island;
import world.bentobox.bentobox.managers.RanksManager;
import world.bentobox.bentobox.util.ItemParser;


public class Flag implements Comparable<Flag> {

    /**
     * Defines the behavior and operation of the flag.
     */
    public enum Type {
        /**
         * Flag protecting an island.
         * It can be modified by the players (island owner).
         * It applies differently depending on the rank of the player who performs the action protected by the flag.
         */
        PROTECTION(Material.SHIELD),
        /**
         * Flag modifying parameters of the island.
         * It can be modified by the players (island owner).
         * This is usually an on/off setting.
         */
        SETTING(Material.COMPARATOR),
        /**
         * Flag applying to the world.
         * It can only be modified by administrators (permission or operator).
         * This is usually an on/off setting.
         */
        WORLD_SETTING(Material.GRASS_BLOCK);

        @NonNull
        private final Material icon;

        Type(@NonNull Material icon) {
            this.icon = icon;
        }

        @NonNull
        public Material getIcon() {
            return icon;
        }
    }

    /**
     * Defines the flag mode
     * @author tastybento
     * @since 1.6.0
     */
    public enum Mode {
        /**
         * Flag should be shown in the basic settings
         */
        BASIC,
        /**
         * Flag should be shown in the advanced settings
         */
        ADVANCED,
        /**
         * Flag should be shown in the expert settings
         */
        EXPERT,
        /**
         * Flag should be shown in the top row if applicable
         */
        TOP_ROW;

        /**
         * Get the next ranking mode above this one. If at the top, it cycles back to the bottom mode
         * @return next ranking mode
         */
        public Mode getNext() {
            return switch (this) {
            case ADVANCED -> EXPERT;
            case BASIC -> ADVANCED;
            default -> BASIC;
            };
        }

        /**
         * Get a list of ranks that are ranked greater than this rank
         * @param rank - rank to compare
         * @return true if ranked greater
         */
        public boolean isGreaterThan(Mode rank) {
            return switch (this) {
            case EXPERT -> rank.equals(BASIC) || rank.equals(ADVANCED);
            case ADVANCED -> rank.equals(BASIC);
            default -> false;
            };
        }
    }

    private static final String PROTECTION_FLAGS = "protection.flags.";

    private final String id;
    private final Material icon;
    private final Listener listener;
    private final Type type;
    private boolean setting;
    private final int defaultRank;
    private final PanelItem.ClickHandler clickHandler;
    private final boolean subPanel;
    private Set<GameModeAddon> gameModes = new HashSet<>();
    private final Addon addon;
    private final int cooldown;
    private final Mode mode;
    private final Set<Flag> subflags;

    private Flag(Builder builder) {
        this.id = builder.id;
        this.icon = builder.icon;
        this.listener = builder.listener;
        this.type = builder.type;
        this.setting = builder.defaultSetting;
        this.defaultRank = builder.defaultRank;
        this.clickHandler = builder.clickHandler;
        this.subPanel = builder.usePanel;
        if (builder.gameModeAddon != null) {
            this.gameModes.add(builder.gameModeAddon);
        }
        this.cooldown = builder.cooldown;
        this.addon = builder.addon;
        this.mode = builder.mode;
        this.subflags = builder.subflags;
    }

    public String getID() {
        return id;
    }

    public Material getIcon() {
        return icon;
    }

    public Optional<Listener> getListener() {
        return Optional.ofNullable(listener);
    }

    /**
     * @return the cooldown
     */
    public int getCooldown() {
        return cooldown;
    }

    /**
     * Check if a setting is set in this world
     * @param world - world
     * @return world setting or default flag setting if a specific world setting is not set.
     * If world is not a game world, then the result will always be false!
     */
    public boolean isSetForWorld(World world) {
        if (!BentoBox.getInstance().getIWM().inWorld(world)) {
            return false;
        }
        WorldSettings ws = BentoBox.getInstance().getIWM().getWorldSettings(world);
        if (type.equals(Type.WORLD_SETTING) || type.equals(Type.PROTECTION)) {
            if (!ws.getWorldFlags().containsKey(getID())) {
                ws.getWorldFlags().put(getID(), setting);
                // Save config file
                BentoBox.getInstance().getIWM().getAddon(world).ifPresent(GameModeAddon::saveWorldSettings);
            }
            return ws.getWorldFlags().get(getID());
        }
        return setting;
    }

    /**
     * Set a world setting
     * @param world - world
     * @param setting - true or false
     */
    public void setSetting(World world, boolean setting) {
        if (getType().equals(Type.WORLD_SETTING) || type.equals(Type.PROTECTION)) {
            BentoBox.getInstance()
            .getIWM()
            .getWorldSettings(world)
            .getWorldFlags()
            .put(getID(), setting);

            // Subflag support
            if (hasSubflags()) {
                subflags.stream()
                .filter(subflag -> subflag.getType().equals(Type.WORLD_SETTING) || subflag.getType().equals(Type.PROTECTION))
                .forEach(subflag -> BentoBox.getInstance()
                        .getIWM()
                        .getWorldSettings(world)
                        .getWorldFlags()
                        .put(subflag.getID(), setting));
            }

            // Save config file
            BentoBox.getInstance().getIWM().getAddon(world).ifPresent(GameModeAddon::saveWorldSettings);
        }
    }

    /**
     * Set the original status of this flag for locations outside of island spaces.
     * May be overridden by the setting for this world.
     * Does not affect subflags.
     * @param defaultSetting - true means it is allowed. false means it is not allowed
     */
    public void setDefaultSetting(boolean defaultSetting) {
        this.setting = defaultSetting;
    }

    /**
     * Set the status of this flag for locations outside of island spaces for a specific world.
     * World must exist and be registered before this method can be called.
     * Does not affect subflags.
     * @param defaultSetting - true means it is allowed. false means it is not allowed
     */
    public void setDefaultSetting(World world, boolean defaultSetting) {
        if (!BentoBox.getInstance().getIWM().inWorld(world)) {
            BentoBox.getInstance().logError("Attempt to set default world setting for unregistered world. Register flags in onEnable.");
            return;
        }
        BentoBox.getInstance().getIWM().getWorldSettings(world).getWorldFlags().put(getID(), defaultSetting);
        // Save config file
        BentoBox.getInstance().getIWM().getAddon(world).ifPresent(GameModeAddon::saveWorldSettings);
    }

    /**
     * @return the type
     */
    public Type getType() {
        return type;
    }

    /**
     * @return the defaultRank
     */
    public int getDefaultRank() {
        return defaultRank;
    }

    /**
     * @return whether the flag uses a subpanel or not
     */
    public boolean hasSubPanel() {
        return subPanel;
    }

    /**
     * Get the addon that made this flag
     * @return the addon
     * @since 1.5.0
     */
    public Addon getAddon() {
        return addon;
    }

    /* (non-Javadoc)
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        result = prime * result + ((type == null) ? 0 : type.hashCode());
        return result;
    }

    /* (non-Javadoc)
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (!(obj instanceof Flag other)) {
            return false;
        }
        if (id == null) {
            if (other.id != null) {
                return false;
            }
        } else if (!id.equals(other.id)) {
            return false;
        }

        return type == other.type;
    }

    /**
     * @return a locale reference for the name of this protection flag
     */
    public String getNameReference() {
        return PROTECTION_FLAGS + this.id + ".name";
    }

    /**
     * @return a locale reference for the icon of this protection flag
     */
    public String getIconReference() {
        return PROTECTION_FLAGS + this.id + ".icon";
    }

    /**
     * @return a locale reference for the description of this protection flag
     */
    public String getDescriptionReference() {
        return PROTECTION_FLAGS + this.id + ".description";
    }

    /**
     * @return a locale reference for the hint of this protection flag
     */
    public String getHintReference() {
        return PROTECTION_FLAGS + this.id + ".hint";
    }

    /**
     * A set of game mode addons that use this flag. If empty, flag applies to all.
     * @return the gameModeAddon
     */
    public Set<GameModeAddon> getGameModes() {
        return gameModes;
    }

    /**
     * @param gameModeAddon the gameModeAddon to set
     */
    public void setGameModes(Set<GameModeAddon> gameModeAddon) {
        this.gameModes = gameModeAddon;
    }

    /**
     * Add a gameModeAddon to this flag
     * @param gameModeAddon - game mode addon
     */
    public void addGameModeAddon(GameModeAddon gameModeAddon) {
        this.gameModes.add(gameModeAddon);
    }

    /**
     * Remove a gameModeAddon to this flag
     * @param gameModeAddon - game mode addon
     * @return <tt>true</tt> if this set contained the specified element
     */
    public boolean removeGameModeAddon(GameModeAddon gameModeAddon) {
        return this.gameModes.remove(gameModeAddon);
    }

    /**
     * Converts a flag to a panel item. The content of the flag will change depending on who the user is and where they are.
     * @param plugin - plugin
     * @param user - user that will see this flag
     * @param island - target island, if any
     * @param invisible - true if this flag is not visible to players
     * @return - PanelItem for this flag or null if item is invisible to user
     */
    @Nullable
    public PanelItem toPanelItem(BentoBox plugin, User user, @Nullable Island island, boolean invisible) {
        // Invisibility
        if (!user.isOp() && invisible) {
            return null;
        }
        // Start the flag conversion
        PanelItemBuilder pib = new PanelItemBuilder()
                .icon(ItemParser.parse(user.getTranslationOrNothing(this.getIconReference()), new ItemStack(icon)))
                .name(user.getTranslation("protection.panel.flag-item.name-layout", TextVariables.NAME, user.getTranslation(getNameReference())))
                .clickHandler(clickHandler)
                .invisible(invisible);
        if (hasSubPanel()) {
            pib.description(user.getTranslation("protection.panel.flag-item.menu-layout", TextVariables.DESCRIPTION, user.getTranslation(getDescriptionReference())));
            return pib.build();
        }
        return switch (getType()) {
        case PROTECTION -> createProtectionFlag(plugin, user, island, pib).build();
        case SETTING -> createSettingFlag(user, island, pib).build();
        case WORLD_SETTING -> createWorldSettingFlag(user, pib).build();
        };
    }

    private PanelItemBuilder createWorldSettingFlag(User user, PanelItemBuilder pib) {
        String worldSetting = this.isSetForWorld(user.getWorld()) ? user.getTranslation("protection.panel.flag-item.setting-active")
                : user.getTranslation("protection.panel.flag-item.setting-disabled");
        pib.description(user.getTranslation("protection.panel.flag-item.setting-layout", TextVariables.DESCRIPTION, user.getTranslation(getDescriptionReference())
                , "[setting]", worldSetting));
        return pib;
    }

    private PanelItemBuilder createSettingFlag(User user, Island island, PanelItemBuilder pib) {
        if (island != null) {
            String islandSetting = island.isAllowed(this) ? user.getTranslation("protection.panel.flag-item.setting-active")
                    : user.getTranslation("protection.panel.flag-item.setting-disabled");
            pib.description(user.getTranslation("protection.panel.flag-item.setting-layout", TextVariables.DESCRIPTION, user.getTranslation(getDescriptionReference())
                    , "[setting]", islandSetting));
            if (this.cooldown > 0 && island.isCooldown(this)) {
                pib.description(user.getTranslation("protection.panel.flag-item.setting-cooldown"));
            }
        }
        return pib;
    }

    private PanelItemBuilder createProtectionFlag(BentoBox plugin, User user, Island island, PanelItemBuilder pib) {
        if (island != null) {
            // Protection flag
            pib.description(user.getTranslation("protection.panel.flag-item.description-layout",
                    TextVariables.DESCRIPTION, user.getTranslation(getDescriptionReference())));
            RanksManager.getInstance().getRanks().forEach((reference, score) -> {
                if (score > RanksManager.BANNED_RANK && score < island.getFlag(this)) {
                    pib.description(user.getTranslation("protection.panel.flag-item.blocked-rank") + user.getTranslation(reference));
                } else if (score <= RanksManager.OWNER_RANK && score > island.getFlag(this)) {
                    pib.description(user.getTranslation("protection.panel.flag-item.allowed-rank") + user.getTranslation(reference));
                } else if (score == island.getFlag(this)) {
                    pib.description(user.getTranslation("protection.panel.flag-item.minimal-rank") + user.getTranslation(reference));
                }
            });
        }
        return pib;
    }


    /**
     * @return the mode
     * @since 1.6.0
     */
    public Mode getMode() {
        return mode;
    }

    /**
     * @return whether the flag has subflags (and therefore is a parent flag)
     * @since 1.17.0
     */
    public boolean hasSubflags() {
        return !subflags.isEmpty();
    }

    /**
     * @return the subflags, an empty Set if none
     * @since 1.17.0
     */
    public Set<Flag> getSubflags() {
        return subflags;
    }
    
    /**
     * Set the name of this flag for a specified locale. This enables the flag's name to be assigned via API. It will not be stored anywhere
     * and must be rewritten using this call every time the flag is built.
     * @param locale locale (language) to which this name should be assigned. Assigning to {@code Locale.US} will make this the default
     * @param name the translated name for this flag
     * @return true if successful, false if the locale is unknown to this server.
     * See {@link world.bentobox.bentobox.managers.LocalesManager#getAvailableLocales(boolean sort)}
     * @since 1.22.1
     */
    public boolean setTranslatedName(Locale locale, String name) {
        return BentoBox.getInstance().getLocalesManager().setTranslation(locale, getNameReference(), name);
    }
    
    /**
     * Set the name of this flag for a specified locale. This enables the flag's name to be assigned via API. It will not be stored anywhere
     * and must be rewritten using this call every time the flag is built.
     * @param locale locale (language) to which this name should be assigned. Assigning to {@code Locale.US} will make this the default
     * @param description the translated description for this flag
     * @return true if successful, false if the locale is unknown to this server.
     * See {@link world.bentobox.bentobox.managers.LocalesManager#getAvailableLocales(boolean sort)}
     * @since 1.22.1
     */

    public boolean setTranslatedDescription(Locale locale, String description) {
        return BentoBox.getInstance().getLocalesManager().setTranslation(locale, getDescriptionReference(), description);
    }

    @Override
    public String toString() {
        return "Flag [id=" + id + "]";
    }

    @Override
    public int compareTo(Flag o) {
        return getID().compareTo(o.getID());
    }

    /**
     * Builder for making flags
     * @author tastybento, Poslovitch
     */
    public static class Builder {
        // Mandatory fields
        private final String id;
        private final Material icon;

        // Listener
        private Listener listener;

        // Type - is defaulted to PROTECTION
        private Type type = Type.PROTECTION;

        // Default settings
        private boolean defaultSetting = false;
        private int defaultRank = RanksManager.MEMBER_RANK;

        // ClickHandler - default depends on the type
        private PanelItem.ClickHandler clickHandler;

        // Whether there is a sub-panel or not
        private boolean usePanel = false;

        // GameModeAddon
        private GameModeAddon gameModeAddon;
        private Addon addon;

        // Cooldown
        private int cooldown;

        // Mode
        private Mode mode = Mode.EXPERT;

        // Subflags
        private final Set<Flag> subflags;

        /**
         * Builder for making flags
         * @param id - a unique id that MUST be the same as the enum of the flag
         * @param icon - a material that will be used as the icon in the GUI
         */
        public Builder(String id, Material icon) {
            this.id = id;
            this.icon = icon;
            this.subflags = new HashSet<>();
        }

        /**
         * The listener that should be instantiated to handle events this flag cares about.
         * If the listener class already exists, then do not create it again in another flag.
         * @param listener - Bukkit Listener
         * @return Builder
         */
        public Builder listener(Listener listener) {
            this.listener = listener;
            return this;
        }

        /**
         * The type of flag.
         * @param type {@link Type#PROTECTION}, {@link Type#SETTING} or {@link Type#WORLD_SETTING}
         * @return Builder
         */
        public Builder type(Type type) {
            this.type = type;
            return this;
        }

        /**
         * The click handler to use when this icon is clicked
         * @param clickHandler - click handler
         * @return Builder
         */
        public Builder clickHandler(PanelItem.ClickHandler clickHandler) {
            this.clickHandler = clickHandler;
            return this;
        }

        /**
         * Set the default setting for {@link Type#SETTING} or {@link Type#WORLD_SETTING} flags
         * @param defaultSetting - true or false
         * @return Builder
         */
        public Builder defaultSetting(boolean defaultSetting) {
            this.defaultSetting = defaultSetting;
            return this;
        }

        /**
         * Set the default rank for {@link Type#PROTECTION} flags
         * @param defaultRank - default rank
         * @return Builder
         */
        public Builder defaultRank(int defaultRank) {
            this.defaultRank = defaultRank;
            return this;
        }

        /**
         * Set that this flag icon will open up a sub-panel
         * @param usePanel - true or false
         * @return Builder
         */
        public Builder usePanel(boolean usePanel) {
            this.usePanel = usePanel;
            return this;
        }

        /**
         * Make this flag specific to this gameMode
         * @param gameModeAddon game mode addon
         * @return Builder
         */
        public Builder setGameMode(GameModeAddon gameModeAddon) {
            this.gameModeAddon = gameModeAddon;
            return this;
        }

        /**
         * The addon registering this flag. Ensure this is set to enable the addon to be reloaded.
         * @param addon addon
         * @return Builder
         * @since 1.5.0
         */
        public Builder addon(Addon addon) {
            this.addon = addon;
            return this;
        }

        /**
         * Set a cooldown for {@link Type#SETTING} flag. Only applicable for settings.
         * @param cooldown in seconds
         * @return Builder
         * @since 1.6.0
         */
        public Builder cooldown(int cooldown) {
            this.cooldown = cooldown;
            return this;
        }

        /**
         * Set the flag difficulty mode.
         * Defaults to {@link Flag.Mode#EXPERT}.
         * @param mode - difficulty mode
         * @return Builder - flag builder
         * @since 1.6.0
         */
        public Builder mode(Mode mode) {
            this.mode = mode;
            return this;
        }

        /**
         * Add subflags and designate this flag as a parent flag.
         * Subflags have their state simultaneously changed with the parent flag.
         * Take extra care to ensure that subflags have the same number of possible values as the parent flag.
         * @param flags all Flags that are subflags
         * @return Builder - flag builder
         * @since 1.17.1
         */
        public Builder subflags(Flag... flags) {
            this.subflags.addAll(Arrays.asList(flags));
            return this;
        }

        /**
         * Build the flag
         * @return Flag
         */
        public Flag build() {
            // If no clickHandler has been set, then apply default ones
            if (clickHandler == null) {
                switch (type) {
                case SETTING -> clickHandler = new IslandToggleClick(id);
                case WORLD_SETTING -> clickHandler = new WorldToggleClick(id);
                default -> clickHandler = new CycleClick(id);
                }
            }

            return new Flag(this);
        }
    }

}