Level up code

    final static Logger logger = LoggerFactory.getLogger(PixelHandler.class);

    private static final ScheduledExecutorService selfDestruct = Executors.newSingleThreadScheduledExecutor();

    /***
     * Handler for performing pixel decay.
     *
     * @param content a wrapper around the Guild API object that contains extra information about the guild.
     * @param user    the profile object for the user that is having decay tested.
     */
    public static void doDecay(GuildObject content, ProfileObject user) {
        long days = user.daysDecayed(content);
        if (7 > days) {
            long decay;
            user.setCurrentLevel(PixelHandler.xpToLevel(user.getXP()));
            //modifiable min and max decay days needs to be implemented.
            if (days > 15) {
                //plateaued xp decay
                decay = (long) ((15 - 7) * (Globals.avgMessagesPerDay * content.config.xpRate * content.config.xpModifier) / 8);
            } else if (days > 90) {
                // kill the xp after 90 days of absences
                decay = (long) ((90 - 7) * (Globals.avgMessagesPerDay * content.config.xpRate * content.config.xpModifier) / 8);
            } else {
                //normal xp decay formula
                decay = (long) ((days - 7) * (Globals.avgMessagesPerDay * content.config.xpRate * content.config.xpModifier) / 8);
            }
            //half decay if you turn you xp gain off but only if it is voluntary
            if (user.getSettings().contains(UserSetting.NO_XP_GAIN)) decay = decay / 2;
            //half decay for patreon supporters
            if (user.getUser(content).isPatron) decay = decay / 2;
            //reward handlers
            if (PixelHandler.getRewardCount(content, user.getUserID()) != 0) {
                long pseudoLevel = xpToLevel(user.getXP() + 120);
                RewardRoleObject rewardRole = content.config.getCurrentReward(pseudoLevel);
                if (rewardRole != null) {

                    long rewardFloor = rewardRole.getXp() - 100;
                    if (user.getXP() > rewardFloor) {
                        user.setXp(user.getXP() - decay);
                        // your total xp should never reach below 0;
                        if (user.getXP() < 0) {
                            user.setXp(0);
                        }
                        //decay should never lower your total xp below the reward floor.
                        if (user.getXP() < rewardFloor) {
                            user.setXp(rewardFloor);
                        }
                        //if user is at level floor add setting.
                        if (user.getXP() == rewardFloor && !user.getSettings().contains(HIT_LEVEL_FLOOR)) {
                            user.getSettings().add(HIT_LEVEL_FLOOR);
                        }
                    }
                    //if your days away is a multiple of 30 you should be checked if you are at the
                    //reward floor, if you are reward decay occurs
                    if (days % 30 == 0 && user.getXP() == rewardFloor) {
                        user.setXp(user.getXP() - 100);
                    }
                }
            }
        }
    }

    /***
     * Handler for performing automatic role allocation
     *
     * @param id      the user ID of the user that is having their roles checked.
     * @param content a wrapper around the Guild API object that contains extra information about the guild.
     */
    public static void checkUsersRoles(long id, GuildObject content) {
        //do code.
        ProfileObject userObject = content.users.getUserByID(id);
        if (userObject == null) {
            return;
        }
        if (userObject.getSettings().contains(DENY_AUTO_ROLE)) return;

        IUser user = Globals.getClient().getUserByID(userObject.getUserID());
        if (user == null) {
            return;
        }
        List<IRole> userRoles = user.getRolesForGuild(content.get());
        //remove all rewardRoles to prep for checking.
        ListIterator iterator = userRoles.listIterator();
        while (iterator.hasNext()) {
            IRole role = (IRole) iterator.next();
            if (content.config.isRoleReward(role.getLongID())) {
                iterator.remove();
            }
        }
        //add all roles that the user should have.
        ArrayList<RewardRoleObject> allRewards = content.config.getAllRewards(userObject.getCurrentLevel());
        for (RewardRoleObject r : allRewards) {
            userRoles.add(r.getRole(content));
        }
        //add the top ten role if they should have it.
        IRole topTenRole = content.get().getRoleByID(content.config.topTenRoleID);
        if (topTenRole != null) {
            long rank = PixelHandler.rank(content.users, content.get(), user.getLongID());
            if (rank <= 10 && rank > 0) {
                userRoles.add(topTenRole);
            }
        }
        //only do a role update if the role count changes
        List<IRole> currentRoles = user.getRolesForGuild(content.get());
        if (!currentRoles.containsAll(userRoles) || currentRoles.size() != userRoles.size()) {
            RequestHandler.roleManagement(user, content.get(), userRoles);
        }
    }

    /***
     * handler for granting users pixels.
     *
     * @param object the container for all relevant API content.
     */
    public static void grantXP(CommandObject object) {
        //bots don't get XP
        if (object.user.get().isBot()) return;

        //creates a profile for the user if they don't already have one.
        ProfileObject user = new ProfileObject(object.user.longID);
        if (object.guild.users.getUserByID(object.user.longID) == null) {
            object.guild.users.getProfiles().add(user);
        } else {
            user = object.guild.users.getUserByID(object.user.longID);
        }

        user.lastTalked = object.message.getTimestamp().toEpochSecond();

        //ony do xp checks if module is true
        if (!object.guild.config.modulePixels) return;
        if (!object.guild.config.xpGain) return;

        //user setting no xp gain
        if (user.getSettings().contains(NO_XP_GAIN) || user.getSettings().contains(DENIED_XP)) return;

        //role xp denying
        IRole xpDenied = object.guild.getXPDeniedRole();
        if (xpDenied != null && object.user.roles.contains(xpDenied)) return;

        //you can only gain xp once per min
        if (object.guild.getSpokenUsers().contains(object.user.longID)) return;

        //messages that might be considered commands should be ignored.
        List<String> deniedPrefixes = new ArrayList<>(object.guild.config.getXpDeniedPrefixes());
        deniedPrefixes.add(object.guild.config.getPrefixCommand());
        deniedPrefixes.add(object.guild.config.getPrefixCC());
        for (String s : deniedPrefixes) {
            if (object.message.get().getContent().startsWith(s)) {
                return;
            }
        }

        //you must have typed at least 10 chars to gain xp and doesn't contain an image.
        if (object.message.get().getContent().length() < 10 &&
                object.message.get().getAttachments().isEmpty()) return;

        //you cannot gain xp in an xpDenied channel
        if (object.channel.settings.contains(ChannelSetting.XP_DENIED)) return;


        //gives them their xp.
        user.addXP(object.guild.config);

        // check level cap, don't grant xp to level-capped users
        if (user.getXP() >= Constants.PIXELS_CAP) user.setXp(Constants.PIXELS_CAP);

        //adds to the list of users who have spoken in the last min
        object.guild.getSpokenUsers().add(object.user.longID);

        //check the level up state of the user.
        handleLevelUp(user, object);
    }

    /***
     * Handler for user level ups.
     *
     * @param user   the user that leveled up.
     * @param object the container for all relevant API content.
     */
    private static void handleLevelUp(ProfileObject user, CommandObject object) {
        RewardRoleObject reward = null;

        //get next level xp
        long nextLevelxp = xpToLevel(user.getCurrentLevel() + 1);

        //sanity check the level
        if (user.getCurrentLevel() == -1) {
            user.setCurrentLevel(xpToLevel(user.getXP()));
            return;
        }

        //check if the user actually leveled up
        if (user.getXP() < nextLevelxp) return;
        user.levelUp();

        //check if the user ranked up
        for (RewardRoleObject r : object.guild.config.getRewardRoles()) {
            if (r.getLevel() == user.getCurrentLevel()) {
                reward = r;
                break;
            }
        }
        //if denyAutoRole remove Reward.
        if (user.getSettings().contains(DENY_AUTO_ROLE)) reward = null;

        //logging
        object.guild.sendDebugLog(object, "PIXELS", reward != null ? "RANKUP" : "LEVELUP", user.getCurrentLevel() + "");

        //handle reactions
        handleReactions(user, object);

        //handle level up messages
        handleMessage(user, object, reward);

        //check user's roles for rank up purposes
        checkUsersRoles(user.getUserID(), object.guild);
    }

    /***
     * Handles the sending of the level up message
     *
     * @param user   the user that leveled up.
     * @param object the container for all relevant API content.
     * @param reward reward object that contains info on the reward they have received.
     */
    private static void handleMessage(ProfileObject user, CommandObject object, RewardRoleObject reward) {
        UserSetting defaultOverride = object.guild.config.defaultLevelMode;
        UserSetting userState = user.getLevelState();
        boolean rankedUp = reward != null;
        IChannel levelChannel = object.guild.getChannelByType(ChannelSetting.LEVEL_UP);
        IChannel currentChannel = object.channel.get();
        IChannel dmChannel = object.user.getDmChannel();
        IMessage levelMessage = null;

        //force override
        if (userState == null || defaultOverride == DONT_SEND_LVLUP || defaultOverride == SEND_LVLUP_DMS) {
            userState = defaultOverride;
        }

        //get custom level up message.
        StringHandler levelUpMessage = new StringHandler(object.guild.config.levelUpMessage);

        //handle level up tags
        for (TagObject t : TagList.getType(TagType.LEVEL)) {
            levelUpMessage.setContent(t.handleTag(levelUpMessage.toString(), object, ""));
        }

        //build rank up message
        if (rankedUp) {
            levelUpMessage.replace("%s", "");
            if (user.getSettings().contains(HIT_LEVEL_FLOOR)) {
                levelUpMessage.appendFront("Welcome Back.\n");
                levelUpMessage.append("\nYour **@%s** role has been returned to you.");
                user.getSettings().remove(HIT_LEVEL_FLOOR);
            } else {
                levelUpMessage.append("\nYou have been granted the **@%s** role for reaching this level.");
            }
            levelUpMessage.format(reward.getRole(object).getName());
        }

        //do send message
        switch (userState) {
            case SEND_LVLUP_CURRENT_CHANNEL:
                levelMessage = sendLevelMessage(levelUpMessage.toString(), currentChannel, rankedUp, false);
            case SEND_LVLUP_RANK_CHANNEL:
                if (levelChannel == null) {
                    levelMessage = sendLevelMessage(levelUpMessage.toString(), currentChannel, rankedUp, false);
                } else {
                    sendLevelMessage(levelUpMessage.toString(), levelChannel, rankedUp, true);
                }
            case SEND_LVLUP_DMS:
                sendLevelMessage(levelUpMessage.toString(), dmChannel, rankedUp, true);
        }

        //self destruct level messages
        if (levelMessage != null) {
            selfDestruct(levelMessage, user, object);
        }
    }

    /***
     * Helper method to send a level up message.
     *
     * @param message  the message to be sent
     * @param channel  the channel the message should be sent to.
     * @param isRankUp weather the rank or level up gif should be used.
     * @param doGif    weather the gif should be displayed.
     * @return the message that was sent.
     */
    private static IMessage sendLevelMessage(String message, IChannel channel, boolean isRankUp, boolean doGif) {
        return doGif ?
                (RequestHandler.sendEmbededImage(message, isRankUp ? Constants.RANK_UP_IMAGE_URL : Constants.LEVEL_UP_IMAGE_URL, channel).get()) :
                (RequestHandler.sendMessage(message, channel).get());
    }

    /***
     * Handler for attaching reactions to the message that leveled the user up.
     *
     * @param user   the user that leveled up
     * @param object the container for all relevant API content.
     */
    private static void handleReactions(ProfileObject user, CommandObject object) {
        if (user.getSettings().contains(UserSetting.NO_LEVEL_UP_REACTIONS)) return;
        if (object.guild.config.levelUpReaction.equalsIgnoreCase("null")) return;
        ReactionEmoji emoji;

        //get Emoji
        try {
            long emojiID = Long.parseUnsignedLong(object.guild.config.levelUpReaction);
            emoji = ReactionEmoji.of(object.client.getEmojiByID(emojiID));
        } catch (NumberFormatException e) {
            emoji = ReactionEmoji.of(object.guild.config.levelUpReaction);
        }

        //send error if the reaction failed
        if (emoji == null) {
            IChannel adminChannel = object.guild.getChannelByType(ChannelSetting.ADMIN);
            if (adminChannel == null) adminChannel = object.channel.get();
            RequestHandler.sendMessage("> The current emoji set to be used for level up reactions is invalid and needs to be updated.", adminChannel);
            return;
        }

        //add the reaction
        RequestHandler.addReaction(object.message, emoji);
    }

    /***
     * Helper method to self destruct messages after a certain time.
     *
     * @param message the message to be deleted.
     * @param user    the user that level up message.
     */
    private static void selfDestruct(IMessage message, ProfileObject user, CommandObject object) {
        if (object.guild.config.selfDestructLevelUps) {
            selfDestruct.schedule(() -> RequestHandler.deleteMessage(message), user.getCurrentLevel() == 1 ? 2 : 1, TimeUnit.MINUTES);
        }
    }