package uulm.teamname.marvelous.gamelibrary.gamelogic;

import uulm.teamname.marvelous.gamelibrary.events.Event;
import uulm.teamname.marvelous.gamelibrary.requests.Request;

import java.util.ArrayDeque;
import java.util.ArrayList;

/** Represents manager for a game state. */
class GameStateManager {
    /** The managed {@link GameState} */
    private final GameState state;

    /** The queue of {@link Event}s to be applied during {@link Request} processing */
    private final ArrayDeque<Event> queue = new ArrayDeque<Event>();

    /**
     * Constructs a new {@link GameStateManager}.
     * @param state A reference to the state to be managed
     */
    public GameStateManager(GameState state) {
        this.state = state;
    }

    /**
     * Checks a list of {@link Request}s for validity and optionally produces resulting {@link Event}s.
     * @param requests The requests to check
     * @param apply True if resulting events should be stored for later application
     */
    public boolean processRequests(Request[] requests, boolean apply) {
        GameState snapshot = state.snapshot();

        for(Request request: requests) {
            if (GameLogic.checkRequest(snapshot, request)) {
                ArrayList<Event> result = GameLogic.executeRequest(snapshot, request);
                if(apply) {
                    queue.addAll(result);
                }
            }else {
                queue.clear();
                return false;
            }
        }

        return true;
    }

    /**
     * Handles events that happen after a turn phase.
     * @return The optionally resulting {@link Event}s
     */
    public ArrayList<Event> checkPostPhase() {
        return GameLogic.checkTurnEnd(state);
    }

    /**
     * Initializes the game.
     * @param selectedCharacters1 The characters selected by player 1
     * @param selectedCharacters2 The characters selected by player 2
     * @return The resulting {@link Event}s
     */
    public ArrayList<Event> initGame(ArrayList<Integer> selectedCharacters1, ArrayList<Integer> selectedCharacters2) {
        return GameLogic.startGame(state, selectedCharacters1, selectedCharacters2);
    }

    /**
     * Starts the game.
     * @return The resulting {@link Event}s
     */
    public ArrayList<Event> startGame() {
        return GameLogic.handleRoundStart(state);
    }

    /**
     * Applies an array of {@link Event}s to the game state.
     * @param events The events to apply
     */
    public void applyEvents(ArrayList<Event> events) {
        for(Event event: events) {
            GameLogic.applyEvent(state, event);
        }
    }

    /**
     * Applies the result of the last processRequests call.
     * @return A list of applied events
     */
    public ArrayList<Event> apply() {
        ArrayList<Event> toReturn = new ArrayList<>(queue.size());
        Event current;
        while ((current = queue.poll()) != null) {
            GameLogic.applyEvent(state, current);
            toReturn.add(current);
        }
        return toReturn;
    }
}