package me.pepe.skywars.game;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import me.pepe.api.MinigameManager;
import me.pepe.skywars.SkyWars;
import me.pepe.skywars.game.lobby.Lobby;
import me.pepe.skywars.game.serializer.ILocationSerializer;
import me.pepe.skywars.game.serializer.SLocationSerializer;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.World;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scheduler.BukkitTask;
import me.pepe.skywars.game.serializer.GameDataSerializer;
import me.pepe.skywars.game.worlds.GameWorld;
import me.pepe.skywars.scoreboard.ScoreboardTemplates;
import me.pepe.skywars.utils.ILocation;
import me.pepe.skywars.utils.SLocation;

import java.io.*;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.logging.Level;

public class GameManager implements MinigameManager<Game, Lobby> {

    private final Gson gson;
    private final SkyWars plugin;
    private final Map<Integer, Game> games = new HashMap<>();
    private Lobby lobby;
    private BukkitTask task;

    public GameManager(SkyWars plugin) {
        this.plugin = plugin;
        this.gson = new GsonBuilder().setPrettyPrinting()
                .registerTypeAdapter(ILocation.class, new ILocationSerializer())
                .registerTypeAdapter(SLocation.class, new SLocationSerializer())
                .registerTypeAdapter(GameData.class, new GameDataSerializer(plugin)).create();
    }

    @Override
    public void register(Game game) {
        games.put(game.getId(), game);
    }

    @Override
    public Game getGame(int id) {
        return games.get(id);
    }

    @Override
    @Deprecated
    public Game getGame(String name) {
        for(Game game : games.values()) {
            if(game.getName().equals(name)) {
                return game;
            }
        }

        return null;
    }

    @Override
    public Game getGame(World world) {
        for(Game game : games.values()) {
            if(game.getWorld() == null) {
                continue;
            }

            if(game.getWorld().getUID().equals(world.getUID())) {
                return game;
            }
        }

        return null;
    }

    public List<Game> getGame(GameWorld gameWorld) {
        List<Game> gameWorlds = new ArrayList<>();

        for(Game game : games.values()) {
            if(game.getGameWorld().equals(gameWorld)) {
                gameWorlds.add(game);
            }
        }

        return gameWorlds;
    }

    @Override
    public Game getGame(UUID uuid) {
        GamePlayer gamePlayer = getGamePlayer(uuid);
        return (gamePlayer == null ? null : gamePlayer.getGame());
    }

    @Override
    public GamePlayer getGamePlayer(UUID uuid) {
        for(Game game : games.values()) {
            GamePlayer gamePlayer = game.getPlayer(uuid);

            if(gamePlayer == null) {
                continue;
            }

            return gamePlayer;
        }

        return null;
    }

    public Collection<Game> getGames() {
        return games.values();
    }

    public List<Game> getGames(GameState... states) {
        List<Game> games = new ArrayList<>();

        for(Game game : getGames()) {
            if(game.getState().is(states)) {
                games.add(game);
            }
        }

        return games;
    }

    @Override
    public void removeGame(int id) {
        games.remove(id);
    }

    @Override
    public int randomID() {
        int random = ThreadLocalRandom.current().nextInt(10000);

        if(games.containsKey(random)) {
            return randomID();
        }

        return random;
    }

    @Override
    public Lobby getLobby() {
        return lobby;
    }

    @Override
    public void setLobby(Lobby lobby) {
        stop();
        this.lobby = lobby;

        if(lobby == null) {
            return;
        }

        task = lobbyRunnable();
    }

    @Override
    public File getFile() {
        return new File(plugin.getDataFolder(), "Games");
    }

    @Override
    public void unloadGames() {
        try {
            File folder = getFile();
            folder.mkdirs();

            for(Game game : games.values()) {
                try(FileWriter writer = new FileWriter(game.getFile())) {
                    writer.write(gson.toJson(game.getGameData()));
                }

                if(game.getState() == GameState.UNLOADED) {
                    continue;
                }

                game.unload();
            }

            games.clear();

            saveLobby();
            stop();
        } catch (IOException e) {
            plugin.getLogger().log(Level.SEVERE, "Couldn't save Games data", e);
        }
    }

    @Override
    public void loadGames() {
        try {
            games.clear();

            loadLobby();

            if(lobby == null) {
                plugin.getLogger().log(Level.SEVERE, "Can't load Games if there isn't a Lobby");
            } else {
                File folder = getFile();

                if (!folder.exists()) {
                    return;
                }

                File[] files = folder.listFiles();
                if(files == null) {
                    return;
                }

                for(File file : files) {
                    try(BufferedReader reader = new BufferedReader(new FileReader(file))) {
                        GameData gameData = gson.fromJson(reader, GameData.class);
                        if (gameData.getGameWorld() == null) {
                            plugin.getLogger().severe("The GameWorld from the Game (" + gameData.getName() + ") is null");
                            continue;
                        }

                        if(gameData.getDefaultChest() == null) {
                            plugin.getLogger().severe("The default ChestLoot from the Game (" + gameData.getName() + ") is null");
                            continue;
                        }

                        Game game = new Game(plugin, gameData);
                        if (game.load()) {
                            register(game);
                        }
                    }
                }
            }
        } catch (IOException e) {
            plugin.getLogger().log(Level.SEVERE, "Couldn't load Games data", e);
        }
    }

    private File getLobbyFile() {
        return new File(plugin.getDataFolder(), "lobby.json");
    }

    private void saveLobby() {
        try {
            File file = getLobbyFile();

            if (lobby == null) {
                return;
            }

            if(!file.exists()) {
                file.createNewFile();
            }

            try(FileWriter writer = new FileWriter(file)) {
                writer.write(gson.toJson(lobby.getLocation()));
            }
        } catch (IOException e) {
            plugin.getLogger().log(Level.SEVERE, "Couldn't save Games data", e);
        }
    }

    private void loadLobby() {
        try {
            lobby = null;
            File file = getLobbyFile();

            if(file.exists()) {
                try(BufferedReader reader = new BufferedReader(new FileReader(file))) {
                    SLocation location = gson.fromJson(reader, SLocation.class);

                    setLobby(new Lobby(location));
                }
            }
        } catch (IOException e) {
            plugin.getLogger().log(Level.SEVERE, "Couldn't load lobby", e);
        }
    }

    private BukkitTask lobbyRunnable() {
        stop();
        return new BukkitRunnable() {
            @Override
            public void run() {
                try {
                    if (lobby == null) {
                        stop();
                    } else {
                        for (Player player : lobby.getPlayers()) {
                            PlayerData playerData = plugin.getDataManager().load(player.getUniqueId(), player.getName());
                            ScoreboardTemplates.LOBBY.get().toBoard(playerData).send(player);
                        }
                    }
                } catch (Exception e) {
                    plugin.getLogger().log(Level.SEVERE, "An error occurred while updating scoreboard", e);
                    stop();
                }
            }
        }.runTaskTimer(plugin, 0, 20);
    }

    public void stop() {
        if(task != null) {
            task.cancel();
            task = null;
        }
    }

    public boolean isActive() {
        return task != null;
    }

    }