package net.knarcraft.blacksmith.config;

import net.knarcraft.blacksmith.BlacksmithPlugin;
import net.knarcraft.blacksmith.util.ItemHelper;
import org.bukkit.Material;
import org.bukkit.Tag;
import org.jetbrains.annotations.NotNull;

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

/**
 * A representation of the presets for different kinds of smiths
 */
public enum SmithPreset {

    /**
     * A blacksmith capable of re-forging everything
     */
    BLACKSMITH(new SmithPresetFilter[]{SmithPresetFilter.GOLD, SmithPresetFilter.IRON, SmithPresetFilter.DIAMOND,
            SmithPresetFilter.NETHERITE}),

    /**
     * A blacksmith capable of re-forging all weapons (including shields)
     */
    WEAPON_SMITH(new SmithPresetFilter[]{SmithPresetFilter.BOW, SmithPresetFilter.SWORD, SmithPresetFilter.RANGED}),

    /**
     * A blacksmith capable of re-forging all armor
     */
    ARMOR_SMITH(new SmithPresetFilter[]{SmithPresetFilter.LEATHER, SmithPresetFilter.IRON, SmithPresetFilter.CHAINMAIL,
            SmithPresetFilter.GOLD, SmithPresetFilter.DIAMOND, SmithPresetFilter.NETHERITE, SmithPresetFilter.HELMET,
            SmithPresetFilter.BOOTS, SmithPresetFilter.LEGGINGS, SmithPresetFilter.CHESTPLATE}),

    /**
     * A blacksmith capable of re-forging all tools (hoe, axe, shovel, pickaxe, flint and steel, shears, fishing rod)
     */
    TOOL_SMITH(new SmithPresetFilter[]{SmithPresetFilter.WOOD, SmithPresetFilter.STONE, SmithPresetFilter.IRON,
            SmithPresetFilter.GOLD, SmithPresetFilter.DIAMOND, SmithPresetFilter.NETHERITE, SmithPresetFilter.PICKAXE,
            SmithPresetFilter.AXE, SmithPresetFilter.HOE, SmithPresetFilter.SHOVEL, SmithPresetFilter.MISC});

    private final SmithPresetFilter[] filters;
    private static final Map<SmithPreset, Set<String>> presetMaterialNames = new HashMap<>();
    private static final Map<SmithPreset, Map<SmithPresetFilter, Set<String>>> filterMaterialNames = new HashMap<>();
    private static Set<Material> armor = null;
    private static Set<Material> ranged = null;
    private static Set<Material> weapons = null;
    private static Set<Material> tools = null;

    /**
     * Instantiates a new smith preset
     *
     * @param filters <p>The filters applicable to this preset</p>
     */
    SmithPreset(@NotNull SmithPresetFilter[] filters) {
        this.filters = filters;
    }

    /**
     * Gets whether this preset supports the given filter
     *
     * @param filter <p>The filter to check</p>
     * @return <p>True if the filter is supported</p>
     */
    public boolean supportsFilter(@NotNull SmithPresetFilter filter) {
        return List.of(filters).contains(filter);
    }

    /**
     * Gets all filters supported by this preset
     *
     * @return <p>The filters supported by this preset</p>
     */
    @NotNull
    public List<SmithPresetFilter> getSupportedFilters() {
        return List.of(filters);
    }

    /**
     * Gets the names of all available smith presets
     *
     * @return <p>All available smith presets</p>
     */
    @NotNull
    public static List<String> getPresetNames() {
        List<String> presetNames = new ArrayList<>();
        for (SmithPreset preset : SmithPreset.values()) {
            presetNames.add(preset.name());
        }
        return presetNames;
    }

    /**
     * Replaces the given string if it's a smith type preset
     *
     * @param possiblePreset <p>The string that might be a preset</p>
     * @return <p>The string, possibly with the preset replaced</p>
     */
    @NotNull
    public static String replacePreset(@NotNull String possiblePreset) {
        boolean negated = false;

        String upperCasedPreset = possiblePreset.replace('-', '_').toUpperCase();
        if (possiblePreset.startsWith("-")) {
            negated = true;
        }

        if ((negated && !upperCasedPreset.startsWith("_PRESET:")) ||
                (!negated && !upperCasedPreset.startsWith("PRESET:"))) {
            return possiblePreset;
        }

        //Strip the "-" here to prevent stripping for material names
        if (negated) {
            upperCasedPreset = upperCasedPreset.substring(1);
        }

        //Parse the input
        SmithPresetFilter filter = null;
        SmithPreset preset;
        try {
            String[] parts = upperCasedPreset.split(":");

            if (parts.length > 2) {
                filter = SmithPresetFilter.valueOf(parts[2]);
            }
            preset = SmithPreset.valueOf(parts[1]);
        } catch (IllegalArgumentException exception) {
            /* This case means that either the preset or the filter given is invalid, and thus the preset string should
               be ignored to prevent any problems. */
            BlacksmithPlugin.warn(String.format("The smith preset %s is invalid, and will be ignored. Please fix it!",
                    possiblePreset));
            return "";
        }

        // Check if the preset result has been stored
        Set<String> materialNames = null;
        if (filter == null) {
            if (presetMaterialNames.containsKey(preset)) {
                materialNames = presetMaterialNames.get(preset);
            }
        } else {
            if (filterMaterialNames.containsKey(preset) && filterMaterialNames.get(preset).containsKey(filter)) {
                materialNames = filterMaterialNames.get(preset).get(filter);
            }
        }

        //Return the list of materials included in the preset
        if (materialNames == null) {
            if (filter != null) {
                materialNames = preset.getMaterialNames(filter);
                filterMaterialNames.putIfAbsent(preset, new HashMap<>());
                filterMaterialNames.get(preset).put(filter, materialNames);
            } else {
                materialNames = preset.getMaterialNames();
                presetMaterialNames.put(preset, materialNames);
            }
        }
        if (negated) {
            materialNames = negateMaterials(materialNames);
        }
        return String.join(",", materialNames);
    }

    /**
     * Gets the materials included in this preset, filtered using the given filter
     *
     * @param filter <p>The filter to use for filtering</p>
     * @return <p>The materials included in this preset, filtered using the given filter</p>
     */
    @NotNull
    public Set<Material> getFilteredMaterials(SmithPresetFilter filter) {
        Set<Material> materials = new HashSet<>(this.getMaterials());
        materials.removeIf((item) -> !filter.isIncluded(item));
        return materials;
    }

    /**
     * Gets all materials included in this preset
     *
     * @return <p>All materials in this preset</p>
     */
    @NotNull
    public Set<Material> getMaterials() {
        return switch (this) {
            case BLACKSMITH -> ItemHelper.getAllReforgeAbleMaterials();
            case WEAPON_SMITH -> getWeapons();
            case ARMOR_SMITH -> getArmor();
            case TOOL_SMITH -> getTools();
        };
    }

    /**
     * Gets all ranged weapon materials
     *
     * @return <p>All ranged weapon materials</p>
     */
    @NotNull
    private Set<Material> getRanged() {
        if (ranged == null) {
            ranged = new HashSet<>();
            ranged.add(Material.TRIDENT);
            ranged.add(Material.BOW);
            ranged.add(Material.CROSSBOW);
        }
        return ranged;
    }

    /**
     * Gets all tool materials
     *
     * @return <p>All tool materials</p>
     */
    @NotNull
    private Set<Material> getTools() {
        if (tools == null) {
            tools = new HashSet<>();
            tools.addAll(Tag.ITEMS_HOES.getValues());
            tools.addAll(Tag.ITEMS_SHOVELS.getValues());
            tools.addAll(Tag.ITEMS_AXES.getValues());
            tools.addAll(Tag.ITEMS_PICKAXES.getValues());
            tools.add(Material.FLINT_AND_STEEL);
            tools.add(Material.FISHING_ROD);
            tools.add(Material.SHEARS);
        }
        return tools;
    }

    /**
     * Gets all weapon materials
     *
     * @return <p>All weapon materials</p>
     */
    @NotNull
    private Set<Material> getWeapons() {
        if (weapons == null) {
            weapons = new HashSet<>(getSwords());
            weapons.addAll(getRanged());
            weapons.add(Material.SHIELD);
        }
        return weapons;
    }

    /**
     * Gets all sword materials
     *
     * @return <p>All sword materials</p>
     */
    @NotNull
    private Set<Material> getSwords() {
        return Tag.ITEMS_SWORDS.getValues();
    }

    /**
     * Gets all types of armor
     *
     * @return <p>All armor types</p>
     */
    @NotNull
    private Set<Material> getArmor() {
        if (armor == null) {
            armor = new HashSet<>();
            armor.addAll(getMaterialsEndingWith("HELMET"));
            armor.addAll(getMaterialsEndingWith("CHESTPLATE"));
            armor.addAll(getMaterialsEndingWith("LEGGINGS"));
            armor.addAll(getMaterialsEndingWith("BOOTS"));
            armor.add(Material.ELYTRA);
        }
        return armor;
    }

    /**
     * Gets all materials ending with the given string
     *
     * @param end <p>The string to look for</p>
     * @return <p>The resulting materials</p>
     */
    @NotNull
    private Set<Material> getMaterialsEndingWith(@NotNull String end) {
        Set<Material> matchedMaterials = new HashSet<>();
        for (Material material : ItemHelper.getAllReforgeAbleMaterials()) {
            if (!material.name().startsWith("LEGACY") && material.name().endsWith(end)) {
                matchedMaterials.add(material);
            }
        }
        return matchedMaterials;
    }

    /**
     * Gets material names of all materials reforge-able by this smith preset
     *
     * @return <p>All material names for this smith preset</p>
     */
    @NotNull
    private Set<String> getMaterialNames() {
        return getNames(this.getMaterials());
    }

    /**
     * Gets material names of all materials reforge-able by this smith
     *
     * @param filter <p>The filter used for filtering materials</p>
     * @return <p>All material names for this smith</p>
     */
    @NotNull
    private Set<String> getMaterialNames(@NotNull SmithPresetFilter filter) {
        return getNames(this.getFilteredMaterials(filter));
    }

    /**
     * Gets a list of material names from the given materials
     *
     * @param materials <p>The materials to get the names of</p>
     * @return <p>The names of the materials</p>
     */
    @NotNull
    private Set<String> getNames(@NotNull Set<Material> materials) {
        Set<String> items = new HashSet<>();
        for (Material material : materials) {
            items.add(material.name().toLowerCase().replace("_", "-"));
        }
        return items;
    }

    /**
     * Negates the given material names
     *
     * @param materials <p>The material names to negate</p>
     * @return <p>The negated material names</p>
     */
    @NotNull
    private static Set<String> negateMaterials(@NotNull Set<String> materials) {
        Set<String> negatedMaterials = new HashSet<>(materials.size());
        materials.forEach((material) -> {
            if (material != null && !material.isBlank()) {
                negatedMaterials.add("-" + material);
            }
        });
        return negatedMaterials;
    }

}