package com.alttd.hunger_games.services;

import com.alttd.hunger_games.config.Messages;
import com.alttd.hunger_games.data_objects.PLAYER_STATE;
import com.alttd.hunger_games.data_objects.ROUND_STATE;
import lombok.RequiredArgsConstructor;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;

import java.util.*;

@RequiredArgsConstructor
public class PlayerService implements RoundListener {

    private final RoundService roundService;
    private ROUND_STATE roundState;

    @Override
    public void stateChange(ROUND_STATE roundState) {
        this.roundState = roundState;
        switch (roundState) {
            case PLAYER_REGISTRATION, KILL_PHASE -> {
                //Nothing
            }
            case COUNTDOWN -> {
                setNonRegisteredPlayersToSpectator();
                //TODO: teleport players to spawn location
            }
            case FINALE -> {
                //TODO: teleport players to finale location
            }
            case ENDED -> {
                roundService.clear();
                //TODO: teleport everyone to spawn (or spectator?) location
            }
        }
    }

    private void setNonRegisteredPlayersToSpectator() {
        Set<UUID> playerUUIDs = roundService.getPlayers(PLAYER_STATE.REGISTERED);
        List<Player> playerList = new ArrayList<>(Bukkit.getOnlinePlayers());
        List<Player> unregisteredPlayers = playerList.stream().filter(player -> !playerUUIDs.contains(player.getUniqueId())).toList();
        unregisteredPlayers.forEach(player -> roundService.setPlayerState(player.getUniqueId(), PLAYER_STATE.SPECTATING));
    }

    public Optional<PLAYER_STATE> registerPlayer(Player player) {
        if (roundState == null) {
            return Optional.empty();
        }
        Optional<PLAYER_STATE> optionalPlayerState = determinePlayerState(player.getUniqueId());
        if (optionalPlayerState.isEmpty()) {
            return Optional.empty();
        }
        PLAYER_STATE playerState = optionalPlayerState.get();

        if (playerState == PLAYER_STATE.SPECTATING) {
            //TODO: teleport player to spectator location
        }

        roundService.setPlayerState(player.getUniqueId(), playerState);
        return optionalPlayerState;
    }

    public void handleDisconnect(Player player) {
        UUID uuid = player.getUniqueId();
        roundService.setPlayerState(uuid, PLAYER_STATE.DISCONNECTED);
    }

    public void handleJoin(Player player) {
        UUID uuid = player.getUniqueId();
        Optional<PLAYER_STATE> state = roundService.getPlayerState(uuid);
        if (state.isEmpty()) {
            return;
        }
        if (state.get() != PLAYER_STATE.DISCONNECTED) {
            return;
        }
        roundService.setPlayerState(uuid, PLAYER_STATE.SPECTATING);
        player.sendRichMessage(Messages.RECONNECT.FORFEITED);
    }

    private Optional<PLAYER_STATE> determinePlayerState(UUID playerUuid) {
        if (roundState == null) {
            return Optional.empty();
        }
        Optional<PLAYER_STATE> optionalPlayerState = roundService.getPlayerState(playerUuid);
        if (optionalPlayerState.isPresent()) {
            PLAYER_STATE playerState = optionalPlayerState.get();
            return Optional.of(switch (playerState) {
                case DISCONNECTED, SPECTATING -> PLAYER_STATE.SPECTATING;
                case IN_GAME -> PLAYER_STATE.IN_GAME;
                case REGISTERED -> PLAYER_STATE.REGISTERED;
            });
        }
        return switch (roundState) {
            case PLAYER_REGISTRATION, COUNTDOWN -> Optional.of(PLAYER_STATE.REGISTERED);
            case KILL_PHASE, FINALE, ENDED -> Optional.of(PLAYER_STATE.SPECTATING);
        };
    }
}