//======================================================================================================
int search_diag_right_upMin(int column,int row, int myValue,int opponentValue)
{
	int count,count2,temp1,a;
	int minValue;
	a =0;
	
	if (minimaxBoard[column+1][row-1]==0)
		return minValue;
	
	if (minimaxBoard[column+1][row-1]==myValue)
		return minValue;
	
	for (count=column+1;count<8;count++)
	{
		a++;
		if(row-a>=0){
			if (minimaxBoard[count][row-a]==opponentValue)
				temp1 = count;
			else
			{
				if(minimaxBoard[count][row-a] == myValue){
					a=1;
					for (count2=column+1;count2<=temp1;count2++)
					{
						//counting minimum value 
						minValue++;
						a++;
						if (row-a<0)
							break;
					}
					return minValue;
				}
				else
					return minValue;
			}
		}
	}
	return minValue;
}

int search_diag_right_downMin(int column,int row, int myValue,int opponentValue)
{
	int count,count2,temp1,a;
	int minValue = 0;
	a =0;
	
	if(minimaxBoard[column+1][row+1]==0)
		return minValue;
	
	if (minimaxBoard[column+1][row+1]==myValue)
		return minValue;
	
	for (count=column+1;count<8;count++)
	{
		a++;
		if(row+a<8){
			if (minimaxBoard[count][row+a]==opponentValue)
				temp1 = count;
			else
			{
				if(minimaxBoard[count][row+a] == myValue){
					a=1;
					for (count2=column+1;count2<=temp1;count2++)
					{
						//counting minimum value 
						minValue++;
						a++;
						if (row+a>=8)
							break;
					}
					return minValue;
				}
				else
					return minValue;
			}
		}
	}
	return minValue;
}

int search_diag_left_downMin(int column,int row,int myValue,int opponentValue)
{
	int count,count2,temp1,a;
	a =0;
	int minValue = 0;
	
	if(minimaxBoard[column-1][row+1] == 0)
		return minValue;

	if(minimaxBoard[column-1][row+1] == myValue)
		return minValue;
	
	for (count=row+1;count<8;count++)
	{
		a++;
		if(column-a>=0){
			if (minimaxBoard[column-a][count]==opponentValue)
				temp1 = count;
			else
			{
				if(minimaxBoard[column-a][count] == myValue){
					a=1;
					for (count2=row+1;count2<=temp1;count2++)
					{
						//counting minimum value
						minValue++;
						a++;
						if (column-a<0)
							break;
					}
					return minValue;
				}
				else
					return minValue;
			}
		}
	}
	return minValue;
}

int search_diag_left_upMin(int column,int row,int myValue,int opponentValue)
{
	int count,count2,temp1,a;
	int minValue = 0;
	a =0;

	
	if(minimaxBoard[column-1][row-1]==0)
		return minValue;
	
	if(minimaxBoard[column-1][row-1]==myValue)
		return minValue;
	
	for (count=row-1;count>=0;count--)
	{
		a++;
		if(column-a>=0){
			if (minimaxBoard[column-a][count]==opponentValue)
				temp1 = count;
			else
			{
				if(minimaxBoard[column-a][count] == myValue){
					a=1;
					for (count2=row-1;count2>=temp1;count2--)
					{
						//counting minimum value
						minValue++;
						a++;
						if (column-a<0)
							break;
					}
					return minValue;
				}
				else
					return minValue;
			}
		}
	}
	return minValue;
}

int search_leftMin(int column,int row, int myValue,int opponentValue)
{
	int count,count2;
	int temp1=column-1;
	int minValue = 0;
	
	if (minimaxBoard[column-1][row]==0)
		return minValue;
	
	if(minimaxBoard[column-1][row]==myValue)
		return minValue;

	for (count=column-1;count>=0;count--)
	{
		if (minimaxBoard[count][row]==opponentValue)
			temp1 = count;
		else
		{
			if(minimaxBoard[count][row] == myValue){
				for (count2=column-1;count2>=temp1;count2--)
				{
					minValue++;
				}
				return minValue;
			}
			else
				return minValue;
				
		}
	}
	return minValue;
}

int search_rightMin(int column,int row, int myValue,int opponentValue)
{
	int count,count2;
	int temp1=column+1;
	int minValue = 0 ;

	if (minimaxBoard[column+1][row] == 0)
		return minValue;
	
	if(minimaxBoard[column+1][row]==myValue)
		return minValue;
	
	for (count=column+1;count<8;count++)
	{
		if (minimaxBoard[count][row]==opponentValue)
			temp1 = count;
		else
		{
			if(minimaxBoard[count][row] == myValue){
				for (count2=column+1;count2<=temp1;count2++)
				{
					//counting minimum value
					minValue++;
				}
				return minValue;
			}
			else
				return minValue;
		}
	}
	return minValue;
}

int search_downMin(int column,int row,int myValue,int opponentValue)
{
	int count,count2;
	int temp1=row-1;
	int minValue = 0;

	if(minimaxBoard[column][row-1]==0)
		return minValue;
	if (minimaxBoard[column][row-1]==myValue)
		return minValue;
	
	for (count=row-1;count>=0;count--)
	{
		if (minimaxBoard[column][count]==opponentValue)
			temp1 = count;
		else
		{
			if(minimaxBoard[column][count] == myValue){
				for (count2=row-1;count2>=temp1;count2--)
				{
					//counting minimum value
					minValue++;
				}
				return minValue;
			}
			else
				return minValue;
		}
	}
	return minValue;
}

int search_upMin(int column,int row, int myValue,int opponentValue)
{
	int count,count2;
	int temp1=row+1;
	int minValue = 0;
	
	if(minimaxBoard[column][row+1]==0)
		return minValue;
	
	if (minimaxBoard[column][row+1]==myValue)
		return minValue;
	
	for (count=row+1;count<8;count++)
	{
		if (minimaxBoard[column][count]==opponentValue)
			temp1 = count;
		else
		{
			if(minimaxBoard[column][count] == myValue){
				for (count2=row+1;count2<=temp1;count2++)
				{
					//counting minimum value
					minValue++;
				}
				return minValue;
			}
			else
				return minValue;
		}
	}
	return minValue;
}
//======================================================================================================

int checkDiagLeftUpMax(int column,int row, char who,int opponentValue,int myValue)
{
	int count,count2,temp1,a;
	a =0;

	if(minimaxBoard[column-1][row-1]==0) //in case nothing there, so return 0.No need to check further
		return 0;
	
	if(minimaxBoard[column-1][row-1]==myValue) //if its player value, also no need to check further
		return 0;
	
	for (count=row-1;count>=0;count--)
	{
		a++;
		if(column-a>=0){
			if (minimaxBoard[column-a][count]==opponentValue)
				temp1 = count;
			else
			{
				if(minimaxBoard[column-a][count] == myValue){
					a=1;
					for (count2=row-1;count2>=temp1;count2--)
					{
						//check if it is 0 or not
						if (minimaxBoard[column-a][count2]!=0){
							//to flip the X and 0
							minimaxBoard[column-a][count2]=myValue;
							a++;
							if (column-a<0)
								break;
						}
					}
					return 1;
				}
				else	//to avoid from fault, so return 0 as nothing to flip
					return 0;
			}
		}
	}
	return 0;
}


/******** int checkDiagLeftDown(int column,int row, char who,int opponentValue,int myValue) *********/
//check whether there is anything to flip in the direction of diagonal left down ....

int checkDiagLeftDownMax(int column,int row, char who,int opponentValue,int myValue)
{
	int count,count2,temp1,a;
	a =0;
	
	if(minimaxBoard[column-1][row+1]==0) //when the place is nothing
		return 0;

	if(minimaxBoard[column-1][row+1]==myValue)	//when the place is value of the player playing at the moment
		return 0;
	
	//start flipping process
	for (count=row+1;count<8;count++)
	{
		a++;
		if(column-a>=0){
			if (minimaxBoard[column-a][count]==opponentValue)
				temp1 = count;
			else
			{
				if(minimaxBoard[column-a][count] == myValue){
					a=1;
					for (count2=row+1;count2<=temp1;count2++)
					{
						//when it is not 0
						if(minimaxBoard[column-a][count2]!=0){
							//start flipping
							minimaxBoard[column-a][count2]=myValue;
							a++;
							if(column-a<0)
								break;
						}
					}
					return 1;
				}
				else	//avoid faults
					return 0;
			}
		}
	}
	return 0;
}

/******** int checkDiagRightDown(int column,int row, char who,int opponentValue,int myValue) *********/
//check whether there is anything to flip in the direction of diagonal right down ....
int checkDiagRightDownMax(int column,int row, char who,int opponentValue,int myValue)
{
	int count,count2,temp1,a;
	a =0;
	
	if(minimaxBoard[column+1][row+1]==0)	//value is 0, no X and 0 
		return 0;
	
	if (minimaxBoard[column+1][row+1]==myValue) //value is player value
		return 0;
	
	//flipping process
	for (count=column+1;count<8;count++)
	{
		a++;
		if(row+a<8){
			if (minimaxBoard[count][row+a]==opponentValue)
				temp1 = count;
			else
			{
				if(minimaxBoard[count][row+a] == myValue){
					a=1;
					//to flip until encounter the player, either X or 0 
					for (count2=column+1;count2<=temp1;count2++)
					{
						//when it is not 0
						if (minimaxBoard[count2][row+a]!=0){
							//start flipping process
							minimaxBoard[count2][row+a]=myValue;
							a++;
							if (row+a<0)
								break;
						}
					}
					return 1;
				}
				else
					return 0;
			}
		}
	}
	return 0;
}

/********* int checkDiagRightUp(int column,int row, char who,int opponentValue,int myValue) ********/
//check whether there is anything to flip in the direction of diagonal right up ....
//same like previous function 
int checkDiagRightUpMax(int column,int row, char who,int opponentValue,int myValue)
{
	int count,count2,temp1,a;
	a =0;
	
	if (minimaxBoard[column+1][row-1]==0)	
		return 0;
	
	if (minimaxBoard[column+1][row-1]==myValue)
		return 0;
	
	for (count=column+1;count<8;count++)
	{
		a++;
		if(row-a>=0){
			if (minimaxBoard[count][row-a]==opponentValue)
				temp1 = count;
			else
			{
				if(minimaxBoard[count][row-a] == myValue){
					a=1;
					for (count2=column+1;count2<=temp1;count2++)
					{
						if (minimaxBoard[count2][row-a]!=0){
							//flipping process
							minimaxBoard[count2][row-a]=myValue;
							a++;
							if (row-a<0)
								break;
						}
					}
					return 1;	//succeed in flipping
				}
				else
					return 0;
			}
		}
	}
	return 0;
}

/********** int checkDown(int column,int row, char who,int opponentValue,int myValue) ************/
//check whether there is anything to flip in the direction of down ....
//same as previous function 
int checkDownMax(int column,int row, char who,int opponentValue,int myValue)
{
	int count,count2;
	int temp1=row+1;
	
	if (minimaxBoard[column][row+1]==0)
		return 0;
	
	if (minimaxBoard[column][row+1]==myValue)
		return 0;
	
	for (count=row+1;count<8;count++)
	{
		if (minimaxBoard[column][count]==opponentValue)
			temp1 = count;
		else
		{
			if(minimaxBoard[column][count] == myValue){
				for (count2=row+1;count2<=temp1;count2++)
				{
					if(minimaxBoard[column][count2]!=0){
						//flipping process
						minimaxBoard[column][count2]=myValue;
					}
				}
				return 1;	//on success in flipping
			}
			else
				return 0;
		}
	}
	return 0;
}

/********** int checkUp(int column,int row, char who,int opponentValue,int myValue) **********/
//check whether there is anything to flip in the direction of up ....
//idea is the same as previous function
int checkUpMax(int column,int row, char who,int opponentValue,int myValue)
{
	int count,count2;
	int temp1;
	
	if (minimaxBoard[column][row-1]==0)
		return 0;

	if (minimaxBoard[column][row-1]==myValue)
		return 0;
	
	for (count=row-1;count>=0;count--)
	{
		if (minimaxBoard[column][count]==opponentValue)
			temp1 = count;
		else
		{
			if(minimaxBoard[column][count] == myValue){
				for (count2=row-1;count2>=temp1;count2--)
				{
					if(minimaxBoard[column][count2]!=0){
						//flipping process 
						minimaxBoard[column][count2]=myValue;
					}
				}
				return 1;	//on success of flipping
			}
			else
				return 0;
		}
	}
	return 0;
}

/********* int checkRight(int column,int row, char who,int opponentValue,int myValue) ********/
//check whether there is anything to flip in the direction of right ....
//similar to the previous function..flippinf is on the right 
int checkRightMax(int column,int row, char who,int opponentValue,int myValue)
{
	int count,count2;
	int temp1=column+1;

	if (minimaxBoard[column+1][row]==0)
		return 0;
	
	if(minimaxBoard[column+1][row]==myValue)
		return 0;
	
	for (count=column+1;count<8;count++)
	{
		if (minimaxBoard[count][row]==opponentValue)
			temp1 = count;
		else
		{
			if(minimaxBoard[count][row] == myValue){
				for (count2=column+1;count2<=temp1;count2++)
				{
					if (minimaxBoard[count2][row]!=0){
						//flipping process
						minimaxBoard[count2][row]=myValue;
					}
				}
				return 1;
			}
			else{
				return 0;
			}
		}
	}
	return 0;
}

/********* int checkLeft(int column,int row, char who,int opponentValue,int myValue) *********/
//check whether there is anything to flip in the direction of left....
int checkLeftMax(int column,int row, char who,int opponentValue,int myValue)
{
	int count,count2;
	int temp1=column-1;
	if(minimaxBoard[column-1][row]==myValue)
		return 0;

	for (count=column-1;count>=0;count--)
	{
		if (minimaxBoard[count][row]==opponentValue)
			temp1 = count;
		else
		{
			if(minimaxBoard[count][row] == myValue){
				for (count2=column-1;count2>=temp1;count2--)
				{
					if(minimaxBoard[count2][row]!=0){
						//flipping process
						minimaxBoard[count2][row]=myValue;
					}
				}
				return 1; //on success
			}
			else
				return 0;
				
		}
	}
	return 0;
}



//======================================================================================================
void flippingMinimaxBoard(int col,int row,int ComputerValue,int playerValue)
{
	int good1,good2,good3,good4,good5,good6,good7,good8;
	minimaxBoard[col][row] = ComputerValue;	
	good1 = checkLeftMax(col,row,'C',playerValue,ComputerValue);
	good2 =	checkRightMax(col,row,'C',playerValue,ComputerValue);
	good3 = checkUpMax(col, row, 'C', playerValue,ComputerValue);
	good4 = checkDownMax(col, row,'C', playerValue,ComputerValue);
	good5 = checkDiagRightUpMax(col,row,'C',playerValue,ComputerValue);
	good6 = checkDiagRightDownMax(col,row,'C',playerValue,ComputerValue);
	good7 = checkDiagLeftUpMax(col,row,'C',playerValue,ComputerValue);
	good8 = checkDiagLeftDownMax(col,row,'C',playerValue,ComputerValue);
	
	if (good1 == 1 || good2 == 1|| good3 == 1|| good4==1||good5==1||good6 == 1||good7 == 1|| good8 == 1){
	}
	else{//extend when i have more time 
		printf("Minimax function trial error!!!\n");
	}
}
void getExpectedMove(int c, int r)
{
	int col, row;
	int min=0;
	char columnInChar;
	int currentPriority = 10;
	int minFlip=100;
	for(col=0;col<8;col++)
		for(row=0;row<8;row++)
			minMoves[c][r].min[col][row] = 0;
			minMoves[c][r].anyMove = 0;
			//get the first biggest value encounter
			if (minMoves[c][r].estimateMin[col][row] >= min){
				if (minimaxBoard[col][row] ==0){
					   if(minMoves[c][r].estimateMin[col][row]!=0){
					   	if (currentPriority >= priorityValue[col][row]){
						  min = minMoves[c][r].estimateMin[col][row];
						  minMoves[c][r].min[col][row] = 1;	//min may move at col, row
						  minMoves[c][r].anyMove = 1;
						  currentPriority = priorityValue[col][row];
						 }
					   }
				}
			}
}


void expectedMinMove(int c, int r, int computerIs, int minIs)
{
	int col,row;
	int min1,min2,min3,min4,min5,min6,min7,min8;

	for (col=0;col<8;col++){
		for (row=0;row<8;row++)
		{
			if (minimaxBoard[col][row] == 0){
				//searching for possible move
				min1 = search_downMin(col,row,minIs,computerIs);
				min2 = search_upMin(col,row,minIs,computerIs);			
				min3 = search_leftMin(col,row,minIs,computerIs);
				min4 = search_rightMin(col,row,minIs,computerIs);
				min5 = search_diag_left_upMin(col,row,minIs,computerIs);
				min6 = search_diag_right_upMin(col,row,minIs,computerIs);
				min7 = search_diag_left_downMin(col,row,minIs,computerIs);
				min8 = search_diag_right_downMin(col,row,minIs,minIs);
				//counting and get the total of each move
				minMoves[c][r].estimateMin[col][row] = min1 + min2 + min3 + min4 + min5 + min6 + min7 + min8;
			}
			else{
				minMoves[c][r].estimateMin[col][row] = 0;
			}

			//if estimateMin is 0 meaning max move will give no way for min to move
			if (minMoves[c][r].estimateMin[col][row] != 0)
				boardValueMinimax[c][r] ++;

			//
			//set the variable back to 0
			min1=0,min2=0,min3=0,min4=0,min5=0,min6=0,min7=0,min8=0;
		}
	}

	getExpectedMove(c,r);
}

void copyValueTominimaxBoard()
{
	int col,row;
	for(col=0;col<8;col++)
		for(row=0;row<8;row++){
			minimaxBoard[col][row] = board[col][row];
		}
}

void initializeBoardminimax()
{
	int col,row;
	for(col=0;col<8;col++)
		for(row=0;row<8;row++){
			boardValueMinimax[col][row] = 0;
		}
}