#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include "common.h"
#include "reform.h"

/**************************************************************\
*函數：isnumber
*
*功能：判斷一個字符是否為數字包括小數點 '.'
*
*返回：如果是數字返回 true 否則返回 false
\**************************************************************/
bool isnumber (
	char c
	)
{
	if (c=='.' || c>= '0' && c<='9') {
		return true;
	} else {
		return false;
	}
}

/**************************************************************\
*函數：isoperator
*
*功能：判斷一個字符是否為操作符，不含數學函數
*
*返回：如果是數字返回 true 否則返回 false
\**************************************************************/
bool isoperator (
	char c
	)
{
	if (c == '+' || c == '-' || c == '*' || c == '/' || c == '\\' || c == '%' || c == '^') {
		return true;
	} else {
		return false;
	}
}

/**************************************************************\
*函數：convert
*
*功能：將數字串轉換為等值的整數實數
*
*返回：返回對應的項標識號
\**************************************************************/
int convert (
	char DataString[],
	TERM *dest
	)
{
	int    i;
	int    signal = NULL;
	int    PointCount = 0;
	int    intTotal = 0;
	double floTotal = 0.0;
	double weight = 0.1;

	for (i = 0;i<MAXSIZE && DataString[i] != NULL;i ++) {
		if (DataString[i] == '.') {
			PointCount ++;
			if (PointCount > 1) {
				error = the_real_number_is_illegal;
				return NULL;
			}
			
		} else {
			if (PointCount == 0) {
				intTotal = intTotal*10+(DataString[i]-'0');
			} else if (PointCount == 1) {
				floTotal += weight*(DataString[i]-'0');
				weight = weight*0.1;
			} 
		}
	}
	if (PointCount == 0) {
		dest->Operand.DataSignal = INTEGER;
		dest->Operand.Data.Integer = intTotal;
	} else {
		dest->Operand.DataSignal = FLOAT;
		dest->Operand.Data.Real = intTotal + floTotal;
	}
	return ISDATA;
}
	    
/**************************************************************\
*函數：reform
*
*功能：將表達式字符串格式化為項串
*
*返回：返回項串的頭指針
*
*注：將所有的 '-' 都當作減號
\**************************************************************/
void reform (
			  char expString[]
			  )
{
	int  i = 0,j = 0;
	int  tempSignal = LEFT_BRACKET;
	TERM tempTerm;
	NODE *tempNode;
    
	if (error != NULL) {
		return;
	}
	
	tempTerm.Operator.Symbol = '(';
	tempTerm.Operator.OperandNumber = 0;
	tempTerm.Operator.Priority = 6;
	ExpressionHead = NewNode (tempTerm,tempSignal);       //加入頭結點
	ExpressionTail = ExpressionHead;
    
	for (i = 0;expString[i] != NULL;i ++) {
		j = 0;
		if (isalpha (expString[i])) {              //獲得標識符
			VarName[j ++] = expString[i];
			while (isalpha(expString[++ i])) {
				if (j == MAXSIZE - 1) {
					error = the_name_is_too_long;
					return;
				}
				VarName[j ++] = expString[i];
			}
			i --;    //將下標返回到第一個非字母字符的前面以便主循環繼續從其開始掃描
			VarName[j] = NULL;
			if ((tempSignal = FunctionSearch (FunctionList,VarName,&tempTerm)) == NULL &&
				(tempSignal = VariableSearch (VariableList,VarName,&tempTerm)) == NULL) {
				error = can_not_identify_identifier;
				return;
			}
		} else if (isoperator (expString[i])) {             //獲得操作符
			tempTerm.Operator.Symbol = expString[i];
			if (expString[i] == '%') {
				tempSignal = UNITARY;
				tempTerm.Operator.OperandNumber = 1;
				tempTerm.Operator.Priority = 0;
			} else {
				tempSignal = DUALITY;
				tempTerm.Operator.OperandNumber = 2;
				if (expString[i] == '^') {
					tempTerm.Operator.Priority = 2;
				} else if (expString[i] == '*' || expString[i] == '/' || expString[i] == '\\') {
					tempTerm.Operator.Priority = 4;
				} else {
					tempTerm.Operator.Priority = 5;
				}
			}
		} else if (isnumber(expString[i])) {                //獲得操作數
			VarName[j ++] = expString[i];
			while (isnumber (expString[++ i])) {
				if (j == MAXSIZE - 1) {
					error = the_data_bit_is_too_long;
					return;
				}
				VarName[j ++] = expString[i];
 			}
			i --;     //將下標返回到第一個非數字字符的前面以便主循環繼續從其開始掃描
			VarName[j] = NULL;
			tempSignal = convert (VarName,&tempTerm);
			if (error != NULL) {
				return;
			}
		} else if (expString[i] == '(') {
			tempTerm.Operator.Symbol = expString[i];
			tempTerm.Operator.Priority = 6;
			tempTerm.Operator.OperandNumber = 0;
			tempSignal = LEFT_BRACKET;
		} else if (expString[i] == ')') {		
			tempTerm.Operator.Symbol = expString[i];
			tempTerm.Operator.Priority = 6;
			tempTerm.Operator.OperandNumber = 0;
			tempSignal = RIGHT_BRACKET;
		} else {
			continue;
		}
		tempNode = NewNode (tempTerm,tempSignal);
		ExpressionTail = InsertEnd (ExpressionTail,tempNode);
	}
	tempSignal = RIGHT_BRACKET;
	tempTerm.Operator.Symbol = ')';
	tempTerm.Operator.OperandNumber = 0;
	tempTerm.Operator.Priority = 6;
	tempNode = NewNode (tempTerm,tempSignal);      
	ExpressionTail = InsertEnd (ExpressionTail,tempNode);                     //加入尾結點
}

bool LicitCompages (NODE *a,NODE *b)
{
	switch (a->TermSignal) {
		case ISDATA:
			if (b->TermSignal == ISDATA) {
				return false;
			} else {
				return true;
			}
		case ISVARIABLE:
			if (b->TermSignal == ISDATA || b->TermSignal == ISVARIABLE) {
				return false;
			} else {
				return true;
			}
		case UNITARY://只表示 '%'
			if (b->TermSignal == UNITARY) {
				return false;
			} else {
				return true;
			}
		case DUALITY://包含負號 '-'
			if (b->TermSignal == DUALITY || b->TermSignal == RIGHT_BRACKET) {
				return false;
			} else {
				return true;
			}
		case MATH_FUNCTION:
			if (b->TermSignal == RIGHT_BRACKET || b->TermSignal == UNITARY || b->TermSignal == DUALITY) {
				return false;
			} else {
				return true;
			}
		case LEFT_BRACKET:
			if (b->TermSignal == RIGHT_BRACKET || b->TermSignal == UNITARY || (b->TermSignal == DUALITY && b->Term.Operator.Symbol != '-')) {
				return false;
			} else {
				return true;
			}
		case RIGHT_BRACKET:	
			if (b->TermSignal == ISDATA || b->TermSignal == ISVARIABLE || b->TermSignal == MATH_FUNCTION) {
				return false;
			} else {
				return true;
			}
		default:
			return false;
			
	}
}

void SyntaxCheck (
	NODE *expHead
	)
{
	int  BracketCounter = 0;
	NODE *a,*b;
	if (error != NULL) {
		return;
	}

	for (a = expHead,b = a->Next;b != NULL;a = b,b = b->Next) {
		if (a->TermSignal == LEFT_BRACKET) {
			BracketCounter ++;
		} else if (a->TermSignal == RIGHT_BRACKET) {
			BracketCounter --;
		}
		if (! LicitCompages (a,b)) {
			error = illegal_compages;
			return;
		}
	}
	BracketCounter --;
	if (BracketCounter != 0) {
		error = the_brackets_are_not_match;
		return;
	}
}

void expAnalyse (
	NODE *expHead
	)
{
	NODE *a;
	NODE *b;
	NODE *tempNode;
	TERM tempTerm;
	int  Signal = DUALITY;
	if (error != NULL) {
		return;
	}
	tempTerm.Operator.Symbol = '*';
	tempTerm.Operator.OperandNumber = 2;
	tempTerm.Operator.Priority = 4;

	for (a = expHead,b = a->Next;b != NULL; a = b,b = b->Next) {
		switch (a->TermSignal) {
			case ISDATA:
			case UNITARY:
				if ((b->TermSignal == ISVARIABLE || b->TermSignal == MATH_FUNCTION || b->TermSignal == LEFT_BRACKET)) {
					tempNode = NewNode (tempTerm,Signal);
					InsertAfter (a,tempNode);
					break;
				}
			case ISVARIABLE:
				if ((b->TermSignal == MATH_FUNCTION || b->TermSignal == LEFT_BRACKET)) {
					tempNode = NewNode (tempTerm,Signal);
					InsertAfter (a,tempNode);
					break;
				}
			case RIGHT_BRACKET:
				if ((b->TermSignal == MATH_FUNCTION || b->TermSignal == LEFT_BRACKET)) {
					tempNode = NewNode (tempTerm,Signal);
					InsertAfter (a,tempNode);
					break;
				}
		}
	}
}


void reformer (
	char expString[]
	)
{
	reform (expString);
	SyntaxCheck (ExpressionHead);
	expAnalyse (ExpressionHead);
}