package com.sk89q.worldguard.bukkit;

import com.sk89q.bukkit.util.CommandsManagerRegistration;
import com.sk89q.minecraft.util.commands.CommandException;
import com.sk89q.minecraft.util.commands.CommandPermissionsException;
import com.sk89q.minecraft.util.commands.CommandUsageException;
import com.sk89q.minecraft.util.commands.CommandsManager;
import com.sk89q.minecraft.util.commands.MissingNestedCommandException;
import com.sk89q.minecraft.util.commands.SimpleInjector;
import com.sk89q.minecraft.util.commands.WrappedCommandException;
import com.sk89q.wepif.PermissionsResolverManager;
import com.sk89q.worldedit.bukkit.WorldEditPlugin;
import com.sk89q.worldguard.LocalPlayer;
import com.sk89q.worldguard.bukkit.commands.GeneralCommands;
import com.sk89q.worldguard.bukkit.commands.ProtectionCommands;
import com.sk89q.worldguard.bukkit.commands.ToggleCommands;
import com.sk89q.worldguard.protection.GlobalRegionManager;
import com.sk89q.worldguard.protection.managers.RegionManager;
import com.sk89q.worldguard.util.FatalConfigurationLoadingException;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.jar.JarFile;
import java.util.logging.Logger;
import java.util.zip.ZipEntry;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Server;
import org.bukkit.World;
import org.bukkit.World.Environment;
import org.bukkit.block.Block;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.entity.Player;
import org.bukkit.permissions.Permissible;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitScheduler;
import org.bukkit.util.Vector;

public class WorldGuardPlugin
  extends JavaPlugin
{
  private final CommandsManager<CommandSender> commands;
  private final GlobalRegionManager globalRegionManager;
  private final ConfigurationManager configuration;
  private FlagStateManager flagStateManager;

  public WorldGuardPlugin()
  {
    this.configuration = new ConfigurationManager(this);
    this.globalRegionManager = new GlobalRegionManager(this);

    final WorldGuardPlugin plugin = this;
    this.commands = new CommandsManager()
    {
      public boolean hasPermission(CommandSender player, String perm)
      {
        return plugin.hasPermission(player, perm);
      }
    };
  }

  public void onEnable()
  {
    this.commands.setInjector(new SimpleInjector(new Object[] { this }));


    final CommandsManagerRegistration reg = new CommandsManagerRegistration(this, this.commands);
    reg.register(ToggleCommands.class);
    reg.register(ProtectionCommands.class);

    getServer().getScheduler().scheduleSyncDelayedTask(this, new Runnable()
    {
      public void run()
      {
        if (!WorldGuardPlugin.this.getGlobalStateManager().hasCommandBookGodMode()) {
          reg.register(GeneralCommands.class);
        }
      }
    }, 0L);





    getDataFolder().mkdirs();

    PermissionsResolverManager.initialize(this);


    LegacyWorldGuardMigration.migrateBlacklist(this);
    try
    {
      this.configuration.load();
      this.globalRegionManager.preload();
    }
    catch (FatalConfigurationLoadingException e)
    {
      e.printStackTrace();
      getServer().shutdown();
    }
    LegacyWorldGuardMigration.migrateRegions(this);

    this.flagStateManager = new FlagStateManager(this);
    if (this.configuration.useRegionsScheduler) {
      getServer().getScheduler().scheduleSyncRepeatingTask(this, this.flagStateManager, 20L, 20L);
    }
    new WorldGuardPlayerListener(this).registerEvents();
    new WorldGuardBlockListener(this).registerEvents();
    new WorldGuardEntityListener(this).registerEvents();
    new WorldGuardWeatherListener(this).registerEvents();
    new WorldGuardVehicleListener(this).registerEvents();
    new WorldGuardServerListener(this).registerEvents();
    if (BukkitUtil.hasHangingEvent()) {
      new WorldGuardHangingListener(this).registerEvents();
    } else {
      new WorldGuardPaintingListener(this).registerEvents();
    }
    this.configuration.updateCommandBookGodMode();
    if (getServer().getPluginManager().isPluginEnabled("CommandBook")) {
      getServer().getPluginManager().registerEvents(new WorldGuardCommandBookListener(this), this);
    }
    WorldGuardWorldListener worldListener = new WorldGuardWorldListener(this);
    for (World world : getServer().getWorlds()) {
      worldListener.initWorld(world);
    }
    worldListener.registerEvents();
    if (!this.configuration.hasCommandBookGodMode()) {
      for (Player player : getServer().getOnlinePlayers()) {
        if ((inGroup(player, "wg-invincible")) || ((this.configuration.autoGodMode) && (hasPermission(player, "worldguard.auto-invincible")))) {
          this.configuration.enableGodMode(player);
        }
      }
    }
  }

  public void onDisable()
  {
    this.globalRegionManager.unload();
    this.configuration.unload();
    getServer().getScheduler().cancelTasks(this);
  }

  public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args)
  {
    try
    {
      this.commands.execute(cmd.getName(), args, sender, new Object[] { sender });
    }
    catch (CommandPermissionsException e)
    {
      sender.sendMessage(ChatColor.RED + "You don't have permission.");
    }
    catch (MissingNestedCommandException e)
    {
      sender.sendMessage(ChatColor.RED + e.getUsage());
    }
    catch (CommandUsageException e)
    {
      sender.sendMessage(ChatColor.RED + e.getMessage());
      sender.sendMessage(ChatColor.RED + e.getUsage());
    }
    catch (WrappedCommandException e)
    {
      if ((e.getCause() instanceof NumberFormatException))
      {
        sender.sendMessage(ChatColor.RED + "Number expected, string received instead.");
      }
      else
      {
        sender.sendMessage(ChatColor.RED + "An error has occurred. See console.");
        e.printStackTrace();
      }
    }
    catch (CommandException e)
    {
      sender.sendMessage(ChatColor.RED + e.getMessage());
    }
    return true;
  }

  public GlobalRegionManager getGlobalRegionManager()
  {
    return this.globalRegionManager;
  }

  @Deprecated
  public ConfigurationManager getGlobalConfiguration()
  {
    return getGlobalStateManager();
  }

  public FlagStateManager getFlagStateManager()
  {
    return this.flagStateManager;
  }

  public ConfigurationManager getGlobalStateManager()
  {
    return this.configuration;
  }

  public boolean inGroup(Player player, String group)
  {
    try
    {
      return PermissionsResolverManager.getInstance().inGroup(player, group);
    }
    catch (Throwable t)
    {
      t.printStackTrace();
    }
    return false;
  }

  public String[] getGroups(Player player)
  {
    try
    {
      return PermissionsResolverManager.getInstance().getGroups(player);
    }
    catch (Throwable t)
    {
      t.printStackTrace();
    }
    return new String[0];
  }

  public String toUniqueName(CommandSender sender)
  {
    if ((sender instanceof ConsoleCommandSender)) {
      return "*Console*";
    }
    return sender.getName();
  }

  public String toName(CommandSender sender)
  {
    if ((sender instanceof ConsoleCommandSender)) {
      return "*Console*";
    }
    if ((sender instanceof Player)) {
      return ((Player)sender).getDisplayName();
    }
    return sender.getName();
  }

  public boolean hasPermission(CommandSender sender, String perm)
  {
    if (sender.isOp()) {
      if ((sender instanceof Player))
      {
        if (getGlobalStateManager().get(((Player)sender).getWorld()).opPermissions) {
          return true;
        }
      }
      else {
        return true;
      }
    }
    if ((sender instanceof Player))
    {
      Player player = (Player)sender;
      return PermissionsResolverManager.getInstance().hasPermission(player.getWorld().getName(), player.getName(), perm);
    }
    return false;
  }

  public void checkPermission(CommandSender sender, String perm)
    throws CommandPermissionsException
  {
    if (!hasPermission(sender, perm)) {
      throw new CommandPermissionsException();
    }
  }

  public Player checkPlayer(CommandSender sender)
    throws CommandException
  {
    if ((sender instanceof Player)) {
      return (Player)sender;
    }
    throw new CommandException("A player is expected.");
  }

  public List<Player> matchPlayerNames(String filter)
  {
    Player[] players = getServer().getOnlinePlayers();

    filter = filter.toLowerCase();
    if ((filter.charAt(0) == '@') && (filter.length() >= 2))
    {
      filter = filter.substring(1);
      for (Player player : players) {
        if (player.getName().equalsIgnoreCase(filter))
        {
          List<Player> list = new ArrayList();
          list.add(player);
          return list;
        }
      }
      return new ArrayList();
    }
    if ((filter.charAt(0) == '*') && (filter.length() >= 2))
    {
      filter = filter.substring(1);

      List<Player> list = new ArrayList();
      for (Player player : players) {
        if (player.getName().toLowerCase().contains(filter)) {
          list.add(player);
        }
      }
      return list;
    }
    List<Player> list = new ArrayList();
    for (Player player : players) {
      if (player.getName().toLowerCase().startsWith(filter)) {
        list.add(player);
      }
    }
    return list;
  }

  protected Iterable<Player> checkPlayerMatch(List<Player> players)
    throws CommandException
  {
    if (players.size() == 0) {
      throw new CommandException("No players matched query.");
    }
    return players;
  }

  public Iterable<Player> matchPlayers(CommandSender source, String filter)
    throws CommandException
  {
    if (getServer().getOnlinePlayers().length == 0) {
      throw new CommandException("No players matched query.");
    }
    if (filter.equals("*")) {
      return checkPlayerMatch(Arrays.asList(getServer().getOnlinePlayers()));
    }
    if (filter.charAt(0) == '#')
    {
      if (filter.equalsIgnoreCase("#world"))
      {
        List<Player> players = new ArrayList();
        Player sourcePlayer = checkPlayer(source);
        World sourceWorld = sourcePlayer.getWorld();
        for (Player player : getServer().getOnlinePlayers()) {
          if (player.getWorld().equals(sourceWorld)) {
            players.add(player);
          }
        }
        return checkPlayerMatch(players);
      }
      if (filter.equalsIgnoreCase("#near"))
      {
        List<Player> players = new ArrayList();
        Player sourcePlayer = checkPlayer(source);
        World sourceWorld = sourcePlayer.getWorld();
        Vector sourceVector = sourcePlayer.getLocation().toVector();
        for (Player player : getServer().getOnlinePlayers()) {
          if ((player.getWorld().equals(sourceWorld)) && (player.getLocation().toVector().distanceSquared(sourceVector) < 900.0D)) {
            players.add(player);
          }
        }
        return checkPlayerMatch(players);
      }
      throw new CommandException("Invalid group '" + filter + "'.");
    }
    List<Player> players = matchPlayerNames(filter);

    return checkPlayerMatch(players);
  }

  public Player matchSinglePlayer(CommandSender sender, String filter)
    throws CommandException
  {
    Iterator<Player> players = matchPlayers(sender, filter).iterator();

    Player match = (Player)players.next();
    if (players.hasNext()) {
      throw new CommandException("More than one player found! Use @<name> for exact matching.");
    }
    return match;
  }

  public CommandSender matchPlayerOrConsole(CommandSender sender, String filter)
    throws CommandException
  {
    if ((filter.equalsIgnoreCase("#console")) || (filter.equalsIgnoreCase("*console*")) || (filter.equalsIgnoreCase("!"))) {
      return getServer().getConsoleSender();
    }
    return matchSinglePlayer(sender, filter);
  }

  public Iterable<Player> matchPlayers(Player player)
  {
    return Arrays.asList(new Player[] { player });
  }

  public World matchWorld(CommandSender sender, String filter)
    throws CommandException
  {
    List<World> worlds = getServer().getWorlds();
    if (filter.charAt(0) == '#')
    {
      if (filter.equalsIgnoreCase("#main")) {
        return (World)worlds.get(0);
      }
      if (filter.equalsIgnoreCase("#normal"))
      {
        for (World world : worlds) {
          if (world.getEnvironment() == World.Environment.NORMAL) {
            return world;
          }
        }
        throw new CommandException("No normal world found.");
      }
      if (filter.equalsIgnoreCase("#nether"))
      {
        for (World world : worlds) {
          if (world.getEnvironment() == World.Environment.NETHER) {
            return world;
          }
        }
        throw new CommandException("No nether world found.");
      }
      if (filter.matches("^#player$"))
      {
        String[] parts = filter.split(":", 2);
        if (parts.length == 1) {
          throw new CommandException("Argument expected for #player.");
        }
        return ((Player)matchPlayers(sender, parts[1]).iterator().next()).getWorld();
      }
      throw new CommandException("Invalid identifier '" + filter + "'.");
    }
    for (World world : worlds) {
      if (world.getName().equals(filter)) {
        return world;
      }
    }
    throw new CommandException("No world by that exact name found.");
  }

  public WorldEditPlugin getWorldEdit()
    throws CommandException
  {
    Plugin worldEdit = getServer().getPluginManager().getPlugin("WorldEdit");
    if (worldEdit == null) {
      throw new CommandException("WorldEdit does not appear to be installed.");
    }
    if ((worldEdit instanceof WorldEditPlugin)) {
      return (WorldEditPlugin)worldEdit;
    }
    throw new CommandException("WorldEdit detection failed (report error).");
  }

  public LocalPlayer wrapPlayer(Player player)
  {
    return new BukkitPlayer(this, player);
  }

  public void createDefaultConfiguration(File actual, String defaultName)
  {
    File parent = actual.getParentFile();
    if (!parent.exists()) {
      parent.mkdirs();
    }
    if (actual.exists()) {
      return;
    }
    InputStream input = null;
    try
    {
      JarFile file = new JarFile(getFile());
      ZipEntry copy = file.getEntry("defaults/" + defaultName);
      if (copy == null) {
        throw new FileNotFoundException();
      }
      input = file.getInputStream(copy);
    }
    catch (IOException e)
    {
      getLogger().severe("Unable to read default configuration: " + defaultName);
    }
    if (input != null)
    {
      FileOutputStream output = null;
      try
      {
        output = new FileOutputStream(actual);
        byte[] buf = new byte[8192];
        int length = 0;
        while ((length = input.read(buf)) > 0) {
          output.write(buf, 0, length);
        }
        getLogger().info("Default configuration file written: " + actual.getAbsolutePath());
      }
      catch (IOException e)
      {
        e.printStackTrace();
      }
      finally
      {
        try
        {
          if (input != null) {
            input.close();
          }
        }
        catch (IOException ignore) {}
        try
        {
          if (output != null) {
            output.close();
          }
        }
        catch (IOException ignore) {}
      }
    }
  }

  public void broadcastNotification(String msg)
  {
    getServer().broadcast(msg, "worldguard.notify");
    Set<Permissible> subs = getServer().getPluginManager().getPermissionSubscriptions("worldguard.notify");
    for (Player player : getServer().getOnlinePlayers()) {
      if (((!subs.contains(player)) || (!player.hasPermission("worldguard.notify"))) && (hasPermission(player, "worldguard.notify"))) {
        player.sendMessage(msg);
      }
    }
    getLogger().info(msg);
  }

  public void forgetPlayer(Player player)
  {
    this.flagStateManager.forget(player);
  }

  public boolean canBuild(Player player, Location loc)
  {
    return getGlobalRegionManager().canBuild(player, loc);
  }

  public boolean canBuild(Player player, Block block)
  {
    return getGlobalRegionManager().canBuild(player, block);
  }

  public RegionManager getRegionManager(World world)
  {
    if (!getGlobalStateManager().get(world).useRegions) {
      return null;
    }
    return getGlobalRegionManager().get(world);
  }

  public String replaceMacros(CommandSender sender, String message)
  {
    Player[] online = getServer().getOnlinePlayers();

    message = message.replace("%name%", toName(sender));
    message = message.replace("%id%", toUniqueName(sender));
    message = message.replace("%online%", String.valueOf(online.length));
    if ((sender instanceof Player))
    {
      Player player = (Player)sender;
      World world = player.getWorld();

      message = message.replace("%world%", world.getName());
      message = message.replace("%health%", String.valueOf(player.getHealth()));
    }
    return message;
  }
}