import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import me.catcoder.core.api.Bukkit;
import me.catcoder.core.api.Bungee;
import me.catcoder.core.api.CoreServer;
import me.catcoder.core.api.Player;
import me.catcoder.core.api.command.ConsoleCommandSender;
import me.catcoder.core.api.event.PlayerLeaveEvent;
import me.catcoder.core.api.event.PlayerLoginEvent;
import me.catcoder.core.api.logger.CoreLogger;
import me.catcoder.core.api.logger.LoggingOutputStream;
import me.catcoder.core.api.plugin.Plugin;
import me.catcoder.core.api.plugin.PluginManager;
import me.catcoder.core.api.scheduler.CoreScheduler;
import me.catcoder.core.api.service.ServiceManager;
import me.catcoder.core.api.service.SimpleServiceManager;
import me.catcoder.core.connection.PlayerImpl;
import me.catcoder.core.network.ConnectionsListener;
import me.catcoder.core.packets.bungee.PlayerConnect;
import me.catcoder.core.util.NetUtils;
import jline.console.ConsoleReader;
import org.fusesource.jansi.AnsiConsole;

import javax.crypto.SecretKey;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Created by CatCoder on 04.01.2017 21:56.
 * Project: Cat
 */
public class Core extends CoreServer {


    private final PluginManager pluginManager;
    private final File pluginsFolder = new File("plugins");
    private final CoreScheduler scheduler = new CoreScheduler();
    private final ConsoleCommandSender sender = new ConsoleCommandSender();
    private final ReadWriteLock connectionLock = new ReentrantReadWriteLock();
    private final ServiceManager serviceManager = new SimpleServiceManager();
    private Logger logger;
    private ConnectionsListener listener;
    private CoreConfiguration configuration;
    private SecretKey secretKey;
    private Map<String, Player> playerMap = Maps.newConcurrentMap();
    private ConsoleReader reader;
    private volatile boolean running;


    public Core() throws IOException {
        setInstance(this);
        this.reader = new ConsoleReader();
        this.reader.setExpandEvents(false);
        AnsiConsole.systemInstall();

        this.logger = new CoreLogger(this);

        System.setOut(new PrintStream(new LoggingOutputStream(this.logger, Level.INFO), true));
        System.setErr(new PrintStream(new LoggingOutputStream(this.logger, Level.SEVERE), true));

        this.logger.info("Initializing Core version " + getVersion() + " by CatCoder");

        this.configuration = new CoreConfiguration("config.yml");

        //this.serviceManager.setProvider(DummyPlugin.INSTANCE, GroupService.class, new SimpleGroupProvider());

        this.secretKey = NetUtils.generateKey();
        this.pluginManager = new PluginManager(this);
        this.listener = new ConnectionsListener(configuration.getPort(), configuration.getAddress(), configuration.getThreads());
        this.pluginsFolder.mkdir();
        this.pluginManager.registerNativeCommands();
        this.pluginManager.detectPlugins(this.getPluginsFolder());
        this.pluginManager.loadPlugins();

    }

    @Override
    public int getOnline() {
        int sum = 0;
        for (Bungee bungee : Bungee.getConnections().values()) {
            sum += bungee.getOnline();
        }
        return sum;
    }

    @Override
    public String getVersion() {
        return "1.2";
    }

    public ConsoleReader getReader() {
        return reader;
    }

    @Override
    public PluginManager getPluginManager() {
        return this.pluginManager;
    }

    @Override
    public Logger getLogger() {
        return logger;
    }

    @Override
    public SecretKey getSecretKey() {
        return secretKey;
    }

    @Override
    public boolean isRunning() {
        return this.running;
    }

    @Override
    public String getName() {
        return "Core";
    }

    @Override
    public void start() throws Exception {
        if (isRunning()) return;

        this.pluginManager.enablePlugins();
        this.getLogger().info(String.format("[PluginManager] Plugins enabled (%s)", this.pluginManager.getPlugins().size()));
        this.running = true;

        this.listener.bind();
        listener.getGroup().execute(() -> {
            String line;
            try {
                while (isRunning() && (line = reader.readLine("> ")) != null) {
                    if (!getPluginManager().dispatchCommand(getConsole(), line)) {
                        getConsole().sendMessage("Command not found.");
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        });}

    @Override
    public CoreConfiguration getConfiguration() {
        return configuration;
    }

    public void addPlayer(PlayerConnect packet, Bungee bungee) {
        connectionLock.writeLock().lock();
        try {
            Player player = new PlayerImpl(288, packet.getName(), packet.getIp(), bungee);
            PlayerLoginEvent event = new PlayerLoginEvent(player);
            getPluginManager().callEvent(event);
            if (event.getResult() == PlayerLoginEvent.Result.DENIED) {
                player.kick(event.getReason() == null ? "Причина не указана." : event.getReason());
                return;
            }
            getLogger().info("Player connect -> " + player.getName());
            playerMap.put(player.getName(), player);
        } finally {
            connectionLock.writeLock().unlock();
        }
    }

    public void removePlayer(String name) {
        connectionLock.writeLock().lock();
        try {
            getPluginManager().callEvent(new PlayerLeaveEvent(playerMap.get(name)));
            playerMap.remove(name);
            getLogger().info("Player disconnect -> " + name);
        } finally {
            connectionLock.writeLock().unlock();
        }
    }

    @Override
    public Player getPlayer(String name) {
        connectionLock.readLock().lock();
        try {
            return playerMap.get(name);
        } finally {
            connectionLock.readLock().unlock();
        }
    }

    @Override
    public Collection<Player> getPlayers() {
        connectionLock.readLock().lock();
        try {
            return playerMap.values();
        } finally {
            connectionLock.readLock().unlock();
        }
    }

    @Override
    public void shutdown(String reason) {
        getLogger().info("Stopping: " + reason);
        new Thread("Shutdown thread") {
            @Override
            public void run() {
                Core.this.running = false;
                getLogger().info("Closing all player connections");

                for (Player player : playerMap.values()) {
                    player.kick(reason);
                }
                playerMap.clear();

                closeListener();

                getLogger().info("Closing IO threads");
                listener.getGroup().shutdownGracefully();

                try {
                    listener.getGroup().awaitTermination(2, TimeUnit.SECONDS);
                } catch (InterruptedException e) {
                }


                getLogger().info("Closing bukkit/bungee connections");

                for (Bungee bungee : Bungee.getConnections().values()) bungee.getChannel().close();
                for (Bukkit bukkit : Bukkit.getConnections().values()) bukkit.getChannel().close();

                getLogger().info("Disabling plugins");

                for (Plugin plugin : Lists.reverse(new ArrayList<>(getPluginManager().getPlugins()))) {
                    try {
                        plugin.onDisable();
                        for (Handler handler : plugin.getLogger().getHandlers()) handler.close();
                    } catch (Throwable ex) {
                        getLogger().log(Level.SEVERE, "Exception while disabling plugin " + plugin.getDescription().getName(),
                                ex);
                    }
                    getScheduler().cancel(plugin);
                    plugin.getExecutorService().shutdownNow();
                }
                getLogger().info("I'm killed. :(");
                for (Handler handler : getLogger().getHandlers()) handler.close();
                System.exit(0);
            }
        }.start();
    }


    private void closeListener() {
        this.listener.getSelf().close().syncUninterruptibly();
        getLogger().log(Level.INFO, "Closed listener {0}", listener.getSelf());
    }

    @Override
    public CoreScheduler getScheduler() {
        return scheduler;
    }

    @Override
    public File getPluginsFolder() {
        return this.pluginsFolder;
    }

    @Override
    public ConsoleCommandSender getConsole() {
        return this.sender;
    }

    @Override
    public ServiceManager getServiceManager() {
        return serviceManager;
    }
}