aaa

package rebirthxsavage.hcf.core.manager;

import rebirthxsavage.hcf.core.MainHCF;
import rebirthxsavage.hcf.core.utils.Manager;
import rebirthxsavage.hcf.core.utils.Utils;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.PotionSplashEvent;
import org.bukkit.event.entity.ProjectileLaunchEvent;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerKickEvent;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.event.player.PlayerPickupItemEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerTeleportEvent;

public class FreezeManager
  extends Manager
  implements Listener
{
  private List<Player> frozen;
  private List<Player> panic;
  boolean isEnableAutoban;
  public FreezeManager(MainHCF plugin)
  {
    super(plugin);
    this.frozen = new ArrayList<Player>();
    this.panic = new ArrayList<Player>();
  }

  public void init()
  {
    getPlugin().getServer().getPluginManager().registerEvents(this, getPlugin());
    reload();
  }
  public void reload()
  {
	  this.isEnableAutoban = this.getPlugin().getConfig().getBoolean("Freeze.Autoban.Enable");
  }
  public boolean isFrozen(Player player)
  {
    return this.frozen.contains(player);
  }
  public void addFreeze(Player player)
  {
		  this.frozen.add(player);
  }
  public void removeFreeze(Player player)
  {
	  if (this.isFrozen(player)){
		  this.frozen.remove(player);
	  }
  }
  public boolean isPanic(Player player)
  {
    return this.panic.contains(player);
  }
  public void addPanic(Player player)
  {
		  this.panic.add(player);
  }
  public void removePanic(Player player)
  {
	  if (this.isPanic(player)){
		  this.panic.remove(player);
	  }
  }
  @EventHandler
  public void onMove(PlayerMoveEvent event)
  {
    Location from = event.getFrom();
    Location to = event.getTo();
    if (((from.getX() != to.getX()) || (from.getZ() != to.getZ())) && (this.isFrozen(event.getPlayer()) || isPanic(event.getPlayer()))) {
      event.setTo(event.getFrom());
    }
  }

  @SuppressWarnings("deprecation")
@EventHandler
  public void onProjectileLaunch(ProjectileLaunchEvent event)
  {
    if (this.frozen.contains(event.getEntity().getShooter()) || this.panic.contains(event.getEntity().getShooter())) {
      event.setCancelled(true);
    }
  }

  @SuppressWarnings("deprecation")
@EventHandler
  public void onEntityDamageByEntity(EntityDamageByEntityEvent event)
  {
	if (event.getEntity() instanceof Player && event.getDamager() instanceof Player){
    if (this.frozen.contains(event.getEntity())) {
    	Player player = (Player) event.getEntity();
    	Player damager = (Player) event.getDamager();
    	damager.sendMessage(Utils.getLocalized(null, "FREEZE.FREEZE_DAMAGER", new Object[0]).replace("<player>", player.getName()));
    	event.setCancelled(true);
    }
    if (this.frozen.contains(event.getDamager())) {
      event.setCancelled(true);
    }
    if (this.panic.contains(event.getEntity())) {
    	Player player = (Player) event.getEntity();
    	Player damager = (Player) event.getDamager();
    	damager.sendMessage(Utils.getLocalized(null, "PANIC.PANIC_DAMAGER", new Object[0]).replace("<player>", player.getName()));
    	event.setCancelled(true);
      }
    if (this.panic.contains(event.getDamager())) {
        event.setCancelled(true);
      }
   }
    if ((event.getDamager() instanceof Projectile))
    {
      Projectile projectile1 = (Projectile)event.getDamager();
      if ((projectile1.getShooter() instanceof Player) && (event.getEntity() instanceof Player))
      {
        Player target = (Player)event.getEntity();
        Player player = (Player)projectile1.getShooter();
        if (this.frozen.contains(player) || this.frozen.contains(target)) {
          event.setCancelled(true);
        }
        if (this.panic.contains(player) || this.panic.contains(target)) {
            event.setCancelled(true);
          }
      }
    }
  }
  @EventHandler
  public void onEntityDamage(EntityDamageEvent event)
  {
	  if (event.getEntity() instanceof Player){
		Player player = (Player) event.getEntity();
		if (this.isFrozen(player) || this.isPanic(player)){
			event.setCancelled(true);
		}
	  }
  }
  @EventHandler
  public void onPlayerTelport(PlayerTeleportEvent event)
  {
    if ((event.getCause() == PlayerTeleportEvent.TeleportCause.ENDER_PEARL) && (this.frozen.contains(event.getPlayer())) || (this.panic.contains(event.getPlayer()))) {
      event.setTo(event.getFrom());
    }
  }

  @EventHandler
  public void onSplash(PotionSplashEvent event)
  {
    if (!this.frozen.isEmpty()) {
      try
      {
        Field eventField = PotionSplashEvent.class.getDeclaredField("affectedEntities");
        eventField.setAccessible(true);
        Map<?, ?> affectedEntities = (Map<?, ?>) eventField.get(event);
        Iterator<?> iterator = affectedEntities.entrySet().iterator();
        while (iterator.hasNext())
        {
          Map.Entry<?, ?> entry = (Entry<?, ?>) iterator.next();
          if (this.frozen.contains(entry.getKey())) {
            iterator.remove();
          }
          if (this.panic.contains(entry.getKey())) {
              iterator.remove();
            }
        }
        eventField.set(event, affectedEntities);
      }
      catch (Exception localException) {}
    }
  }

  @EventHandler
  public void onPlayerQuit(PlayerQuitEvent e)
  {
    Player p = e.getPlayer();
    if (this.frozen.contains(p))
    {
      this.frozen.remove(p);
      if (this.isEnableAutoban && p.hasPermission("freeze.logout.alert")){
      Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), "ban " + e.getPlayer().getName() + " " + Utils.getLocalized(null, "FREEZE.FREEZE_AUTOBAN_REASON", new Object[0]));
          Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&7&m------------------------------------"));
    	  Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', ""));
		  Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&c&lPlayer &4&l" + e.getPlayer().getName() + " &c&ldisconnected while he was frozen"));
		  Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', ""));
		  Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&7&m------------------------------------"));
      }
    }
    if (this.panic.contains(e.getPlayer()))
    {
    	this.panic.remove(e.getPlayer());
    }
  }

  @EventHandler
  public void onPlayerKick(PlayerKickEvent event)
  {
    if (this.frozen.contains(event.getPlayer())) {
      this.frozen.remove(event.getPlayer());
    }
    if (this.panic.contains(event.getPlayer())) {
        this.panic.remove(event.getPlayer());
      }
  }

  @EventHandler
  public void onPickup(PlayerPickupItemEvent event)
  {
    if (this.frozen.contains(event.getPlayer()) || this.panic.contains(event.getPlayer())) {
      event.setCancelled(true);
    }
  }

  @EventHandler
  public void onDrop(PlayerDropItemEvent event)
  {
    if (this.frozen.contains(event.getPlayer()) || this.panic.contains(event.getPlayer())) {
      event.setCancelled(true);
    }
  }

  @EventHandler
  public void onInteract(PlayerInteractEvent event)
  {
    if (this.frozen.contains(event.getPlayer()) || this.panic.contains(event.getPlayer())) {
      event.setCancelled(true);
    }
  }
	@EventHandler(ignoreCancelled=true, priority=EventPriority.MONITOR)
	public void onCommandFreeze(PlayerCommandPreprocessEvent e) {
      if (this.isFrozen(e.getPlayer())) {
          List<String> restrict;
          String commandd = e.getMessage();
          String firstt = commandd.split(" ")[0];
          int index = firstt.indexOf(":");
          if (index != -1) {
              commandd = "/" + commandd.substring(index + 1, commandd.length());
          }
          if ((restrict = this.getPlugin().getConfig().getStringList("Freeze.Disable-commands")) != null) {
              for (String str : restrict) {
                  if (e.getMessage().equalsIgnoreCase(str)){
                  Utils.sendLocalized(e.getPlayer(), "FREEZE.FREEZE_BLOCK_CMD", new Object[0]);
                  e.setCancelled(true);
                  return;
                  }
              }
          }
      }
      if (this.isPanic(e.getPlayer())) {
          List<String> restrictt;
          String commands = e.getMessage();
          String frst = commands.split(" ")[0];
          int indexx = frst.indexOf(":");
          if (indexx != -1) {
        	  commands = "/" + commands.substring(indexx + 1, commands.length());
          }
          if ((restrictt = this.getPlugin().getConfig().getStringList("Freeze.Disable-commands")) != null) {
              for (String strr : restrictt) {
                  if (e.getMessage().equalsIgnoreCase(strr)){
                  Utils.sendLocalized(e.getPlayer(), "PANIC.PANIC_BLOCK_CMD", new Object[0]);
                  e.setCancelled(true);
                  return;
                  }
              }
          }
      }
  }
}