package de.fanta.lobby;

import de.cubeside.connection.GlobalServer;
import de.cubeside.connection.event.GlobalServerConnectedEvent;
import de.cubeside.connection.event.GlobalServerDisconnectedEvent;
import de.fanta.challenge.Challenge;
import de.fanta.lobby.ChallengesGlobalDataHelper.ChallengeMessageType;
import de.iani.cubesideutils.bukkit.plugin.api.GlobalDataHelperBukkit;
import de.speedy64.globalport.GlobalApi;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;

import java.io.DataInputStream;
import java.io.IOException;
import java.util.UUID;

public class ChallengesGlobalDataHelper extends GlobalDataHelperBukkit<ChallengeMessageType> implements Listener {

    public static final String CHANNEL = "ChallengesJoinEntities";

    private final Lobby plugin;

    public ChallengesGlobalDataHelper(Lobby plugin) {
        super(ChallengeMessageType.class, CHANNEL, plugin);
        this.plugin = plugin;
    }

    @Override
    protected void handleMessage(ChallengeMessageType challengeMessageType, GlobalServer globalServer, DataInputStream data) throws IOException {
        String serverName = data.readUTF();
        switch (challengeMessageType) {
            case TIMER -> {
                boolean running = data.readBoolean();
                plugin.updateTimerStatus(serverName, running);
            }
            case EVENT -> {
                boolean event = data.readBoolean();
                plugin.updateEventStatus(serverName, event);
            }
            case SERVER_STATUS -> {
                boolean online = data.readBoolean();
                plugin.updateServerStatus(serverName, online);
            }
            case PLAYER_COUNT -> {
                int count = data.readInt();
                int maxPlayers = data.readInt();
                plugin.updatePlayerCount(serverName, count, maxPlayers);
            }
            case INITIAL_DATA_REQUEST -> {
                if (Bukkit.getPluginManager().getPlugin("Challenge") != null) { //TODO MOVE TIMER TO CORE
                    Challenge challenges = (Challenge) Bukkit.getPluginManager().getPlugin("Challenge");
                    boolean timerRunning = challenges.getTimer().isRunning();
                    int playerCount = Bukkit.getOnlinePlayers().size();
                    int maxPlayers = Bukkit.getMaxPlayers();

                    sendInitialData(serverName, timerRunning, playerCount, maxPlayers);
                }
            }
            case INITIAL_DATA -> {
                boolean timerRunning = data.readBoolean();
                int playerCount = data.readInt();
                int maxPlayers = data.readInt();
                plugin.updateTimerStatus(serverName, timerRunning);
                plugin.updatePlayerCount(serverName, playerCount, maxPlayers);
            }
            default -> throw new UnsupportedOperationException();
        }
    }

    public void sendTimerUpdate(boolean running) {
        sendData(ChallengeMessageType.TIMER, getThisServerName(), running);
    }

    public void sendEventUpdate(boolean event) {
        sendData(ChallengeMessageType.EVENT, getThisServerName(), event);
    }

    public void sendServerStatusUpdate(boolean online) {
        sendData(ChallengeMessageType.SERVER_STATUS, getThisServerName(), online);
    }

    public void sendPlayerCountUpdate(int count) {
        sendData(ChallengeMessageType.PLAYER_COUNT, getThisServerName(), count, Bukkit.getMaxPlayers());
    }

    public void requestInitialData(String fromServer) {
        sendData(getServer(fromServer), ChallengeMessageType.INITIAL_DATA_REQUEST, getThisServerName());
    }

    public void sendInitialData(String toServer, boolean timerRunning, int playerCount, int maxPlayers) {
        sendData(getServer(toServer), ChallengeMessageType.INITIAL_DATA, getThisServerName(), timerRunning, playerCount, maxPlayers);
    }

    @EventHandler
    public void onGlobalServerConnected(GlobalServerConnectedEvent event) {
        plugin.getServer().getScheduler().runTaskLater(plugin, () -> {
            if (plugin.getEntityData(event.getServer().getName()) != null) {
                plugin.updateServerStatus(event.getServer().getName(), true);
                this.requestInitialData(event.getServer().getName());
            }

            for (Server server : plugin.getPluginConfig().getChallengeServers()) {
                if (server.getName().equals(event.getServer().getName())) {
                    UUID uuid = Server.serverPlayers.get(server);
                    if (uuid != null) {
                        Player p = Bukkit.getPlayer(uuid);
                        if (p != null) {
                            server.spawnPiglin(p);
                            GlobalApi.portOnlinePlayerToLocation(p.getName(), server.getGPLocation());
                        }
                    }
                    break;
                }
            }

            for (Server server : plugin.getPluginConfig().getAdventureServers()) {
                if (server.getName().equals(event.getServer().getName())) {
                    UUID uuid = Server.serverPlayers.get(server);
                    Player p = Bukkit.getPlayer(uuid);
                    if (p != null) {
                        server.spawnPiglin(p);
                        GlobalApi.portOnlinePlayerToLocation(p.getName(), server.getGPLocation());
                    }
                    break;
                }
            }
        }, 200L);
    }

    @EventHandler
    public void onGlobalServerDisconnected(GlobalServerDisconnectedEvent event) {
        if (plugin.getEntityData(event.getServer().getName()) != null) {
            plugin.updateServerStatus(event.getServer().getName(), false);
        }

        for (Server server : plugin.getPluginConfig().getChallengeServers()) {
            if (server.getName().equals(event.getServer().getName())) {
                server.setOnline(false);
                Server.serverPlayers.remove(server);
                server.despawnPiglin();
                break;
            }
        }

        for (Server server : plugin.getPluginConfig().getAdventureServers()) {
            if (server.getName().equals(event.getServer().getName())) {
                server.setOnline(false);
                Server.serverPlayers.remove(server);
                //server.despawnNPC();
                server.despawnPiglin();
                break;
            }
        }

        plugin.getAvailableServers().remove(event.getServer().getName());
    }

    public enum ChallengeMessageType {
        TIMER, SERVER_STATUS, PLAYER_COUNT, INITIAL_DATA_REQUEST, INITIAL_DATA, EVENT
    }
}