/**

 *   $Id: KIBoard.java 144 2008-04-25 13:09:35Z mbroeker $

 *  $URL: http://localhost/svn/eclipse/Schachspiel/trunk/org/homelinux/largo/checkers/KIBoard.java $

 */

package org.homelinux.largo.checkers;

import org.homelinux.largo.games.board.Move;

import org.homelinux.largo.games.board.checkersboard.CheckersBoard;

public class KIBoard extends CheckersBoard {

	static final long serialVersionUID = 250408;

	static final int game_const = 500;

	protected boolean SIMU_DEBUG  = false;

	private boolean negate_estimation = false;

	private Move bestMove;

	private int desired_depth;

	public KIBoard(int w, int h) {

		super(w, h);

		desired_depth = -1;

	}

	/**

	 * Set the current DEBUG-Level:

	 * simu: print all valid, simulated moves

	 * undo: print all undos

	 */

	public void setDebug(boolean simu, boolean undo) {

		SIMU_DEBUG = simu;

		UNDO_DEBUG = undo;

	}

	public boolean simu_debug() {

		return SIMU_DEBUG;

	}

	public boolean undo_debug() {

		return UNDO_DEBUG;

	}

	/**

	 * This function flips the sides: Player A maximizes and Player B minimizes

	 */

	public void negateEstimation(boolean b) {

		negate_estimation = b;

	}

	/**

	 * The Minimax-Algorithm works for TWO-PLAYER Games

	 * Player A minimizes, Player B maximizes

	 */

	public int estimateFunction() {

		int i;

		int white = 0;

		int black = 0;

		for(i=0;i<64;i++) {

			if (isWhite(i))

				white+=getValue(i);

			if (isBlack(i))

				black+=getValue(i);

		}

		/**

		 * solves ticket #3

		 */

		if ( negate_estimation )

			return white-black;

		return black-white;

	}

	/**

	 * simulates and returns the next possible move for a Player or null, when no more moves are possible.

	 */

	Move simulate(int t, int o) {

		Move move = null;

		int value;

		if ( validTurn(o) ) {

			while ( t < 64 ) {

				if (!simulateMove(t, o) ) {

					t++;

					continue;

				}

				value = estimateFunction();

				move = new Move(value, t, o);

				/* Flip Sides */

				setBlacksTurn(!isBlacksTurn());

				return move;

			}

		}

		return null;

	}

	/**

	 * AlphaBeta-Algorithm: the Maximizer

	 */

	int max_alpha_beta (int depth, int alpha, int beta) {

		int moveValue;

		int o, t;

		Move move = null;

		if ( desired_depth == -1 )

			desired_depth = depth;

		for (o = 0; o < 64; o++) {

			t=0;

			while ( (move=simulate(t, o)) != null ) {

				/* particular move from black */

				t = move.target;

				if ( depth == 0 || Math.abs(move.value) > game_const )

					moveValue = move.value;

				else /* best next move */

					moveValue = min_alpha_beta(depth-1, alpha, beta);

				undo();

				t++;

				if ( moveValue >= beta )

					return beta;

				if ( moveValue > alpha ) {

					alpha = moveValue;

					if ( depth == desired_depth )

						bestMove = move;

				}

			}

		}

		return alpha;

	}

	/**

	 * AlphaBeta-Algorithm: the Minimizer

	 */

	int min_alpha_beta(int depth, int alpha, int beta) {

		int moveValue;

		int o, t;

		Move move = null;

		for (o = 0; o < 64; o++) {

			t=0;

			while ( (move=simulate(t, o)) != null ) {

				/* particular move from white */

				t = move.target;

				if ( depth == 0 || Math.abs(move.value) > game_const )

					moveValue = move.value;

				else /* best next move */

					moveValue = max_alpha_beta(depth-1, alpha, beta);

				undo();

				t++;

				if ( moveValue <= alpha )

					return alpha;

				if ( moveValue < beta )

					beta = moveValue;

			}

		}

		return beta;

	}

	/**

	 * Evaluates the next, best Move after search_depth half-moves.

	 * When the Machine has Black, set negateEstimation(false);

	 * When the Machine has White, set negateEstimation(true);

	 */

	public boolean doBestMove(int search_depth) {

		int value;

		desired_depth = -1;

		bestMove = null;

		value = max_alpha_beta(search_depth, Integer.MIN_VALUE, Integer.MAX_VALUE);

		if ( bestMove == null ) {

			System.err.println("Computing once more...");

			value = max_alpha_beta(1, Integer.MIN_VALUE, Integer.MAX_VALUE);

			if (bestMove == null) {

				System.out.println("Finito");

				return false;

			}

		}

		if (doMove(bestMove.target, bestMove.origin)) {

			System.out.println("Next Move");

			return true;

		}

		return false;

	}

}