#include "RandomAnalysis.h"

RandomAnalysis::RandomAnalysis()
{
  RandomAnalysis(hex_board(), VERT);
}

RandomAnalysis::RandomAnalysis(hex_board theBoard)
{
  RandomAnalysis(theBoard, VERT);
}

RandomAnalysis::RandomAnalysis(hex_board theBoard, occupantType side)
{
  this->theBoard = theBoard;
  this->side = side;
  SIZE = theBoard.SIZE;
  
  total = theBoard.numberOfEmpties();
  moves = (int) (total + 1)/2;
  
  available = MoveList(total);
  choices = MoveList(moves);
}


    
void RandomAnalysis::setuplists()
{
  int i,j;
  int counter = 0;
  
  Move here;
    
  for(i=0; i<SIZE;i++){
    for(j=0;j<SIZE;j++){
      if (theBoard.board[i][j].contains == EMPTY)
	{	  
	  here = Move(i,j);
	  available.add(counter, here);
	}
    }
  }
}

void RandomAnalysis::fillup()
{
  int i,j;
  
  double randomPercent;
  
  int index;
  Move here;
  MoveList tempAvailable(available);
  
  int tempMoves = moves - 1;
  int tempTotal = total - 1;
  
  while(tempMoves>0)
    {
      randomPercent = rand()/(RAND_MAX+1.0); ;
      
      index = (int) (tempTotal*randomPercent);
            
      here = tempAvailable.move(index);

      theBoard.doIt(here, VERT);
      
      tempAvailable.remove(index);
      
      choices.add(here);
      
      tempTotal--;
      tempMoves--;
    }
}


void RandomAnalysis::refresh()
{
  int i,j;
  
  Move here;

  int tempMoves = choices.getLength();
  
  //Here we unplay all of the random moves from fillup.
  
  for(i=0;i<tempMoves;i++){
    
    here = choices.move(i);
    
    theBoard.doIt(here, EMPTY);    
  }
	
  //  We have to reset the list of choices.
  
  choices = MoveList(moves);
  
  //Also, we have to untest the whole board.
  
  for(i=0;i<SIZE;i++){
    for(j=0;j<SIZE;j++){
      theBoard.board[i][j].untest();
    }
  }
}
    
Move RandomAnalysis::choose_move()
{
  //Searches for the best move based on a 1-ply search with
  //the evaluation given by probability of winning
  //a random outcome.
    
  int i,j;
  int n;
  
  Move result;  
  MoveList orderedAvailable;
  
  int index;
  double eval, best;
  
  Move here;

  if (total<=0) return result;
  
  setuplists();
  
  best = 0;
  
  result = available.move(0);  

  orderedAvailable = MoveList(available);
  
  for (i=0; i < total; i++)
    {
      //Pick a move, play it, and test it.
      
      here = orderedAvailable.move(i);
      
      available.remove(here);
      
      theBoard.doIt(here, VERT);
      
      //Then evaluate the position.
         
      eval = value();
      
      //Test against the best evaluation so far.
      
      if (eval > best)
	{
	  best = eval;
	  result = here;
	}
      
      //Refresh the move tested.
      
      theBoard.doIt(here, EMPTY);
         
      available.add(here);            
      
    }
    
  cout << "Best Move: " << result.hex.y << "-" << result.hex.x <<"\n";
  
  cout << "Best: " << best << "\n";
    
  return result;
}


double RandomAnalysis::value()
{
  double eval=0;
  int i;
  int move_test;
  move_test = MAX_TEST;

  //  if (move_test > (2^(total - 2))) move_test = (int) (2^(total - 2) + 1) 
	
  for(i=0; i < move_test; i++)
    {
      fillup();
      
      //Play random moves.
      //Test for a vertical win.
      //The evaluation is the probability of a win.
      
      
      if (theBoard.isWon(side)) 
	{
	  eval++;	  
	}
      refresh();
    }
  
  eval = eval/move_test;
  return eval;
}