Core/src/main/java/eu/univento/core/api/map/MapVoting.java

package eu.univento.core.api.map;

import eu.univento.commons.player.Rank;
import eu.univento.core.api.items.ItemBuilder;
import eu.univento.core.api.player.CustomPlayer;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.plugin.Plugin;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

/**
 * @author joethei
 * @version 0.1
 */
public class MapVoting implements Listener{


    private Map map1;
    private Map map2;
    private Map map3;
    private final String invTitle;
    private final ArrayList<CustomPlayer> votes1 = new ArrayList<>();
    private final ArrayList<CustomPlayer> votes2 = new ArrayList<>();
    private final ArrayList<CustomPlayer> votes3 = new ArrayList<>();
    private Map forcedMap;
    private final ArrayList<Map> allMaps = new ArrayList<>();

    public MapVoting(String invTitle) {
        this.invTitle = invTitle;
    }

    private void vote(CustomPlayer p, Integer map) {
        switch (map) {
            case 1 : votes1.add(p);
            case 2 : votes2.add(p);
            case 3 : votes3.add(p);
        }
    }

    public int getVotes(Integer map) {
        switch (map) {
            case 1 : return votes1.size();
            case 2 : return votes2.size();
            case 3 : return votes3.size();
            default: return 0;
        }
    }

    public Map getForcedMap() {
        return forcedMap;
    }

    public Map getWinningMap() {
        if(forcedMap != null) {
            return forcedMap;
        }
        ArrayList<Integer> votes = new ArrayList<>();
        votes.add(votes1.size());
        votes.add(votes2.size());
        votes.add(votes3.size());
        int max = Collections.max(votes);
        return getMap(getMapID(max));
    }

    private Map getMap(int id) {
        switch (id) {
            case 1: return map1;
            case 2: return map2;
            case 3: return map3;
            default: return null;
        }
    }

    private int getMapID(int votes) {
        if(votes == votes1.size()) return 1;
        if(votes == votes2.size()) return 2;
        if(votes == votes3.size()) return 3;
        return 0;
    }

    public void setVotingMaps() {
        ArrayList<Map> temp = allMaps;
        Random random = new Random();
        map1 = allMaps.get(random.nextInt(temp.size()));
        temp.remove(map1);
        map2 = allMaps.get(random.nextInt(temp.size()));
        temp.remove(map2);
        map3 = allMaps.get(random.nextInt(temp.size()));
        temp.remove(map3);

    }

    public void addMap(Map map) {
        allMaps.add(map);
    }

    public Inventory getInventory(CustomPlayer p) {
        if(p.getDatabasePlayer().isAllowed(Rank.Admin)) {
            Inventory inv = Bukkit.createInventory(p, 45, invTitle);

            for(Map map : allMaps)
                inv.addItem(new ItemBuilder(map.getItem()).name(map.getName()).lore("§aby " + map.getBuilder()).make());

            return inv;
        }else{
            Inventory inv = Bukkit.createInventory(p, 9, invTitle);

            inv.setItem(1, new ItemBuilder(this.map1.getItem()).name(this.map1.getName()).lore("§aby " + this.map1.getBuilder()).make());
            inv.setItem(4, new ItemBuilder(this.map2.getItem()).name(this.map2.getName()).lore("§aby " + this.map2.getBuilder()).make());
            inv.setItem(7, new ItemBuilder(this.map3.getItem()).name(this.map3.getName()).lore("§aby " + this.map3.getBuilder()).make());

            return inv;
        }
    }

    @EventHandler
    public void onInventoryClick(InventoryClickEvent e) {
        if(e.getWhoClicked() instanceof Player) {
            CustomPlayer p = CustomPlayer.getPlayer(e.getWhoClicked().getName());
            if(e.getInventory().getName().equals(invTitle)) {
                if(p.getDatabasePlayer().isAllowed(Rank.Admin)) {
                    allMaps.stream().filter(map -> e.getCurrentItem().getType() == map.getItem()).forEach(map -> forcedMap = map);
                }else{
                    if(e.getCurrentItem().getType() == map1.getItem()) {
                        vote(p, 1);
                        p.closeInventory();
                    }
                    if(e.getCurrentItem().getType() == map2.getItem()) {
                        vote(p, 2);
                        p.closeInventory();
                    }
                    if(e.getCurrentItem().getType() == map3.getItem()) {
                        vote(p, 3);
                        p.closeInventory();
                    }
                }

            }
        }
    }

    public void registerListener(Plugin plugin) {
        plugin.getServer().getPluginManager().registerEvents(this, plugin);
    }
}