package dev.kske.chess.game.ai;

import java.util.List;
import java.util.concurrent.Callable;

import dev.kske.chess.board.Board;
import dev.kske.chess.board.Move;
import dev.kske.chess.board.Piece.Color;

/**
 * Project: <strong>Chess</strong><br>
 * File: <strong>MoveProcessor.java</strong><br>
 * Created: <strong>08.07.2019</strong><br>
 * Author: <strong>Kai S. K. Engelbart</strong>
 */
public class MoveProcessor implements Callable<ProcessingResult> {

	private final Board			board;
	private final List<Move>	rootMoves;
	private final Color			color;
	private final int			maxDepth;
	private final int			alphaBetaThreshold;

	private Move bestMove;

	public MoveProcessor(Board board, List<Move> rootMoves, Color color, int maxDepth, int alphaBetaThreshold) {
		this.board				= board;
		this.rootMoves			= rootMoves;
		this.color				= color;
		this.maxDepth			= maxDepth;
		this.alphaBetaThreshold	= alphaBetaThreshold;
	}

	@Override
	public ProcessingResult call() throws Exception {
		int score = miniMax(board, rootMoves, color, 0);
		return new ProcessingResult(bestMove, score);
	}

	private int miniMax(Board board, List<Move> moves, Color color, int depth) {
		int bestValue = Integer.MIN_VALUE;
		for (Move move : moves) {
			board.move(move);
			int	teamValue	= board.evaluate(color);
			int	enemyValue	= board.evaluate(color.opposite());
			int	valueChange	= teamValue - enemyValue;

			if (depth < maxDepth && valueChange >= alphaBetaThreshold)
				valueChange -= miniMax(board, board.getMoves(color.opposite()), color.opposite(), depth + 1);

			if (valueChange > bestValue) {
				bestValue = valueChange;
				if (depth == 0) bestMove = move;
			}

			board.revert();
		}
		return bestValue;
	}
}