import entity.Amazon;

import entity.GameBoard;

import entity.Move;

import evaluation.FunctionEvaluation;

import evaluation.WebEvaluation;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

import java.util.Random;

/**

* Created by amareelez on 23.12.16.

*/

@SuppressWarnings("JavaDoc") class AI {

private GameBoard board = null;

public AI(GameBoard b) {

this.board = b;

}

public Move.MoveAndBoard getNextMove(GameBoard b) {

this.board = b;

//TestClass2.AI.Edge nextMove = GreedyBestSearch(2);

return minimaxSearch(1000, 4, 3);

}

// currently not using

private Move.MoveAndBoard GreedyBestSearch(int advance) {

//we need to check to see if any of our amazons are almost blocked in (having a freedom of 1 or 2). If so then we need to move them immediately and not worry about anything else

Amazon current = checkForDireAmazon();

ArrayList<Move.MoveAndBoard> searchResults = new ArrayList<>();

// if we found an amazon that needs to be moved, only look at its possible moves.

if (current != null) {

//get only moves from the amazon

searchResults.addAll(board.getPossibleMoves(current.id));

if (searchResults.size() == 0) {

for (int i = 0; i < 4; i++) {

searchResults.addAll(board.getPossibleMoves(i));

}

}

} else {

searchResults = new ArrayList<>();

for (int i = 0; i < 4; i++) {

searchResults.addAll(board.getPossibleMoves(i));

}

}

Move.MoveAndBoard newState;

if (advance == 0)

newState = defaultHeuristic(searchResults);

else if (advance == 1)

newState = advancedHeuristic(searchResults);

else

newState = superHeuristic(searchResults);

return newState;

}

/**

* @param timer - Amount of seconds to restrict the search to.

* @param depth - The maximum depth to expand within the amount of time.

* @return Recommended next move.

*/

private Move.MoveAndBoard minimaxSearch(int timer, int depth, int advance) {

SearchNode initialNode = new SearchNode(new Move.MoveAndBoard(board, null));

long endtime = System.currentTimeMillis() + timer;

return minimax(initialNode, true, endtime, depth, advance).state;

}

private SearchNode minimax(SearchNode node, boolean max, long endtime, int depth, int advance) {

if ((System.currentTimeMillis() - TestClass2.time > 500) || (depth <= 0))

return new SearchNode(node.state,

new WebEvaluation(node.state.getNewBoard()).Evaluate());

double alpha;

ArrayList<SearchNode> children;

if (advance == 1) {

children = getAdvancedChildren(node, max);

alpha = max ? Double.MIN_VALUE : Double.MAX_VALUE;

} else if (advance == 0) {

children = getChildren(node, max);

alpha = max ? Integer.MIN_VALUE : Integer.MAX_VALUE;

} else {

children = getSuperChildren(node, max);

alpha = max ? Double.MIN_VALUE : Double.MAX_VALUE;

}

SearchNode nextBestNode = null;

for (SearchNode aChildren : children) {

if (System.currentTimeMillis() - TestClass2.time > 500)

break;

nextBestNode = minimax(aChildren, !max, endtime, depth - 1, advance);

alpha = max ?

Math.max(alpha, nextBestNode.heuristic) :

Math.min(alpha, nextBestNode.heuristic);

nextBestNode.heuristic = alpha;

}

return nextBestNode;

}

private ArrayList<SearchNode> getSuperChildren(SearchNode node, boolean ourTurn) {

ArrayList<SearchNode> children = new ArrayList<>();

for (int i = 0; i < 4; i++) {

int j = ourTurn ? i : i + 4;

ArrayList<Move.MoveAndBoard> amazonMoves = node.state.getNewBoard().getPossibleMoves(j);

for (Move.MoveAndBoard amazonMove : amazonMoves) {

children.add(new SearchNode(amazonMove,

new WebEvaluation(amazonMove.getNewBoard()).Evaluate()));

}

}

return children;

}

private ArrayList<SearchNode> getChildren(SearchNode node, boolean ourTurn) {

ArrayList<SearchNode> children = new ArrayList<>();

for (int i = 0; i < 4; i++) {

int j = ourTurn ? i : i + 4;

ArrayList<Move.MoveAndBoard> amazonMoves = node.state.getNewBoard().getPossibleMoves(j);

for (Move.MoveAndBoard amazonMove : amazonMoves) {

children

.add(new SearchNode(amazonMove, evaluateHeuristic(amazonMove.getNewBoard())));

}

}

return children;

}

private ArrayList<SearchNode> getAdvancedChildren(SearchNode node, boolean ourTurn) {

ArrayList<SearchNode> children = new ArrayList<>();

for (int i = 0; i < 4; i++) {

int j = ourTurn ? i : i + 4;

ArrayList<Move.MoveAndBoard> amazonMoves = node.state.getNewBoard().getPossibleMoves(j);

for (Move.MoveAndBoard amazonMove : amazonMoves) {

children.add(new SearchNode(amazonMove,

new FunctionEvaluation(amazonMove.getNewBoard()).Evaluate()));

}

}

return children;

}

private Amazon checkForDireAmazon() {

Amazon dire = null;

for (int j = 0; j < 4; j++) {

if (board.getOurFreedom(board.Amazons[j]) <= 2) {

dire = board.Amazons[j];

}

}

return dire;

}

private Move.MoveAndBoard defaultHeuristic(ArrayList<Move.MoveAndBoard> moves) {

ArrayList<Integer> evaluations = new ArrayList<>(moves.size());

for (int i = 0; i < moves.size(); i++) {

evaluations.add(i, evaluateHeuristic(moves.get(i).getNewBoard()));

}

Integer max = Collections.max(evaluations);

return moves.get(evaluations.indexOf(max));

}

private Move.MoveAndBoard advancedHeuristic(ArrayList<Move.MoveAndBoard> moves) {

ArrayList<Double> evaluations = new ArrayList<>(moves.size());

for (int i = 0; i < moves.size(); i++) {

evaluations.add(i, new FunctionEvaluation(moves.get(i).getNewBoard()).Evaluate());

}

Double max = Collections.max(evaluations);

return moves.get(evaluations.indexOf(max));

}

private Move.MoveAndBoard superHeuristic(ArrayList<Move.MoveAndBoard> moves) {

ArrayList<Double> evaluations = new ArrayList<>(moves.size());

for (int i = 0; i < moves.size(); i++) {

evaluations.add(i, new WebEvaluation(moves.get(i).getNewBoard()).Evaluate());

}

Double max = Collections.max(evaluations);

return moves.get(evaluations.indexOf(max));

}

private Move.MoveAndBoard randomHeuristic(ArrayList<Move.MoveAndBoard> moves) {

ArrayList<Integer> evaluations = new ArrayList<>(moves.size());

for (int i = 0; i < moves.size(); i++) {

evaluations.add(i, evaluateRandomHeuristic(moves.get(i).getNewBoard()));

}

Integer max = Collections.max(evaluations);

return moves.get(evaluations.indexOf(max));

}

private int evaluateRandomHeuristic(GameBoard board) {

Random rand = new Random();

return rand.nextInt(10000);

}

private int evaluateHeuristic(GameBoard board) {

int sum = getSpaceConfiguration(board);

sum += getOurFreedom(board);

return sum;

}

/**

* Returns the score of the board as determined by freedom. For a single amazon their freedom is (8 - the number of arrows/queens beside them). This calculates the freedom of each of our amazons.

*

* @param board

* @return Returns the overall freedom of our amazons. The bigger the better.

*/

private int getOurFreedom(GameBoard board) {

return board.getOurFreedoms();

}

/**

* This will return how many of the spaces are ours minus the number of spaces that are theirs.

*

* @param board

* @return Number of spaces that are ours - spaces theirs. Larger the better

*/

private int getSpaceConfiguration(GameBoard board) {

//Set containing all the board squares movable to by our TestClass2.AI.AmazonUnit players.

HashSet<Integer> A;

A = board.ourSpaces();

//Set containing all the board squares movable to by the opponents players.

HashSet<Integer> B;

B = board.theirSpaces();

HashSet<Integer> C = new HashSet<>(A);

A.removeAll(B);

B.removeAll(C);

return A.size() - B.size();

}

public static class SearchNode {

final Move.MoveAndBoard state;

double heuristic;

public SearchNode(Move.MoveAndBoard state) {

this.state = state;

this.heuristic = 0;

}

public SearchNode(Move.MoveAndBoard state, double heuristic) {

this.state = state;

this.heuristic = heuristic;

}

public Move.MoveAndBoard getState() {

return this.state;

}

public double heuristic() {

return heuristic;

}

}

}