package tc.oc.pgm.raindrops;
import java.time.Duration;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import com.google.common.collect.HashMultimap;
import com.google.common.primitives.Ints;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TranslatableComponent;
import org.bukkit.ChatColor;
import org.bukkit.DyeColor;
import org.bukkit.Material;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Item;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDespawnInVoidEvent;
import org.bukkit.event.inventory.CraftItemEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.material.Wool;
import tc.oc.api.docs.PlayerId;
import tc.oc.commons.bukkit.raindrops.RaindropConstants;
import tc.oc.commons.bukkit.raindrops.RaindropUtil;
import tc.oc.commons.core.chat.Component;
import tc.oc.commons.core.util.Comparables;
import tc.oc.pgm.PGM;
import tc.oc.pgm.destroyable.DestroyableContribution;
import tc.oc.pgm.destroyable.DestroyableDestroyedEvent;
import tc.oc.pgm.events.ListenerScope;
import tc.oc.pgm.events.MatchEndEvent;
import tc.oc.pgm.events.MatchPlayerDeathEvent;
import tc.oc.pgm.goals.Goal;
import tc.oc.pgm.goals.GoalMatchModule;
import tc.oc.pgm.goals.TouchableGoal;
import tc.oc.pgm.goals.events.GoalCompleteEvent;
import tc.oc.pgm.goals.events.GoalTouchEvent;
import tc.oc.pgm.match.Competitor;
import tc.oc.pgm.match.Match;
import tc.oc.pgm.match.MatchPlayer;
import tc.oc.pgm.match.MatchPlayerState;
import tc.oc.pgm.match.MatchScope;
import tc.oc.pgm.match.ParticipantState;
import tc.oc.pgm.teams.Team;
import tc.oc.pgm.teams.TeamMatchModule;
import tc.oc.pgm.victory.VictoryMatchModule;
import tc.oc.pgm.wool.MonumentWool;
import tc.oc.pgm.wool.MonumentWoolFactory;
import tc.oc.pgm.wool.PlayerWoolPlaceEvent;
@ListenerScope(MatchScope.LOADED)
public class RaindropListener implements Listener {
private final HashMultimap<MonumentWool, PlayerId> touchedWools = HashMultimap.create();
private final Map<Item, PlayerId> droppedWools = new WeakHashMap<>();
private final HashMultimap<DyeColor, PlayerId> destroyedWools = HashMultimap.create();
private final HashMultimap<TouchableGoal, ParticipantState> deferredTouches = HashMultimap.create();
private double tiedRewardPercent(Match match) {
return 1.0d / match.needMatchModule(TeamMatchModule.class).getTeams().size();
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void handleItemDrop(final PlayerDropItemEvent event) {
ParticipantState player = PGM.getMatchManager().getParticipantState(event.getPlayer());
if(player == null) return;
Competitor team = player.getParty();
Item itemDrop = event.getItemDrop();
ItemStack item = itemDrop.getItemStack();
if (this.isDestroyableWool(item, team)) {
this.droppedWools.put(itemDrop, player.getPlayerId());
}
}
@EventHandler(priority = EventPriority.MONITOR)
public void handleItemDespawn(final EntityDespawnInVoidEvent event) {
Entity entity = event.getEntity();
if (!(entity instanceof Item)) return;
ItemStack stack = ((Item) entity).getItemStack();
PlayerId playerId = this.droppedWools.remove(entity);
if (playerId == null) return;
ParticipantState player = PGM.getMatchManager().getParticipantState(playerId);
if (player == null) return;
if(isDestroyableWool(stack, player.getParty())) {
giveWoolDestroyRaindrops(player, ((Wool) stack.getData()).getColor());
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void handleCraft(final CraftItemEvent event) {
ParticipantState player = PGM.getMatchManager().getParticipantState(event.getWhoClicked());
if (player == null) return;
for (ItemStack ingredient : event.getInventory().getMatrix()) {
if(this.isDestroyableWool(ingredient, player.getParty())) {
giveWoolDestroyRaindrops(player, ((Wool) ingredient.getData()).getColor());
}
}
}
@EventHandler(priority = EventPriority.MONITOR)
public void handleMatchEndEvent(final MatchEndEvent event) {
final Set<Competitor> winners = event.getMatch().needMatchModule(VictoryMatchModule.class).winners();
Match match = event.getMatch();
boolean applyCutoff = Comparables.greaterThan(match.getLength(), RaindropConstants.TEAM_REWARD_CUTOFF);
for(MatchPlayer player : match.getParticipatingPlayers()) {
if(player.getParty() instanceof Team) {
Team team = (Team) player.getParty();
Duration teamTime = team.getCumulativeParticipation(player.getPlayerId());
if(!(applyCutoff && Comparables.lessThan(teamTime, RaindropConstants.TEAM_REWARD_CUTOFF))) {
Component message = new Component(net.md_5.bungee.api.ChatColor.GRAY);
double percent = 1.0;
Competitor playerTeam = player.getCompetitor();
assert playerTeam != null;
if(winners.contains(playerTeam)) {
if(winners.size() == 1) {
message.extra(new TranslatableComponent("matchend.team.won", playerTeam.getComponentName()));
} else {
message.extra(new TranslatableComponent("matchend.team.tied", playerTeam.getComponentName()));
percent = tiedRewardPercent(match);
}
} else {
message.extra(new TranslatableComponent("matchend.team.loyalty",
playerTeam.getComponentName(),
new Component(String.valueOf(teamTime.toMinutes()))));
percent = RaindropConstants.LOSING_TEAM_REWARD_PERCENT;
}
givePercentageRaindrops(player.getParticipantState(), RaindropConstants.TEAM_REWARD, message, true, percent);
}
}
}
this.touchedWools.clear();
this.droppedWools.clear();
this.destroyedWools.clear();
this.deferredTouches.clear();
}
private void giveGoalTouchRaindrops(ParticipantState player, TouchableGoal goal) {
this.giveRaindrops(player,
RaindropConstants.TOUCH_GOAL_REWARD,
goal.getTouchMessage(player, true));
}
@EventHandler(priority = EventPriority.MONITOR)
public void handleGoalTouch(final GoalTouchEvent event) {
Goal goal = event.getGoal();
if (!goal.isVisible() || goal.isCompleted() || event.getPlayer() == null || !event.isFirstForPlayerLife()) {
return;
}
if (goal instanceof MonumentWool) {
PlayerId playerId = event.getPlayer().getPlayerId();
if (this.touchedWools.containsEntry(goal, playerId)) {
return;
} else {
this.touchedWools.put((MonumentWool) goal, playerId);
}
}
if(event.getGoal().getDeferTouches()) {
this.deferredTouches.put(event.getGoal(), event.getPlayer());
} else {
this.giveGoalTouchRaindrops(event.getPlayer(), event.getGoal());
event.setCancelToucherMessage(true);
}
}
@EventHandler
public void handleGoalComplete(GoalCompleteEvent event) {
if(event.getGoal() instanceof TouchableGoal) {
TouchableGoal goal = (TouchableGoal) event.getGoal();
for(ParticipantState player : this.deferredTouches.get(goal)) {
this.giveGoalTouchRaindrops(player, goal);
}
this.deferredTouches.removeAll(goal);
}
}
@EventHandler(priority = EventPriority.MONITOR)
public void woolPlace(final PlayerWoolPlaceEvent event) {
if (event.getWool().isVisible()) {
giveRaindrops(event.getPlayer().getPlayerId(), RaindropConstants.WOOL_PLACE_REWARD, new TranslatableComponent("match.wool.place", event.getWool().getComponentName()));
}
}
@EventHandler(priority = EventPriority.MONITOR)
public void destroyableDestroy(final DestroyableDestroyedEvent event) {
if (event.getDestroyable().isVisible()) {
for (DestroyableContribution info : event.getDestroyable().getContributions()) {
String percentage = ChatColor.GREEN.toString() + ((int) (info.getPercentage() * 100)) + ChatColor.GRAY;
BaseComponent reason = new TranslatableComponent("match.destroyable.destroy", percentage, new Component(event.getDestroyable().getName(), net.md_5.bungee.api.ChatColor.GREEN));
giveRaindrops(info.getPlayerState().getPlayerId(), (int) (RaindropConstants.DESTROYABLE_DESTROY_PERCENT_REWARD * info.getPercentage()), reason);
}
}
}
@EventHandler(priority = EventPriority.NORMAL)
public void kill(final MatchPlayerDeathEvent event) {
if(!event.isChallengeKill()) return;
// Death raindrops are given by the backend, to reduce API usage
final int raindrops = calculateRaindrops(
event.getKiller(),
RaindropConstants.KILL_REWARD,
false,
1
);
event.setRaindrops(raindrops);
final MatchPlayer killer = event.getOnlineKiller();
if(killer != null) {
RaindropUtil.showRaindrops(
killer.getBukkit(),
raindrops,
RaindropUtil.calculateMultiplier(event.getKiller().getPlayerId()),
new TranslatableComponent("match.kill.killed", event.getVictim().getComponentName())
);
}
}
private void giveWoolDestroyRaindrops(final ParticipantState player, final DyeColor wool) {
MatchPlayer online = player.getMatchPlayer();
if(online != null) giveWoolDestroyRaindrops(online, wool);
}
private void giveWoolDestroyRaindrops(final MatchPlayer player, final DyeColor wool) {
if(!this.destroyedWools.containsEntry(wool, player.getPlayerId())) {
this.destroyedWools.put(wool, player.getPlayerId());
giveRaindrops(player.getPlayerId(), RaindropConstants.WOOL_DESTROY_REWARD, new TranslatableComponent("match.wool.destroy", MonumentWoolFactory.makeComponentName(wool)));
}
}
private int calculateRaindrops(MatchPlayerState player, int count, boolean scaled, double percent) {
if(scaled) {
final Match match = player.getMatch();
count += (int) ((double) match.getParticipatingPlayers().size() / match.getMaxPlayers() * RaindropConstants.MATCH_FULLNESS_BONUS);
if(player.getParty() instanceof Team) {
count += Ints.min((int) (Math.sqrt(((Team) player.getParty()).getCumulativeParticipation(player.getPlayerId()).getSeconds()) / RaindropConstants.PLAY_TIME_BONUS), RaindropConstants.PLAY_TIME_BONUS_CUTOFF);
}
}
return RaindropUtil.calculateRaindrops(player.getPlayerId(), (int) (count * percent), true);
}
private void giveRaindrops(final MatchPlayerState player, int count, BaseComponent reason) {
giveRaindrops(player, count, reason, true);
}
private void giveRaindrops(final MatchPlayerState player, int count, final BaseComponent reason, boolean scaled) {
givePercentageRaindrops(player, count, reason, scaled, 1.0);
}
private void giveRaindrops(final PlayerId playerId, int count, BaseComponent reason) {
RaindropUtil.giveRaindrops(playerId, count, null, reason);
}
private void givePercentageRaindrops(final MatchPlayerState player, int count, final BaseComponent reason, boolean scaled, double percent) {
RaindropUtil.giveRaindrops(
player.getPlayerId(),
calculateRaindrops(player, count, scaled, percent),
RaindropUtil.calculateMultiplier(player.getPlayerId()),
null,
reason,
true
);
}
/**
* Test if the given ItemStack is strictly an enemy wool i.e. not also
* a wool that the given team can capture.
*/
private boolean isDestroyableWool(ItemStack stack, Competitor team) {
if(stack == null || stack.getType() != Material.WOOL) {
return false;
}
DyeColor color = ((Wool) stack.getData()).getColor();
boolean enemyOwned = false;
for(Goal goal : team.getMatch().needMatchModule(GoalMatchModule.class).getGoals()) {
if(goal instanceof MonumentWool) {
MonumentWool wool = (MonumentWool) goal;
if(wool.isVisible() && !wool.isPlaced() && wool.getDyeColor() == color) {
if(wool.getOwner() == team) {
return false;
} else {
enemyOwned = true;
}
}
}
}
return enemyOwned;
}
}