package us.tastybento.bskyblock;

import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;

import us.tastybento.bskyblock.api.configuration.BSBConfig;
import us.tastybento.bskyblock.api.configuration.WorldSettings;
import us.tastybento.bskyblock.api.events.BSBReadyEvent;
import us.tastybento.bskyblock.api.placeholders.PlaceholderHandler;
import us.tastybento.bskyblock.api.user.Notifier;
import us.tastybento.bskyblock.commands.AdminCommand;
import us.tastybento.bskyblock.commands.IslandCommand;
import us.tastybento.bskyblock.database.BSBDbSetup;
import us.tastybento.bskyblock.listeners.BannedVisitorCommands;
import us.tastybento.bskyblock.listeners.BlockEndDragon;
import us.tastybento.bskyblock.listeners.JoinLeaveListener;
import us.tastybento.bskyblock.listeners.NetherPortals;
import us.tastybento.bskyblock.listeners.ObsidianToLava;
import us.tastybento.bskyblock.listeners.PanelListenerManager;
import us.tastybento.bskyblock.listeners.protection.FlyingMobEvents;
import us.tastybento.bskyblock.managers.AddonsManager;
import us.tastybento.bskyblock.managers.CommandsManager;
import us.tastybento.bskyblock.managers.FlagsManager;
import us.tastybento.bskyblock.managers.IslandWorldManager;
import us.tastybento.bskyblock.managers.IslandsManager;
import us.tastybento.bskyblock.managers.LocalesManager;
import us.tastybento.bskyblock.managers.PlayersManager;
import us.tastybento.bskyblock.managers.RanksManager;
import us.tastybento.bskyblock.managers.SchemsManager;
import us.tastybento.bskyblock.util.HeadGetter;

/**
 * Main BSkyBlock class - provides an island minigame in the sky
 * @author tastybento
 * @author Poslovitch
 */
public class BSkyBlock extends JavaPlugin {

    private static BSkyBlock instance;

    // Databases
    private PlayersManager playersManager;
    private IslandsManager islandsManager;

    // Metrics
    private Metrics metrics;

    // Managers
    private CommandsManager commandsManager;
    private LocalesManager localesManager;
    private AddonsManager addonsManager;
    private FlagsManager flagsManager;
    private IslandWorldManager islandWorldManager;
    private RanksManager ranksManager;
    private SchemsManager schemsManager;

    // Settings
    private Settings settings;

    // Notifier
    private Notifier notifier;

    private HeadGetter headGetter;

    private boolean isLoaded;

    @Override
    public void onEnable(){
        // Not loaded
        isLoaded = false;
        // Store the current millis time so we can tell how many ms it took for BSB to fully load.
        final long startMillis = System.currentTimeMillis();

        // Save the default config from config.yml
        saveDefaultConfig();
        setInstance(this);

        // Load Flags
        flagsManager = new FlagsManager(instance);

        // Load settings from config.yml. This will check if there are any issues with it too.
        settings = new BSBConfig<>(this, Settings.class).loadConfigObject("");
        // Start Database managers
        playersManager = new PlayersManager(this);
        // Check if this plugin is now disabled (due to bad database handling)
        if (!this.isEnabled()) {
            return;
        }
        islandsManager = new IslandsManager(this);
        ranksManager = new RanksManager(this);

        // Start head getter
        headGetter = new HeadGetter(this);

        // Load metrics
        metrics = new Metrics(instance);
        registerCustomCharts();

        // Load Notifier
        notifier = new Notifier();

        // Set up command manager
        commandsManager = new CommandsManager();

        // These items have to be loaded when the server has done 1 tick.
        // Note Worlds are not loaded this early, so any Locations or World reference will be null
        // at this point. Therefore, the 1 tick scheduler is required.
        getServer().getScheduler().runTask(this, () -> {
            // Create the world if it does not exist
            islandWorldManager = new IslandWorldManager(instance);
            // Load schems manager
            schemsManager = new SchemsManager(instance);
            // Load the default island schems
            schemsManager.loadIslands(getIWM().getBSBIslandWorld());

            // Set up commands
            new IslandCommand();
            new AdminCommand();

            // Locales manager must be loaded before addons
            localesManager = new LocalesManager(instance);
            PlaceholderHandler.register(instance);

            // Load addons. Addons may load worlds, so they must go before islands are loaded.
            addonsManager = new AddonsManager(instance);
            addonsManager.loadAddons();
            // Enable addons
            addonsManager.enableAddons();

            getServer().getScheduler().runTask(instance, () -> {
                // Register Listeners
                registerListeners();

                // Load islands from database - need to wait until all the worlds are loaded
                islandsManager.load();

                // Save islands & players data asynchronously every X minutes
                instance.getServer().getScheduler().runTaskTimer(instance, () -> {
                    playersManager.save(true);
                    islandsManager.save(true);
                }, getSettings().getDatabaseBackupPeriod() * 20 * 60L, getSettings().getDatabaseBackupPeriod() * 20 * 60L);
                isLoaded = true;
                flagsManager.registerListeners();
                instance.log("#############################################");
                instance.log(instance.getDescription().getFullName() + " has been fully enabled.");
                instance.log("It took: " + (System.currentTimeMillis() - startMillis + "ms"));
                instance.log("Thanks for using our plugin !");
                instance.log("- Tastybento and Poslovitch, 2017-2018");
                instance.log("#############################################");

                // Fire plugin ready event
                Bukkit.getServer().getPluginManager().callEvent(new BSBReadyEvent());
            });
        });
    }

    /**
     * Register listeners
     */
    private void registerListeners() {
        PluginManager manager = getServer().getPluginManager();
        // Player join events
        manager.registerEvents(new JoinLeaveListener(this), this);
        // Panel listener manager
        manager.registerEvents(new PanelListenerManager(), this);
        // Nether portals
        manager.registerEvents(new NetherPortals(this), this);
        // Obsidian to lava helper
        manager.registerEvents(new ObsidianToLava(this), this);
        // Flying mobs protection
        manager.registerEvents(new FlyingMobEvents(this), this);
        // End dragon blocking
        manager.registerEvents(new BlockEndDragon(this), this);
        // Banned visitor commands
        manager.registerEvents(new BannedVisitorCommands(this), this);
    }

    @Override
    public void onDisable() {
        if (addonsManager != null) {
            addonsManager.disableAddons();
        }
        // Save data
        if (playersManager != null) {
            playersManager.shutdown();
        }
        if (islandsManager != null) {
            islandsManager.shutdown();
        }
        // Save settings
        if (settings != null) {
            new BSBConfig<>(this, Settings.class).saveConfigObject(settings);
        }
    }

    private void registerCustomCharts(){
        metrics.addCustomChart(new Metrics.SingleLineChart("islands_count") {

            @Override
            public int getValue() {
                return islandsManager.getCount();
            }
        });

        metrics.addCustomChart(new Metrics.SingleLineChart("created_islands") {

            @Override
            public int getValue() {
                int created = islandsManager.metrics_getCreatedCount();
                islandsManager.metrics_setCreatedCount(0);
                return created;
            }
        });

        metrics.addCustomChart(new Metrics.SimplePie("default_locale") {

            @Override
            public String getValue() {
                return getSettings().getDefaultLanguage();
            }
        });

        metrics.addCustomChart(new Metrics.SimplePie("database") {

            @Override
            public String getValue() {
                return BSBDbSetup.getDatabase().toString();
            }
        });
    }

    /**
     * Returns the player database
     * @return the player database
     */
    public PlayersManager getPlayers(){
        return playersManager;
    }

    /**
     * Returns the island database
     * @return the island database
     */
    public IslandsManager getIslands(){
        return islandsManager;
    }

    private static void setInstance(BSkyBlock plugin) {
        BSkyBlock.instance = plugin;
    }

    public static BSkyBlock getInstance() {
        return instance;
    }

    /**
     * @return the Commands manager
     */
    public CommandsManager getCommandsManager() {
        return commandsManager;
    }

    /**
     * @return the Locales manager
     */
    public LocalesManager getLocalesManager() {
        return localesManager;
    }

    /**
     * @return the Addons manager
     */
    public AddonsManager getAddonsManager() {
        return addonsManager;
    }

    /**
     * @return the Flags manager
     */
    public FlagsManager getFlagsManager() {
        return flagsManager;
    }

    /**
     * @return the ranksManager
     */
    public RanksManager getRanksManager() {
        return ranksManager;
    }

    /**
     * @return the Island World Manager
     */
    public IslandWorldManager getIWM() {
        return islandWorldManager;
    }

    /**
     * @return the settings
     */
    public Settings getSettings() {
        return settings;
    }

    /**
     * @return the notifier
     */
    public Notifier getNotifier() {
        return notifier;
    }

    /**
     * @return the headGetter
     */
    public HeadGetter getHeadGetter() {
        return headGetter;
    }

    public void log(String string) {
        getLogger().info(() -> string);
    }

    public void logDebug(Object object) {
        getLogger().info(() -> "DEBUG: " + object);
    }

    public void logError(String error) {
        getLogger().severe(() -> error);
    }

    public void logWarning(String warning) {
        getLogger().warning(warning);
    }

    /**
     * Registers a world as a world to be covered by this plugin
     * @param world - Bukkit over world
     * @param worldSettings - settings for this world
     */
    public void registerWorld(World world, WorldSettings worldSettings) {
        islandWorldManager.addWorld(world, worldSettings);
    }



    /**
     * @return the schemsManager
     */
    public SchemsManager getSchemsManager() {
        return schemsManager;
    }



    /**
     * True if the plugin is loaded and ready
     * @return the isLoaded
     */
    public boolean isLoaded() {
        return isLoaded;
    }

}