Blacksmith/src/main/java/net/knarcraft/blacksmith/config/scrapper/ScrapperNPCSettings.java

package net.knarcraft.blacksmith.config.scrapper;

import net.citizensnpcs.api.util.DataKey;
import net.knarcraft.blacksmith.config.SettingValueType;
import net.knarcraft.blacksmith.config.TraitSettings;
import net.knarcraft.blacksmith.util.ConfigHelper;
import net.knarcraft.blacksmith.util.ItemHelper;
import org.bukkit.Material;

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

public class ScrapperNPCSettings implements TraitSettings<ScrapperSetting> {

    private final Map<ScrapperSetting, Object> currentValues = new HashMap<>();
    private final GlobalScrapperSettings globalScrapperSettings;
    private final List<Material> salvageAbleItems = new ArrayList<>();

    /**
     * Instantiates a new scrapper NPC settings object
     *
     * @param globalScrapperSettings <p>The global settings object to get default values from</p>
     */
    public ScrapperNPCSettings(GlobalScrapperSettings globalScrapperSettings) {
        this.globalScrapperSettings = globalScrapperSettings;
    }

    /**
     * Loads variables from the given data key
     *
     * @param key <p>The data key to load variables from</p>
     */
    public void loadVariables(DataKey key) {
        for (ScrapperSetting setting : ScrapperSetting.values()) {
            if (key.keyExists(setting.getChildPath())) {
                currentValues.put(setting, key.getRaw(setting.getChildPath()));
            }
        }
    }

    /**
     * Saves variables to the given data key
     *
     * @param key <p>The data key to save variables to</p>
     */
    public void saveVariables(DataKey key) {
        for (ScrapperSetting setting : ScrapperSetting.values()) {
            key.setRaw(setting.getChildPath(), currentValues.get(setting));
        }
    }

    /**
     * Changes one setting to the given value
     *
     * @param setting  <p>The setting to change</p>
     * @param newValue <p>The new value of the setting</p>
     */
    public void changeValue(ScrapperSetting setting, Object newValue) {
        if (setting.getValueType() == SettingValueType.STRING_LIST ||
                setting.getValueType() == SettingValueType.REFORGE_ABLE_ITEMS) {
            //Workaround to make sure it's treated as the correct type
            currentValues.put(setting, newValue == null ? null : ConfigHelper.asStringList(newValue));
        } else {
            currentValues.put(setting, newValue);
        }
        if (setting == ScrapperSetting.SALVAGE_ABLE_ITEMS) {
            updateSalvageAbleItems();
        }
    }

    /**
     * Updates the reforge-able items according to the current value of the setting
     */
    private void updateSalvageAbleItems() {
        this.salvageAbleItems.clear();
        List<String> materialStrings = ConfigHelper.asStringList(getValue(ScrapperSetting.SALVAGE_ABLE_ITEMS));
        if (materialStrings != null) {
            this.salvageAbleItems.addAll(ItemHelper.getItems(materialStrings, !extendedSalvageEnabled()));
        }
    }

    /**
     * Gets the raw current value of a setting
     *
     * @param setting <p>The setting to get the value of</p>
     * @return <p>The current value of the setting</p>
     */
    public Object getRawValue(ScrapperSetting setting) {
        return currentValues.get(setting);
    }

    @Override
    public String getBusyWithPlayerMessage() {
        return asString(ScrapperSetting.BUSY_WITH_PLAYER_MESSAGE);
    }

    @Override
    public String getBusyWorkingMessage() {
        return asString(ScrapperSetting.BUSY_WITH_SALVAGE_MESSAGE);
    }

    @Override
    public String getStartWorkingMessage() {
        return asString(ScrapperSetting.START_SALVAGE_MESSAGE);
    }

    /**
     * Gets the message to display when a scrapper has successfully scrapped an item
     *
     * @return <p>The salvage success message</p>
     */
    public String getSuccessMessage() {
        return asString(ScrapperSetting.SUCCESS_SALVAGE_MESSAGE);
    }

    /**
     * Gets the message to display when a scrapper fails to salvage an item
     *
     * @return <p>The salvage fail message</p>
     */
    public String getFailMessage() {
        return asString(ScrapperSetting.FAIL_SALVAGE_MESSAGE);
    }

    @Override
    public String getCoolDownUnexpiredMessage() {
        return asString(ScrapperSetting.COOL_DOWN_UNEXPIRED_MESSAGE);
    }

    /**
     * The message displayed if a player presents a different item after seeing the price to salvage an item
     */
    public String getItemChangedMessage() {
        return asString(ScrapperSetting.ITEM_UNEXPECTEDLY_CHANGED_MESSAGE);
    }

    /**
     * Gets the minimum delay used to wait for a salvaging to finish.
     *
     * @return <p>The minimum salvage delay</p>
     */
    public int getMinSalvageDelay() {
        return asInt(ScrapperSetting.MIN_SALVAGE_DELAY);
    }

    /**
     * Gets the maximum delay used to wait for a salvaging to finish
     *
     * @return <p>The maximum salvage delay</p>
     */
    public int getMaxSalvageDelay() {
        return asInt(ScrapperSetting.MAX_SALVAGE_DELAY);
    }

    /**
     * Gets the cool-down between each salvaging
     *
     * @return <p>The salvage cool-down</p>
     */
    public int getSalvageCoolDown() {
        return asInt(ScrapperSetting.SALVAGE_COOL_DOWN);
    }

    /**
     * Gets whether an item should be dropped on the ground instead of being given to the player
     *
     * @return <p>Whether to drop reforged items on the ground</p>
     */
    public boolean getDropItem() {
        return ConfigHelper.asBoolean(getValue(ScrapperSetting.DROP_ITEM));
    }

    @Override
    public boolean getDisableCoolDown() {
        return asInt(ScrapperSetting.SALVAGE_COOL_DOWN) <= 0;
    }

    /**
     * Gets whether to disable the delay between starting reforging and the reforging finishing
     *
     * @return <p>Whether to disable the reforge delay</p>
     */
    public boolean getDisableDelay() {
        return asInt(ScrapperSetting.MAX_SALVAGE_DELAY) <= 0;
    }

    /**
     * Gets the chance of a salvaging to fail
     *
     * @return <p>The chance of a salvaging to fail</p>
     */
    public int getFailChance() {
        return asInt(ScrapperSetting.FAIL_SALVAGE_CHANCE);
    }

    /**
     * Gets the given value as an integer
     *
     * <p>This will throw an exception if used for a non-integer setting</p>
     *
     * @param setting <p>The setting to get the value of</p>
     * @return <p>The value of the given setting as an integer</p>
     */
    private int asInt(ScrapperSetting setting) {
        return ConfigHelper.asInt(getValue(setting));
    }

    /**
     * Gets the string value of the given setting
     *
     * @param setting <p>The setting to get the value of</p>
     * @return <p>The value of the given setting as a string</p>
     */
    private String asString(ScrapperSetting setting) {
        return getValue(setting).toString();
    }

    /**
     * Gets the value of a setting, using the default if not set
     *
     * @param setting <p>The setting to get the value of</p>
     * @return <p>The current value</p>
     */
    private Object getValue(ScrapperSetting setting) {
        Object value = currentValues.get(setting);
        //If not set, use the default value from the config.yml file
        if (value == null) {
            Map<ScrapperSetting, Object> defaultNPCSettings = globalScrapperSettings.getDefaultNPCSettings();
            if (defaultNPCSettings.containsKey(setting)) {
                value = defaultNPCSettings.get(setting);
            }
        }
        //If not set in config.yml, use the default value from the enum
        if (value == null) {
            value = setting.getDefaultValue();
        }
        return value;
    }

    /**
     * Gets all item types this NPC is able to salvage
     *
     * @return <p>All salvageable items</p>
     */
    public List<Material> getSalvageAbleItems() {
        Object currentValue = currentValues.get(ScrapperSetting.SALVAGE_ABLE_ITEMS);
        if (currentValue == null || String.valueOf(currentValue).isEmpty()) {
            return globalScrapperSettings.getSalvageAbleItems();
        } else {
            return new ArrayList<>(this.salvageAbleItems);
        }
    }

    /**
     * Whether extended salvaging is enabled
     *
     * <p>When not extended, only repairable items can be salvaged. When extended, any item produced using a crafting
     * recipe or a smithing transformation can be salvaged. This does not include smelting or similar.</p>
     *
     * @return <p>True if extended salvaging is enabled</p>
     */
    public boolean extendedSalvageEnabled() {
        return ConfigHelper.asBoolean(getValue(ScrapperSetting.EXTENDED_SALVAGE_ENABLED));
    }

    /**
     * Gets the title of this scrapper NPC
     *
     * <p>The title is used to specify scrapper sub-types in order to make it clear which items a scrapper can salvage.
     * For example, an armor-scrapper would only be able to salvage armor pieces.</p>
     *
     * @return <p>The title of this scrapper NPC</p>
     */
    public String getScrapperTitle() {
        return asString(ScrapperSetting.SCRAPPER_TITLE);
    }

    /**
     * Gets the message to display if this NPC is given an item it cannot salvage
     *
     * @return <p>The message to display</p>
     */
    public String getInvalidItemMessage() {
        return asString(ScrapperSetting.INVALID_ITEM_MESSAGE);
    }

}