/*
 * canmove(), isLegalMove() and num_valid_moves() are helper functions to 
 * count the number of valid moves for a given player in a given
 * board configuration
 */
 
bool canmove(char self, char opp, char *str)  {
	if (str[0] != opp) return false;
	for (int ctr = 1; ctr < 8; ctr++) {
		if (str[ctr] == '-') return false;
		if (str[ctr] == self) return true;
	}
	return false;
}

bool isLegalMove(char self, char opp, char grid[8][8], int startx, int starty)   {
	if (grid[startx][starty] != '-') return false;
	char str[10];
	int x, y, dx, dy, ctr;
	for (dy = -1; dy <= 1; dy++)
		for (dx = -1; dx <= 1; dx++)    {
	// keep going if both velocities are zero
			if (!dy && !dx) continue;
			str[0] = '\0';
			for (ctr = 1; ctr < 8; ctr++)   {
				x = startx + ctr*dx;
				y = starty + ctr*dy;
				if (x >= 0 && y >= 0 && x<8 && y<8) str[ctr-1] = grid[x][y];
				else str[ctr-1] = 0;
			}
			if (canmove(self, opp, str)) return true;
		}
	return false;
}

int num_valid_moves(char self, char opp, char grid[8][8])   {
	int count = 0, i, j;
	for(i=0; i<8; i++)
		for(j=0; j<8; j++)
			if(isLegalMove(self, opp, grid, i, j)) count++;
	return count;
}

/*
 * Assuming my_color stores your color and opp_color stores opponent's color
 * '-' indicates an empty square on the board
 * 'b' indicates a black tile and 'w' indicates a white tile on the board
 */
double dynamic_heuristic_evaluation_function(char grid[8][8])  {
	int my_tiles = 0, opp_tiles = 0, i, j, k, my_front_tiles = 0, opp_front_tiles = 0, x, y;
	double p = 0, c = 0, l = 0, m = 0, f = 0, d = 0;

	int X1[] = {-1, -1, 0, 1, 1, 1, 0, -1};
	int Y1[] = {0, 1, 1, 1, 0, -1, -1, -1};
	int V[8][8];

	V[0] = {20, -3, 11, 8, 8, 11, -3, 20};
    	V[1] = {-3, -7, -4, 1, 1, -4, -7, -3};
    	V[2] = {11, -4, 2, 2, 2, 2, -4, 11};
    	V[3] = {8, 1, 2, -3, -3, 2, 1, 8};
    	V[4] = {8, 1, 2, -3, -3, 2, 1, 8};
    	V[5] = {11, -4, 2, 2, 2, 2, -4, 11};
    	V[6] = {-3, -7, -4, 1, 1, -4, -7, -3};
    	V[7] = {20, -3, 11, 8, 8, 11, -3, 20};

// Piece difference, frontier disks and disk squares
	for(i=0; i<8; i++)
		for(j=0; j<8; j++)  {
			if(grid[i][j] == my_color)  {
				d += V[i][j];
				my_tiles++;
			} else if(grid[i][j] == opp_color)  {
				d -= V[i][j];
				opp_tiles++;
			}
			if(grid[i][j] != '-')   {
				for(k=0; k<8; k++)  {
					x = i + X1[k]; y = j + Y1[k];
					if(x >= 0 && x < bound_x && y >= 0 && y < bound_y && grid[x][y] == '-') {
						if(grid[i][j] == my_color)  my_front_tiles++;
						else opp_front_tiles++;
						break;
					}
				}
			}
		}
	if(my_tiles > opp_tiles)
		p = (100.0 * my_tiles)/(my_tiles + opp_tiles);
	else if(my_tiles < opp_tiles)
		p = -(100.0 * opp_tiles)/(my_tiles + opp_tiles);
	else p = 0;

	if(my_front_tiles > opp_front_tiles)
		f = -(100.0 * my_front_tiles)/(my_front_tiles + opp_front_tiles);
	else if(my_front_tiles < opp_front_tiles)
		f = (100.0 * opp_front_tiles)/(my_front_tiles + opp_front_tiles);
	else f = 0;

// Corner occupancy
	my_tiles = opp_tiles = 0;
	if(grid[0][0] == my_color) my_tiles++;
	else if(grid[0][0] == opp_color) opp_tiles++;
	if(grid[0][7] == my_color) my_tiles++;
	else if(grid[0][7] == opp_color) opp_tiles++;
	if(grid[7][0] == my_color) my_tiles++;
	else if(grid[7][0] == opp_color) opp_tiles++;
	if(grid[7][7] == my_color) my_tiles++;
	else if(grid[7][7] == opp_color) opp_tiles++;
	c = 25 * (my_tiles - opp_tiles);

// Corner closeness
	my_tiles = opp_tiles = 0;
	if(grid[0][0] == '-')   {
		if(grid[0][1] == my_color) my_tiles++;
		else if(grid[0][1] == opp_color) opp_tiles++;
		if(grid[1][1] == my_color) my_tiles++;
		else if(grid[1][1] == opp_color) opp_tiles++;
		if(grid[1][0] == my_color) my_tiles++;
		else if(grid[1][0] == opp_color) opp_tiles++;
	}
	if(grid[0][7] == '-')   {
		if(grid[0][6] == my_color) my_tiles++;
		else if(grid[0][6] == opp_color) opp_tiles++;
		if(grid[1][6] == my_color) my_tiles++;
		else if(grid[1][6] == opp_color) opp_tiles++;
		if(grid[1][7] == my_color) my_tiles++;
		else if(grid[1][7] == opp_color) opp_tiles++;
	}
	if(grid[7][0] == '-')   {
		if(grid[7][1] == my_color) my_tiles++;
		else if(grid[7][1] == opp_color) opp_tiles++;
		if(grid[6][1] == my_color) my_tiles++;
		else if(grid[6][1] == opp_color) opp_tiles++;
		if(grid[6][0] == my_color) my_tiles++;
		else if(grid[6][0] == opp_color) opp_tiles++;
	}
	if(grid[7][7] == '-')   {
		if(grid[6][7] == my_color) my_tiles++;
		else if(grid[6][7] == opp_color) opp_tiles++;
		if(grid[6][6] == my_color) my_tiles++;
		else if(grid[6][6] == opp_color) opp_tiles++;
		if(grid[7][6] == my_color) my_tiles++;
		else if(grid[7][6] == opp_color) opp_tiles++;
	}
	l = -12.5 * (my_tiles - opp_tiles);

// Mobility
	my_tiles = num_valid_moves(my_color, opp_color, grid);
	opp_tiles = num_valid_moves(opp_color, my_color, grid);
	if(my_tiles > opp_tiles)
		m = (100.0 * my_tiles)/(my_tiles + opp_tiles);
	else if(my_tiles < opp_tiles)
		m = -(100.0 * opp_tiles)/(my_tiles + opp_tiles);
	else m = 0;

// final weighted score
	double score = (10 * p) + (801.724 * c) + (382.026 * l) + (78.922 * m) + (74.396 * f) + (10 * d);
	return score;
}