/* 
    This file is a part of the SteamWar software.
    
    Copyright (C) 2020  SteamWar.de-Serverteam

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

package de.steamwar.fightsystem;

import de.steamwar.core.CommandRemover;
import de.steamwar.core.Core;
import de.steamwar.fightsystem.commands.*;
import de.steamwar.fightsystem.countdown.*;
import de.steamwar.fightsystem.fight.Fight;
import de.steamwar.fightsystem.fight.FightPlayer;
import de.steamwar.fightsystem.fight.FightTeam;
import de.steamwar.fightsystem.kit.KitManager;
import de.steamwar.fightsystem.listener.*;
import de.steamwar.fightsystem.record.RecordSystem;
import de.steamwar.fightsystem.record.Recorder;
import de.steamwar.fightsystem.states.FightState;
import de.steamwar.fightsystem.states.StateDependent;
import de.steamwar.fightsystem.utils.EnterHandler;
import de.steamwar.fightsystem.utils.FightScoreboard;
import de.steamwar.fightsystem.utils.FightStatistics;
import de.steamwar.fightsystem.utils.TechHider;
import de.steamwar.fightsystem.winconditions.*;
import de.steamwar.sql.EventFight;
import de.steamwar.sql.Schematic;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.logging.Level;

public class FightSystem extends JavaPlugin {

    public static final String PREFIX = "§eArena§8» ";
    private static FightSystem plugin;

    private static FightState fightState = FightState.PRE_LEADER_SETUP;
    private static Map<StateDependent, Boolean> stateDependentFeatures = new HashMap<>();
    private static int fightTime = 0;
    private static Countdown mainCountdown;

    @Override
    public void onLoad() {
        setPlugin(this);
        IFightSystem.init(this);
    }

    @Override
    public void onEnable() {
        Fight.init();
        KitManager.loadAllKits();
        TechHider.init();
        FightScoreboard.init();
        RecordSystem.init();

        try {
            CommandRemover.removeAll("gamemode");
            CommandInjector.injectCommand(new GamemodeCommand());
        } catch (Exception e) {
            getLogger().log(Level.SEVERE, "Failed to replace commands", e);
            Bukkit.shutdown();
            return;
        }

        new EntityDamageListener();
        new EntityExplodeListener();
        new FoodLevelChangeListener();
        new PistonListener();
        new PlayerChatListener();
        new HotbarGUIListener();
        new PlayerMoveListener();
        new PlayerStateListener();
        new ProjectileLaunchListener();
        new InFightDamageListener();
        new InFightInventoryListener();
        new FreezeWorldStateListener();
        new EventJoinListener();
        new EventRecordListener();
        new CheckListener();
        new TestListener();
        new NormalJoinListener();
        new RankedJoinListener();
        new GameplayListener();
        new PersonalKitCreator();
        new ScoreboardListener();
        if(Core.getVersion() > 8)
            new VersionDependentListener();

        new EnterHandler();

        new WinconditionAllDead();
        new WinconditionCaptainDead();
        new WinconditionPumpkinTechKO();
        new WinconditionWaterTechKO();
        new WinconditionPercentSystem();
        new WinconditionRelativePercent();
        new WinconditionPoints();
        new WinconditionTimeout();
        new WinconditionHeartRatioTimeout();
        new WinconditionTechKO();

        Objects.requireNonNull(getCommand("leave")).setExecutor(new LeaveCommand());
        Objects.requireNonNull(getCommand("kit")).setExecutor(new KitCommand());
        Objects.requireNonNull(getCommand("remove")).setExecutor(new RemoveCommand());
        Objects.requireNonNull(getCommand("accept")).setExecutor(new AcceptCommand());
        Objects.requireNonNull(getCommand("decline")).setExecutor(new DeclineCommand());
        Objects.requireNonNull(getCommand("invite")).setExecutor(new InviteCommand());
        Objects.requireNonNull(getCommand("ready")).setExecutor(new ReadyCommand());
        Objects.requireNonNull(getCommand("ak")).setExecutor(new AkCommand());
        Objects.requireNonNull(getCommand("leader")).setExecutor(new LeaderCommand());
        Objects.requireNonNull(getCommand("lockschem")).setExecutor(new LockschemCommand());

        mainCountdown = new NoPlayersOnlineCountdown();

        if(Config.event() || Config.Ranked) {
            Objects.requireNonNull(getCommand("invite")).setExecutor(new EventDummyCommand());
            Objects.requireNonNull(getCommand("ready")).setExecutor(new EventDummyCommand());
            Objects.requireNonNull(getCommand("ak")).setExecutor(new EventDummyCommand());
            Objects.requireNonNull(getCommand("leader")).setExecutor(new EventDummyCommand());

            setPreSchemState();
        }else if(Config.test()){
            if(Config.check()){
                Bukkit.getScheduler().runTaskLater(this, () -> Fight.getBlueTeam().setSchematic(Schematic.getSchemFromDB(Config.CheckSchemID)), 0);
            }else{
                Bukkit.getScheduler().runTaskLater(this, Fight.getBlueTeam()::pasteDummy, 0);
            }
            Bukkit.getScheduler().runTaskLater(this, Fight.getRedTeam()::pasteDummy, 0);

            setPreSchemState();
            setPostSchemState();
        }
    }

    @Override
    public void onDisable() {

        Recorder.closeAll();
    }

    public static void setPreSchemState() {
        if(fightState != FightState.PRE_LEADER_SETUP)
            throw new SecurityException(fightState.name());
        setFightState(FightState.PRE_SCHEM_SETUP);

        Fight.calcAvailibleSchemTypes();
        mainCountdown = new PreSchemPasteCountdown();
    }

    public static void setPostSchemState() {
        if(fightState != FightState.PRE_SCHEM_SETUP)
            throw new SecurityException(fightState.name());
        setFightState(FightState.POST_SCHEM_SETUP);

        TechHider.start();
        if(!Config.test()){
            Fight.getBlueTeam().pasteSchematic();
            Fight.getRedTeam().pasteSchematic();
        }

        if(Config.test())
            mainCountdown = null;
        else
            mainCountdown = new SetupOverCountdown();
    }

    public static void setPreRunningState() {
        if(fightState != FightState.POST_SCHEM_SETUP)
            throw new SecurityException(fightState.name());
        setFightState(FightState.PRE_RUNNING);

        Fight.getBlueTeam().loadKits();
        Fight.getRedTeam().loadKits();
        setAllPlayersGM(GameMode.SURVIVAL);
        Bukkit.broadcastMessage(PREFIX + "§aDer Kampf beginnt!");

        mainCountdown = new PreRunningCountdown();

        Fight.replaceSync();

        if(Config.event())
            new EventTeamOffWincondition();
    }

    public static void setRunningState() {
        if(fightState != FightState.PRE_RUNNING)
            throw new SecurityException(fightState.name());
        setFightState(FightState.RUNNING);
        setAllPlayersGM(GameMode.SURVIVAL);

        FightStatistics.start();
        Bukkit.broadcastMessage(PREFIX + "§aArena freigegeben!");
    }

    public static void setSpectateState(FightTeam winFightTeam, String windescription) {
        if(fightState == FightState.SPECTATE)
            return;
        setFightState(FightState.SPECTATE);

        setAllPlayersGM(GameMode.SPECTATOR);
        Fight.getBlueTeam().teleportToSpawn();
        Fight.getRedTeam().teleportToSpawn();
        Bukkit.getOnlinePlayers().forEach(player -> player.getInventory().clear());

        Bukkit.broadcastMessage(" ");

        if(winFightTeam != null) {
            Bukkit.broadcastMessage(PREFIX + "§aDas Team " + winFightTeam.getColoredName() + " §ahat gewonnen!");
        } else {
            Bukkit.broadcastMessage(PREFIX + "§aKein Team hat gewonnen!");
        }

        if(Config.event()) {
            if (winFightTeam == null)
                getEventFight().setErgebnis(0);
            else if (winFightTeam.isBlue())
                getEventFight().setErgebnis(1);
            else
                getEventFight().setErgebnis(2);
        }

        if(!Config.test()){
            new SpectateOverCountdown();
            FightStatistics.saveStats(winFightTeam, windescription);
        }
    }

    public static void setFightTime(int fightTime) {
        FightSystem.fightTime = fightTime;
    }

    public static void setEventLeiter(Player el){
        IFightSystem.setEventLeiter(el);
    }

    public static Player getEventLeiter(){
        return IFightSystem.getEventLeiter();
    }

    public static EventFight getEventFight(){
        return IFightSystem.getEventFight();
    }

    private static void setPlugin(FightSystem pl){
        plugin = pl;
    }

    public static FightSystem getPlugin() {
        return plugin;
    }

    public static FightState getFightState() {
        return fightState;
    }

    public static int getFightTime() {
        return fightTime;
    }

    public static void shutdown(String reason){
        IFightSystem.shutdown(reason);
    }

    public static void registerStateDependent(StateDependent stateDependent){
        if(stateDependent.enabled().isEmpty())
            return;
        boolean enabled = stateDependent.enabled().contains(fightState);
        stateDependentFeatures.put(stateDependent, enabled);
        if(enabled)
            stateDependent.enable();
    }

    private static void setAllPlayersGM(GameMode gm) {
        for(FightPlayer fightPlayer: Fight.getBlueTeam().getPlayers()){
            Fight.setPlayerGamemode(fightPlayer.getPlayer(), gm);
        }
        for(FightPlayer fightPlayer: Fight.getRedTeam().getPlayers()){
            Fight.setPlayerGamemode(fightPlayer.getPlayer(), gm);
        }
    }

    private static void setFightState(FightState state){
        fightState = state;
        if(mainCountdown != null){
            mainCountdown.disable();
            mainCountdown = null;
        }
        postStateChange();
    }

    private static void postStateChange(){
        for(Map.Entry<StateDependent, Boolean> feature : stateDependentFeatures.entrySet()){
            //Enable feature if should be enabled and currently disabled
            if(feature.getKey().enabled().contains(fightState)){
                if(!feature.getValue()){
                    feature.getKey().enable();
                    feature.setValue(true);
                }
                feature.getKey().stateChange(fightState);
            }


            //Disable feature if should be disabled and currently enabled
            if(!feature.getKey().enabled().contains(fightState) && feature.getValue()){
                feature.getKey().disable();
                feature.setValue(false);
            }
        }
    }
}