package chess.controller.event;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Consumer;

import chess.controller.commands.PromoteCommand.PromoteType;
import chess.model.Color;
import chess.model.Coordinate;
import chess.model.Move;

public class GameDispatcher implements GameListener {

	private final List<GameListener> listeners;
	private final ExecutorService executor;

	public GameDispatcher() {
		this.listeners = new ArrayList<>();
		this.executor = Executors.newSingleThreadExecutor();
	}

	public void addListener(GameListener listener) {
		this.listeners.add(listener);
	}

	private void asyncForEachCall(Consumer<GameListener> func) {
		this.executor.execute(() -> this.listeners.forEach(func));
	}

	@Override
	public void onPlayerTurn(Color color, boolean undone) {
		asyncForEachCall((l) -> l.onPlayerTurn(color, undone));
	}

	@Override
	public void onWin(Color color) {
		asyncForEachCall((l) -> l.onWin(color));
	}

	@Override
	public void onKingInCheck() {
		asyncForEachCall((l) -> l.onKingInCheck());
	}

	@Override
	public void onKingInMat() {
		asyncForEachCall((l) -> l.onKingInMat());
	}

	@Override
	public void onPatSituation() {
		asyncForEachCall((l) -> l.onPatSituation());
	}

	@Override
	public void onSurrender(Color color) {
		asyncForEachCall((l) -> l.onSurrender(color));
	}

	@Override
	public void onGameStart() {
		asyncForEachCall((l) -> l.onGameStart());
	}

	@Override
	public void onPromotePawn(Coordinate pieceCoords) {
		asyncForEachCall((l) -> l.onPromotePawn(pieceCoords));
	}

	@Override
	public void onBoardUpdate() {
		asyncForEachCall((l) -> l.onBoardUpdate());
	}

	@Override
	public void onGameEnd() {
		asyncForEachCall((l) -> l.onGameEnd());
	}

	@Override
	public void onMove(Move move) {
		asyncForEachCall((l) -> l.onMove(move));
	}

	@Override
	public void onMoveNotAllowed(Move move) {
		asyncForEachCall((l) -> l.onMoveNotAllowed(move));
	}

	@Override
	public void onDraw() {
		asyncForEachCall((l) -> l.onDraw());
	}

	@Override
	public void onCastling(boolean bigCastling) {
		asyncForEachCall((l) -> l.onCastling(bigCastling));		
	}

	@Override
	public void onPawnPromoted(PromoteType promotion, Color player) {
		asyncForEachCall((l) -> l.onPawnPromoted(promotion, player));
	}

	public void stopService() {
		this.executor.shutdown();
	}

}