addon-challenges/src/main/java/world/bentobox/challenges/panel/CommonPanel.java

//
// Created by BONNe
// Copyright - 2021
//

package world.bentobox.challenges.panel;

import java.time.Duration;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

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

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.util.Util;
import world.bentobox.challenges.ChallengesAddon;
import world.bentobox.challenges.database.object.Challenge;
import world.bentobox.challenges.database.object.ChallengeLevel;
import world.bentobox.challenges.database.object.requirements.InventoryRequirements;
import world.bentobox.challenges.database.object.requirements.IslandRequirements;
import world.bentobox.challenges.database.object.requirements.OtherRequirements;
import world.bentobox.challenges.database.object.requirements.StatisticRequirements;
import world.bentobox.challenges.managers.ChallengesManager;
import world.bentobox.challenges.utils.Constants;
import world.bentobox.challenges.utils.LevelStatus;
import world.bentobox.challenges.utils.Utils;

/**
 * This class contains common methods for all panels.
 */
public abstract class CommonPanel {
    /**
     * This is default constructor for all classes that extends CommonPanel.
     *
     * @param addon ChallengesAddon instance.
     * @param user  User who opens panel.
     */
    protected CommonPanel(ChallengesAddon addon, User user, World world, String topLabel, String permissionPrefix) {
        this.addon = addon;
        this.world = world;
        this.manager = addon.getChallengesManager();
        this.user = user;

        this.topLabel = topLabel;
        this.permissionPrefix = permissionPrefix;

        this.parentPanel = null;

        this.returnButton = new PanelItemBuilder().name(this.user.getTranslation(Constants.BUTTON + "quit.name"))
                .description(this.user.getTranslationOrNothing(Constants.BUTTON + "quit.description")).description("")
                .description(this.user.getTranslationOrNothing(Constants.TIPS + "click-to-quit"))
                .icon(Material.OAK_DOOR).clickHandler((panel, user1, clickType, i) -> {
                    this.user.closeInventory();
                    return true;
                }).build();
    }

    /**
     * This is default constructor for all classes that extends CommonPanel.
     *
     * @param parentPanel Parent panel of current panel.
     */
    protected CommonPanel(@NonNull CommonPanel parentPanel) {
        this.addon = parentPanel.addon;
        this.manager = parentPanel.manager;
        this.user = parentPanel.user;
        this.world = parentPanel.world;

        this.topLabel = parentPanel.topLabel;
        this.permissionPrefix = parentPanel.permissionPrefix;

        this.parentPanel = parentPanel;

        this.returnButton = new PanelItemBuilder().name(this.user.getTranslation(Constants.BUTTON + "return.name"))
                .description(this.user.getTranslationOrNothing(Constants.BUTTON + "return.description")).description("")
                .description(this.user.getTranslationOrNothing(Constants.TIPS + "click-to-return"))
                .icon(Material.OAK_DOOR).clickHandler((panel, user1, clickType, i) -> {
                    this.parentPanel.build();
                    return true;
                }).build();
    }

    /**
     * This method allows building panel.
     */
    protected abstract void build();

    /**
     * This method reopens given panel.
     * 
     * @param panel Panel that must be reopened.
     */
    public static void reopen(CommonPanel panel) {
        panel.build();
    }

    // ---------------------------------------------------------------------
    // Section: Common methods
    // ---------------------------------------------------------------------

    /**
     * This method generates and returns given challenge description. It is used
     * here to avoid multiple duplicates, as it would be nice to have single place
     * where challenge could be generated.
     * 
     * @param challenge Challenge which description must be generated.
     * @param target    target player.
     * @return List of strings that will be used in challenges description.
     */
    protected List<String> generateChallengeDescription(Challenge challenge, @Nullable User target) {
        // Some values to avoid over checking.
        final boolean isCompletedOnce = target != null
                && this.manager.isChallengeComplete(target.getUniqueId(), this.world, challenge);

        final long doneTimes = target != null && challenge.isRepeatable()
                ? this.manager.getChallengeTimes(target, this.world, challenge)
                : (isCompletedOnce ? 0 : 1);

        boolean isCompletedAll = isCompletedOnce
                && (!challenge.isRepeatable() || challenge.getMaxTimes() > 0 && doneTimes >= challenge.getMaxTimes());

        final String reference = Constants.DESCRIPTIONS + "challenge.";

        // Get description from custom translations
        String description = this.user
                .getTranslationOrNothing("challenges.challenges." + challenge.getUniqueId() + ".description");

        if (description.isEmpty()) {
            // Get data from object in single string.
            description = Util.translateColorCodes(String.join("\n", challenge.getDescription()));
        }

        // Non-memory optimal code used for easier debugging and nicer code layout for
        // my eye :)
        // Get status in single string
        String status = this.generateChallengeStatus(isCompletedOnce, isCompletedAll, doneTimes,
                challenge.getMaxTimes());
        // Get requirements in single string
        String requirements = isCompletedAll ? "" : this.generateRequirements(challenge, target);
        // Get rewards in single string
        String rewards = isCompletedAll ? "" : this.generateRewards(challenge, isCompletedOnce);
        // Get coolDown in singe string
        String coolDown = isCompletedAll || challenge.getTimeout() <= 0 ? "" : this.generateCoolDown(challenge, target);

        if (!description.replaceAll("(?m)^[ \\t]*\\r?\\n", "").isEmpty()) {
            String returnString = this.user.getTranslationOrNothing(reference + "lore", "[requirements]", requirements,
                    "[rewards]", rewards, "[status]", status, "[cooldown]", coolDown);

            // remove empty lines from the generated text.
            List<String> collect = Arrays.stream(returnString.replaceAll("(?m)^[ \\t]*\\r?\\n", "").split("\n"))
                    .collect(Collectors.toList());

            // find and replace description from collected blocks.

            for (int i = 0; i < collect.size(); i++) {
                if (collect.get(i).contains(Constants.PARAMETER_DESCRIPTION)) {
                    collect.set(i, collect.get(i).replace(Constants.PARAMETER_DESCRIPTION, description));
                }
            }

            return collect;
        } else {
            String returnString = this.user.getTranslationOrNothing(reference + "lore", Constants.PARAMETER_DESCRIPTION,
                    description, "[requirements]", requirements, "[rewards]", rewards, "[status]", status, "[cooldown]",
                    coolDown);

            // Remove empty lines and returns as a list.

            return Arrays.stream(returnString.replaceAll("(?m)^[ \\t]*\\r?\\n", "").split("\n"))
                    .collect(Collectors.toList());
        }
    }

    /**
     * Generate cool down string.
     *
     * @param challenge the challenge
     * @param target    the target
     * @return the string
     */
    private String generateCoolDown(Challenge challenge, @Nullable User target) {
        final String reference = Constants.DESCRIPTIONS + "challenge.cooldown.";

        String coolDown;

        if (target != null && this.manager.isBreachingTimeOut(target, this.world, challenge)) {
            long missing = this.manager.getLastCompletionDate(this.user, this.world, challenge) + challenge.getTimeout()
                    - System.currentTimeMillis();

            coolDown = this.user.getTranslation(reference + "wait-time", "[time]",
                    Utils.parseDuration(Duration.ofMillis(missing), this.user));
        } else {
            coolDown = "";
        }

        String timeout = this.user.getTranslation(reference + "timeout", "[time]",
                Utils.parseDuration(Duration.ofMillis(challenge.getTimeout()), this.user));

        return this.user.getTranslation(reference + "lore", "[timeout]", timeout, "[wait-time]", coolDown);
    }

    /**
     * This method generate requirements description for given challenge.
     * 
     * @param challenge Challenge which requirements must be generated.
     * @return Lore message with requirements.
     */
    private String generateRequirements(Challenge challenge, @Nullable User target) {
        final String reference = Constants.DESCRIPTIONS + "challenge.requirements.";

        String environment;

        if (challenge.getEnvironment().isEmpty() || challenge.getEnvironment().size() == 3) {
            // If challenge can be completed everywhere, do not display requirement.
            environment = "";
        } else if (challenge.getEnvironment().size() == 1) {
            environment = this.user.getTranslationOrNothing(reference + "environment-single",
                    Constants.PARAMETER_ENVIRONMENT,
                    Utils.prettifyObject(challenge.getEnvironment().iterator().next(), this.user));
        } else {
            StringBuilder builder = new StringBuilder();
            builder.append(this.user.getTranslationOrNothing(reference + "environment-title"));
            challenge.getEnvironment().stream().sorted().forEach(en -> {
                builder.append("\n");
                builder.append(this.user.getTranslationOrNothing(reference + "environment-single",
                        Constants.PARAMETER_ENVIRONMENT, Utils.prettifyObject(en, this.user)));
            });

            environment = builder.toString();
        }

        String permissions;

        if (!challenge.getRequirements().getRequiredPermissions().isEmpty()) {
            // Yes list duplication for complete menu.
            List<String> missingPermissions = challenge.getRequirements().getRequiredPermissions().stream()
                    .filter(permission -> target == null || !target.hasPermission(permission)).sorted().toList();

            StringBuilder permissionBuilder = new StringBuilder();

            if (missingPermissions.size() == 1) {
                permissionBuilder.append(this.user.getTranslationOrNothing(reference + "permission-single",
                        Constants.PARAMETER_PERMISSION, missingPermissions.get(0)));
            } else if (!missingPermissions.isEmpty()) {
                permissionBuilder.append(this.user.getTranslationOrNothing(reference + "permissions-title"));
                missingPermissions.forEach(permission -> {
                    permissionBuilder.append("\n");
                    permissionBuilder.append(this.user.getTranslationOrNothing(reference + "permissions-list",
                            Constants.PARAMETER_PERMISSION, permission));
                });
            }

            permissions = permissionBuilder.toString();
        } else {
            permissions = "";
        }

        String typeRequirement = switch (challenge.getChallengeType()) {
        case INVENTORY_TYPE -> this.generateInventoryChallenge(challenge.getRequirements());
        case ISLAND_TYPE -> this.generateIslandChallenge(challenge.getRequirements());
        case OTHER_TYPE -> this.generateOtherChallenge(challenge.getRequirements());
        case STATISTIC_TYPE -> this.generateStatisticChallenge(challenge.getRequirements());
        };

        return this.user.getTranslationOrNothing(reference + "lore", Constants.PARAMETER_ENVIRONMENT, environment,
                "[type-requirement]", typeRequirement, "[permissions]", permissions);
    }

    /**
     * This method generates lore message for island requirement.
     * 
     * @param requirement Island Requirement.
     * @return Requirement lore message.
     */
    private String generateIslandChallenge(IslandRequirements requirement) {
        final String reference = Constants.DESCRIPTIONS + "challenge.requirements.island.";

        String blocks;

        if (!requirement.getRequiredBlocks().isEmpty()) {
            StringBuilder builder = new StringBuilder();
            builder.append(this.user.getTranslationOrNothing(reference + "blocks-title"));
            requirement.getRequiredBlocks().entrySet().stream().sorted(Map.Entry.comparingByKey()).forEach(entry -> {
                builder.append("\n");

                if (entry.getValue() > 1) {
                    builder.append(this.user.getTranslationOrNothing(reference + "blocks-value",
                            Constants.PARAMETER_NUMBER, String.valueOf(entry.getValue()), Constants.PARAMETER_MATERIAL,
                            Utils.prettifyObject(entry.getKey(), this.user)));
                } else {
                    builder.append(this.user.getTranslationOrNothing(reference + "block-value",
                            Constants.PARAMETER_MATERIAL, Utils.prettifyObject(entry.getKey(), this.user)));
                }
            });

            blocks = builder.toString();
        } else {
            blocks = "";
        }

        String entities;

        if (!requirement.getRequiredEntities().isEmpty()) {
            StringBuilder builder = new StringBuilder();
            builder.append(this.user.getTranslationOrNothing(reference + "entities-title"));
            requirement.getRequiredEntities().entrySet().stream().sorted(Map.Entry.comparingByKey()).forEach(entry -> {
                builder.append("\n");

                if (entry.getValue() > 1) {
                    builder.append(this.user.getTranslationOrNothing(reference + "entities-value",
                            Constants.PARAMETER_NUMBER, String.valueOf(entry.getValue()), Constants.PARAMETER_ENTITY,
                            Utils.prettifyObject(entry.getKey(), this.user)));
                } else {
                    builder.append(this.user.getTranslationOrNothing(reference + "entity-value",
                            Constants.PARAMETER_ENTITY, Utils.prettifyObject(entry.getKey(), this.user)));
                }
            });

            entities = builder.toString();
        } else {
            entities = "";
        }

        String searchRadius = this.user.getTranslationOrNothing(reference + "search-radius", Constants.PARAMETER_NUMBER,
                String.valueOf(requirement.getSearchRadius()));

        String warningBlocks = requirement.isRemoveBlocks()
                ? this.user.getTranslationOrNothing(reference + "warning-block")
                : "";
        String warningEntities = requirement.isRemoveEntities()
                ? this.user.getTranslationOrNothing(reference + "warning-entity")
                : "";

        return this.user.getTranslationOrNothing(reference + "lore", "[blocks]", blocks, "[entities]", entities,
                "[warning-block]", warningBlocks, "[warning-entity]", warningEntities, "[search-radius]", searchRadius);
    }

    /**
     * This method generates lore message for inventory requirement.
     * 
     * @param requirement Inventory Requirement.
     * @return Requirement lore message.
     */
    private String generateInventoryChallenge(InventoryRequirements requirement) {
        final String reference = Constants.DESCRIPTIONS + "challenge.requirements.inventory.";

        String items;

        if (!requirement.getRequiredItems().isEmpty()) {
            StringBuilder builder = new StringBuilder();
            builder.append(this.user.getTranslationOrNothing(reference + "item-title"));
            Utils.groupEqualItems(requirement.getRequiredItems(), requirement.getIgnoreMetaData()).stream()
                    .sorted(Comparator.comparing(ItemStack::getType)).forEach(itemStack -> {
                        builder.append("\n");

                        if (itemStack.getAmount() > 1) {
                            builder.append(this.user.getTranslationOrNothing(reference + "items-value", "[number]",
                                    String.valueOf(itemStack.getAmount()), "[item]",
                                    Utils.prettifyObject(itemStack, this.user)));
                        } else {
                            builder.append(this.user.getTranslationOrNothing(reference + "item-value", "[item]",
                                    Utils.prettifyObject(itemStack, this.user)));
                        }
                    });

            items = builder.toString();
        } else {
            items = "";
        }

        String warning = requirement.isTakeItems() ? this.user.getTranslationOrNothing(reference + "warning") : "";

        return this.user.getTranslationOrNothing(reference + "lore", "[items]", items, "[warning]", warning);
    }

    /**
     * This method generates lore message for other requirement.
     * 
     * @param requirement Other Requirement.
     * @return Requirement lore message.
     */
    private String generateOtherChallenge(OtherRequirements requirement) {
        final String reference = Constants.DESCRIPTIONS + "challenge.requirements.other.";

        String experience = requirement.getRequiredExperience() <= 0 ? ""
                : this.user.getTranslationOrNothing(reference + "experience", "[number]",
                        String.valueOf(requirement.getRequiredExperience()));

        String experienceWarning = requirement.getRequiredExperience() > 0 && requirement.isTakeExperience()
                ? this.user.getTranslationOrNothing(reference + "experience-warning")
                : "";

        String money = !this.addon.isEconomyProvided() || requirement.getRequiredMoney() <= 0 ? ""
                : this.user.getTranslationOrNothing(reference + "money", "[number]",
                        String.valueOf(requirement.getRequiredMoney()));

        String moneyWarning = this.addon.isEconomyProvided() && requirement.getRequiredMoney() > 0
                && requirement.isTakeMoney() ? this.user.getTranslationOrNothing(reference + "money-warning") : "";

        String level = !this.addon.isLevelProvided() || requirement.getRequiredIslandLevel() <= 0 ? ""
                : this.user.getTranslationOrNothing(reference + "level", "[number]",
                        String.valueOf(requirement.getRequiredIslandLevel()));

        return this.user.getTranslationOrNothing(reference + "lore", "[experience]", experience, "[experience-warning]",
                experienceWarning, "[money]", money, "[money-warning]", moneyWarning, "[level]", level);
    }

    /**
     * This method generates lore message for Statistic requirement.
     * 
     * @param requirement Statistic Requirement.
     * @return Requirement lore message.
     */
    private String generateStatisticChallenge(StatisticRequirements requirement) {
        final String reference = Constants.DESCRIPTIONS + "challenge.requirements.statistic.";

        String statistic;

        if (requirement.getStatistic() == null) {
            // Challenges by default comes with empty statistic field.
            return "";
        }

        switch (requirement.getStatistic().getType()) {
        case UNTYPED -> statistic = this.user.getTranslationOrNothing(reference + "statistic", "[statistic]",
                Utils.prettifyObject(requirement.getStatistic(), this.user), "[number]",
                String.valueOf(requirement.getAmount()));
        case ITEM, BLOCK -> {
            if (requirement.getAmount() > 1) {
                statistic = this.user.getTranslationOrNothing(reference + "multiple-target", "[statistic]",
                        Utils.prettifyObject(requirement.getStatistic(), this.user), "[number]",
                        String.valueOf(requirement.getAmount()), "[target]",
                        Utils.prettifyObject(requirement.getMaterial(), this.user));
            } else {
                statistic = this.user.getTranslationOrNothing(reference + "single-target", "[statistic]",
                        Utils.prettifyObject(requirement.getStatistic(), this.user), "[target]",
                        Utils.prettifyObject(requirement.getMaterial(), this.user));
            }
        }
        case ENTITY -> {
            if (requirement.getAmount() > 1) {
                statistic = this.user.getTranslationOrNothing(reference + "multiple-target", "[statistic]",
                        Utils.prettifyObject(requirement.getStatistic(), this.user), "[number]",
                        String.valueOf(requirement.getAmount()), "[target]",
                        Utils.prettifyObject(requirement.getEntity(), this.user));
            } else {
                statistic = this.user.getTranslationOrNothing(reference + "single-target", "[statistic]",
                        Utils.prettifyObject(requirement.getStatistic(), this.user), "[target]",
                        Utils.prettifyObject(requirement.getEntity(), this.user));
            }
        }
        default -> statistic = "";
        }

        String warning = requirement.isReduceStatistic() ? this.user.getTranslationOrNothing(reference + "warning")
                : "";

        return this.user.getTranslationOrNothing(reference + "lore", "[statistic]", statistic, "[warning]", warning);
    }

    /**
     * This message generates challenge status description.
     * 
     * @param completedOnce   Indicate that challenge is completed at least one
     *                        time.
     * @param completedAll    Indicate that challenge is not repeatable anymore.
     * @param completionCount Number of completion count.
     * @param maxCompletions  Number of max completion count.
     * @return String with a text that will be generated for status.
     */
    private String generateChallengeStatus(boolean completedOnce, boolean completedAll, long completionCount,
            int maxCompletions) {
        final String reference = Constants.DESCRIPTIONS + "challenge.status.";

        if (completedAll) {
            if (maxCompletions > 1) {
                return this.user.getTranslationOrNothing(reference + "completed-times-reached", Constants.PARAMETER_MAX,
                        String.valueOf(maxCompletions));
            } else {
                return this.user.getTranslationOrNothing(reference + "completed");
            }
        } else if (completedOnce) {
            if (maxCompletions > 0) {
                return this.user.getTranslationOrNothing(reference + "completed-times-of", Constants.PARAMETER_MAX,
                        String.valueOf(maxCompletions), Constants.PARAMETER_NUMBER, String.valueOf(completionCount));
            } else {
                return this.user.getTranslationOrNothing(reference + "completed-times", Constants.PARAMETER_NUMBER,
                        String.valueOf(completionCount));
            }
        } else {
            return "";
        }
    }

    /**
     * This method creates reward lore text.
     * 
     * @param challenge   Challenge which reward lore must be generated.
     * @param isRepeating Boolean that indicate if it is repeating reward or first
     *                    time.
     * @return Reward text.
     */
    private String generateRewards(Challenge challenge, boolean isRepeating) {
        if (isRepeating) {
            return this.generateRepeatReward(challenge);
        } else {
            return this.generateReward(challenge);
        }
    }

    /**
     * This method creates repeat reward lore text.
     * 
     * @param challenge Challenge which reward lore must be generated.
     * @return Reward text.
     */
    private String generateRepeatReward(Challenge challenge) {
        final String reference = Constants.DESCRIPTIONS + "challenge.rewards.";

        String items;

        if (!challenge.getRepeatItemReward().isEmpty()) {
            StringBuilder builder = new StringBuilder();
            builder.append(this.user.getTranslationOrNothing(reference + "item-title"));
            Utils.groupEqualItems(challenge.getRepeatItemReward(), challenge.getIgnoreRewardMetaData()).stream()
                    .sorted(Comparator.comparing(ItemStack::getType)).forEach(itemStack -> {
                        builder.append("\n");

                        if (itemStack.getAmount() > 1) {
                            builder.append(this.user.getTranslationOrNothing(reference + "items-value", "[number]",
                                    String.valueOf(itemStack.getAmount()), "[item]",
                                    Utils.prettifyObject(itemStack, this.user)));
                        } else {
                            builder.append(this.user.getTranslationOrNothing(reference + "item-value", "[item]",
                                    Utils.prettifyObject(itemStack, this.user)));
                        }
                    });

            items = builder.toString();
        } else {
            items = "";
        }

        String experience = challenge.getRepeatExperienceReward() <= 0 ? ""
                : this.user.getTranslationOrNothing(reference + "experience", "[number]",
                        String.valueOf(challenge.getRepeatExperienceReward()));

        String money = !this.addon.isEconomyProvided() || challenge.getRepeatMoneyReward() <= 0 ? ""
                : this.user.getTranslationOrNothing(reference + "money", "[number]",
                        addon.getPlugin().getVault().map(v -> v.format(challenge.getRepeatMoneyReward()))
                                .orElse(String.valueOf(challenge.getRepeatMoneyReward())));

        String commands;

        if (!challenge.getRepeatRewardCommands().isEmpty()) {
            StringBuilder permissionBuilder = new StringBuilder();

            if (!challenge.getRepeatRewardCommands().isEmpty()) {
                permissionBuilder.append(this.user.getTranslationOrNothing(reference + "commands-title"));

                challenge.getRepeatRewardCommands().forEach(command -> {
                    permissionBuilder.append("\n");
                    permissionBuilder
                            .append(this.user.getTranslationOrNothing(reference + "command", "[command]", command));
                });
            }

            commands = permissionBuilder.toString();
        } else {
            commands = "";
        }

        if (challenge.getRepeatRewardText().isEmpty() && items.isEmpty() && experience.isEmpty() && money.isEmpty()
                && commands.isEmpty()) {
            // If everything is empty, do not return anything.
            return "";
        }

        String rewardText = this.user
                .getTranslationOrNothing("challenges.challenges." + challenge.getUniqueId() + ".repeat-reward-text");

        if (rewardText.isEmpty()) {
            rewardText = Util.translateColorCodes(String.join("\n", challenge.getRepeatRewardText()));
        }

        return this.user.getTranslationOrNothing(reference + "lore", "[text]", rewardText, "[items]", items,
                "[experience]", experience, "[money]", money, "[commands]", commands);
    }

    /**
     * This method creates reward lore text.
     * 
     * @param challenge Challenge which reward lore must be generated.
     * @return Reward text.
     */
    private String generateReward(Challenge challenge) {
        final String reference = Constants.DESCRIPTIONS + "challenge.rewards.";

        String items;

        if (!challenge.getRewardItems().isEmpty()) {
            StringBuilder builder = new StringBuilder();
            builder.append(this.user.getTranslationOrNothing(reference + "item-title"));
            Utils.groupEqualItems(challenge.getRewardItems(), challenge.getIgnoreRewardMetaData()).stream()
                    .sorted(Comparator.comparing(ItemStack::getType)).forEach(itemStack -> {
                        builder.append("\n");

                        if (itemStack.getAmount() > 1) {
                            builder.append(this.user.getTranslationOrNothing(reference + "items-value", "[number]",
                                    String.valueOf(itemStack.getAmount()), "[item]",
                                    Utils.prettifyObject(itemStack, this.user)));
                        } else {
                            builder.append(this.user.getTranslationOrNothing(reference + "item-value", "[item]",
                                    Utils.prettifyObject(itemStack, this.user)));
                        }
                    });

            items = builder.toString();
        } else {
            items = "";
        }

        String experience = challenge.getRewardExperience() <= 0 ? ""
                : this.user.getTranslationOrNothing(reference + "experience", "[number]",
                        String.valueOf(challenge.getRewardExperience()));

        String money = !this.addon.isEconomyProvided() || challenge.getRewardMoney() <= 0 ? ""
                : this.user.getTranslationOrNothing(reference + "money", "[number]",
                        addon.getPlugin().getVault().map(v -> v.format(challenge.getRewardMoney()))
                                .orElse(String.valueOf(challenge.getRewardMoney())));

        String commands;

        if (!challenge.getRewardCommands().isEmpty()) {
            StringBuilder permissionBuilder = new StringBuilder();

            if (!challenge.getRewardCommands().isEmpty()) {
                permissionBuilder.append(this.user.getTranslationOrNothing(reference + "commands-title"));

                challenge.getRewardCommands().forEach(command -> {
                    permissionBuilder.append("\n");
                    permissionBuilder
                            .append(this.user.getTranslationOrNothing(reference + "command", "[command]", command));
                });
            }

            commands = permissionBuilder.toString();
        } else {
            commands = "";
        }

        if (challenge.getRewardText().isEmpty() && items.isEmpty() && experience.isEmpty() && money.isEmpty()
                && commands.isEmpty()) {
            // If everything is empty, do not return anything.
            return "";
        }

        String rewardText = this.user
                .getTranslationOrNothing("challenges.challenges." + challenge.getUniqueId() + ".reward-text");

        if (rewardText.isEmpty()) {
            rewardText = Util.translateColorCodes(String.join("\n", challenge.getRewardText()));
        }

        return this.user.getTranslationOrNothing(reference + "lore", "[text]", rewardText, "[items]", items,
                "[experience]", experience, "[money]", money, "[commands]", commands);
    }

    /**
     * This method generates level description string.
     * 
     * @param level Level which string must be generated.
     * @return List with generated description.
     */
    protected List<String> generateLevelDescription(ChallengeLevel level) {
        final String reference = Constants.DESCRIPTIONS + "level.";

        // Non-memory optimal code used for easier debugging and nicer code layout for
        // my eye :)
        // Get status in single string
        String status = "";
        // Get requirements in single string
        String waiver = this.manager.isLastLevel(level, this.world) ? ""
                : this.user.getTranslationOrNothing(reference + "waiver", "[number]",
                        String.valueOf(level.getWaiverAmount()));
        // Get rewards in single string
        String rewards = this.generateReward(level);

        String returnString = this.user.getTranslation(reference + "lore", "[text]",
                Util.translateColorCodes(level.getUnlockMessage()), "[waiver]", waiver, "[rewards]", rewards,
                "[status]", status);

        // Remove empty lines and returns as a list.

        return Arrays.stream(returnString.replaceAll("(?m)^[ \\t]*\\r?\\n", "").split("\n"))
                .collect(Collectors.toList());
    }

    /**
     * This method generates level description string.
     * 
     * @param levelStatus Level which string must be generated.
     * @param user        User who calls generation.
     * @return List with generated description.
     */
    protected List<String> generateLevelDescription(LevelStatus levelStatus, User user) {
        ChallengeLevel level = levelStatus.getLevel();

        final String reference = Constants.DESCRIPTIONS + "level.";

        // Non-memory optimal code used for easier debugging and nicer code layout for
        // my eye :)
        // Get status in single string
        String status = this.generateLevelStatus(levelStatus);
        // Get requirements in single string
        String waiver = this.manager.isLastLevel(level, this.world) || !levelStatus.isUnlocked()
                || levelStatus.isComplete() ? ""
                        : this.user.getTranslationOrNothing(reference + "waiver", "[number]",
                                String.valueOf(level.getWaiverAmount()));
        // Get rewards in single string
        String rewards = !levelStatus.isUnlocked() ? "" : this.generateReward(level);

        String description = this.user
                .getTranslationOrNothing("challenges.levels." + level.getUniqueId() + ".description");

        if (description.isEmpty()) {
            description = Util.translateColorCodes(String.join("\n", level.getUnlockMessage()));
        }

        String returnString = this.user.getTranslation(reference + "lore", "[text]", description, "[waiver]", waiver,
                "[rewards]", rewards, "[status]", status);

        // Remove empty lines and returns as a list.

        return Arrays.stream(returnString.replaceAll("(?m)^[ \\t]*\\r?\\n", "").split("\n"))
                .collect(Collectors.toList());
    }

    /**
     * This method generates level status description.
     * 
     * @param levelStatus Level status which description must be generated.
     * @return Level status text.
     */
    private String generateLevelStatus(LevelStatus levelStatus) {
        final String reference = Constants.DESCRIPTIONS + "level.status.";

        if (!levelStatus.isUnlocked()) {
            return this.user.getTranslationOrNothing(reference + "locked") + "\n"
                    + this.user.getTranslationOrNothing(reference + "missing-challenges", "[number]",
                            String.valueOf(levelStatus.getNumberOfChallengesStillToDo()));
        } else if (levelStatus.isComplete()) {
            return this.user.getTranslationOrNothing(reference + "completed");
        } else {
            ChallengeLevel level = levelStatus.getLevel();
            List<Challenge> challengeList = this.addon.getChallengesManager().getLevelChallenges(level);

            // Check if unlock message should appear.
            int doneChallenges = (int) challengeList.stream().filter(challenge -> this.addon.getChallengesManager()
                    .isChallengeComplete(user.getUniqueId(), world, challenge)).count();

            return this.user.getTranslation(reference + "completed-challenges-of", "[number]",
                    String.valueOf(doneChallenges), "[max]", String.valueOf(challengeList.size()));
        }
    }

    /**
     * This method creates reward lore text.
     * 
     * @param level ChallengeLevel which reward lore must be generated.
     * @return Reward text.
     */
    private String generateReward(ChallengeLevel level) {
        final String reference = Constants.DESCRIPTIONS + "level.rewards.";

        String items;

        if (!level.getRewardItems().isEmpty()) {
            StringBuilder builder = new StringBuilder();
            builder.append(this.user.getTranslationOrNothing(reference + "item-title"));
            Utils.groupEqualItems(level.getRewardItems(), level.getIgnoreRewardMetaData()).stream()
                    .sorted(Comparator.comparing(ItemStack::getType)).forEach(itemStack -> {
                        builder.append("\n");

                        if (itemStack.getAmount() > 1) {
                            builder.append(this.user.getTranslationOrNothing(reference + "items-value", "[number]",
                                    String.valueOf(itemStack.getAmount()), "[item]",
                                    Utils.prettifyObject(itemStack, this.user)));
                        } else {
                            builder.append(this.user.getTranslationOrNothing(reference + "item-value", "[item]",
                                    Utils.prettifyObject(itemStack, this.user)));
                        }
                    });

            items = builder.toString();
        } else {
            items = "";
        }

        String experience = level.getRewardExperience() <= 0 ? ""
                : this.user.getTranslationOrNothing(reference + "experience", "[number]",
                        String.valueOf(level.getRewardExperience()));

        String money = !this.addon.isEconomyProvided() || level.getRewardMoney() <= 0 ? ""
                : this.user.getTranslationOrNothing(reference + "money", "[number]",
                        String.valueOf(level.getRewardMoney()));

        String commands;

        if (!level.getRewardCommands().isEmpty()) {
            StringBuilder permissionBuilder = new StringBuilder();

            if (!level.getRewardCommands().isEmpty()) {
                permissionBuilder.append(this.user.getTranslationOrNothing(reference + "commands-title"));

                level.getRewardCommands().forEach(command -> {
                    permissionBuilder.append("\n");
                    permissionBuilder
                            .append(this.user.getTranslationOrNothing(reference + "command", "[command]", command));
                });
            }

            commands = permissionBuilder.toString();
        } else {
            commands = "";
        }

        if (level.getRewardText().isEmpty() && items.isEmpty() && experience.isEmpty() && money.isEmpty()
                && commands.isEmpty()) {
            // If everything is empty, do not return anything.
            return "";
        }

        String rewardText = this.user
                .getTranslationOrNothing("challenges.levels." + level.getUniqueId() + ".reward-text");

        if (rewardText.isEmpty()) {
            rewardText = Util.translateColorCodes(String.join("\n", level.getRewardText()));
        }

        return this.user.getTranslationOrNothing(reference + "lore", "[text]", rewardText, "[items]", items,
                "[experience]", experience, "[money]", money, "[commands]", commands);
    }

    // ---------------------------------------------------------------------
    // Section: Variables
    // ---------------------------------------------------------------------

    /**
     * This variable stores parent gui.
     */
    @Nullable
    protected final CommonPanel parentPanel;

    /**
     * Variable stores Challenges addon.
     */
    protected final ChallengesAddon addon;

    /**
     * Variable stores Challenges addon manager.
     */
    protected final ChallengesManager manager;

    /**
     * Variable stores world in which panel is referred to.
     */
    protected final World world;

    /**
     * Variable stores user who created this panel.
     */
    protected final User user;

    /**
     * Variable stores top label of command from which panel was called.
     */
    protected final String topLabel;

    /**
     * Variable stores permission prefix of command from which panel was called.
     */
    protected final String permissionPrefix;

    /**
     * This object holds PanelItem that allows to return to previous panel.
     */
    protected PanelItem returnButton;
}