package me.ryanhamshire.GriefPrevention;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import me.ryanhamshire.GriefPrevention.events.PreventBlockBreakEvent;
import me.ryanhamshire.GriefPrevention.events.SaveTrappedPlayerEvent;
import net.milkbowl.vault.economy.Economy;
import org.bukkit.BanList;
import org.bukkit.BanList.Type;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Chunk;
import org.bukkit.ChunkSnapshot;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.OfflinePlayer;
import org.bukkit.Server;
import org.bukkit.Statistic;
import org.bukkit.World;
import org.bukkit.World.Environment;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.FileConfigurationOptions;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.inventory.EquipmentSlot;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
import org.bukkit.material.MaterialData;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.RegisteredServiceProvider;
import org.bukkit.plugin.ServicesManager;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitScheduler;
import org.bukkit.scheduler.BukkitTask;
import org.bukkit.util.BlockIterator;

public class GriefPrevention
  extends JavaPlugin
{
  public static GriefPrevention instance;
  private static Logger log;
  public DataStore dataStore;
  ArrayList<PendingItemProtection> pendingItemWatchList = new ArrayList();
  CustomLogger customLogger;
  public ConcurrentHashMap<World, ClaimsMode> config_claims_worldModes;
  private boolean config_creativeWorldsExist;
  public boolean config_claims_preventGlobalMonsterEggs;
  public boolean config_claims_preventTheft;
  public boolean config_claims_protectCreatures;
  public boolean config_claims_protectHorses;
  public boolean config_claims_preventButtonsSwitches;
  public boolean config_claims_lockWoodenDoors;
  public boolean config_claims_lockTrapDoors;
  public boolean config_claims_lockFenceGates;
  public boolean config_claims_enderPearlsRequireAccessTrust;
  public int config_claims_maxClaimsPerPlayer;
  public boolean config_claims_respectWorldGuard;
  public boolean config_claims_portalsRequirePermission;
  public boolean config_claims_villagerTradingRequiresTrust;
  public int config_claims_initialBlocks;
  public double config_claims_abandonReturnRatio;
  public int config_claims_blocksAccruedPerHour_default;
  public int config_claims_maxAccruedBlocks_default;
  public int config_claims_accruedIdleThreshold;
  public int config_claims_accruedIdlePercent;
  public int config_claims_maxDepth;
  public int config_claims_expirationDays;
  public int config_claims_expirationExemptionTotalBlocks;
  public int config_claims_expirationExemptionBonusBlocks;
  public int config_claims_automaticClaimsForNewPlayersRadius;
  public int config_claims_claimsExtendIntoGroundDistance;
  public int config_claims_minWidth;
  public int config_claims_minArea;
  public int config_claims_chestClaimExpirationDays;
  public int config_claims_unusedClaimExpirationDays;
  public boolean config_claims_survivalAutoNatureRestoration;
  public boolean config_claims_allowTrappedInAdminClaims;
  public Material config_claims_investigationTool;
  public Material config_claims_modificationTool;
  public ArrayList<String> config_claims_commandsRequiringAccessTrust;
  public boolean config_claims_supplyPlayerManual;
  public int config_claims_manualDeliveryDelaySeconds;
  public ArrayList<World> config_siege_enabledWorlds;
  public ArrayList<Material> config_siege_blocks;
  public boolean config_spam_enabled;
  public int config_spam_loginCooldownSeconds;
  public int config_spam_loginLogoutNotificationsPerMinute;
  public ArrayList<String> config_spam_monitorSlashCommands;
  public boolean config_spam_banOffenders;
  public String config_spam_banMessage;
  public String config_spam_warningMessage;
  public String config_spam_allowedIpAddresses;
  public int config_spam_deathMessageCooldownSeconds;
  public int config_spam_logoutMessageDelaySeconds;
  HashMap<World, Boolean> config_pvp_specifiedWorlds;
  public boolean config_pvp_protectFreshSpawns;
  public boolean config_pvp_punishLogout;
  public int config_pvp_combatTimeoutSeconds;
  public boolean config_pvp_allowCombatItemDrop;
  public ArrayList<String> config_pvp_blockedCommands;
  public boolean config_pvp_noCombatInPlayerLandClaims;
  public boolean config_pvp_noCombatInAdminLandClaims;
  public boolean config_pvp_noCombatInAdminSubdivisions;
  public boolean config_pvp_allowLavaNearPlayers;
  public boolean config_pvp_allowFireNearPlayers;
  public boolean config_pvp_protectPets;
  public boolean config_lockDeathDropsInPvpWorlds;
  public boolean config_lockDeathDropsInNonPvpWorlds;
  public double config_economy_claimBlocksPurchaseCost;
  public double config_economy_claimBlocksSellValue;
  public boolean config_blockClaimExplosions;
  public boolean config_blockSurfaceCreeperExplosions;
  public boolean config_blockSurfaceOtherExplosions;
  public boolean config_blockSkyTrees;
  public boolean config_fireSpreads;
  public boolean config_fireDestroys;
  public boolean config_whisperNotifications;
  public boolean config_signNotifications;
  public ArrayList<String> config_eavesdrop_whisperCommands;
  public boolean config_smartBan;
  public boolean config_endermenMoveBlocks;
  public boolean config_silverfishBreakBlocks;
  public boolean config_creaturesTrampleCrops;
  public boolean config_rabbitsEatCrops;
  public boolean config_zombiesBreakDoors;
  public int config_ipLimit;
  public boolean config_trollFilterEnabled;
  public MaterialCollection config_mods_accessTrustIds;
  public MaterialCollection config_mods_containerTrustIds;
  public List<String> config_mods_ignoreClaimsAccounts;
  public MaterialCollection config_mods_explodableIds;
  public HashMap<String, Integer> config_seaLevelOverride;
  public boolean config_limitTreeGrowth;
  public boolean config_pistonsInClaimsOnly;
  public int config_logs_daysToKeep;
  public boolean config_logs_socialEnabled;
  public boolean config_logs_suspiciousEnabled;
  public boolean config_logs_adminEnabled;
  public boolean config_logs_debugEnabled;
  public boolean config_logs_mutedChatEnabled;
  public boolean config_ban_useCommand;
  public String config_ban_commandFormat;
  private String databaseUrl;
  private String databaseUserName;
  private String databasePassword;
  public static Economy economy = null;
  public static final int TREE_RADIUS = 5;
  public static final int NOTIFICATION_SECONDS = 20;

  public static synchronized void AddLogEntry(String entry, CustomLogEntryTypes customLogType, boolean excludeFromServerLogs)
  {
    if ((customLogType != null) && (instance.customLogger != null)) {
      instance.customLogger.AddEntry(entry, customLogType);
    }
    if (!excludeFromServerLogs) {
      log.info(entry);
    }
  }

  public static synchronized void AddLogEntry(String entry, CustomLogEntryTypes customLogType)
  {
    AddLogEntry(entry, customLogType, false);
  }

  public static synchronized void AddLogEntry(String entry)
  {
    AddLogEntry(entry, CustomLogEntryTypes.Debug);
  }

  public void onEnable()
  {
    instance = this;
    log = instance.getLogger();

    loadConfig();

    this.customLogger = new CustomLogger();

    AddLogEntry("Finished loading configuration.");
    if (this.databaseUrl.length() > 0) {
      try
      {
        DatabaseDataStore databaseStore = new DatabaseDataStore(this.databaseUrl, this.databaseUserName, this.databasePassword);
        if (FlatFileDataStore.hasData())
        {
          AddLogEntry("There appears to be some data on the hard drive.  Migrating those data to the database...");
          FlatFileDataStore flatFileStore = new FlatFileDataStore();
          this.dataStore = flatFileStore;
          flatFileStore.migrateData(databaseStore);
          AddLogEntry("Data migration process complete.  Reloading data from the database...");
          databaseStore.close();
          databaseStore = new DatabaseDataStore(this.databaseUrl, this.databaseUserName, this.databasePassword);
        }
        this.dataStore = databaseStore;
      }
      catch (Exception e)
      {
        AddLogEntry("Because there was a problem with the database, GriefPrevention will not function properly.  Either update the database config settings resolve the issue, or delete those lines from your config.yml so that GriefPrevention can use the file system to store data.");
        e.printStackTrace();
        getServer().getPluginManager().disablePlugin(this);
        return;
      }
    }
    if (this.dataStore == null)
    {
      File oldclaimdata = new File(getDataFolder(), "ClaimData");
      if ((oldclaimdata.exists()) &&
        (!FlatFileDataStore.hasData()))
      {
        File claimdata = new File("plugins" + File.separator + "GriefPreventionData" + File.separator + "ClaimData");
        oldclaimdata.renameTo(claimdata);
        File oldplayerdata = new File(getDataFolder(), "PlayerData");
        File playerdata = new File("plugins" + File.separator + "GriefPreventionData" + File.separator + "PlayerData");
        oldplayerdata.renameTo(playerdata);
      }
      try
      {
        this.dataStore = new FlatFileDataStore();
      }
      catch (Exception e)
      {
        AddLogEntry("Unable to initialize the file system data store.  Details:");
        AddLogEntry(e.getMessage());
        e.printStackTrace();
      }
    }
    String dataMode = (this.dataStore instanceof FlatFileDataStore) ? "(File Mode)" : "(Database Mode)";
    AddLogEntry("Finished loading data " + dataMode + ".");
    if (this.config_claims_blocksAccruedPerHour_default > 0)
    {
      DeliverClaimBlocksTask task = new DeliverClaimBlocksTask(null, this);
      getServer().getScheduler().scheduleSyncRepeatingTask(this, task, 12000L, 12000L);
    }
    EntityCleanupTask task = new EntityCleanupTask(0.0D);
    getServer().getScheduler().scheduleSyncDelayedTask(instance, task, 2400L);

    FindUnusedClaimsTask task2 = new FindUnusedClaimsTask();
    getServer().getScheduler().scheduleSyncRepeatingTask(this, task2, 1200L, 1200L);

    PluginManager pluginManager = getServer().getPluginManager();

    PlayerEventHandler playerEventHandler = new PlayerEventHandler(this.dataStore, this);
    pluginManager.registerEvents(playerEventHandler, this);

    BlockEventHandler blockEventHandler = new BlockEventHandler(this.dataStore);
    pluginManager.registerEvents(blockEventHandler, this);

    EntityEventHandler entityEventHandler = new EntityEventHandler(this.dataStore, this);
    pluginManager.registerEvents(entityEventHandler, this);
    if ((this.config_economy_claimBlocksPurchaseCost > 0.0D) || (this.config_economy_claimBlocksSellValue > 0.0D))
    {
      AddLogEntry("GriefPrevention requires Vault for economy integration.");
      AddLogEntry("Attempting to load Vault...");
      RegisteredServiceProvider<Economy> economyProvider = getServer().getServicesManager().getRegistration(Economy.class);
      AddLogEntry("Vault loaded successfully!");

      AddLogEntry("Looking for a Vault-compatible economy plugin...");
      if (economyProvider != null)
      {
        economy = (Economy)economyProvider.getProvider();
        if (economy != null)
        {
          AddLogEntry("Hooked into economy: " + economy.getName() + ".");
          AddLogEntry("Ready to buy/sell claim blocks!");
        }
        else
        {
          AddLogEntry("ERROR: Vault was unable to find a supported economy plugin.  Either install a Vault-compatible economy plugin, or set both of the economy config variables to zero.");
        }
      }
      else
      {
        AddLogEntry("ERROR: Vault was unable to find a supported economy plugin.  Either install a Vault-compatible economy plugin, or set both of the economy config variables to zero.");
      }
    }
    OfflinePlayer[] offlinePlayers = getServer().getOfflinePlayers();
    CacheOfflinePlayerNamesThread namesThread = new CacheOfflinePlayerNamesThread(offlinePlayers, this.playerNameToIDMap);
    namesThread.setPriority(1);
    namesThread.start();

    Collection<Player> players = instance.getServer().getOnlinePlayers();
    for (Player player : players) {
      new IgnoreLoaderThread(player.getUniqueId(), this.dataStore.getPlayerData(player.getUniqueId()).ignoredPlayers).start();
    }
    AddLogEntry("Boot finished.");
  }

  private void loadConfig()
  {
    FileConfiguration config = YamlConfiguration.loadConfiguration(new File(DataStore.configFilePath));
    FileConfiguration outConfig = new YamlConfiguration();
    outConfig.options().header("Default values are perfect for most servers.  If you want to customize and have a question, look for the answer here first: http://dev.bukkit.org/bukkit-plugins/grief-prevention/pages/setup-and-configuration/");

    List<World> worlds = getServer().getWorlds();
    List<String> deprecated_claimsEnabledWorldNames = config.getStringList("GriefPrevention.Claims.Worlds");
    for (int i = 0; i < deprecated_claimsEnabledWorldNames.size(); i++)
    {
      String worldName = (String)deprecated_claimsEnabledWorldNames.get(i);
      World world = getServer().getWorld(worldName);
      if (world == null) {
        deprecated_claimsEnabledWorldNames.remove(i--);
      }
    }
    List<String> deprecated_creativeClaimsEnabledWorldNames = config.getStringList("GriefPrevention.Claims.CreativeRulesWorlds");
    for (int i = 0; i < deprecated_creativeClaimsEnabledWorldNames.size(); i++)
    {
      String worldName = (String)deprecated_creativeClaimsEnabledWorldNames.get(i);
      World world = getServer().getWorld(worldName);
      if (world == null) {
        deprecated_claimsEnabledWorldNames.remove(i--);
      }
    }
    this.config_claims_worldModes = new ConcurrentHashMap();
    this.config_creativeWorldsExist = false;
    for (World world : worlds)
    {
      String configSetting = config.getString("GriefPrevention.Claims.Mode." + world.getName());
      if (configSetting != null)
      {
        ClaimsMode claimsMode = configStringToClaimsMode(configSetting);
        if (claimsMode != null)
        {
          this.config_claims_worldModes.put(world, claimsMode);
          if (claimsMode == ClaimsMode.Creative) {
            this.config_creativeWorldsExist = true;
          }
        }
        else
        {
          AddLogEntry("Error: Invalid claim mode \"" + configSetting + "\".  Options are Survival, Creative, and Disabled.");
          this.config_claims_worldModes.put(world, ClaimsMode.Creative);
          this.config_creativeWorldsExist = true;
        }
      }
      else
      {
        if (deprecated_creativeClaimsEnabledWorldNames.contains(world.getName()))
        {
          this.config_claims_worldModes.put(world, ClaimsMode.Creative);
          this.config_creativeWorldsExist = true;
        }
        else if (deprecated_claimsEnabledWorldNames.contains(world.getName()))
        {
          this.config_claims_worldModes.put(world, ClaimsMode.Survival);
        }
        else if (world.getName().toLowerCase().contains("survival"))
        {
          this.config_claims_worldModes.put(world, ClaimsMode.Survival);
        }
        else if (world.getName().toLowerCase().contains("creative"))
        {
          this.config_claims_worldModes.put(world, ClaimsMode.Creative);
          this.config_creativeWorldsExist = true;
        }
        else if (getServer().getDefaultGameMode() == GameMode.CREATIVE)
        {
          this.config_claims_worldModes.put(world, ClaimsMode.Creative);
          this.config_creativeWorldsExist = true;
        }
        else if (world.getEnvironment() == World.Environment.NORMAL)
        {
          this.config_claims_worldModes.put(world, ClaimsMode.Survival);
        }
        else
        {
          this.config_claims_worldModes.put(world, ClaimsMode.Disabled);
        }
        if ((this.config_claims_worldModes.get(world) == ClaimsMode.Disabled) &&
          (deprecated_claimsEnabledWorldNames.size() > 0)) {
          this.config_claims_worldModes.put(world, ClaimsMode.Survival);
        }
      }
    }
    this.config_pvp_specifiedWorlds = new HashMap();
    for (World world : worlds)
    {
      boolean pvpWorld = config.getBoolean("GriefPrevention.PvP.RulesEnabledInWorld." + world.getName(), world.getPVP());
      this.config_pvp_specifiedWorlds.put(world, Boolean.valueOf(pvpWorld));
    }
    this.config_seaLevelOverride = new HashMap();
    for (int i = 0; i < worlds.size(); i++)
    {
      int seaLevelOverride = config.getInt("GriefPrevention.SeaLevelOverrides." + ((World)worlds.get(i)).getName(), -1);
      outConfig.set("GriefPrevention.SeaLevelOverrides." + ((World)worlds.get(i)).getName(), Integer.valueOf(seaLevelOverride));
      this.config_seaLevelOverride.put(((World)worlds.get(i)).getName(), Integer.valueOf(seaLevelOverride));
    }
    this.config_claims_preventGlobalMonsterEggs = config.getBoolean("GriefPrevention.Claims.PreventGlobalMonsterEggs", true);
    this.config_claims_preventTheft = config.getBoolean("GriefPrevention.Claims.PreventTheft", true);
    this.config_claims_protectCreatures = config.getBoolean("GriefPrevention.Claims.ProtectCreatures", true);
    this.config_claims_protectHorses = config.getBoolean("GriefPrevention.Claims.ProtectHorses", true);
    this.config_claims_preventButtonsSwitches = config.getBoolean("GriefPrevention.Claims.PreventButtonsSwitches", true);
    this.config_claims_lockWoodenDoors = config.getBoolean("GriefPrevention.Claims.LockWoodenDoors", false);
    this.config_claims_lockTrapDoors = config.getBoolean("GriefPrevention.Claims.LockTrapDoors", false);
    this.config_claims_lockFenceGates = config.getBoolean("GriefPrevention.Claims.LockFenceGates", true);
    this.config_claims_enderPearlsRequireAccessTrust = config.getBoolean("GriefPrevention.Claims.EnderPearlsRequireAccessTrust", true);
    this.config_claims_initialBlocks = config.getInt("GriefPrevention.Claims.InitialBlocks", 100);
    this.config_claims_blocksAccruedPerHour_default = config.getInt("GriefPrevention.Claims.BlocksAccruedPerHour", 100);
    this.config_claims_blocksAccruedPerHour_default = config.getInt("GriefPrevention.Claims.Claim Blocks Accrued Per Hour.Default", this.config_claims_blocksAccruedPerHour_default);
    this.config_claims_maxAccruedBlocks_default = config.getInt("GriefPrevention.Claims.MaxAccruedBlocks", 2000);
    this.config_claims_maxAccruedBlocks_default = config.getInt("GriefPrevention.Claims.Max Accrued Claim Blocks.Default", this.config_claims_maxAccruedBlocks_default);
    this.config_claims_accruedIdleThreshold = config.getInt("GriefPrevention.Claims.AccruedIdleThreshold", 0);
    this.config_claims_accruedIdleThreshold = config.getInt("GriefPrevention.Claims.Accrued Idle Threshold", this.config_claims_accruedIdleThreshold);
    this.config_claims_accruedIdlePercent = config.getInt("GriefPrevention.Claims.AccruedIdlePercent", 0);
    this.config_claims_abandonReturnRatio = config.getDouble("GriefPrevention.Claims.AbandonReturnRatio", 1.0D);
    this.config_claims_automaticClaimsForNewPlayersRadius = config.getInt("GriefPrevention.Claims.AutomaticNewPlayerClaimsRadius", 4);
    this.config_claims_claimsExtendIntoGroundDistance = Math.abs(config.getInt("GriefPrevention.Claims.ExtendIntoGroundDistance", 5));
    this.config_claims_minWidth = config.getInt("GriefPrevention.Claims.MinimumWidth", 5);
    this.config_claims_minArea = config.getInt("GriefPrevention.Claims.MinimumArea", 100);
    this.config_claims_maxDepth = config.getInt("GriefPrevention.Claims.MaximumDepth", 0);
    this.config_claims_chestClaimExpirationDays = config.getInt("GriefPrevention.Claims.Expiration.ChestClaimDays", 7);
    this.config_claims_unusedClaimExpirationDays = config.getInt("GriefPrevention.Claims.Expiration.UnusedClaimDays", 14);
    this.config_claims_expirationDays = config.getInt("GriefPrevention.Claims.Expiration.AllClaims.DaysInactive", 60);
    this.config_claims_expirationExemptionTotalBlocks = config.getInt("GriefPrevention.Claims.Expiration.AllClaims.ExceptWhenOwnerHasTotalClaimBlocks", 10000);
    this.config_claims_expirationExemptionBonusBlocks = config.getInt("GriefPrevention.Claims.Expiration.AllClaims.ExceptWhenOwnerHasBonusClaimBlocks", 5000);
    this.config_claims_survivalAutoNatureRestoration = config.getBoolean("GriefPrevention.Claims.Expiration.AutomaticNatureRestoration.SurvivalWorlds", false);
    this.config_claims_allowTrappedInAdminClaims = config.getBoolean("GriefPrevention.Claims.AllowTrappedInAdminClaims", false);

    this.config_claims_maxClaimsPerPlayer = config.getInt("GriefPrevention.Claims.MaximumNumberOfClaimsPerPlayer", 0);
    this.config_claims_respectWorldGuard = config.getBoolean("GriefPrevention.Claims.CreationRequiresWorldGuardBuildPermission", true);
    this.config_claims_portalsRequirePermission = config.getBoolean("GriefPrevention.Claims.PortalGenerationRequiresPermission", false);
    this.config_claims_villagerTradingRequiresTrust = config.getBoolean("GriefPrevention.Claims.VillagerTradingRequiresPermission", true);
    String accessTrustSlashCommands = config.getString("GriefPrevention.Claims.CommandsRequiringAccessTrust", "/sethome");
    this.config_claims_supplyPlayerManual = config.getBoolean("GriefPrevention.Claims.DeliverManuals", true);
    this.config_claims_manualDeliveryDelaySeconds = config.getInt("GriefPrevention.Claims.ManualDeliveryDelaySeconds", 30);

    this.config_spam_enabled = config.getBoolean("GriefPrevention.Spam.Enabled", true);
    this.config_spam_loginCooldownSeconds = config.getInt("GriefPrevention.Spam.LoginCooldownSeconds", 60);
    this.config_spam_loginLogoutNotificationsPerMinute = config.getInt("GriefPrevention.Spam.LoginLogoutNotificationsPerMinute", 5);
    this.config_spam_warningMessage = config.getString("GriefPrevention.Spam.WarningMessage", "Please reduce your noise level.  Spammers will be banned.");
    this.config_spam_allowedIpAddresses = config.getString("GriefPrevention.Spam.AllowedIpAddresses", "1.2.3.4; 5.6.7.8");
    this.config_spam_banOffenders = config.getBoolean("GriefPrevention.Spam.BanOffenders", true);
    this.config_spam_banMessage = config.getString("GriefPrevention.Spam.BanMessage", "Banned for spam.");
    String slashCommandsToMonitor = config.getString("GriefPrevention.Spam.MonitorSlashCommands", "/me;/global;/local");
    slashCommandsToMonitor = config.getString("GriefPrevention.Spam.ChatSlashCommands", slashCommandsToMonitor);
    this.config_spam_deathMessageCooldownSeconds = config.getInt("GriefPrevention.Spam.DeathMessageCooldownSeconds", 120);
    this.config_spam_logoutMessageDelaySeconds = config.getInt("GriefPrevention.Spam.Logout Message Delay In Seconds", 0);

    this.config_pvp_protectFreshSpawns = config.getBoolean("GriefPrevention.PvP.ProtectFreshSpawns", true);
    this.config_pvp_punishLogout = config.getBoolean("GriefPrevention.PvP.PunishLogout", true);
    this.config_pvp_combatTimeoutSeconds = config.getInt("GriefPrevention.PvP.CombatTimeoutSeconds", 15);
    this.config_pvp_allowCombatItemDrop = config.getBoolean("GriefPrevention.PvP.AllowCombatItemDrop", false);
    String bannedPvPCommandsList = config.getString("GriefPrevention.PvP.BlockedSlashCommands", "/home;/vanish;/spawn;/tpa");

    this.config_economy_claimBlocksPurchaseCost = config.getDouble("GriefPrevention.Economy.ClaimBlocksPurchaseCost", 0.0D);
    this.config_economy_claimBlocksSellValue = config.getDouble("GriefPrevention.Economy.ClaimBlocksSellValue", 0.0D);

    this.config_lockDeathDropsInPvpWorlds = config.getBoolean("GriefPrevention.ProtectItemsDroppedOnDeath.PvPWorlds", false);
    this.config_lockDeathDropsInNonPvpWorlds = config.getBoolean("GriefPrevention.ProtectItemsDroppedOnDeath.NonPvPWorlds", true);

    this.config_blockClaimExplosions = config.getBoolean("GriefPrevention.BlockLandClaimExplosions", true);
    this.config_blockSurfaceCreeperExplosions = config.getBoolean("GriefPrevention.BlockSurfaceCreeperExplosions", true);
    this.config_blockSurfaceOtherExplosions = config.getBoolean("GriefPrevention.BlockSurfaceOtherExplosions", true);
    this.config_blockSkyTrees = config.getBoolean("GriefPrevention.LimitSkyTrees", true);
    this.config_limitTreeGrowth = config.getBoolean("GriefPrevention.LimitTreeGrowth", false);
    this.config_pistonsInClaimsOnly = config.getBoolean("GriefPrevention.LimitPistonsToLandClaims", true);

    this.config_fireSpreads = config.getBoolean("GriefPrevention.FireSpreads", false);
    this.config_fireDestroys = config.getBoolean("GriefPrevention.FireDestroys", false);

    this.config_whisperNotifications = config.getBoolean("GriefPrevention.AdminsGetWhispers", true);
    this.config_signNotifications = config.getBoolean("GriefPrevention.AdminsGetSignNotifications", true);
    String whisperCommandsToMonitor = config.getString("GriefPrevention.WhisperCommands", "/tell;/pm;/r;/whisper;/msg");
    whisperCommandsToMonitor = config.getString("GriefPrevention.Spam.WhisperSlashCommands", whisperCommandsToMonitor);

    this.config_smartBan = config.getBoolean("GriefPrevention.SmartBan", true);
    this.config_trollFilterEnabled = config.getBoolean("GriefPrevention.Mute New Players Using Banned Words", true);
    this.config_ipLimit = config.getInt("GriefPrevention.MaxPlayersPerIpAddress", 3);

    this.config_endermenMoveBlocks = config.getBoolean("GriefPrevention.EndermenMoveBlocks", false);
    this.config_silverfishBreakBlocks = config.getBoolean("GriefPrevention.SilverfishBreakBlocks", false);
    this.config_creaturesTrampleCrops = config.getBoolean("GriefPrevention.CreaturesTrampleCrops", false);
    this.config_rabbitsEatCrops = config.getBoolean("GriefPrevention.RabbitsEatCrops", true);
    this.config_zombiesBreakDoors = config.getBoolean("GriefPrevention.HardModeZombiesBreakDoors", false);
    this.config_ban_useCommand = config.getBoolean("GriefPrevention.UseBanCommand", false);
    this.config_ban_commandFormat = config.getString("GriefPrevention.BanCommandPattern", "ban %name% %reason%");

    this.config_mods_ignoreClaimsAccounts = config.getStringList("GriefPrevention.Mods.PlayersIgnoringAllClaims");
    if (this.config_mods_ignoreClaimsAccounts == null) {
      this.config_mods_ignoreClaimsAccounts = new ArrayList();
    }
    this.config_mods_accessTrustIds = new MaterialCollection();
    List<String> accessTrustStrings = config.getStringList("GriefPrevention.Mods.BlockIdsRequiringAccessTrust");

    parseMaterialListFromConfig(accessTrustStrings, this.config_mods_accessTrustIds);

    this.config_mods_containerTrustIds = new MaterialCollection();
    List<String> containerTrustStrings = config.getStringList("GriefPrevention.Mods.BlockIdsRequiringContainerTrust");
    if ((containerTrustStrings == null) || (containerTrustStrings.size() == 0)) {
      containerTrustStrings.add(new MaterialInfo(99999, "Example - ID 99999, all data values.").toString());
    }
    parseMaterialListFromConfig(containerTrustStrings, this.config_mods_containerTrustIds);

    this.config_mods_explodableIds = new MaterialCollection();
    List<String> explodableStrings = config.getStringList("GriefPrevention.Mods.BlockIdsExplodable");

    parseMaterialListFromConfig(explodableStrings, this.config_mods_explodableIds);

    String investigationToolMaterialName = Material.STICK.name();

    investigationToolMaterialName = config.getString("GriefPrevention.Claims.InvestigationTool", investigationToolMaterialName);

    this.config_claims_investigationTool = Material.getMaterial(investigationToolMaterialName);
    if (this.config_claims_investigationTool == null)
    {
      AddLogEntry("ERROR: Material " + investigationToolMaterialName + " not found.  Defaulting to the stick.  Please update your config.yml.");
      this.config_claims_investigationTool = Material.STICK;
    }
    String modificationToolMaterialName = Material.GOLD_SPADE.name();

    modificationToolMaterialName = config.getString("GriefPrevention.Claims.ModificationTool", modificationToolMaterialName);

    this.config_claims_modificationTool = Material.getMaterial(modificationToolMaterialName);
    if (this.config_claims_modificationTool == null)
    {
      AddLogEntry("ERROR: Material " + modificationToolMaterialName + " not found.  Defaulting to the golden shovel.  Please update your config.yml.");
      this.config_claims_modificationTool = Material.GOLD_SPADE;
    }
    ArrayList<String> defaultSiegeWorldNames = new ArrayList();

    List<String> siegeEnabledWorldNames = config.getStringList("GriefPrevention.Siege.Worlds");
    if (siegeEnabledWorldNames == null) {
      siegeEnabledWorldNames = defaultSiegeWorldNames;
    }
    this.config_siege_enabledWorlds = new ArrayList();
    for (int i = 0; i < siegeEnabledWorldNames.size(); i++)
    {
      String worldName = (String)siegeEnabledWorldNames.get(i);
      World world = getServer().getWorld(worldName);
      if (world == null) {
        AddLogEntry("Error: Siege Configuration: There's no world named \"" + worldName + "\".  Please update your config.yml.");
      } else {
        this.config_siege_enabledWorlds.add(world);
      }
    }
    this.config_siege_blocks = new ArrayList();
    this.config_siege_blocks.add(Material.DIRT);
    this.config_siege_blocks.add(Material.GRASS);
    this.config_siege_blocks.add(Material.LONG_GRASS);
    this.config_siege_blocks.add(Material.COBBLESTONE);
    this.config_siege_blocks.add(Material.GRAVEL);
    this.config_siege_blocks.add(Material.SAND);
    this.config_siege_blocks.add(Material.GLASS);
    this.config_siege_blocks.add(Material.THIN_GLASS);
    this.config_siege_blocks.add(Material.WOOD);
    this.config_siege_blocks.add(Material.WOOL);
    this.config_siege_blocks.add(Material.SNOW);

    ArrayList<String> defaultBreakableBlocksList = new ArrayList();
    for (int i = 0; i < this.config_siege_blocks.size(); i++) {
      defaultBreakableBlocksList.add(((Material)this.config_siege_blocks.get(i)).name());
    }
    List<String> breakableBlocksList = config.getStringList("GriefPrevention.Siege.BreakableBlocks");
    if ((breakableBlocksList == null) || (breakableBlocksList.size() == 0)) {
      breakableBlocksList = defaultBreakableBlocksList;
    }
    this.config_siege_blocks = new ArrayList();
    for (int i = 0; i < breakableBlocksList.size(); i++)
    {
      String blockName = (String)breakableBlocksList.get(i);
      Material material = Material.getMaterial(blockName);
      if (material == null) {
        AddLogEntry("Siege Configuration: Material not found: " + blockName + ".");
      } else {
        this.config_siege_blocks.add(material);
      }
    }
    this.config_pvp_noCombatInPlayerLandClaims = config.getBoolean("GriefPrevention.PvP.ProtectPlayersInLandClaims.PlayerOwnedClaims", this.config_siege_enabledWorlds.size() == 0);
    this.config_pvp_noCombatInAdminLandClaims = config.getBoolean("GriefPrevention.PvP.ProtectPlayersInLandClaims.AdministrativeClaims", this.config_siege_enabledWorlds.size() == 0);
    this.config_pvp_noCombatInAdminSubdivisions = config.getBoolean("GriefPrevention.PvP.ProtectPlayersInLandClaims.AdministrativeSubdivisions", this.config_siege_enabledWorlds.size() == 0);
    this.config_pvp_allowLavaNearPlayers = config.getBoolean("GriefPrevention.PvP.AllowLavaDumpingNearOtherPlayers", true);
    this.config_pvp_allowFireNearPlayers = config.getBoolean("GriefPrevention.PvP.AllowFlintAndSteelNearOtherPlayers", true);
    this.config_pvp_protectPets = config.getBoolean("GriefPrevention.PvP.ProtectPetsOutsideLandClaims", false);

    this.databaseUrl = config.getString("GriefPrevention.Database.URL", "");
    this.databaseUserName = config.getString("GriefPrevention.Database.UserName", "");
    this.databasePassword = config.getString("GriefPrevention.Database.Password", "");

    this.config_logs_daysToKeep = config.getInt("GriefPrevention.Abridged Logs.Days To Keep", 7);
    this.config_logs_socialEnabled = config.getBoolean("GriefPrevention.Abridged Logs.Included Entry Types.Social Activity", true);
    this.config_logs_suspiciousEnabled = config.getBoolean("GriefPrevention.Abridged Logs.Included Entry Types.Suspicious Activity", true);
    this.config_logs_adminEnabled = config.getBoolean("GriefPrevention.Abridged Logs.Included Entry Types.Administrative Activity", false);
    this.config_logs_debugEnabled = config.getBoolean("GriefPrevention.Abridged Logs.Included Entry Types.Debug", false);
    this.config_logs_mutedChatEnabled = config.getBoolean("GriefPrevention.Abridged Logs.Included Entry Types.Muted Chat Messages", false);
    try
    {
      for (World world : this.config_claims_worldModes.keySet()) {
        outConfig.set("GriefPrevention.Claims.Mode." + world
          .getName(),
          ((ClaimsMode)this.config_claims_worldModes.get(world)).name());
      }
    }
    catch (NoSuchMethodError e)
    {
      getLogger().severe("You are running an old version of Java which is susceptible to security exploits. Please update to Java 8.");
      getLogger().severe("If you are on a shared host, tell your hosting provider to update, as Java 7 is End of Life, and you're missing out on security and performance improvements");
      getLogger().severe("If they refuse, I'd suggesting switching to a more secure and responsive host.");
      getLogger().severe("But if you truly have absolutely no choice, then please download the Java 7 version of GriefPrevention.");
      getServer().getPluginManager().disablePlugin(this);
      return;
    }
    outConfig.set("GriefPrevention.Claims.PreventGlobalMonsterEggs", Boolean.valueOf(this.config_claims_preventGlobalMonsterEggs));
    outConfig.set("GriefPrevention.Claims.PreventTheft", Boolean.valueOf(this.config_claims_preventTheft));
    outConfig.set("GriefPrevention.Claims.ProtectCreatures", Boolean.valueOf(this.config_claims_protectCreatures));
    outConfig.set("GriefPrevention.Claims.PreventButtonsSwitches", Boolean.valueOf(this.config_claims_preventButtonsSwitches));
    outConfig.set("GriefPrevention.Claims.LockWoodenDoors", Boolean.valueOf(this.config_claims_lockWoodenDoors));
    outConfig.set("GriefPrevention.Claims.LockTrapDoors", Boolean.valueOf(this.config_claims_lockTrapDoors));
    outConfig.set("GriefPrevention.Claims.LockFenceGates", Boolean.valueOf(this.config_claims_lockFenceGates));
    outConfig.set("GriefPrevention.Claims.EnderPearlsRequireAccessTrust", Boolean.valueOf(this.config_claims_enderPearlsRequireAccessTrust));
    outConfig.set("GriefPrevention.Claims.ProtectHorses", Boolean.valueOf(this.config_claims_protectHorses));
    outConfig.set("GriefPrevention.Claims.InitialBlocks", Integer.valueOf(this.config_claims_initialBlocks));
    outConfig.set("GriefPrevention.Claims.Claim Blocks Accrued Per Hour.Default", Integer.valueOf(this.config_claims_blocksAccruedPerHour_default));
    outConfig.set("GriefPrevention.Claims.Max Accrued Claim Blocks.Default", Integer.valueOf(this.config_claims_maxAccruedBlocks_default));
    outConfig.set("GriefPrevention.Claims.Accrued Idle Threshold", Integer.valueOf(this.config_claims_accruedIdleThreshold));
    outConfig.set("GriefPrevention.Claims.AccruedIdlePercent", Integer.valueOf(this.config_claims_accruedIdlePercent));
    outConfig.set("GriefPrevention.Claims.AbandonReturnRatio", Double.valueOf(this.config_claims_abandonReturnRatio));
    outConfig.set("GriefPrevention.Claims.AutomaticNewPlayerClaimsRadius", Integer.valueOf(this.config_claims_automaticClaimsForNewPlayersRadius));
    outConfig.set("GriefPrevention.Claims.ExtendIntoGroundDistance", Integer.valueOf(this.config_claims_claimsExtendIntoGroundDistance));
    outConfig.set("GriefPrevention.Claims.MinimumWidth", Integer.valueOf(this.config_claims_minWidth));
    outConfig.set("GriefPrevention.Claims.MinimumArea", Integer.valueOf(this.config_claims_minArea));
    outConfig.set("GriefPrevention.Claims.MaximumDepth", Integer.valueOf(this.config_claims_maxDepth));
    outConfig.set("GriefPrevention.Claims.InvestigationTool", this.config_claims_investigationTool.name());
    outConfig.set("GriefPrevention.Claims.ModificationTool", this.config_claims_modificationTool.name());
    outConfig.set("GriefPrevention.Claims.Expiration.ChestClaimDays", Integer.valueOf(this.config_claims_chestClaimExpirationDays));
    outConfig.set("GriefPrevention.Claims.Expiration.UnusedClaimDays", Integer.valueOf(this.config_claims_unusedClaimExpirationDays));
    outConfig.set("GriefPrevention.Claims.Expiration.AllClaims.DaysInactive", Integer.valueOf(this.config_claims_expirationDays));
    outConfig.set("GriefPrevention.Claims.Expiration.AllClaims.ExceptWhenOwnerHasTotalClaimBlocks", Integer.valueOf(this.config_claims_expirationExemptionTotalBlocks));
    outConfig.set("GriefPrevention.Claims.Expiration.AllClaims.ExceptWhenOwnerHasBonusClaimBlocks", Integer.valueOf(this.config_claims_expirationExemptionBonusBlocks));
    outConfig.set("GriefPrevention.Claims.Expiration.AutomaticNatureRestoration.SurvivalWorlds", Boolean.valueOf(this.config_claims_survivalAutoNatureRestoration));
    outConfig.set("GriefPrevention.Claims.AllowTrappedInAdminClaims", Boolean.valueOf(this.config_claims_allowTrappedInAdminClaims));
    outConfig.set("GriefPrevention.Claims.MaximumNumberOfClaimsPerPlayer", Integer.valueOf(this.config_claims_maxClaimsPerPlayer));
    outConfig.set("GriefPrevention.Claims.CreationRequiresWorldGuardBuildPermission", Boolean.valueOf(this.config_claims_respectWorldGuard));
    outConfig.set("GriefPrevention.Claims.PortalGenerationRequiresPermission", Boolean.valueOf(this.config_claims_portalsRequirePermission));
    outConfig.set("GriefPrevention.Claims.VillagerTradingRequiresPermission", Boolean.valueOf(this.config_claims_villagerTradingRequiresTrust));
    outConfig.set("GriefPrevention.Claims.CommandsRequiringAccessTrust", accessTrustSlashCommands);
    outConfig.set("GriefPrevention.Claims.DeliverManuals", Boolean.valueOf(this.config_claims_supplyPlayerManual));
    outConfig.set("GriefPrevention.Claims.ManualDeliveryDelaySeconds", Integer.valueOf(this.config_claims_manualDeliveryDelaySeconds));

    outConfig.set("GriefPrevention.Spam.Enabled", Boolean.valueOf(this.config_spam_enabled));
    outConfig.set("GriefPrevention.Spam.LoginCooldownSeconds", Integer.valueOf(this.config_spam_loginCooldownSeconds));
    outConfig.set("GriefPrevention.Spam.LoginLogoutNotificationsPerMinute", Integer.valueOf(this.config_spam_loginLogoutNotificationsPerMinute));
    outConfig.set("GriefPrevention.Spam.ChatSlashCommands", slashCommandsToMonitor);
    outConfig.set("GriefPrevention.Spam.WhisperSlashCommands", whisperCommandsToMonitor);
    outConfig.set("GriefPrevention.Spam.WarningMessage", this.config_spam_warningMessage);
    outConfig.set("GriefPrevention.Spam.BanOffenders", Boolean.valueOf(this.config_spam_banOffenders));
    outConfig.set("GriefPrevention.Spam.BanMessage", this.config_spam_banMessage);
    outConfig.set("GriefPrevention.Spam.AllowedIpAddresses", this.config_spam_allowedIpAddresses);
    outConfig.set("GriefPrevention.Spam.DeathMessageCooldownSeconds", Integer.valueOf(this.config_spam_deathMessageCooldownSeconds));
    outConfig.set("GriefPrevention.Spam.Logout Message Delay In Seconds", Integer.valueOf(this.config_spam_logoutMessageDelaySeconds));
    for (World world : worlds) {
      outConfig.set("GriefPrevention.PvP.RulesEnabledInWorld." + world.getName(), Boolean.valueOf(pvpRulesApply(world)));
    }
    outConfig.set("GriefPrevention.PvP.ProtectFreshSpawns", Boolean.valueOf(this.config_pvp_protectFreshSpawns));
    outConfig.set("GriefPrevention.PvP.PunishLogout", Boolean.valueOf(this.config_pvp_punishLogout));
    outConfig.set("GriefPrevention.PvP.CombatTimeoutSeconds", Integer.valueOf(this.config_pvp_combatTimeoutSeconds));
    outConfig.set("GriefPrevention.PvP.AllowCombatItemDrop", Boolean.valueOf(this.config_pvp_allowCombatItemDrop));
    outConfig.set("GriefPrevention.PvP.BlockedSlashCommands", bannedPvPCommandsList);
    outConfig.set("GriefPrevention.PvP.ProtectPlayersInLandClaims.PlayerOwnedClaims", Boolean.valueOf(this.config_pvp_noCombatInPlayerLandClaims));
    outConfig.set("GriefPrevention.PvP.ProtectPlayersInLandClaims.AdministrativeClaims", Boolean.valueOf(this.config_pvp_noCombatInAdminLandClaims));
    outConfig.set("GriefPrevention.PvP.ProtectPlayersInLandClaims.AdministrativeSubdivisions", Boolean.valueOf(this.config_pvp_noCombatInAdminSubdivisions));
    outConfig.set("GriefPrevention.PvP.AllowLavaDumpingNearOtherPlayers", Boolean.valueOf(this.config_pvp_allowLavaNearPlayers));
    outConfig.set("GriefPrevention.PvP.AllowFlintAndSteelNearOtherPlayers", Boolean.valueOf(this.config_pvp_allowFireNearPlayers));
    outConfig.set("GriefPrevention.PvP.ProtectPetsOutsideLandClaims", Boolean.valueOf(this.config_pvp_protectPets));

    outConfig.set("GriefPrevention.Economy.ClaimBlocksPurchaseCost", Double.valueOf(this.config_economy_claimBlocksPurchaseCost));
    outConfig.set("GriefPrevention.Economy.ClaimBlocksSellValue", Double.valueOf(this.config_economy_claimBlocksSellValue));

    outConfig.set("GriefPrevention.ProtectItemsDroppedOnDeath.PvPWorlds", Boolean.valueOf(this.config_lockDeathDropsInPvpWorlds));
    outConfig.set("GriefPrevention.ProtectItemsDroppedOnDeath.NonPvPWorlds", Boolean.valueOf(this.config_lockDeathDropsInNonPvpWorlds));

    outConfig.set("GriefPrevention.BlockLandClaimExplosions", Boolean.valueOf(this.config_blockClaimExplosions));
    outConfig.set("GriefPrevention.BlockSurfaceCreeperExplosions", Boolean.valueOf(this.config_blockSurfaceCreeperExplosions));
    outConfig.set("GriefPrevention.BlockSurfaceOtherExplosions", Boolean.valueOf(this.config_blockSurfaceOtherExplosions));
    outConfig.set("GriefPrevention.LimitSkyTrees", Boolean.valueOf(this.config_blockSkyTrees));
    outConfig.set("GriefPrevention.LimitTreeGrowth", Boolean.valueOf(this.config_limitTreeGrowth));
    outConfig.set("GriefPrevention.LimitPistonsToLandClaims", Boolean.valueOf(this.config_pistonsInClaimsOnly));

    outConfig.set("GriefPrevention.FireSpreads", Boolean.valueOf(this.config_fireSpreads));
    outConfig.set("GriefPrevention.FireDestroys", Boolean.valueOf(this.config_fireDestroys));

    outConfig.set("GriefPrevention.AdminsGetWhispers", Boolean.valueOf(this.config_whisperNotifications));
    outConfig.set("GriefPrevention.AdminsGetSignNotifications", Boolean.valueOf(this.config_signNotifications));

    outConfig.set("GriefPrevention.SmartBan", Boolean.valueOf(this.config_smartBan));
    outConfig.set("GriefPrevention.Mute New Players Using Banned Words", Boolean.valueOf(this.config_trollFilterEnabled));
    outConfig.set("GriefPrevention.MaxPlayersPerIpAddress", Integer.valueOf(this.config_ipLimit));

    outConfig.set("GriefPrevention.Siege.Worlds", siegeEnabledWorldNames);
    outConfig.set("GriefPrevention.Siege.BreakableBlocks", breakableBlocksList);

    outConfig.set("GriefPrevention.EndermenMoveBlocks", Boolean.valueOf(this.config_endermenMoveBlocks));
    outConfig.set("GriefPrevention.SilverfishBreakBlocks", Boolean.valueOf(this.config_silverfishBreakBlocks));
    outConfig.set("GriefPrevention.CreaturesTrampleCrops", Boolean.valueOf(this.config_creaturesTrampleCrops));
    outConfig.set("GriefPrevention.RabbitsEatCrops", Boolean.valueOf(this.config_rabbitsEatCrops));
    outConfig.set("GriefPrevention.HardModeZombiesBreakDoors", Boolean.valueOf(this.config_zombiesBreakDoors));

    outConfig.set("GriefPrevention.Database.URL", this.databaseUrl);
    outConfig.set("GriefPrevention.Database.UserName", this.databaseUserName);
    outConfig.set("GriefPrevention.Database.Password", this.databasePassword);

    outConfig.set("GriefPrevention.UseBanCommand", Boolean.valueOf(this.config_ban_useCommand));
    outConfig.set("GriefPrevention.BanCommandPattern", this.config_ban_commandFormat);

    outConfig.set("GriefPrevention.Mods.BlockIdsRequiringAccessTrust", this.config_mods_accessTrustIds);
    outConfig.set("GriefPrevention.Mods.BlockIdsRequiringContainerTrust", this.config_mods_containerTrustIds);
    outConfig.set("GriefPrevention.Mods.BlockIdsExplodable", this.config_mods_explodableIds);
    outConfig.set("GriefPrevention.Mods.PlayersIgnoringAllClaims", this.config_mods_ignoreClaimsAccounts);
    outConfig.set("GriefPrevention.Mods.BlockIdsRequiringAccessTrust", accessTrustStrings);
    outConfig.set("GriefPrevention.Mods.BlockIdsRequiringContainerTrust", containerTrustStrings);
    outConfig.set("GriefPrevention.Mods.BlockIdsExplodable", explodableStrings);

    outConfig.set("GriefPrevention.Abridged Logs.Days To Keep", Integer.valueOf(this.config_logs_daysToKeep));
    outConfig.set("GriefPrevention.Abridged Logs.Included Entry Types.Social Activity", Boolean.valueOf(this.config_logs_socialEnabled));
    outConfig.set("GriefPrevention.Abridged Logs.Included Entry Types.Suspicious Activity", Boolean.valueOf(this.config_logs_suspiciousEnabled));
    outConfig.set("GriefPrevention.Abridged Logs.Included Entry Types.Administrative Activity", Boolean.valueOf(this.config_logs_adminEnabled));
    outConfig.set("GriefPrevention.Abridged Logs.Included Entry Types.Debug", Boolean.valueOf(this.config_logs_debugEnabled));
    outConfig.set("GriefPrevention.Abridged Logs.Included Entry Types.Muted Chat Messages", Boolean.valueOf(this.config_logs_mutedChatEnabled));
    try
    {
      outConfig.save(DataStore.configFilePath);
    }
    catch (IOException exception)
    {
      AddLogEntry("Unable to write to the configuration file at \"" + DataStore.configFilePath + "\"");
    }
    this.config_claims_commandsRequiringAccessTrust = new ArrayList();
    String[] commands = accessTrustSlashCommands.split(";");
    for (int i = 0; i < commands.length; i++) {
      if (!commands[i].isEmpty()) {
        this.config_claims_commandsRequiringAccessTrust.add(commands[i].trim().toLowerCase());
      }
    }
    this.config_spam_monitorSlashCommands = new ArrayList();
    commands = slashCommandsToMonitor.split(";");
    for (int i = 0; i < commands.length; i++) {
      this.config_spam_monitorSlashCommands.add(commands[i].trim().toLowerCase());
    }
    this.config_eavesdrop_whisperCommands = new ArrayList();
    commands = whisperCommandsToMonitor.split(";");
    for (int i = 0; i < commands.length; i++) {
      this.config_eavesdrop_whisperCommands.add(commands[i].trim().toLowerCase());
    }
    this.config_pvp_blockedCommands = new ArrayList();
    commands = bannedPvPCommandsList.split(";");
    for (int i = 0; i < commands.length; i++) {
      this.config_pvp_blockedCommands.add(commands[i].trim().toLowerCase());
    }
  }

  private ClaimsMode configStringToClaimsMode(String configSetting)
  {
    if (configSetting.equalsIgnoreCase("Survival")) {
      return ClaimsMode.Survival;
    }
    if (configSetting.equalsIgnoreCase("Creative")) {
      return ClaimsMode.Creative;
    }
    if (configSetting.equalsIgnoreCase("Disabled")) {
      return ClaimsMode.Disabled;
    }
    if (configSetting.equalsIgnoreCase("SurvivalRequiringClaims")) {
      return ClaimsMode.SurvivalRequiringClaims;
    }
    return null;
  }

  public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args)
  {
    Player player = null;
    if ((sender instanceof Player)) {
      player = (Player)sender;
    }
    if ((cmd.getName().equalsIgnoreCase("claim")) && (player != null))
    {
      if (!instance.claimsEnabledForWorld(player.getWorld()))
      {
        sendMessage(player, TextMode.Err, Messages.ClaimsDisabledWorld, new String[0]);
        return true;
      }
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      if ((instance.config_claims_maxClaimsPerPlayer > 0) &&
        (!player.hasPermission("griefprevention.overrideclaimcountlimit")) &&
        (playerData.getClaims().size() >= instance.config_claims_maxClaimsPerPlayer))
      {
        sendMessage(player, TextMode.Err, Messages.ClaimCreationFailedOverClaimCountLimit, new String[0]);
        return true;
      }
      int radius = instance.config_claims_automaticClaimsForNewPlayersRadius;
      if (radius < 0) {
        radius = (int)Math.ceil(Math.sqrt(instance.config_claims_minArea) / 2.0D);
      }
      if (playerData.getClaims().size() > 0)
      {
        if ((playerData.getClaims().size() == 1) && (player.getGameMode() != GameMode.CREATIVE) && (player.getItemInHand().getType() != instance.config_claims_modificationTool))
        {
          sendMessage(player, TextMode.Err, Messages.MustHoldModificationToolForThat, new String[0]);
          return true;
        }
        radius = (int)Math.ceil(Math.sqrt(instance.config_claims_minArea) / 2.0D);
      }
      if (args.length > 0)
      {
        if ((playerData.getClaims().size() < 2) && (player.getGameMode() != GameMode.CREATIVE) && (player.getItemInHand().getType() != instance.config_claims_modificationTool))
        {
          sendMessage(player, TextMode.Err, Messages.RadiusRequiresGoldenShovel, new String[0]);
          return true;
        }
        try
        {
          specifiedRadius = Integer.parseInt(args[0]);
        }
        catch (NumberFormatException e)
        {
          int specifiedRadius;
          return false;
        }
        int specifiedRadius;
        if (specifiedRadius < radius)
        {
          sendMessage(player, TextMode.Err, Messages.MinimumRadius, new String[] { String.valueOf(radius) });
          return true;
        }
        radius = specifiedRadius;
      }
      if (radius < 0) {
        radius = 0;
      }
      Location lc = player.getLocation().add(-radius, 0.0D, -radius);
      Location gc = player.getLocation().add(radius, 0.0D, radius);

      int area = Math.abs((gc.getBlockX() - lc.getBlockX() + 1) * (gc.getBlockZ() - lc.getBlockZ() + 1));
      int remaining = playerData.getRemainingClaimBlocks();
      if (remaining < area)
      {
        sendMessage(player, TextMode.Err, Messages.CreateClaimInsufficientBlocks, new String[] { String.valueOf(area - remaining) });
        instance.dataStore.tryAdvertiseAdminAlternatives(player);
        return true;
      }
      CreateClaimResult result = this.dataStore.createClaim(lc.getWorld(), lc
        .getBlockX(), gc.getBlockX(), lc
        .getBlockY() - instance.config_claims_claimsExtendIntoGroundDistance - 1, gc
        .getWorld().getHighestBlockYAt(gc) - instance.config_claims_claimsExtendIntoGroundDistance - 1, lc
        .getBlockZ(), gc.getBlockZ(), player
        .getUniqueId(), null, null, player);
      if (!result.succeeded)
      {
        if (result.claim != null)
        {
          sendMessage(player, TextMode.Err, Messages.CreateClaimFailOverlapShort, new String[0]);

          Visualization visualization = Visualization.FromClaim(result.claim, player.getEyeLocation().getBlockY(), VisualizationType.ErrorClaim, player.getLocation());
          Visualization.Apply(player, visualization);
        }
        else
        {
          sendMessage(player, TextMode.Err, Messages.CreateClaimFailOverlapRegion, new String[0]);
        }
      }
      else
      {
        sendMessage(player, TextMode.Success, Messages.CreateClaimSuccess, new String[0]);
        if (instance.creativeRulesApply(player.getLocation())) {
          sendMessage(player, TextMode.Instr, Messages.CreativeBasicsVideo2, new String[] { DataStore.CREATIVE_VIDEO_URL });
        } else if (instance.claimsEnabledForWorld(player.getLocation().getWorld())) {
          sendMessage(player, TextMode.Instr, Messages.SurvivalBasicsVideo2, new String[] { DataStore.SURVIVAL_VIDEO_URL });
        }
        Visualization visualization = Visualization.FromClaim(result.claim, player.getEyeLocation().getBlockY(), VisualizationType.Claim, player.getLocation());
        Visualization.Apply(player, visualization);
        playerData.claimResizing = null;
        playerData.lastShovelLocation = null;

        autoExtendClaim(result.claim);
      }
      return true;
    }
    Claim claim;
    if ((cmd.getName().equalsIgnoreCase("extendclaim")) && (player != null))
    {
      if (args.length < 1)
      {
        if (instance.creativeRulesApply(player.getLocation())) {
          sendMessage(player, TextMode.Instr, Messages.CreativeBasicsVideo2, new String[] { DataStore.CREATIVE_VIDEO_URL });
        } else if (instance.claimsEnabledForWorld(player.getLocation().getWorld())) {
          sendMessage(player, TextMode.Instr, Messages.SurvivalBasicsVideo2, new String[] { DataStore.SURVIVAL_VIDEO_URL });
        }
        return false;
      }
      try
      {
        amount = Integer.parseInt(args[0]);
      }
      catch (NumberFormatException e)
      {
        int amount;
        if (instance.creativeRulesApply(player.getLocation())) {
          sendMessage(player, TextMode.Instr, Messages.CreativeBasicsVideo2, new String[] { DataStore.CREATIVE_VIDEO_URL });
        } else if (instance.claimsEnabledForWorld(player.getLocation().getWorld())) {
          sendMessage(player, TextMode.Instr, Messages.SurvivalBasicsVideo2, new String[] { DataStore.SURVIVAL_VIDEO_URL });
        }
        return false;
      }
      int amount;
      if ((player.getGameMode() != GameMode.CREATIVE) && (player.getItemInHand().getType() != instance.config_claims_modificationTool))
      {
        sendMessage(player, TextMode.Err, Messages.MustHoldModificationToolForThat, new String[0]);
        return true;
      }
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      claim = this.dataStore.getClaimAt(player.getLocation(), true, playerData.lastClaim);
      if (claim == null)
      {
        sendMessage(player, TextMode.Err, Messages.StandInClaimToResize, new String[0]);
        return true;
      }
      String errorMessage = claim.allowEdit(player);
      if (errorMessage != null)
      {
        sendMessage(player, TextMode.Err, Messages.NotYourClaim, new String[0]);
        return true;
      }
      org.bukkit.util.Vector direction = player.getLocation().getDirection();
      if (direction.getY() > 0.75D)
      {
        sendMessage(player, TextMode.Info, Messages.ClaimsExtendToSky, new String[0]);
        return true;
      }
      if (direction.getY() < -0.75D)
      {
        sendMessage(player, TextMode.Info, Messages.ClaimsAutoExtendDownward, new String[0]);
        return true;
      }
      Location lc = claim.getLesserBoundaryCorner();
      Location gc = claim.getGreaterBoundaryCorner();
      int newx1 = lc.getBlockX();
      int newx2 = gc.getBlockX();
      int newy1 = lc.getBlockY();
      int newy2 = gc.getBlockY();
      int newz1 = lc.getBlockZ();
      int newz2 = gc.getBlockZ();
      if (Math.abs(direction.getX()) < 0.3D)
      {
        if (direction.getZ() > 0.0D) {
          newz2 += amount;
        } else {
          newz1 -= amount;
        }
      }
      else if (Math.abs(direction.getZ()) < 0.3D)
      {
        if (direction.getX() > 0.0D) {
          newx2 += amount;
        } else {
          newx1 -= amount;
        }
      }
      else
      {
        if (direction.getX() > 0.0D) {
          newx2 += amount;
        } else {
          newx1 -= amount;
        }
        if (direction.getZ() > 0.0D) {
          newz2 += amount;
        } else {
          newz1 -= amount;
        }
      }
      playerData.claimResizing = claim;
      this.dataStore.resizeClaimWithChecks(player, playerData, newx1, newx2, newy1, newy2, newz1, newz2);
      playerData.claimResizing = null;

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("abandonclaim")) && (player != null)) {
      return abandonClaimHandler(player, false);
    }
    if ((cmd.getName().equalsIgnoreCase("abandontoplevelclaim")) && (player != null)) {
      return abandonClaimHandler(player, true);
    }
    if ((cmd.getName().equalsIgnoreCase("ignoreclaims")) && (player != null))
    {
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());

      playerData.ignoreClaims = (!playerData.ignoreClaims);
      if (!playerData.ignoreClaims) {
        sendMessage(player, TextMode.Success, Messages.RespectingClaims, new String[0]);
      } else {
        sendMessage(player, TextMode.Success, Messages.IgnoringClaims, new String[0]);
      }
      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("abandonallclaims")) && (player != null))
    {
      if (args.length != 0) {
        return false;
      }
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      int originalClaimCount = playerData.getClaims().size();
      if (originalClaimCount == 0)
      {
        sendMessage(player, TextMode.Err, Messages.YouHaveNoClaims, new String[0]);
        return true;
      }
      for (Claim claim : playerData.getClaims()) {
        playerData.setAccruedClaimBlocks(Integer.valueOf(playerData.getAccruedClaimBlocks() - (int)Math.ceil(claim.getArea() * (1.0D - this.config_claims_abandonReturnRatio))));
      }
      this.dataStore.deleteClaimsForPlayer(player.getUniqueId(), false);

      int remainingBlocks = playerData.getRemainingClaimBlocks();
      sendMessage(player, TextMode.Success, Messages.SuccessfulAbandon, new String[] { String.valueOf(remainingBlocks) });

      Visualization.Revert(player);

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("restorenature")) && (player != null))
    {
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      playerData.shovelMode = ShovelMode.RestoreNature;
      sendMessage(player, TextMode.Instr, Messages.RestoreNatureActivate, new String[0]);
      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("restorenatureaggressive")) && (player != null))
    {
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      playerData.shovelMode = ShovelMode.RestoreNatureAggressive;
      sendMessage(player, TextMode.Warn, Messages.RestoreNatureAggressiveActivate, new String[0]);
      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("restorenaturefill")) && (player != null))
    {
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      playerData.shovelMode = ShovelMode.RestoreNatureFill;

      playerData.fillRadius = 2;
      if (args.length > 0) {
        try
        {
          playerData.fillRadius = Integer.parseInt(args[0]);
        }
        catch (Exception localException) {}
      }
      if (playerData.fillRadius < 0) {
        playerData.fillRadius = 2;
      }
      sendMessage(player, TextMode.Success, Messages.FillModeActive, new String[] { String.valueOf(playerData.fillRadius) });
      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("trust")) && (player != null))
    {
      if (args.length != 1) {
        return false;
      }
      handleTrustCommand(player, ClaimPermission.Build, args[0]);

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("transferclaim")) && (player != null))
    {
      Claim claim = this.dataStore.getClaimAt(player.getLocation(), true, null);
      if (claim == null)
      {
        sendMessage(player, TextMode.Instr, Messages.TransferClaimMissing, new String[0]);
        return true;
      }
      if ((claim.isAdminClaim()) && (!player.hasPermission("griefprevention.adminclaims")))
      {
        sendMessage(player, TextMode.Err, Messages.TransferClaimPermission, new String[0]);
        return true;
      }
      UUID newOwnerID = null;
      String ownerName = "admin";
      if (args.length > 0)
      {
        OfflinePlayer targetPlayer = resolvePlayerByName(args[0]);
        if (targetPlayer == null)
        {
          sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
          return true;
        }
        newOwnerID = targetPlayer.getUniqueId();
        ownerName = targetPlayer.getName();
      }
      try
      {
        this.dataStore.changeClaimOwner(claim, newOwnerID);
      }
      catch (DataStore.NoTransferException e)
      {
        sendMessage(player, TextMode.Instr, Messages.TransferTopLevel, new String[0]);
        return true;
      }
      sendMessage(player, TextMode.Success, Messages.TransferSuccess, new String[0]);
      AddLogEntry(player.getName() + " transferred a claim at " + getfriendlyLocationString(claim.getLesserBoundaryCorner()) + " to " + ownerName + ".", CustomLogEntryTypes.AdminActivity);

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("trustlist")) && (player != null))
    {
      Claim claim = this.dataStore.getClaimAt(player.getLocation(), true, null);
      if (claim == null)
      {
        sendMessage(player, TextMode.Err, Messages.TrustListNoClaim, new String[0]);
        return true;
      }
      String errorMessage = claim.allowGrantPermission(player);
      if (errorMessage != null)
      {
        sendMessage(player, TextMode.Err, errorMessage);
        return true;
      }
      ArrayList<String> builders = new ArrayList();
      ArrayList<String> containers = new ArrayList();
      ArrayList<String> accessors = new ArrayList();
      ArrayList<String> managers = new ArrayList();
      claim.getPermissions(builders, containers, accessors, managers);

      sendMessage(player, TextMode.Info, Messages.TrustListHeader, new String[0]);

      StringBuilder permissions = new StringBuilder();
      permissions.append(ChatColor.GOLD + ">");
      if (managers.size() > 0) {
        for (int i = 0; i < managers.size(); i++) {
          permissions.append(trustEntryToPlayerName((String)managers.get(i)) + " ");
        }
      }
      player.sendMessage(permissions.toString());
      permissions = new StringBuilder();
      permissions.append(ChatColor.YELLOW + ">");
      if (builders.size() > 0) {
        for (int i = 0; i < builders.size(); i++) {
          permissions.append(trustEntryToPlayerName((String)builders.get(i)) + " ");
        }
      }
      player.sendMessage(permissions.toString());
      permissions = new StringBuilder();
      permissions.append(ChatColor.GREEN + ">");
      if (containers.size() > 0) {
        for (int i = 0; i < containers.size(); i++) {
          permissions.append(trustEntryToPlayerName((String)containers.get(i)) + " ");
        }
      }
      player.sendMessage(permissions.toString());
      permissions = new StringBuilder();
      permissions.append(ChatColor.BLUE + ">");
      if (accessors.size() > 0) {
        for (int i = 0; i < accessors.size(); i++) {
          permissions.append(trustEntryToPlayerName((String)accessors.get(i)) + " ");
        }
      }
      player.sendMessage(permissions.toString());

      player.sendMessage(ChatColor.GOLD + this.dataStore
        .getMessage(Messages.Manage, new String[0]) + " " + ChatColor.YELLOW + this.dataStore
        .getMessage(Messages.Build, new String[0]) + " " + ChatColor.GREEN + this.dataStore
        .getMessage(Messages.Containers, new String[0]) + " " + ChatColor.BLUE + this.dataStore
        .getMessage(Messages.Access, new String[0]));

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("untrust")) && (player != null))
    {
      if (args.length != 1) {
        return false;
      }
      Claim claim = this.dataStore.getClaimAt(player.getLocation(), true, null);
      if ((args[0].contains(".")) && (!args[0].startsWith("[")) && (!args[0].endsWith("]"))) {
        args[0] = ("[" + args[0] + "]");
      }
      boolean clearPermissions = false;
      OfflinePlayer otherPlayer = null;
      if (args[0].equals("all"))
      {
        if ((claim == null) || (claim.allowEdit(player) == null))
        {
          clearPermissions = true;
        }
        else
        {
          sendMessage(player, TextMode.Err, Messages.ClearPermsOwnerOnly, new String[0]);
          return true;
        }
      }
      else if ((!args[0].startsWith("[")) || (!args[0].endsWith("]")))
      {
        otherPlayer = resolvePlayerByName(args[0]);
        if ((!clearPermissions) && (otherPlayer == null) && (!args[0].equals("public")))
        {
          sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
          return true;
        }
        if (otherPlayer != null) {
          args[0] = otherPlayer.getName();
        }
      }
      if (claim == null)
      {
        PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
        for (int i = 0; i < playerData.getClaims().size(); i++)
        {
          claim = (Claim)playerData.getClaims().get(i);
          if (clearPermissions)
          {
            claim.clearPermissions();
          }
          else
          {
            String idToDrop = args[0];
            if (otherPlayer != null) {
              idToDrop = otherPlayer.getUniqueId().toString();
            }
            claim.dropPermission(idToDrop);
            claim.managers.remove(idToDrop);
          }
          this.dataStore.saveClaim(claim);
        }
        if (args[0].equals("public")) {
          args[0] = "the public";
        }
        if (!clearPermissions) {
          sendMessage(player, TextMode.Success, Messages.UntrustIndividualAllClaims, new String[] { args[0] });
        } else {
          sendMessage(player, TextMode.Success, Messages.UntrustEveryoneAllClaims, new String[0]);
        }
      }
      else
      {
        if (claim.allowGrantPermission(player) != null)
        {
          sendMessage(player, TextMode.Err, Messages.NoPermissionTrust, new String[] { claim.getOwnerName() });
          return true;
        }
        if (clearPermissions)
        {
          if (claim.allowEdit(player) != null)
          {
            sendMessage(player, TextMode.Err, Messages.UntrustAllOwnerOnly, new String[0]);
            return true;
          }
          claim.clearPermissions();
          sendMessage(player, TextMode.Success, Messages.ClearPermissionsOneClaim, new String[0]);
        }
        else
        {
          String idToDrop = args[0];
          if (otherPlayer != null) {
            idToDrop = otherPlayer.getUniqueId().toString();
          }
          boolean targetIsManager = claim.managers.contains(idToDrop);
          if ((targetIsManager) && (claim.allowEdit(player) != null))
          {
            sendMessage(player, TextMode.Err, Messages.ManagersDontUntrustManagers, new String[] { claim.getOwnerName() });
            return true;
          }
          claim.dropPermission(idToDrop);
          claim.managers.remove(idToDrop);
          if (args[0].equals("public")) {
            args[0] = "the public";
          }
          sendMessage(player, TextMode.Success, Messages.UntrustIndividualSingleClaim, new String[] { args[0] });
        }
        this.dataStore.saveClaim(claim);
      }
      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("accesstrust")) && (player != null))
    {
      if (args.length != 1) {
        return false;
      }
      handleTrustCommand(player, ClaimPermission.Access, args[0]);

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("containertrust")) && (player != null))
    {
      if (args.length != 1) {
        return false;
      }
      handleTrustCommand(player, ClaimPermission.Inventory, args[0]);

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("permissiontrust")) && (player != null))
    {
      if (args.length != 1) {
        return false;
      }
      handleTrustCommand(player, null, args[0]);

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("buyclaimblocks")) && (player != null))
    {
      if (economy == null)
      {
        sendMessage(player, TextMode.Err, Messages.BuySellNotConfigured, new String[0]);
        return true;
      }
      if (!player.hasPermission("griefprevention.buysellclaimblocks"))
      {
        sendMessage(player, TextMode.Err, Messages.NoPermissionForCommand, new String[0]);
        return true;
      }
      if (instance.config_economy_claimBlocksPurchaseCost == 0.0D)
      {
        sendMessage(player, TextMode.Err, Messages.OnlySellBlocks, new String[0]);
        return true;
      }
      if (args.length != 1)
      {
        sendMessage(player, TextMode.Info, Messages.BlockPurchaseCost, new String[] { String.valueOf(instance.config_economy_claimBlocksPurchaseCost), String.valueOf(economy.getBalance(player.getName())) });
        return false;
      }
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      try
      {
        blockCount = Integer.parseInt(args[0]);
      }
      catch (NumberFormatException numberFormatException)
      {
        int blockCount;
        return false;
      }
      int blockCount;
      if (blockCount <= 0) {
        return false;
      }
      double balance = economy.getBalance(player.getName());
      double totalCost = blockCount * instance.config_economy_claimBlocksPurchaseCost;
      if (totalCost > balance)
      {
        sendMessage(player, TextMode.Err, Messages.InsufficientFunds, new String[] { String.valueOf(totalCost), String.valueOf(balance) });
      }
      else
      {
        economy.withdrawPlayer(player.getName(), totalCost);

        playerData.setBonusClaimBlocks(Integer.valueOf(playerData.getBonusClaimBlocks() + blockCount));
        this.dataStore.savePlayerData(player.getUniqueId(), playerData);

        sendMessage(player, TextMode.Success, Messages.PurchaseConfirmation, new String[] { String.valueOf(totalCost), String.valueOf(playerData.getRemainingClaimBlocks()) });
      }
      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("sellclaimblocks")) && (player != null))
    {
      if (economy == null)
      {
        sendMessage(player, TextMode.Err, Messages.BuySellNotConfigured, new String[0]);
        return true;
      }
      if (!player.hasPermission("griefprevention.buysellclaimblocks"))
      {
        sendMessage(player, TextMode.Err, Messages.NoPermissionForCommand, new String[0]);
        return true;
      }
      if (instance.config_economy_claimBlocksSellValue == 0.0D)
      {
        sendMessage(player, TextMode.Err, Messages.OnlyPurchaseBlocks, new String[0]);
        return true;
      }
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      int availableBlocks = playerData.getRemainingClaimBlocks();
      if (args.length != 1)
      {
        sendMessage(player, TextMode.Info, Messages.BlockSaleValue, new String[] { String.valueOf(instance.config_economy_claimBlocksSellValue), String.valueOf(availableBlocks) });
        return false;
      }
      try
      {
        blockCount = Integer.parseInt(args[0]);
      }
      catch (NumberFormatException numberFormatException)
      {
        int blockCount;
        return false;
      }
      int blockCount;
      if (blockCount <= 0) {
        return false;
      }
      if (blockCount > availableBlocks)
      {
        sendMessage(player, TextMode.Err, Messages.NotEnoughBlocksForSale, new String[0]);
      }
      else
      {
        double totalValue = blockCount * instance.config_economy_claimBlocksSellValue;
        economy.depositPlayer(player.getName(), totalValue);

        playerData.setBonusClaimBlocks(Integer.valueOf(playerData.getBonusClaimBlocks() - blockCount));
        this.dataStore.savePlayerData(player.getUniqueId(), playerData);

        sendMessage(player, TextMode.Success, Messages.BlockSaleConfirmation, new String[] { String.valueOf(totalValue), String.valueOf(playerData.getRemainingClaimBlocks()) });
      }
      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("adminclaims")) && (player != null))
    {
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      playerData.shovelMode = ShovelMode.Admin;
      sendMessage(player, TextMode.Success, Messages.AdminClaimsMode, new String[0]);

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("basicclaims")) && (player != null))
    {
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      playerData.shovelMode = ShovelMode.Basic;
      playerData.claimSubdividing = null;
      sendMessage(player, TextMode.Success, Messages.BasicClaimsMode, new String[0]);

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("subdivideclaims")) && (player != null))
    {
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      playerData.shovelMode = ShovelMode.Subdivide;
      playerData.claimSubdividing = null;
      sendMessage(player, TextMode.Instr, Messages.SubdivisionMode, new String[0]);
      sendMessage(player, TextMode.Instr, Messages.SubdivisionVideo2, new String[] { DataStore.SUBDIVISION_VIDEO_URL });

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("deleteclaim")) && (player != null))
    {
      Claim claim = this.dataStore.getClaimAt(player.getLocation(), true, null);
      if (claim == null)
      {
        sendMessage(player, TextMode.Err, Messages.DeleteClaimMissing, new String[0]);
      }
      else if ((!claim.isAdminClaim()) || (player.hasPermission("griefprevention.adminclaims")))
      {
        PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
        if ((claim.children.size() > 0) && (!playerData.warnedAboutMajorDeletion))
        {
          sendMessage(player, TextMode.Warn, Messages.DeletionSubdivisionWarning, new String[0]);
          playerData.warnedAboutMajorDeletion = true;
        }
        else
        {
          claim.removeSurfaceFluids(null);
          this.dataStore.deleteClaim(claim, true, true);
          if ((instance.creativeRulesApply(claim.getLesserBoundaryCorner())) || (instance.config_claims_survivalAutoNatureRestoration)) {
            instance.restoreClaim(claim, 0L);
          }
          sendMessage(player, TextMode.Success, Messages.DeleteSuccess, new String[0]);
          AddLogEntry(player.getName() + " deleted " + claim.getOwnerName() + "'s claim at " + getfriendlyLocationString(claim.getLesserBoundaryCorner()), CustomLogEntryTypes.AdminActivity);

          Visualization.Revert(player);

          playerData.warnedAboutMajorDeletion = false;
        }
      }
      else
      {
        sendMessage(player, TextMode.Err, Messages.CantDeleteAdminClaim, new String[0]);
      }
      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("claimexplosions")) && (player != null))
    {
      Claim claim = this.dataStore.getClaimAt(player.getLocation(), true, null);
      if (claim == null)
      {
        sendMessage(player, TextMode.Err, Messages.DeleteClaimMissing, new String[0]);
      }
      else
      {
        String noBuildReason = claim.allowBuild(player, Material.STONE);
        if (noBuildReason != null)
        {
          sendMessage(player, TextMode.Err, noBuildReason);
          return true;
        }
        if (claim.areExplosivesAllowed)
        {
          claim.areExplosivesAllowed = false;
          sendMessage(player, TextMode.Success, Messages.ExplosivesDisabled, new String[0]);
        }
        else
        {
          claim.areExplosivesAllowed = true;
          sendMessage(player, TextMode.Success, Messages.ExplosivesEnabled, new String[0]);
        }
      }
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("deleteallclaims"))
    {
      if (args.length != 1) {
        return false;
      }
      OfflinePlayer otherPlayer = resolvePlayerByName(args[0]);
      if (otherPlayer == null)
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return true;
      }
      this.dataStore.deleteClaimsForPlayer(otherPlayer.getUniqueId(), true);

      sendMessage(player, TextMode.Success, Messages.DeleteAllSuccess, new String[] { otherPlayer.getName() });
      if (player != null)
      {
        AddLogEntry(player.getName() + " deleted all claims belonging to " + otherPlayer.getName() + ".", CustomLogEntryTypes.AdminActivity);

        Visualization.Revert(player);
      }
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("deleteclaimsinworld"))
    {
      if (player != null)
      {
        sendMessage(player, TextMode.Err, Messages.ConsoleOnlyCommand, new String[0]);
        return true;
      }
      if (args.length != 1) {
        return false;
      }
      World world = Bukkit.getServer().getWorld(args[0]);
      if (world == null)
      {
        sendMessage(player, TextMode.Err, Messages.WorldNotFound, new String[0]);
        return true;
      }
      this.dataStore.deleteClaimsInWorld(world, true);
      AddLogEntry("Deleted all claims in world: " + world.getName() + ".", CustomLogEntryTypes.AdminActivity);
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("deleteclaimsinworld"))
    {
      if (player != null)
      {
        sendMessage(player, TextMode.Err, Messages.ConsoleOnlyCommand, new String[0]);
        return true;
      }
      if (args.length != 1) {
        return false;
      }
      World world = Bukkit.getServer().getWorld(args[0]);
      if (world == null)
      {
        sendMessage(player, TextMode.Err, Messages.WorldNotFound, new String[0]);
        return true;
      }
      this.dataStore.deleteClaimsInWorld(world, false);
      AddLogEntry("Deleted all user claims in world: " + world.getName() + ".", CustomLogEntryTypes.AdminActivity);
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("claimbook"))
    {
      if (args.length != 1) {
        return false;
      }
      Player otherPlayer = getServer().getPlayer(args[0]);
      if (otherPlayer == null)
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return true;
      }
      WelcomeTask task = new WelcomeTask(otherPlayer);
      task.run();
      return true;
    }
    PlayerData playerData;
    int i;
    if (cmd.getName().equalsIgnoreCase("claimslist"))
    {
      if (args.length > 1) {
        return false;
      }
      OfflinePlayer otherPlayer;
      if (args.length < 1)
      {
        OfflinePlayer otherPlayer;
        if (player != null) {
          otherPlayer = player;
        } else {
          return false;
        }
      }
      else
      {
        if ((player != null) && (!player.hasPermission("griefprevention.claimslistother")))
        {
          sendMessage(player, TextMode.Err, Messages.ClaimsListNoPermission, new String[0]);
          return true;
        }
        otherPlayer = resolvePlayerByName(args[0]);
        if (otherPlayer == null)
        {
          sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
          return true;
        }
      }
      playerData = this.dataStore.getPlayerData(otherPlayer.getUniqueId());
      java.util.Vector<Claim> claims = playerData.getClaims();
      sendMessage(player, TextMode.Instr, Messages.StartBlockMath, new String[] {
        String.valueOf(playerData.getAccruedClaimBlocks()),
        String.valueOf(playerData.getBonusClaimBlocks() + this.dataStore.getGroupBonusBlocks(otherPlayer.getUniqueId())),
        String.valueOf(playerData.getAccruedClaimBlocks() + playerData.getBonusClaimBlocks() + this.dataStore.getGroupBonusBlocks(otherPlayer.getUniqueId())) });
      if (claims.size() > 0)
      {
        sendMessage(player, TextMode.Instr, Messages.ClaimsListHeader, new String[0]);
        for (i = 0; i < playerData.getClaims().size(); i++)
        {
          Claim claim = (Claim)playerData.getClaims().get(i);
          sendMessage(player, TextMode.Instr, getfriendlyLocationString(claim.getLesserBoundaryCorner()) + this.dataStore.getMessage(Messages.ContinueBlockMath, new String[] { String.valueOf(claim.getArea()) }));
        }
        sendMessage(player, TextMode.Instr, Messages.EndBlockMath, new String[] { String.valueOf(playerData.getRemainingClaimBlocks()) });
      }
      if (!otherPlayer.isOnline()) {
        this.dataStore.clearCachedPlayerData(otherPlayer.getUniqueId());
      }
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("adminclaimslist"))
    {
      java.util.Vector<Claim> claims = new java.util.Vector();
      for (Claim claim : this.dataStore.claims) {
        if (claim.ownerID == null) {
          claims.add(claim);
        }
      }
      if (claims.size() > 0)
      {
        sendMessage(player, TextMode.Instr, Messages.ClaimsListHeader, new String[0]);
        for (int i = 0; i < claims.size(); i++)
        {
          Claim claim = (Claim)claims.get(i);
          sendMessage(player, TextMode.Instr, getfriendlyLocationString(claim.getLesserBoundaryCorner()));
        }
      }
      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("unlockdrops")) && (player != null))
    {
      PlayerData playerData;
      if ((player.hasPermission("griefprevention.unlockothersdrops")) && (args.length == 1))
      {
        Player otherPlayer = Bukkit.getPlayer(args[0]);
        if (otherPlayer == null)
        {
          sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
          return true;
        }
        PlayerData playerData = this.dataStore.getPlayerData(otherPlayer.getUniqueId());
        sendMessage(player, TextMode.Success, Messages.DropUnlockOthersConfirmation, new String[] { otherPlayer.getName() });
      }
      else
      {
        playerData = this.dataStore.getPlayerData(player.getUniqueId());
        sendMessage(player, TextMode.Success, Messages.DropUnlockConfirmation, new String[0]);
      }
      playerData.dropsAreUnlocked = true;

      return true;
    }
    if ((player != null) && (cmd.getName().equalsIgnoreCase("deletealladminclaims")))
    {
      if (!player.hasPermission("griefprevention.deleteclaims"))
      {
        sendMessage(player, TextMode.Err, Messages.NoDeletePermission, new String[0]);
        return true;
      }
      this.dataStore.deleteClaimsForPlayer(null, true);

      sendMessage(player, TextMode.Success, Messages.AllAdminDeleted, new String[0]);
      if (player != null)
      {
        AddLogEntry(player.getName() + " deleted all administrative claims.", CustomLogEntryTypes.AdminActivity);

        Visualization.Revert(player);
      }
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("adjustbonusclaimblocks"))
    {
      if (args.length != 2) {
        return false;
      }
      try
      {
        adjustment = Integer.parseInt(args[1]);
      }
      catch (NumberFormatException numberFormatException)
      {
        int adjustment;
        return false;
      }
      int adjustment;
      if ((args[0].startsWith("[")) && (args[0].endsWith("]")))
      {
        String permissionIdentifier = args[0].substring(1, args[0].length() - 1);
        int newTotal = this.dataStore.adjustGroupBonusBlocks(permissionIdentifier, adjustment);

        sendMessage(player, TextMode.Success, Messages.AdjustGroupBlocksSuccess, new String[] { permissionIdentifier, String.valueOf(adjustment), String.valueOf(newTotal) });
        if (player != null) {
          AddLogEntry(player.getName() + " adjusted " + permissionIdentifier + "'s bonus claim blocks by " + adjustment + ".");
        }
        return true;
      }
      OfflinePlayer targetPlayer;
      try
      {
        UUID playerID = UUID.fromString(args[0]);
        targetPlayer = getServer().getOfflinePlayer(playerID);
      }
      catch (IllegalArgumentException e)
      {
        OfflinePlayer targetPlayer;
        targetPlayer = resolvePlayerByName(args[0]);
      }
      if (targetPlayer == null)
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return true;
      }
      PlayerData playerData = this.dataStore.getPlayerData(targetPlayer.getUniqueId());
      playerData.setBonusClaimBlocks(Integer.valueOf(playerData.getBonusClaimBlocks() + adjustment));
      this.dataStore.savePlayerData(targetPlayer.getUniqueId(), playerData);

      sendMessage(player, TextMode.Success, Messages.AdjustBlocksSuccess, new String[] { targetPlayer.getName(), String.valueOf(adjustment), String.valueOf(playerData.getBonusClaimBlocks()) });
      if (player != null) {
        AddLogEntry(player.getName() + " adjusted " + targetPlayer.getName() + "'s bonus claim blocks by " + adjustment + ".", CustomLogEntryTypes.AdminActivity);
      }
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("adjustbonusclaimblocksall"))
    {
      if (args.length != 1) {
        return false;
      }
      try
      {
        adjustment = Integer.parseInt(args[0]);
      }
      catch (NumberFormatException numberFormatException)
      {
        int adjustment;
        return false;
      }
      int adjustment;
      Collection<Player> players = getServer().getOnlinePlayers();
      StringBuilder builder = new StringBuilder();
      for (Player onlinePlayer : players)
      {
        UUID playerID = onlinePlayer.getUniqueId();
        PlayerData playerData = this.dataStore.getPlayerData(playerID);
        playerData.setBonusClaimBlocks(Integer.valueOf(playerData.getBonusClaimBlocks() + adjustment));
        this.dataStore.savePlayerData(playerID, playerData);
        builder.append(onlinePlayer.getName() + " ");
      }
      sendMessage(player, TextMode.Success, Messages.AdjustBlocksAllSuccess, new String[] { String.valueOf(adjustment) });
      AddLogEntry("Adjusted all " + players.size() + "players' bonus claim blocks by " + adjustment + ".  " + builder.toString(), CustomLogEntryTypes.AdminActivity);

      return true;
    }
    if (cmd.getName().equalsIgnoreCase("setaccruedclaimblocks"))
    {
      if (args.length != 2) {
        return false;
      }
      try
      {
        newAmount = Integer.parseInt(args[1]);
      }
      catch (NumberFormatException numberFormatException)
      {
        int newAmount;
        return false;
      }
      int newAmount;
      OfflinePlayer targetPlayer = resolvePlayerByName(args[0]);
      if (targetPlayer == null)
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return true;
      }
      PlayerData playerData = this.dataStore.getPlayerData(targetPlayer.getUniqueId());
      playerData.setAccruedClaimBlocks(Integer.valueOf(newAmount));
      this.dataStore.savePlayerData(targetPlayer.getUniqueId(), playerData);

      sendMessage(player, TextMode.Success, Messages.SetClaimBlocksSuccess, new String[0]);
      if (player != null) {
        AddLogEntry(player.getName() + " set " + targetPlayer.getName() + "'s accrued claim blocks to " + newAmount + ".", CustomLogEntryTypes.AdminActivity);
      }
      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("trapped")) && (player != null))
    {
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      Claim claim = this.dataStore.getClaimAt(player.getLocation(), false, playerData.lastClaim);
      if (playerData.pendingTrapped) {
        return true;
      }
      if ((claim == null) || (claim.allowBuild(player, Material.AIR) == null))
      {
        sendMessage(player, TextMode.Err, Messages.NotTrappedHere, new String[0]);
        return true;
      }
      SaveTrappedPlayerEvent event = new SaveTrappedPlayerEvent(claim);
      Bukkit.getPluginManager().callEvent(event);
      if ((player.getWorld().getEnvironment() != World.Environment.NORMAL) && (event.getDestination() == null))
      {
        sendMessage(player, TextMode.Err, Messages.TrappedWontWorkHere, new String[0]);
        return true;
      }
      if ((!instance.config_claims_allowTrappedInAdminClaims) && (claim.isAdminClaim()) && (event.getDestination() == null))
      {
        sendMessage(player, TextMode.Err, Messages.TrappedWontWorkHere, new String[0]);
        return true;
      }
      sendMessage(player, TextMode.Instr, Messages.RescuePending, new String[0]);

      PlayerRescueTask task = new PlayerRescueTask(player, player.getLocation(), event.getDestination());
      getServer().getScheduler().scheduleSyncDelayedTask(this, task, 200L);

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("siege")) && (player != null))
    {
      if (!siegeEnabledForWorld(player.getWorld()))
      {
        sendMessage(player, TextMode.Err, Messages.NonSiegeWorld, new String[0]);
        return true;
      }
      if (args.length > 1) {
        return false;
      }
      Player attacker = player;
      PlayerData attackerData = this.dataStore.getPlayerData(attacker.getUniqueId());
      if (attackerData.siegeData != null)
      {
        sendMessage(player, TextMode.Err, Messages.AlreadySieging, new String[0]);
        return true;
      }
      if (attackerData.pvpImmune)
      {
        sendMessage(player, TextMode.Err, Messages.CantFightWhileImmune, new String[0]);
        return true;
      }
      Player defender = null;
      if (args.length >= 1)
      {
        defender = getServer().getPlayer(args[0]);
        if (defender == null)
        {
          sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
          return true;
        }
      }
      else if (attackerData.lastPvpPlayer.length() > 0)
      {
        defender = getServer().getPlayer(attackerData.lastPvpPlayer);
        if (defender == null) {
          return false;
        }
      }
      else
      {
        return false;
      }
      if (attacker.getName().equals(defender.getName()))
      {
        sendMessage(player, TextMode.Err, Messages.NoSiegeYourself, new String[0]);
        return true;
      }
      if (defender.hasPermission("griefprevention.siegeimmune"))
      {
        sendMessage(player, TextMode.Err, Messages.SiegeImmune, new String[0]);
        return true;
      }
      PlayerData defenderData = this.dataStore.getPlayerData(defender.getUniqueId());
      if (defenderData.siegeData != null)
      {
        sendMessage(player, TextMode.Err, Messages.AlreadyUnderSiegePlayer, new String[0]);
        return true;
      }
      if (defenderData.pvpImmune)
      {
        sendMessage(player, TextMode.Err, Messages.NoSiegeDefenseless, new String[0]);
        return true;
      }
      Claim defenderClaim = this.dataStore.getClaimAt(defender.getLocation(), false, null);
      if ((defenderClaim == null) || (defenderClaim.allowAccess(defender) != null))
      {
        sendMessage(player, TextMode.Err, Messages.NotSiegableThere, new String[0]);
        return true;
      }
      if (!defenderClaim.isNear(attacker.getLocation(), 25))
      {
        sendMessage(player, TextMode.Err, Messages.SiegeTooFarAway, new String[0]);
        return true;
      }
      if (defenderClaim.siegeData != null)
      {
        sendMessage(player, TextMode.Err, Messages.AlreadyUnderSiegeArea, new String[0]);
        return true;
      }
      if (defenderClaim.isAdminClaim())
      {
        sendMessage(player, TextMode.Err, Messages.NoSiegeAdminClaim, new String[0]);
        return true;
      }
      if (this.dataStore.onCooldown(attacker, defender, defenderClaim))
      {
        sendMessage(player, TextMode.Err, Messages.SiegeOnCooldown, new String[0]);
        return true;
      }
      this.dataStore.startSiege(attacker, defender, defenderClaim);

      sendMessage(defender, TextMode.Warn, Messages.SiegeAlert, new String[] { attacker.getName() });
      sendMessage(player, TextMode.Success, Messages.SiegeConfirmed, new String[] { defender.getName() });

      return true;
    }
    if (cmd.getName().equalsIgnoreCase("softmute"))
    {
      if (args.length != 1) {
        return false;
      }
      OfflinePlayer targetPlayer = resolvePlayerByName(args[0]);
      if (targetPlayer == null)
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return true;
      }
      boolean isMuted = this.dataStore.toggleSoftMute(targetPlayer.getUniqueId());
      if (isMuted)
      {
        sendMessage(player, TextMode.Success, Messages.SoftMuted, new String[] { targetPlayer.getName() });
        String executorName = "console";
        if (player != null) {
          executorName = player.getName();
        }
        AddLogEntry(executorName + " muted " + targetPlayer.getName() + ".", CustomLogEntryTypes.AdminActivity, true);
      }
      else
      {
        sendMessage(player, TextMode.Success, Messages.UnSoftMuted, new String[] { targetPlayer.getName() });
      }
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("gpreload"))
    {
      loadConfig();
      if (player != null) {
        sendMessage(player, TextMode.Success, "Configuration updated.  If you have updated your Grief Prevention JAR, you still need to /reload or reboot your server.");
      } else {
        AddLogEntry("Configuration updated.  If you have updated your Grief Prevention JAR, you still need to /reload or reboot your server.");
      }
      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("givepet")) && (player != null))
    {
      if (args.length < 1) {
        return false;
      }
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      if (args[0].equalsIgnoreCase("cancel"))
      {
        playerData.petGiveawayRecipient = null;
        sendMessage(player, TextMode.Success, Messages.PetTransferCancellation, new String[0]);
        return true;
      }
      OfflinePlayer targetPlayer = resolvePlayerByName(args[0]);
      if (targetPlayer == null)
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return true;
      }
      playerData.petGiveawayRecipient = targetPlayer;

      sendMessage(player, TextMode.Instr, Messages.ReadyToTransferPet, new String[0]);

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("gpblockinfo")) && (player != null))
    {
      ItemStack inHand = player.getItemInHand();
      player.sendMessage("In Hand: " + String.format("%s(%d:%d)", new Object[] { inHand.getType().name(), Integer.valueOf(inHand.getTypeId()), Byte.valueOf(inHand.getData().getData()) }));

      Block inWorld = getTargetNonAirBlock(player, 300);
      player.sendMessage("In World: " + String.format("%s(%d:%d)", new Object[] { inWorld.getType().name(), Integer.valueOf(inWorld.getTypeId()), Byte.valueOf(inWorld.getData()) }));

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("ignoreplayer")) && (player != null))
    {
      if (args.length < 1) {
        return false;
      }
      OfflinePlayer targetPlayer = resolvePlayerByName(args[0]);
      if (targetPlayer == null)
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return true;
      }
      setIgnoreStatus(player, targetPlayer, IgnoreMode.StandardIgnore);

      sendMessage(player, TextMode.Success, Messages.IgnoreConfirmation, new String[0]);

      return true;
    }
    Boolean ignoreStatus;
    if ((cmd.getName().equalsIgnoreCase("unignoreplayer")) && (player != null))
    {
      if (args.length < 1) {
        return false;
      }
      OfflinePlayer targetPlayer = resolvePlayerByName(args[0]);
      if (targetPlayer == null)
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return true;
      }
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      ignoreStatus = (Boolean)playerData.ignoredPlayers.get(targetPlayer.getUniqueId());
      if ((ignoreStatus == null) || (ignoreStatus.booleanValue() == true))
      {
        sendMessage(player, TextMode.Err, Messages.NotIgnoringPlayer, new String[0]);
        return true;
      }
      setIgnoreStatus(player, targetPlayer, IgnoreMode.None);

      sendMessage(player, TextMode.Success, Messages.UnIgnoreConfirmation, new String[0]);

      return true;
    }
    if ((cmd.getName().equalsIgnoreCase("ignoredplayerlist")) && (player != null))
    {
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      StringBuilder builder = new StringBuilder();
      for (Map.Entry<UUID, Boolean> entry : playerData.ignoredPlayers.entrySet()) {
        if (entry.getValue() != null) {
          if (!((Boolean)entry.getValue()).booleanValue())
          {
            builder.append(lookupPlayerName((UUID)entry.getKey()));
            builder.append(" ");
          }
        }
      }
      String list = builder.toString().trim();
      if (list.isEmpty()) {
        sendMessage(player, TextMode.Info, Messages.NotIgnoringAnyone, new String[0]);
      } else {
        sendMessage(player, TextMode.Info, list);
      }
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("separate"))
    {
      if (args.length < 2) {
        return false;
      }
      OfflinePlayer targetPlayer = resolvePlayerByName(args[0]);
      if (targetPlayer == null)
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return true;
      }
      OfflinePlayer targetPlayer2 = resolvePlayerByName(args[1]);
      if (targetPlayer2 == null)
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return true;
      }
      setIgnoreStatus(targetPlayer, targetPlayer2, IgnoreMode.AdminIgnore);

      sendMessage(player, TextMode.Success, Messages.SeparateConfirmation, new String[0]);

      return true;
    }
    if (cmd.getName().equalsIgnoreCase("unseparate"))
    {
      if (args.length < 2) {
        return false;
      }
      OfflinePlayer targetPlayer = resolvePlayerByName(args[0]);
      if (targetPlayer == null)
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return true;
      }
      OfflinePlayer targetPlayer2 = resolvePlayerByName(args[1]);
      if (targetPlayer2 == null)
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return true;
      }
      setIgnoreStatus(targetPlayer, targetPlayer2, IgnoreMode.None);
      setIgnoreStatus(targetPlayer2, targetPlayer, IgnoreMode.None);

      sendMessage(player, TextMode.Success, Messages.UnSeparateConfirmation, new String[0]);

      return true;
    }
    return false;
  }

  void setIgnoreStatus(OfflinePlayer ignorer, OfflinePlayer ignoree, IgnoreMode mode)
  {
    PlayerData playerData = this.dataStore.getPlayerData(ignorer.getUniqueId());
    if (mode == IgnoreMode.None) {
      playerData.ignoredPlayers.remove(ignoree.getUniqueId());
    } else {
      playerData.ignoredPlayers.put(ignoree.getUniqueId(), Boolean.valueOf(mode != IgnoreMode.StandardIgnore));
    }
    playerData.ignoreListChanged = true;
    if (!ignorer.isOnline())
    {
      this.dataStore.savePlayerData(ignorer.getUniqueId(), playerData);
      this.dataStore.clearCachedPlayerData(ignorer.getUniqueId());
    }
  }

  public static enum IgnoreMode
  {
    None,  StandardIgnore,  AdminIgnore;

    private IgnoreMode() {}
  }

  private String trustEntryToPlayerName(String entry)
  {
    if ((entry.startsWith("[")) || (entry.equals("public"))) {
      return entry;
    }
    return lookupPlayerName(entry);
  }

  public static String getfriendlyLocationString(Location location)
  {
    return location.getWorld().getName() + ": x" + location.getBlockX() + ", z" + location.getBlockZ();
  }

  private boolean abandonClaimHandler(Player player, boolean deleteTopLevelClaim)
  {
    PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());

    Claim claim = this.dataStore.getClaimAt(player.getLocation(), true, null);
    if (claim == null)
    {
      sendMessage(player, TextMode.Instr, Messages.AbandonClaimMissing, new String[0]);
    }
    else if (claim.allowEdit(player) != null)
    {
      sendMessage(player, TextMode.Err, Messages.NotYourClaim, new String[0]);
    }
    else
    {
      if ((claim.children.size() > 0) && (!deleteTopLevelClaim))
      {
        sendMessage(player, TextMode.Instr, Messages.DeleteTopLevelClaim, new String[0]);
        return true;
      }
      claim.removeSurfaceFluids(null);
      this.dataStore.deleteClaim(claim, true, false);
      if (instance.creativeRulesApply(claim.getLesserBoundaryCorner()))
      {
        AddLogEntry(player.getName() + " abandoned a claim @ " + getfriendlyLocationString(claim.getLesserBoundaryCorner()));
        sendMessage(player, TextMode.Warn, Messages.UnclaimCleanupWarning, new String[0]);
        instance.restoreClaim(claim, 2400L);
      }
      if (claim.parent == null) {
        playerData.setAccruedClaimBlocks(Integer.valueOf(playerData.getAccruedClaimBlocks() - (int)Math.ceil(claim.getArea() * (1.0D - this.config_claims_abandonReturnRatio))));
      }
      int remainingBlocks = playerData.getRemainingClaimBlocks();
      sendMessage(player, TextMode.Success, Messages.AbandonSuccess, new String[] { String.valueOf(remainingBlocks) });

      Visualization.Revert(player);

      playerData.warnedAboutMajorDeletion = false;
    }
    return true;
  }

  private void handleTrustCommand(Player player, ClaimPermission permissionLevel, String recipientName)
  {
    Claim claim = this.dataStore.getClaimAt(player.getLocation(), true, null);

    String permission = null;
    OfflinePlayer otherPlayer = null;
    UUID recipientID = null;
    if ((recipientName.startsWith("[")) && (recipientName.endsWith("]")))
    {
      permission = recipientName.substring(1, recipientName.length() - 1);
      if ((permission == null) || (permission.isEmpty())) {
        sendMessage(player, TextMode.Err, Messages.InvalidPermissionID, new String[0]);
      }
    }
    else if (recipientName.contains("."))
    {
      permission = recipientName;
    }
    else
    {
      otherPlayer = resolvePlayerByName(recipientName);
      if ((otherPlayer == null) && (!recipientName.equals("public")) && (!recipientName.equals("all")))
      {
        sendMessage(player, TextMode.Err, Messages.PlayerNotFound2, new String[0]);
        return;
      }
      if (otherPlayer != null)
      {
        recipientName = otherPlayer.getName();
        recipientID = otherPlayer.getUniqueId();
      }
      else
      {
        recipientName = "public";
      }
    }
    ArrayList<Claim> targetClaims = new ArrayList();
    if (claim == null)
    {
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      for (int i = 0; i < playerData.getClaims().size(); i++) {
        targetClaims.add(playerData.getClaims().get(i));
      }
    }
    else
    {
      if (claim.allowGrantPermission(player) != null)
      {
        sendMessage(player, TextMode.Err, Messages.NoPermissionTrust, new String[] { claim.getOwnerName() });
        return;
      }
      String errorMessage = null;
      if (permissionLevel == null)
      {
        errorMessage = claim.allowEdit(player);
        if (errorMessage != null) {
          errorMessage = "Only " + claim.getOwnerName() + " can grant /PermissionTrust here.";
        }
      }
      else
      {
        switch (permissionLevel)
        {
        case Access:
          errorMessage = claim.allowAccess(player);
          break;
        case Inventory:
          errorMessage = claim.allowContainers(player);
          break;
        default:
          errorMessage = claim.allowBuild(player, Material.AIR);
        }
      }
      if (errorMessage != null)
      {
        sendMessage(player, TextMode.Err, Messages.CantGrantThatPermission, new String[0]);
        return;
      }
      targetClaims.add(claim);
    }
    if (targetClaims.size() == 0)
    {
      sendMessage(player, TextMode.Err, Messages.GrantPermissionNoClaim, new String[0]);
      return;
    }
    for (int i = 0; i < targetClaims.size(); i++)
    {
      Claim currentClaim = (Claim)targetClaims.get(i);
      String identifierToAdd = recipientName;
      if (permission != null) {
        identifierToAdd = "[" + permission + "]";
      } else if (recipientID != null) {
        identifierToAdd = recipientID.toString();
      }
      if (permissionLevel == null)
      {
        if (!currentClaim.managers.contains(identifierToAdd)) {
          currentClaim.managers.add(identifierToAdd);
        }
      }
      else {
        currentClaim.setPermission(identifierToAdd, permissionLevel);
      }
      this.dataStore.saveClaim(currentClaim);
    }
    if (recipientName.equals("public")) {
      recipientName = this.dataStore.getMessage(Messages.CollectivePublic, new String[0]);
    }
    String permissionDescription;
    String permissionDescription;
    if (permissionLevel == null)
    {
      permissionDescription = this.dataStore.getMessage(Messages.PermissionsPermission, new String[0]);
    }
    else
    {
      String permissionDescription;
      if (permissionLevel == ClaimPermission.Build)
      {
        permissionDescription = this.dataStore.getMessage(Messages.BuildPermission, new String[0]);
      }
      else
      {
        String permissionDescription;
        if (permissionLevel == ClaimPermission.Access) {
          permissionDescription = this.dataStore.getMessage(Messages.AccessPermission, new String[0]);
        } else {
          permissionDescription = this.dataStore.getMessage(Messages.ContainersPermission, new String[0]);
        }
      }
    }
    String location;
    String location;
    if (claim == null) {
      location = this.dataStore.getMessage(Messages.LocationAllClaims, new String[0]);
    } else {
      location = this.dataStore.getMessage(Messages.LocationCurrentClaim, new String[0]);
    }
    sendMessage(player, TextMode.Success, Messages.GrantPermissionConfirmation, new String[] { recipientName, permissionDescription, location });
  }

  ConcurrentHashMap<String, UUID> playerNameToIDMap = new ConcurrentHashMap();

  private class CacheOfflinePlayerNamesThread
    extends Thread
  {
    private OfflinePlayer[] offlinePlayers;
    private ConcurrentHashMap<String, UUID> playerNameToIDMap;

    CacheOfflinePlayerNamesThread(ConcurrentHashMap<String, UUID> offlinePlayers)
    {
      this.offlinePlayers = offlinePlayers;
      this.playerNameToIDMap = playerNameToIDMap;
    }

    public void run()
    {
      long now = System.currentTimeMillis();
      long millisecondsPerDay = 86400000L;
      for (OfflinePlayer player : this.offlinePlayers) {
        try
        {
          UUID playerID = player.getUniqueId();
          if (playerID != null)
          {
            long lastSeen = player.getLastPlayed();

            long diff = now - lastSeen;
            long daysDiff = diff / 86400000L;
            if (daysDiff <= 90L)
            {
              String playerName = player.getName();
              if (playerName == null) {
                continue;
              }
              this.playerNameToIDMap.put(playerName, playerID);
              this.playerNameToIDMap.put(playerName.toLowerCase(), playerID);
            }
          }
        }
        catch (Exception e)
        {
          e.printStackTrace();
        }
      }
    }
  }

  public OfflinePlayer resolvePlayerByName(String name)
  {
    Player targetPlayer = getServer().getPlayerExact(name);
    if (targetPlayer != null) {
      return targetPlayer;
    }
    targetPlayer = getServer().getPlayer(name);
    if (targetPlayer != null) {
      return targetPlayer;
    }
    UUID bestMatchID = null;

    bestMatchID = (UUID)this.playerNameToIDMap.get(name);
    if (bestMatchID == null) {
      bestMatchID = (UUID)this.playerNameToIDMap.get(name.toLowerCase());
    }
    if (bestMatchID == null) {
      return null;
    }
    return getServer().getOfflinePlayer(bestMatchID);
  }

  static String lookupPlayerName(UUID playerID)
  {
    if (playerID == null) {
      return "somebody";
    }
    OfflinePlayer player = instance.getServer().getOfflinePlayer(playerID);
    if ((player.hasPlayedBefore()) || (player.isOnline())) {
      return player.getName();
    }
    return "someone(" + playerID.toString() + ")";
  }

  static void cacheUUIDNamePair(UUID playerID, String playerName)
  {
    instance.playerNameToIDMap.put(playerName, playerID);
    instance.playerNameToIDMap.put(playerName.toLowerCase(), playerID);
  }

  static String lookupPlayerName(String playerID)
  {
    try
    {
      id = UUID.fromString(playerID);
    }
    catch (IllegalArgumentException ex)
    {
      UUID id;
      AddLogEntry("Error: Tried to look up a local player name for invalid UUID: " + playerID);
      return "someone";
    }
    UUID id;
    return lookupPlayerName(id);
  }

  public void onDisable()
  {
    Collection<Player> players = getServer().getOnlinePlayers();
    for (Player player : players)
    {
      UUID playerID = player.getUniqueId();
      PlayerData playerData = this.dataStore.getPlayerData(playerID);
      this.dataStore.savePlayerDataSync(playerID, playerData);
    }
    this.dataStore.close();

    this.customLogger.WriteEntries();

    AddLogEntry("GriefPrevention disabled.");
  }

  public void checkPvpProtectionNeeded(Player player)
  {
    if (!this.config_pvp_protectFreshSpawns) {
      return;
    }
    if (!pvpRulesApply(player.getWorld())) {
      return;
    }
    if (player.getGameMode() == GameMode.CREATIVE) {
      return;
    }
    if (player.hasPermission("griefprevention.nopvpimmunity")) {
      return;
    }
    if (isInventoryEmpty(player))
    {
      PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
      playerData.pvpImmune = true;

      sendMessage(player, TextMode.Success, Messages.PvPImmunityStart, 5L, new String[0]);

      PvPImmunityValidationTask task = new PvPImmunityValidationTask(player);
      getServer().getScheduler().scheduleSyncDelayedTask(this, task, 1200L);
    }
  }

  static boolean isInventoryEmpty(Player player)
  {
    PlayerInventory inventory = player.getInventory();
    ItemStack[] armorStacks = inventory.getArmorContents();
    for (int i = 0; i < armorStacks.length; i++) {
      if ((armorStacks[i] != null) && (armorStacks[i].getType() != Material.AIR)) {
        return false;
      }
    }
    ItemStack[] generalStacks = inventory.getContents();
    for (int i = 0; i < generalStacks.length; i++) {
      if ((generalStacks[i] != null) && (generalStacks[i].getType() != Material.AIR)) {
        return false;
      }
    }
    return true;
  }

  public boolean siegeEnabledForWorld(World world)
  {
    return this.config_siege_enabledWorlds.contains(world);
  }

  public Location ejectPlayer(Player player)
  {
    Location candidateLocation = player.getLocation();
    for (;;)
    {
      Claim claim = null;
      claim = instance.dataStore.getClaimAt(candidateLocation, false, null);
      if (claim == null) {
        break;
      }
      candidateLocation = new Location(claim.lesserBoundaryCorner.getWorld(), claim.lesserBoundaryCorner.getBlockX() - 1, claim.lesserBoundaryCorner.getBlockY(), claim.lesserBoundaryCorner.getBlockZ() - 1);
    }
    GuaranteeChunkLoaded(candidateLocation);
    Block highestBlock = candidateLocation.getWorld().getHighestBlockAt(candidateLocation.getBlockX(), candidateLocation.getBlockZ());
    Location destination = new Location(highestBlock.getWorld(), highestBlock.getX(), highestBlock.getY() + 2, highestBlock.getZ());
    player.teleport(destination);
    return destination;
  }

  private static void GuaranteeChunkLoaded(Location location)
  {
    Chunk chunk = location.getChunk();
    while ((!chunk.isLoaded()) || (!chunk.load(true))) {}
  }

  static void sendMessage(Player player, ChatColor color, Messages messageID, String... args)
  {
    sendMessage(player, color, messageID, 0L, args);
  }

  static void sendMessage(Player player, ChatColor color, Messages messageID, long delayInTicks, String... args)
  {
    String message = instance.dataStore.getMessage(messageID, args);
    sendMessage(player, color, message, delayInTicks);
  }

  static void sendMessage(Player player, ChatColor color, String message)
  {
    if ((message == null) || (message.length() == 0)) {
      return;
    }
    if (player == null) {
      AddLogEntry(color + message);
    } else {
      player.sendMessage(color + message);
    }
  }

  static void sendMessage(Player player, ChatColor color, String message, long delayInTicks)
  {
    SendPlayerMessageTask task = new SendPlayerMessageTask(player, color, message);
    instance.getServer().getScheduler().runTaskLater(instance, task, delayInTicks);
  }

  public boolean claimsEnabledForWorld(World world)
  {
    ClaimsMode mode = (ClaimsMode)this.config_claims_worldModes.get(world);
    return (mode != null) && (mode != ClaimsMode.Disabled);
  }

  boolean creativeRulesApply(Location location)
  {
    if (!this.config_creativeWorldsExist) {
      return false;
    }
    return this.config_claims_worldModes.get(location.getWorld()) == ClaimsMode.Creative;
  }

  public String allowBuild(Player player, Location location)
  {
    return allowBuild(player, location, location.getBlock().getType());
  }

  public String allowBuild(Player player, Location location, Material material)
  {
    if (!instance.claimsEnabledForWorld(location.getWorld())) {
      return null;
    }
    PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
    Claim claim = this.dataStore.getClaimAt(location, false, playerData.lastClaim);
    if ((playerData.ignoreClaims) || (instance.config_mods_ignoreClaimsAccounts.contains(player.getName()))) {
      return null;
    }
    if (claim == null)
    {
      if ((creativeRulesApply(location)) || (this.config_claims_worldModes.get(location.getWorld()) == ClaimsMode.SurvivalRequiringClaims))
      {
        if ((material != Material.CHEST) || (playerData.getClaims().size() > 0) || (instance.config_claims_automaticClaimsForNewPlayersRadius == -1))
        {
          String reason = this.dataStore.getMessage(Messages.NoBuildOutsideClaims, new String[0]);
          if (player.hasPermission("griefprevention.ignoreclaims")) {
            reason = reason + "  " + this.dataStore.getMessage(Messages.IgnoreClaimsAdvertisement, new String[0]);
          }
          reason = reason + "  " + this.dataStore.getMessage(Messages.CreativeBasicsVideo2, new String[] { DataStore.CREATIVE_VIDEO_URL });
          return reason;
        }
        return null;
      }
      return null;
    }
    playerData.lastClaim = claim;
    return claim.allowBuild(player, material);
  }

  public String allowBreak(Player player, Block block, Location location)
  {
    return allowBreak(player, block, location, null);
  }

  public String allowBreak(Player player, Block block, Location location, BlockBreakEvent breakEvent)
  {
    if (!instance.claimsEnabledForWorld(location.getWorld())) {
      return null;
    }
    PlayerData playerData = this.dataStore.getPlayerData(player.getUniqueId());
    Claim claim = this.dataStore.getClaimAt(location, false, playerData.lastClaim);
    if ((playerData.ignoreClaims) || (instance.config_mods_ignoreClaimsAccounts.contains(player.getName()))) {
      return null;
    }
    if (claim == null)
    {
      if ((creativeRulesApply(location)) || (this.config_claims_worldModes.get(location.getWorld()) == ClaimsMode.SurvivalRequiringClaims))
      {
        String reason = this.dataStore.getMessage(Messages.NoBuildOutsideClaims, new String[0]);
        if (player.hasPermission("griefprevention.ignoreclaims")) {
          reason = reason + "  " + this.dataStore.getMessage(Messages.IgnoreClaimsAdvertisement, new String[0]);
        }
        reason = reason + "  " + this.dataStore.getMessage(Messages.CreativeBasicsVideo2, new String[] { DataStore.CREATIVE_VIDEO_URL });
        return reason;
      }
      return null;
    }
    playerData.lastClaim = claim;

    String cancel = claim.allowBreak(player, block.getType());
    if ((cancel != null) && (breakEvent != null))
    {
      PreventBlockBreakEvent preventionEvent = new PreventBlockBreakEvent(breakEvent);
      Bukkit.getPluginManager().callEvent(preventionEvent);
      if (preventionEvent.isCancelled()) {
        cancel = null;
      }
    }
    return cancel;
  }

  public void restoreClaim(Claim claim, long delayInTicks)
  {
    if (claim.isAdminClaim()) {
      return;
    }
    if (claim.getArea() > 10000) {
      return;
    }
    ArrayList<Chunk> chunks = claim.getChunks();
    for (Chunk chunk : chunks) {
      restoreChunk(chunk, getSeaLevel(chunk.getWorld()) - 15, false, delayInTicks, null);
    }
  }

  public void restoreChunk(Chunk chunk, int miny, boolean aggressiveMode, long delayInTicks, Player playerReceivingVisualization)
  {
    int maxHeight = chunk.getWorld().getMaxHeight();
    BlockSnapshot[][][] snapshots = new BlockSnapshot[18][maxHeight][18];
    Block startBlock = chunk.getBlock(0, 0, 0);
    Location startLocation = new Location(chunk.getWorld(), startBlock.getX() - 1, 0.0D, startBlock.getZ() - 1);
    for (int x = 0; x < snapshots.length; x++) {
      for (int z = 0; z < snapshots[0][0].length; z++) {
        for (int y = 0; y < snapshots[0].length; y++)
        {
          Block block = chunk.getWorld().getBlockAt(startLocation.getBlockX() + x, startLocation.getBlockY() + y, startLocation.getBlockZ() + z);
          snapshots[x][y][z] = new BlockSnapshot(block.getLocation(), block.getTypeId(), block.getData());
        }
      }
    }
    Location lesserBoundaryCorner = chunk.getBlock(0, 0, 0).getLocation();
    Location greaterBoundaryCorner = chunk.getBlock(15, 0, 15).getLocation();

    RestoreNatureProcessingTask task = new RestoreNatureProcessingTask(snapshots, miny, chunk.getWorld().getEnvironment(), lesserBoundaryCorner.getBlock().getBiome(), lesserBoundaryCorner, greaterBoundaryCorner, getSeaLevel(chunk.getWorld()), aggressiveMode, instance.creativeRulesApply(lesserBoundaryCorner), playerReceivingVisualization);
    instance.getServer().getScheduler().runTaskLaterAsynchronously(instance, task, delayInTicks);
  }

  private void parseMaterialListFromConfig(List<String> stringsToParse, MaterialCollection materialCollection)
  {
    materialCollection.clear();
    for (int i = 0; i < stringsToParse.size(); i++)
    {
      MaterialInfo materialInfo = MaterialInfo.fromString((String)stringsToParse.get(i));
      if (materialInfo == null)
      {
        AddLogEntry("ERROR: Unable to read a material entry from the config file.  Please update your config.yml.");
        if (!((String)stringsToParse.get(i)).contains("can't")) {
          stringsToParse.set(i, (String)stringsToParse.get(i) + "     <-- can't understand this entry, see BukkitDev documentation");
        }
      }
      else
      {
        materialCollection.Add(materialInfo);
      }
    }
  }

  public int getSeaLevel(World world)
  {
    Integer overrideValue = (Integer)this.config_seaLevelOverride.get(world.getName());
    if ((overrideValue == null) || (overrideValue.intValue() == -1)) {
      return world.getSeaLevel();
    }
    return overrideValue.intValue();
  }

  private static Block getTargetNonAirBlock(Player player, int maxDistance)
    throws IllegalStateException
  {
    BlockIterator iterator = new BlockIterator(player.getLocation(), player.getEyeHeight(), maxDistance);
    Block result = player.getLocation().getBlock().getRelative(BlockFace.UP);
    while (iterator.hasNext())
    {
      result = iterator.next();
      if (result.getType() != Material.AIR) {
        return result;
      }
    }
    return result;
  }

  public boolean containsBlockedIP(String message)
  {
    message = message.replace("\r\n", "");
    Pattern ipAddressPattern = Pattern.compile("([0-9]{1,3}\\.){3}[0-9]{1,3}");
    Matcher matcher = ipAddressPattern.matcher(message);
    if (matcher.find()) {
      if (!instance.config_spam_allowedIpAddresses.contains(matcher.group())) {
        return true;
      }
    }
    return false;
  }

  void autoExtendClaim(Claim newClaim)
  {
    Location lesserCorner = newClaim.getLesserBoundaryCorner();
    Location greaterCorner = newClaim.getGreaterBoundaryCorner();
    World world = lesserCorner.getWorld();
    ArrayList<ChunkSnapshot> snapshots = new ArrayList();
    for (int chunkx = lesserCorner.getBlockX() / 16; chunkx <= greaterCorner.getBlockX() / 16; chunkx++) {
      for (int chunkz = lesserCorner.getBlockZ() / 16; chunkz <= greaterCorner.getBlockZ() / 16; chunkz++) {
        if (world.isChunkLoaded(chunkx, chunkz)) {
          snapshots.add(world.getChunkAt(chunkx, chunkz).getChunkSnapshot(true, true, false));
        }
      }
    }
    Bukkit.getScheduler().runTaskAsynchronously(instance, new AutoExtendClaimTask(newClaim, snapshots, world.getEnvironment()));
  }

  public boolean pvpRulesApply(World world)
  {
    Boolean configSetting = (Boolean)this.config_pvp_specifiedWorlds.get(world);
    if (configSetting != null) {
      return configSetting.booleanValue();
    }
    return world.getPVP();
  }

  public static boolean isNewToServer(Player player)
  {
    if (player.getStatistic(Statistic.PICKUP, Material.WOOD) > 0) {
      return false;
    }
    PlayerData playerData = instance.dataStore.getPlayerData(player.getUniqueId());
    if (playerData.getClaims().size() > 0) {
      return false;
    }
    return true;
  }

  static void banPlayer(Player player, String reason, String source)
  {
    if (instance.config_ban_useCommand)
    {
      Bukkit.getServer().dispatchCommand(
        Bukkit.getConsoleSender(), instance.config_ban_commandFormat
        .replace("%name%", player.getName()).replace("%reason%", reason));
    }
    else
    {
      BanList bans = Bukkit.getServer().getBanList(BanList.Type.NAME);
      bans.addBan(player.getName(), reason, null, source);
      if (player.isOnline()) {
        player.kickPlayer(reason);
      }
    }
  }

  public ItemStack getItemInHand(Player player, EquipmentSlot hand)
  {
    if (hand == EquipmentSlot.OFF_HAND) {
      return player.getInventory().getItemInOffHand();
    }
    return player.getInventory().getItemInMainHand();
  }

  public boolean claimIsPvPSafeZone(Claim claim)
  {
    return ((claim.isAdminClaim()) && (claim.parent == null) && (instance.config_pvp_noCombatInAdminLandClaims)) ||
      ((claim.isAdminClaim()) && (claim.parent != null) && (instance.config_pvp_noCombatInAdminSubdivisions)) || (
      (!claim.isAdminClaim()) && (instance.config_pvp_noCombatInPlayerLandClaims));
  }

  ConcurrentHashMap<UUID, BukkitTask> portalReturnTaskMap = new ConcurrentHashMap();

  public void startRescueTask(Player player)
  {
    BukkitTask task = new CheckForPortalTrapTask(player, this).runTaskLater(instance, 400L);
    if (this.portalReturnTaskMap.containsKey(player.getUniqueId())) {
      ((BukkitTask)this.portalReturnTaskMap.put(player.getUniqueId(), task)).cancel();
    } else {
      this.portalReturnTaskMap.put(player.getUniqueId(), task);
    }
  }
}