BlockOwn.java

package com.nicewuerfel.blockown;

import com.nicewuerfel.blockown.command.CE_AddFriend;
import com.nicewuerfel.blockown.command.CE_Ignore;
import com.nicewuerfel.blockown.command.CE_Import;
import com.nicewuerfel.blockown.command.CE_List;
import com.nicewuerfel.blockown.command.CE_Lock;
import com.nicewuerfel.blockown.command.CE_Own;
import com.nicewuerfel.blockown.command.CE_OwnOther;
import com.nicewuerfel.blockown.command.CE_Owning;
import com.nicewuerfel.blockown.command.CE_Protect;
import com.nicewuerfel.blockown.command.CE_RemFriend;
import com.nicewuerfel.blockown.command.CE_ShowOwner;
import com.nicewuerfel.blockown.command.CE_Unlock;
import com.nicewuerfel.blockown.command.CE_Unown;
import com.nicewuerfel.blockown.command.CE_UnownPlayer;
import com.nicewuerfel.blockown.command.CE_Unprotect;
import com.nicewuerfel.blockown.command.CE_UnprotectPlayer;
import com.nicewuerfel.blockown.database.Database;
import com.nicewuerfel.blockown.database.MySqlDatabase;
import com.nicewuerfel.blockown.database.SqliteDatabase;
import com.nicewuerfel.blockown.event.L_BlockBreak;
import com.nicewuerfel.blockown.event.L_BlockPlace;
import com.nicewuerfel.blockown.event.L_EnvironmentDamage;
import com.nicewuerfel.blockown.event.L_PlayerInteract;
import com.nicewuerfel.blockown.output.DebugOutput;
import com.nicewuerfel.blockown.output.DefaultOutput;
import com.nicewuerfel.blockown.output.Output;
import com.nicewuerfel.blockown.protection.Protection;

import org.bukkit.Bukkit;
import org.bukkit.command.PluginCommand;
import org.bukkit.plugin.java.JavaPlugin;

import java.io.File;
import java.io.IOException;
import java.sql.SQLException;

public class BlockOwn extends JavaPlugin {

  private Setting setting;

  private Database database;
  private Protection protection;

  private File messageFile;
  private File configFile;
  private File importerFolder;

  @Override
  public void onDisable() {
    if (database != null) {
      database.disable();
    }
    if (protection != null) {
      protection.disable();
    }

    super.onDisable();
  }

  @Override
  public void onEnable() {
    super.onEnable();
    configFile = new File(getDataFolder(), "config.yml");
    messageFile = new File(getDataFolder(), "messages.yml");
    importerFolder = new File(getDataFolder(), "Importer");

    if (!createDataStructure()) {
      getOutput().printError("Error creating data structure.");
      Bukkit.getPluginManager().disablePlugin(this);
      return;
    }

    setting = Setting.load(new DebugOutput(), configFile);
    getServer().getScheduler().scheduleSyncDelayedTask(this, new Runnable() {
      @Override
      public void run() {
        setting.loadEnabledWorlds(getServer().getWorlds());
        try {
          setting.save();
        } catch (IOException e) {
          getOutput().printError("Could not save config!");
        }
      }
    }, 1);

    if (!setting.DEBUG_MODE) {
      setting.setOutput(new DefaultOutput());
    }
    getOutput().debugMessage("Debug mode enabled");
    setting.updateDeprecatedSettings();
    User.initialize(this);

    if (!Message.loadMessages(getOutput(), getMessageFile())) {
      getOutput().printError("Error loading messages.");
      Bukkit.getPluginManager().disablePlugin(this);
      return;
    }

    if (!initializeDatabase()) {
      getOutput().printError("Couldn't connect to database.");
      Bukkit.getPluginManager().disablePlugin(this);
      return;
    }

    if (!initializeProtection()) {
      getOutput().printError("Couldn't initialize Protection.");
      Bukkit.getPluginManager().disablePlugin(this);
      return;
    }

    registerListeners();
    registerCommands();

    setting.VERSION = new PluginVersion(getVersion(), getReleaseChannel());

    getProtection().getDecayer(this).start();
  }

  private boolean createDataStructure() {
    File dataFolder = getDataFolder();
    if (!dataFolder.exists()) {
      if (!dataFolder.mkdir()) {
        return false;
      }
    }
    getConfig().options().copyDefaults(true);
    if (!configFile.exists()) {
      saveDefaultConfig();
    }
    if (!importerFolder.exists()) {
      if (!importerFolder.mkdir()) {
        return false;
      }
    }
    return true;
  }

  private boolean initializeDatabase() {
    if (setting.DATABASE.MYSQL.ENABLE) {
      try {
        database = new MySqlDatabase.Builder(getOutput()).database(setting.DATABASE.MYSQL.DATABASE)
            .pluginFolder(getDataFolder()).host(setting.DATABASE.MYSQL.HOST)
            .port(setting.DATABASE.MYSQL.PORT).user(setting.DATABASE.MYSQL.USER)
            .password(setting.DATABASE.MYSQL.PASSWORD).build();
        return true;
      } catch (ClassNotFoundException e) {
        getOutput().printError("MySQL driver class not found", e);
        return false;
      } catch (SQLException e) {
        getOutput().printError("Exception during MySQL initialization", e);
        return false;
      }
    } else {
      try {
        database = new SqliteDatabase(getOutput(), getDataFolder());
        return true;
      } catch (ClassNotFoundException e) {
        getOutput().printError("SQLite driver class not found", e);
        return false;
      } catch (SQLException e) {
        getOutput().printError("Exception during SQLite initialization", e);
        return false;
      }
    }
  }

  private boolean initializeProtection() {
    try {
      protection = new Protection(setting, getDataFolder());
      return true;
    } catch (IOException e) {
      getOutput().printError("Exception while loading protections file", e);
      return false;
    }
  }

  private void registerListeners() {
    getServer().getPluginManager()
        .registerEvents(new L_BlockPlace(setting, getOwningDatabase(), getProtection()), this);
    getServer().getPluginManager().registerEvents(
        new L_EnvironmentDamage(setting, getOwningDatabase(), getProtection()), this);
    getServer().getPluginManager()
        .registerEvents(new L_PlayerInteract(setting, getOwningDatabase(), getProtection()), this);
    getServer().getPluginManager()
        .registerEvents(new L_BlockBreak(setting, getOwningDatabase(), getProtection()), this);
  }

  private void registerCommands() {
    PluginCommand cmd;

    cmd = getCommand(Command.ADDFRIEND.toString());
    cmd.setExecutor(new CE_AddFriend(setting, database, protection));
    cmd.setUsage("/<command> <player>");
    cmd.setPermission(Permission.PROTECTION_ADDFRIEND.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.IGNORE.toString());
    cmd.setExecutor(new CE_Ignore(setting, database, protection));
    cmd.setUsage("/<command> [on | off | <player>]");
    cmd.setPermission(Permission.ADMIN_IGNORE.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.IMPORT.toString());
    cmd.setExecutor(new CE_Import(setting, database, protection, getImporterFolder()));
    cmd.setUsage("/<command> <importer-name>");

    cmd = getCommand(Command.LIST.toString());
    cmd.setExecutor(new CE_List(setting, database, protection));
    cmd.setUsage("/<command> [protected | locked | friends]");
    cmd.setPermission(Permission.PROTECTION_LIST.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.LOCK.toString());
    cmd.setExecutor(new CE_Lock(setting, database, protection));
    cmd.setUsage("/<command> (opt.)[e | b | <material-name>]");
    cmd.setPermission(Permission.PROTECTION_LOCK.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.OWN.toString());
    cmd.setExecutor(new CE_Own(setting, database, protection));
    cmd.setUsage("/<command> (opt.)[e | b | selection]");
    cmd.setPermission(Permission.OWN_OWN.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.OWNOTHER.toString());
    cmd.setExecutor(new CE_OwnOther(setting, database, protection));
    cmd.setUsage("/<command> <player> (opt.)[selection]");
    cmd.setPermission(Permission.OWN_OWNING_OWNOTHER.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.OWNING.toString());
    cmd.setExecutor(new CE_Owning(setting, database, protection));
    cmd.setUsage("/<command> (opt.)[on | off]");
    cmd.setPermission(Permission.OWN_SWITCH_OWNING.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.PROTECT.toString());
    cmd.setExecutor(new CE_Protect(setting, database, protection));
    cmd.setUsage("/<command> (opt.)[e | b | <material-name>]");
    cmd.setPermission(Permission.PROTECTION_PROTECT.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.REMFRIEND.toString());
    cmd.setExecutor(new CE_RemFriend(setting, database, protection));
    cmd.setUsage("/<command> <player>");
    cmd.setPermission(Permission.PROTECTION_REMFRIEND.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.SHOWOWNER.toString());
    cmd.setExecutor(new CE_ShowOwner(setting, database, protection));
    cmd.setUsage("/<command> (opt.)[e | b]");
    cmd.setPermission(Permission.OWN_SHOWOWNER.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.UNLOCK.toString());
    cmd.setExecutor(new CE_Unlock(setting, database, protection));
    cmd.setUsage("/<command> (opt.)[e | b | <material-name>]");
    cmd.setPermission(Permission.PROTECTION_UNLOCK.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.UNOWN.toString());
    cmd.setExecutor(new CE_Unown(setting, database, protection));
    cmd.setUsage("/<command> (opt.)[e | b | selection]");
    cmd.setPermission(Permission.OWN_UNOWN.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.UNOWNPLAYER.toString());
    cmd.setExecutor(new CE_UnownPlayer(setting, database, protection));
    cmd.setUsage("/<command> <player>");
    cmd.setPermission(Permission.ADMIN_UNOWNPLAYER.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.UNPROTECT.toString());
    cmd.setExecutor(new CE_Unprotect(setting, database, protection));
    cmd.setUsage("/<command> (opt.)[e | b | <material-name>]");
    cmd.setPermission(Permission.PROTECTION_UNPROTECT.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));

    cmd = getCommand(Command.UNPROTECTPLAYER.toString());
    cmd.setExecutor(new CE_UnprotectPlayer(setting, database, protection));
    cmd.setUsage("/<command> <player>");
    cmd.setPermission(Permission.ADMIN_UNPROTECTPLAYER.toString());
    cmd.setPermissionMessage(Message.COMMAND_NO_PERMISSION.getMessage(cmd.getPermission()));
  }

  public Database getOwningDatabase() {
    return database;
  }

  public Setting getSettings() {
    return setting;
  }

  public Protection getProtection() {
    return protection;
  }

  public ReleaseChannel getReleaseChannel() {
    return setting.VERSION.getReleaseChannel();
  }

  public Output getOutput() {
    return setting.getOutput();
  }

  public File getMessageFile() {
    return messageFile;
  }

  private File getImporterFolder() {
    return importerFolder;
  }

  public String getVersion() {
    return getDescription().getVersion();
  }

  @Override
  public File getFile() {
    return super.getFile();
  }
}