L_PlayerInteract.java

package com.nicewuerfel.blockown.event;

import com.google.common.base.Optional;

import com.nicewuerfel.blockown.InvalidWorldNameException;
import com.nicewuerfel.blockown.Material;
import com.nicewuerfel.blockown.Message;
import com.nicewuerfel.blockown.OwnedBlock;
import com.nicewuerfel.blockown.OwnedEntity;
import com.nicewuerfel.blockown.Permission;
import com.nicewuerfel.blockown.Setting;
import com.nicewuerfel.blockown.User;
import com.nicewuerfel.blockown.WaitType;
import com.nicewuerfel.blockown.database.Database;
import com.nicewuerfel.blockown.database.DatabaseAction;
import com.nicewuerfel.blockown.protection.ProtectAction;
import com.nicewuerfel.blockown.protection.Protection;
import com.nicewuerfel.blockown.protection.ProtectionCause;

import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.Action;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.hanging.HangingBreakByEntityEvent;
import org.bukkit.event.player.PlayerInteractEntityEvent;
import org.bukkit.event.player.PlayerInteractEvent;

import javax.annotation.Nonnull;

public class L_PlayerInteract extends Listener {

  public L_PlayerInteract(Setting setting, Database database, Protection protection) {
    super(setting, database, protection);
  }

  private boolean checkValidity(Player player, @Nonnull OwnedBlock block)
      throws InvalidWorldNameException {
    if (block.getBlock().getType() == org.bukkit.Material.AIR) {
      return true;
    }

    if (!setting.isEnabledIn(block.getWorld())) {
      return true;
    }

    User user = User.getInstance(player.getUniqueId(), player);

    if (setting.isIgnoring(user)) {
      return true;
    }

    Optional<User> owner = database.getOwner(block);
    if (!owner.isPresent()) {
      return true;
    }
    ProtectionCause cause = user.getAccess(block.getMaterial(), owner.get());
    if (cause != ProtectionCause.NONE) {
      if (setting.PROTECTION.ENABLE_MESSAGES) {
        player.sendMessage(cause.getMessage(Message.BLOCK.getMessage(), owner.get().getName()));
      }
      return false;
    } else {
      return true;
    }
  }

  private boolean checkValidity(Player player, @Nonnull OwnedEntity entity)
      throws InvalidWorldNameException {
    if (!setting.isEnabledIn(entity.getWorld())) {
      return true;
    }

    User user = User.getInstance(player.getUniqueId(), player);

    if (setting.isIgnoring(user)) {
      return true;
    }

    Optional<User> owner = database.getOwner(entity);
    if (!owner.isPresent()) {
      return true;
    }
    ProtectionCause cause = user.getAccess(entity.getMaterial(), owner.get());
    if (cause != ProtectionCause.NONE) {
      if (setting.PROTECTION.ENABLE_MESSAGES) {
        player.sendMessage(cause.getMessage(Message.ENTITY.getMessage(), owner.get().getName()));
      }
      return false;
    } else {
      return true;
    }
  }

  @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
  public void onPlayerBlockInteract(PlayerInteractEvent event) {
    Block block = event.getClickedBlock();
    if (block == null) {
      return;
    }

    OwnedBlock ownedBlock = OwnedBlock.newInstance(block);

    try {
      if (setting.PROTECTION.ALLOW_RIGHT_CLICKS_ON.contains(ownedBlock.getMaterial())
          && event.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
        return;
      }

      if (!checkValidity(event.getPlayer(), ownedBlock)) {
        event.setCancelled(true);
      }
    } catch (InvalidWorldNameException ignored) {
    }
  }

  @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
  public void onPlayerEntityInteract(PlayerInteractEntityEvent event) {

    OwnedEntity entity = OwnedEntity.newInstance(event.getRightClicked());

    try {
      if (setting.PROTECTION.ALLOW_RIGHT_CLICKS_ON.contains(entity.getMaterial())) {
        return;
      }
      if (!checkValidity(event.getPlayer(), entity)) {
        event.setCancelled(true);
      }
    } catch (InvalidWorldNameException ignored) {
    }
  }

  @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
  public void onPlayerDamageEntity(EntityDamageByEntityEvent event) {
    if (event.getDamager() instanceof Player) {
      Player player = (Player) event.getDamager();
      OwnedEntity entity = OwnedEntity.newInstance(event.getEntity());
      try {
        if (!checkValidity(player, entity)) {
          event.setCancelled(true);
        }
      } catch (InvalidWorldNameException ignored) {
      }
    }
  }

  @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
  public void onPlayerBreakHanging(HangingBreakByEntityEvent event) {
    if (event.getRemover() instanceof Player) {
      Player player = (Player) event.getRemover();
      OwnedEntity entity = OwnedEntity.newInstance(event.getEntity());
      try {
        if (!checkValidity(player, entity)) {
          event.setCancelled(true);
        }
      } catch (InvalidWorldNameException ignored) {
      }
    }
  }

  /*
   * Handle entity choosing
   */
  @EventHandler(priority = EventPriority.LOWEST)
  public void onPlayerChooseEntity(PlayerInteractEntityEvent event) {
    if (!setting.isEnabledIn(event.getRightClicked().getWorld())) {
      return;
    }
    User user = User.getInstance(event.getPlayer().getUniqueId());

    WaitType waitType = setting.getWaiting(user);
    if (waitType == null) {
      return;
    }
    event.setCancelled(true);

    OwnedEntity entity = OwnedEntity.newInstance(event.getRightClicked());
    Material material;
    try {
      material = entity.getMaterial();
    } catch (InvalidWorldNameException e) {
      // can't happen, since the OwnedEntity is backed by a bukkit Entity
      getOutput().printError("This should never happen! L_PLAYERINTERACT", e);
      return;
    }
    if (!setting.isOwnEnabled(material)) {
      return;
    }
    Optional<User> owner = database.getOwner(entity);
    Player player = event.getPlayer();

    ProtectAction protectAction;
    DatabaseAction databaseAction;
    switch (waitType) {
      case SHOW_OWNER_ENTITY:
        if (!owner.isPresent()) {
          player
              .sendMessage(Message.COMMAND_SHOWOWNER_ENTITY_UNOWNED.getMessage(material.getName()));
        } else {
          player.sendMessage(Message.COMMAND_SHOWOWNER_ENTITY_FOUND
              .getMessage(owner.get().getName(), material.getName()));
        }
        break;
      case OWN_ENTITY:
        if (!owner.isPresent()) {
          databaseAction = DatabaseAction.newOwnInstance(entity, user);
          database.enqueue(databaseAction);
          player.sendMessage(Message.COMMAND_OWN_ENTITYSUCCESS.getMessage(material.getName()));
        } else {
          if (!owner.get().equals(user)) {
            player.sendMessage(Message.COMMAND_OWN_NOPERMISSIONFOROTHERS.getMessage());
          }
        }
        break;
      case UNOWN_ENTITY:
        if (!owner.isPresent() || owner.get().equals(user)
            || player.hasPermission(Permission.ADMIN_UNOWN.toString())) {
          databaseAction = DatabaseAction.newUnownInstance(entity);
          database.enqueue(databaseAction);
          player.sendMessage(Message.COMMAND_UNOWN_ENTITYSUCCESS.getMessage(material.getName()));
        } else {
          player.sendMessage(Message.COMMAND_UNOWN_FOROTHERS_NOTALLOWED.getMessage());
        }
        break;
      case PROTECT_ENTITY:
        protectAction = new ProtectAction.Builder(user).protect(material).build();
        protection.enqueue(protectAction);
        player.sendMessage(Message.COMMAND_PROTECT_SUCCESS.getMessage(material.getName()));
        player.sendMessage(Message.COMMAND_NO_MORE_CLICK_WAITING.getMessage());
        setting.removeWaiting(user);
        break;
      case UNPROTECT_ENTITY:
        protectAction = new ProtectAction.Builder(user).unprotect(material).build();
        protection.enqueue(protectAction);
        player.sendMessage(Message.COMMAND_UNPROTECT_SUCCESS.getMessage(material.getName()));
        player.sendMessage(Message.COMMAND_NO_MORE_CLICK_WAITING.getMessage());
        setting.removeWaiting(user);
        break;
      case LOCK_ENTITY:
        protectAction = new ProtectAction.Builder(user).lock(material).build();
        protection.enqueue(protectAction);
        player.sendMessage(Message.COMMAND_LOCK_SUCCESS.getMessage(material.getName()));
        player.sendMessage(Message.COMMAND_NO_MORE_CLICK_WAITING.getMessage());
        setting.removeWaiting(user);
        break;
      case UNLOCK_ENTITY:
        protectAction = new ProtectAction.Builder(user).unlock(material).build();
        protection.enqueue(protectAction);
        player.sendMessage(Message.COMMAND_UNLOCK_SUCCESS.getMessage(material.getName()));
        player.sendMessage(Message.COMMAND_NO_MORE_CLICK_WAITING.getMessage());
        setting.removeWaiting(user);
        break;
      default:
        break;
    }
  }

  /*
   * Handle block choosing
   */
  @EventHandler(priority = EventPriority.LOWEST)
  public void onPlayerChooseBlock(PlayerInteractEvent event) {
    if (event.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {

      Block nativeBlock = event.getClickedBlock();
      if (!setting.isEnabledIn(nativeBlock.getWorld())) {
        return;
      }
      User user = User.getInstance(event.getPlayer().getUniqueId());

      WaitType waitType = setting.getWaiting(user);
      if (waitType == null) {
        return;
      }
      event.setCancelled(true);

      OwnedBlock block = OwnedBlock.newInstance(nativeBlock);
      Material material;
      try {
        material = block.getMaterial();
      } catch (InvalidWorldNameException e) {
        // can't happen, since the OwnedBlock is backed by a bukkit Block
        getOutput().printError("This should never happen! L_PLAYERINTERACT", e);
        return;
      }
      if (!setting.isOwnEnabled(material)) {
        return;
      }
      Optional<User> owner = database.getOwner(block);
      Player player = event.getPlayer();

      ProtectAction protectAction;
      DatabaseAction databaseAction;

      switch (waitType) {
        case SHOW_OWNER_BLOCK:
          if (!owner.isPresent()) {
            player.sendMessage(
                Message.COMMAND_SHOWOWNER_BLOCK_UNOWNED.getMessage(material.getName()));
          } else {
            player.sendMessage(Message.COMMAND_SHOWOWNER_BLOCK_FOUND
                .getMessage(owner.get().getName(), material.getName()));
          }
          break;
        case OWN_BLOCK:
          if (!owner.isPresent()) {
            databaseAction = DatabaseAction.newOwnInstance(block, user);
            database.enqueue(databaseAction);
            player.sendMessage(Message.COMMAND_OWN_BLOCKSUCCESS.getMessage(material.getName()));
          } else {
            if (!owner.get().equals(user)) {
              player.sendMessage(Message.COMMAND_OWN_NOPERMISSIONFOROTHERS.getMessage());
            }
          }
          break;
        case UNOWN_BLOCK:
          if (!owner.isPresent() || owner.get().equals(user)
              || player.hasPermission(Permission.ADMIN_UNOWN.toString())) {
            databaseAction = DatabaseAction.newUnownInstance(block);
            database.enqueue(databaseAction);
            player.sendMessage(Message.COMMAND_UNOWN_BLOCKSUCCESS.getMessage(material.getName()));
          } else {
            player.sendMessage(Message.COMMAND_UNOWN_FOROTHERS_NOTALLOWED.getMessage());
          }
          break;
        case PROTECT_BLOCK:
          protectAction = new ProtectAction.Builder(user).protect(material).build();
          protection.enqueue(protectAction);
          player.sendMessage(Message.COMMAND_PROTECT_SUCCESS.getMessage(material.getName()));
          player.sendMessage(Message.COMMAND_NO_MORE_CLICK_WAITING.getMessage());
          setting.removeWaiting(user);
          break;
        case UNPROTECT_BLOCK:
          protectAction = new ProtectAction.Builder(user).unprotect(material).build();
          protection.enqueue(protectAction);
          player.sendMessage(Message.COMMAND_UNPROTECT_SUCCESS.getMessage(material.getName()));
          player.sendMessage(Message.COMMAND_NO_MORE_CLICK_WAITING.getMessage());
          setting.removeWaiting(user);
          break;
        case LOCK_BLOCK:
          protectAction = new ProtectAction.Builder(user).lock(material).build();
          protection.enqueue(protectAction);
          player.sendMessage(Message.COMMAND_LOCK_SUCCESS.getMessage(material.getName()));
          player.sendMessage(Message.COMMAND_NO_MORE_CLICK_WAITING.getMessage());
          setting.removeWaiting(user);
          break;
        case UNLOCK_BLOCK:
          protectAction = new ProtectAction.Builder(user).unlock(material).build();
          protection.enqueue(protectAction);
          player.sendMessage(Message.COMMAND_UNLOCK_SUCCESS.getMessage(material.getName()));
          player.sendMessage(Message.COMMAND_NO_MORE_CLICK_WAITING.getMessage());
          setting.removeWaiting(user);
          break;
        default:
          break;
      }
    }
  }
}