OctoCord Polls

Poll.java

package net.octopvp.octocord.object;

import com.google.gson.annotations.SerializedName;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.Setter;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.interactions.components.ActionRow;
import net.dv8tion.jda.api.interactions.components.Button;
import net.dv8tion.jda.api.interactions.components.Component;
import net.octopvp.octocord.OctoCord;
import net.octopvp.octocord.manager.PollManager;
import net.octopvp.octocord.utils.DiscordEmbedBuilder;
import net.octopvp.octocord.utils.emoji.EmojiUtils;

import java.util.*;

@Getter
@Setter
@RequiredArgsConstructor
public class Poll {
    private final long guild,channel,start = System.currentTimeMillis();
    @SerializedName("uuid")
    private final UUID pollID = UUID.randomUUID();
    private final String pollName;
    private boolean ended = false,prev = true,disabled = false,sent = false;
    private long endTime = start + 86400000L, messageID = -1L; //default to 1 day
    private LinkedHashMap<Integer, Set<Long>> votes = new LinkedHashMap<>(); // Question, [voters]
    private LinkedHashMap<Integer,String> options = new LinkedHashMap<>();
    private int previousVotes = votes.hashCode();
    public void vote(User user,String s){
        if (hasEnded())
            return;
        int a;
        try{
            a = Integer.parseInt(s);
        } catch (NumberFormatException e) {
            return;
        }
        votes.forEach((i,set)->{
            set.remove(user.getIdLong());
            if (a == i)
                set.add(user.getIdLong());
        });
        sendMessage();
    }
    public boolean hasEnded(){
        ended = endTime < System.currentTimeMillis();
        return ended;
    }
    public void update(){ //update every second
        if (prev){
            if (hasEnded()){
                prev = false;
                //disabled = true;
                sendMessage();
            }else{
                int hash = votes.hashCode();
                if (hash != previousVotes){
                    previousVotes = hash;
                    sendMessage();
                }
            }
        }
    }
    public void start(){
        PollManager.getPolls().add(this);
        sendMessage();
    }
    public void sendMessage(){
        if (messageID == -1L){
            if (sent)
                return;
            sent = true;
            LinkedHashMap<String,String> map = new LinkedHashMap<>();
            for (Map.Entry<Integer, String> entry : options.entrySet()) {
                int size = votes.get(entry.getKey()).size();
                map.put(
                        EmojiUtils.getNumberEmoji(
                                entry.getKey()) + " " +
                                entry.getValue(),
                        votes.get(
                                entry.getKey()).size() + " vote" + (size == 1 ? "" : "s"));
            }
            DiscordEmbedBuilder discordEmbedBuilder = new DiscordEmbedBuilder();
            discordEmbedBuilder.setTitle("Poll: " + pollName).addEntries(map)
                    .setFooter("Ends at: ")
                    .setTimestamp(endTime);
            discordEmbedBuilder.setEntries(map);
            OctoCord.getJda().getGuildById(guild).getTextChannelById(channel).sendMessage(discordEmbedBuilder.build()).setActionRows(getActionRow()).queue(m -> {
                messageID = m.getIdLong();
                PollManager.getPollMessages().put(messageID,this);
            });
        }else{
            OctoCord.getJda().getGuildById(guild).getTextChannelById(channel).retrieveMessageById(messageID).queue(message ->{
                if (message == null){
                    ended = true;
                    return;
                }
                LinkedHashMap<String,String> map = new LinkedHashMap<>();
                for (Map.Entry<Integer, String> entry : options.entrySet()) {
                    int size = votes.get(entry.getKey()).size();
                    map.put(EmojiUtils.getNumberEmoji(entry.getKey()) + " " + entry.getValue(),size + " vote" + (size == 1 ? "" : "s"));
                }
                if (ended){
                    boolean tie = false;
                    int highest = 0;
                    List<Integer> tied = new ArrayList<>();
                    Map<Integer,Integer> intMap = new HashMap<>();
                    List<Integer> list = new ArrayList<>(votes.size());
                    for (Map.Entry<Integer, Set<Long>> entry : votes.entrySet()) {
                        list.add(entry.getValue().size());
                        intMap.put(entry.getValue().size(), entry.getKey());
                    }
                    list.sort(Collections.reverseOrder());
                    for (Integer integer : list) {
                        if (integer == highest){
                            tie = true;
                            tied.add(integer);
                        }else if (integer > highest){
                            highest = integer;
                            tie = false;
                            tied.clear();
                        }
                    }
                    DiscordEmbedBuilder discordEmbedBuilder = new DiscordEmbedBuilder().setTitle((ended ? "~~Poll: " + pollName + "~~ **ENDED**" : "Poll: " + pollName));
                    if (tie){
                        discordEmbedBuilder.setDescription("Tied");
                    }else{
                        int a = intMap.get(highest);
                        String name = options.get(a);
                        discordEmbedBuilder.setDescription("\"" + name + "\" won.");
                    }
                    discordEmbedBuilder.addEntries(map);
                    discordEmbedBuilder.setFooter("Ended At: ").setTimestamp(endTime);

                    message.editMessage(discordEmbedBuilder.build()).queue();
                    return;
                }
                DiscordEmbedBuilder embedBuilder = new DiscordEmbedBuilder().setTitle("Poll: " + pollName)
                        .setFooter("Ends At: ").setTimestamp(endTime);
                embedBuilder.setEntries(map);
                message.editMessage(embedBuilder.build()).setActionRows(getActionRow()).queue();
            });
        }
    }
    public ActionRow getActionRow(){
        List<Component> components = new ArrayList<>();
        options.forEach((i,s)-> components.add(Button.primary(i + "", EmojiUtils.getNumberEmoji(i)).withDisabled(disabled)));
        return ActionRow.of(components);
    }
}

PollManager.java

package net.octopvp.octocord.manager;

import lombok.Getter;
import net.dv8tion.jda.api.events.interaction.ButtonClickEvent;
import net.dv8tion.jda.api.hooks.ListenerAdapter;
import net.octopvp.octocord.OctoCord;
import net.octopvp.octocord.object.Poll;
import org.jetbrains.annotations.NotNull;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

public class PollManager extends ListenerAdapter {
    @Getter
    private static Set<Poll> polls = new HashSet<>();
    public static void init(){
        OctoCord.getJda().addEventListener(new PollManager());
        OctoCord.getThreadPool().scheduleAtFixedRate(()->{
            for (Poll poll : polls) {
                poll.update();
                if (poll.hasEnded() && !poll.isPrev()) {
                    polls.remove(poll);
                    pollMessages.remove(poll.getMessageID());
                    OctoCord.getDataSource().deletePoll(poll.getPollID());
                }
            }
        }, 0L, 500L, TimeUnit.MILLISECONDS);
        OctoCord.getThreadPool().scheduleAtFixedRate(PollManager::savePolls, 5L,5L,TimeUnit.MINUTES);
        loadPollsFromDB();
    }
    public static void stop(){
        /*
        for (Poll poll : polls) {
            poll.setDisabled(true);
        }
         */
        savePolls();
    }
    public static void savePolls(){
        for (Poll poll : polls) {
            OctoCord.getDataSource().savePoll(poll);
        }
    }
    public static void loadPollsFromDB(){
        polls.clear();
        polls.addAll(Arrays.asList(OctoCord.getDataSource().getPolls()));
        pollMessages.clear();
        for (Poll poll : polls) {
            long id = poll.getMessageID();
            if (id == -1)
                continue;
            pollMessages.put(id,poll);
        }
    }
    @Getter
    private static Map<Long,Poll> pollMessages = new ConcurrentHashMap<>();
    @Override
    public void onButtonClick(@NotNull ButtonClickEvent event) {
        if (pollMessages.containsKey(event.getMessage().getIdLong())){
            Poll poll = pollMessages.get(event.getMessage().getIdLong());
            if (poll != null && !poll.hasEnded()){
                //if (poll != null && !poll.hasEnded() && !poll.isDisabled()){
                event.deferEdit().queue();
                poll.vote(event.getUser(),event.getButton().getId());
            }
        }
    }
}