/* This file is part of Cloudy and is copyright (C)1978-2013 by Gary J. Ferland and
 * others.  For conditions of distribution and use see copyright notice in license.txt */

#include "cddefines.h"
#include "parser.h"
#include "called.h"
#include "energy.h"
#include "flux.h"
#include "input.h"
#include "elementnames.h"

#include <deque>
namespace
{
	class Token
	{
	public:
		enum symType { symNull, symNumber, symOp, symVar };
		string s;
		symType t;
		explicit Token(enum symType type) : s(""), t(type) {}
		explicit Token() : s(""), t(symNull) {}
	};
}

typedef std::map<string,double> symtab;
STATIC bool ParseExpr(deque<Token> &chTokens, vector<double> &valstack,
	const symtab &tab);

const char *Parser::nWord(const char *chKey) const
{
	return ::nWord(chKey, m_card);
}

/*nWord determine whether match to a keyword occurs on command line,
 * return value is 0 if no match, and position of match within string if hit */
const char *nWord(const char *chKey, 
	    const char *chCard)
{
	DEBUG_ENTRY( "nWord()" );

	// Ignore leading space in chKey -- logic below is designed
	// to avoid the need to include this in the first place
	while (isspace(*chKey))
	{
		++chKey;
	}

	const long lenkey = strlen(chKey);
	ASSERT( lenkey > 0 );

	bool atBoundary = true, inQuote=false;
	for (const char *ptr = chCard; *ptr; ++ptr)
	{
		if (!inQuote)
		{
			if (*ptr == '\"')
			{
				inQuote = true;
			}
			else
			{		
				if ( atBoundary && strncmp( ptr, chKey, lenkey) == 0 )
				{
					return ptr;
				}
				
				atBoundary = isBoundaryChar(*ptr);
			}
		}
		else
		{
			if (*ptr == '\"')
			{
				inQuote = false;
			}		
		}
	}

	return NULL;
}

bool isBoundaryChar(char c)
{
	const bool lgAnyWhitespacePrecedesWord = false;
	
	if (lgAnyWhitespacePrecedesWord)
		return isspace(c) ? true : false ;
	else 	// Words are strings starting with A-Z, a-z or _
		return (! isalpha(c) ) && c != '_';
}

bool Parser::isComment(void) const
{
	return lgInputComment(m_card);
}
bool Parser::isCommandComment(void) const
{
	return ( m_card[0]=='C' && (m_card[1]==' ' || m_card[1]== '\0')) ||
		isComment();
}
bool Parser::isVar(void) const
{
	return ( *m_ptr=='$' );
}
std::string Parser::getVarName(void)
{
	std::string name("");
	while (*m_ptr)
	{
		char c = *m_ptr;
		if (!(isalnum(c) || c == '_'))
			break;
		name += c;
		++m_ptr;
	}
	return name;
}
void Parser::doSetVar(void)
{
	DEBUG_ENTRY(" Parser::doSetVar()");
	char c='\0';
	++m_ptr;
	std::string name = getVarName();
	while (*m_ptr)
	{
		c = *m_ptr;
		++m_ptr;
		if (c == '=')
			break;
	}
	if (! *m_ptr)
	{
		fprintf(ioQQQ,"Expected '=' in variable definition\n");
		cdEXIT(EXIT_FAILURE);
	}
	while (*m_ptr)
	{
		c = *m_ptr;
		if (c != ' ')
			break;
		++m_ptr;
	}
	m_symtab[name] = FFmtRead();
}

void Parser::echo(void) const
{
	/* >>chng 04 jan 21, add HIDE option, mostly for print quiet command */
	if( called.lgTalk && !::nMatch("HIDE",m_card) )
		fprintf( ioQQQ, "%23c* %-80s*\n", ' ', m_card_raw );
}

NORETURN void Parser::CommandError(void) const
{
	DEBUG_ENTRY(" Parser::CommandError()");
	fprintf( ioQQQ, "  Unrecognized command. Key=\"%4.4s\".  This is routine ParseCommands.\n", 
				m_card );
	fprintf( ioQQQ, " The line image was\n");
	PrintLine(ioQQQ);
	fprintf( ioQQQ, " Sorry.\n" );
	cdEXIT(EXIT_FAILURE);
}
bool Parser::getline(void)
{
	input.readarray(m_card_raw,&m_lgEOF);
	newlineProcess();
	if (m_lgEOF)
		return false;
	else
		return true;
}
	
const char *Parser::StandardEnergyUnit(void) const
{
	return ::StandardEnergyUnit(m_card);
}
string Parser::StandardFluxUnit(void) const
{
	return ::StandardFluxUnit(m_card);
}
void Parser::help(FILE *fp) const
{
	DEBUG_ENTRY("Parser::help()");
	fprintf(fp,"Available commands are:\n\n");
	long int i=0, l=0, len;
	while (1)
	{
		len = strlen(m_Commands[i].name);
		if (l+len+2 > 80)
		{
			fprintf(fp,"\n");
			l = 0;
		}
		l += len+2;
		fprintf(fp,"%s",m_Commands[i].name);
		++i;
		if (m_Commands[i].name == NULL)
			break;
		fprintf(fp,", ");
	}
				  
	fprintf(fp,"\n\nSorry, no further help available yet -- try Hazy.\n\n");
	cdEXIT(EXIT_SUCCESS);
}

/*GetElem scans line image, finds element. returns atomic number j, 
 * on C scale, -1 if no hit.  chCARD_CAPS must be in CAPS to hit element */
long int Parser::GetElem(void ) const
{
	int i;

	DEBUG_ENTRY( "GetElem()" );

	/* find which element */

	/* >>>chng 99 apr 17, lower limit to loop had been 1, so search started with helium,
	 * change to 0 so we can pick up hydrogen.  needed for parseasserts command */
	/* find match with element name, start with helium */
	for( i=0; i<(int)LIMELM; ++i )
	{
		if( nMatch( elementnames.chElementNameShort[i] ) )
		{
			/* return value is in C counting, hydrogen would be 0*/
			return i;
		}
	}
	/* fall through, did not hit, return -1 as error condition */
	return (-1 );
}

/*NoNumb general error handler for no numbers on input line */
NORETURN void Parser::NoNumb(const char * chDesc) const
{
	DEBUG_ENTRY( "NoNumb()" );

	/* general catch-all for no number when there should have been */
	fprintf( ioQQQ, " There is a problem on the following command line:\n" );
	fprintf( ioQQQ, " %s\n", m_card_raw );
	fprintf( ioQQQ, " A value for %s should have been on this line.\n   Sorry.\n",chDesc );
	cdEXIT(EXIT_FAILURE);
 }

double Parser::getWaveOpt()
{
	double val = FFmtRead();
	/* check for optional micron or cm units, else interpret as Angstroms */
	if( chPoint() == 'M' )
	{
		/* microns */
		val *= 1e4;
	}
	else if( chPoint() == 'C' )
	{
		/* centimeters */
		val *= 1e8;
	}
	return val;
}
double Parser::getWave()
{
	double val = getWaveOpt();
	if( lgEOL() )
	{
		NoNumb("wavelength");
	}
	return val;
}
double Parser::getNumberPlain( const char * )
{
	return FFmtRead();
}
double Parser::getNumberCheck( const char *chDesc )
{
	double val = FFmtRead();
	if( lgEOL() )
	{
		NoNumb(chDesc);
	}
	return val;
}
double Parser::getNumberDefault( const char *, double fdef )
{
	double val = FFmtRead();
	if( lgEOL() )
	{
		val = fdef;
	}
	return val;
}
double Parser::getNumberCheckLogLinNegImplLog( const char *chDesc )
{
	double val = getNumberCheck(chDesc);
	if( nMatch(" LOG") )
	{
		val = pow(10.,val);
	}		
	else if(! nMatch("LINE") )
	{
		/* log, linear not specified, neg so log */
		if( val <= 0. )
		{
			val = pow(10.,val);
		}
	}
	return val;
}
double Parser::getNumberCheckAlwaysLog( const char *chDesc )
{
	double val = getNumberCheck(chDesc);
	val = pow(10., val);
	return val;
}
double Parser::getNumberCheckAlwaysLogLim( const char *chDesc, double flim )
{
	double val = getNumberCheck(chDesc);
	if ( val > flim )
	{
		fprintf(ioQQQ,"WARNING - the log of %s is too "
				  "large, I shall probably crash.  The value was %.2e\n",
				  chDesc, val );
		fflush(ioQQQ);		
	}
	val = pow(10., val);
	return val;
}
double Parser::getNumberDefaultAlwaysLog( const char *, double fdef )
{
	double val = pow(10.,FFmtRead());
	if ( lgEOL() )
	{
		val = fdef;
	}
	return val;
}
double Parser::getNumberDefaultNegImplLog( const char *, double fdef )
{
	double val = FFmtRead();
	if ( lgEOL() )
	{
		val = fdef;
	}
	if (val < 0.0)
	{
		val = pow(10.,val);
	}
	return val;
}

/*FFmtRead scan input line for free format number */


double Parser::FFmtRead(void)
{

	DEBUG_ENTRY( "Parser::FFmtRead()" );

	char chr = '\0';
	// eol_ptr points one beyond last valid char
	const char * const eol_ptr = m_card+m_len; 

	// Look for start of next expression
	while( m_ptr < eol_ptr && ( chr = *m_ptr++ ) != '\0' )
	{
		if ( chr == '$')
			break;
		const char *lptr = m_ptr;
		char lchr = chr;
		if( lchr == '-' || lchr == '+' )
			lchr = *lptr++;
		if( lchr == '.' )
			lchr = *lptr;
		if( isdigit(lchr) )
			break;
	}

	if( m_ptr == eol_ptr || chr == '\0' )
	{
		m_lgEOL = true;
		return 0.;
	}

	// Lexer for expression
	deque<Token> chTokens(0);
	bool lgCommaFound = false, lgLastComma = false;
	do
	{
		lgCommaFound = lgLastComma;
		if( chr != ',' )
		{
			if (chr == '^' || chr == '*' || chr == '/' ) 
			{
				chTokens.push_back(Token(Token::symOp));
				chTokens.back().s += chr;
			}
			else if (chr == '$')
			{
				chTokens.push_back(Token(Token::symVar));
				chTokens.back().s += getVarName();
			}
			else
			{
				if (chTokens.size() == 0 || chTokens.back().t != Token::symNumber)
					chTokens.push_back(Token(Token::symNumber));
				chTokens.back().s += chr;
			}
		}
		else
		{
			/* don't complain about comma if it appears after number,
				as determined by exiting loop before this sets lgCommaFound */
			lgLastComma = true;

		}
		if( m_ptr == eol_ptr )
			break;
		chr = *m_ptr++;
	}
	while( isdigit(chr) || chr == '.' || chr == '-' || chr == '+' || chr == ',' 
			 || chr == 'e' || chr == 'E' || chr == '^' || chr == '*' || chr == '/' 
			 || chr == '$' );

	if( lgCommaFound )
	{
		fprintf( ioQQQ, " PROBLEM - a comma was found embedded in a number, this is deprecated.\n" );
		fprintf(ioQQQ, "== %-80s ==\n",m_card);
	}

	// Parse tokens
	vector<double> valstack;
	const bool lgParseOK = ParseExpr(chTokens, valstack, m_symtab);
	if (!lgParseOK || 1 != valstack.size())
	{
		fprintf(ioQQQ," PROBLEM - syntax error in number\n");
		fprintf(ioQQQ, "== %-80s ==\n",m_card);
	}

	double value = valstack[0];

	m_lgEOL = false;
	m_ptr--;	 // m_ptr already points 1 beyond where next read should start

	return value;
}

void Parser::getLineID(char *LabelBuf, realnum *wave)
{
	/* order on line is label (col 1-4), wavelength */
	strncpy( LabelBuf, getCommand(4).c_str() , 4 );
	
	/* null terminate the string*/
	LabelBuf[4] = 0;
	
	/* now get wavelength */
	*wave = (realnum)getWaveOpt();

}

// Simple recursive descent parser for expressions
//
// for discussion, see e.g. http://www.ddj.com/architect/184406384
//
// for a possibly more efficient alternative, see
// http://eli.thegreenplace.net/2010/01/02/top-down-operator-precedence-parsing/

STATIC bool ParseNumber(deque<Token> &chTokens, vector<double> &valstack,
	const symtab &tab)
{
	DEBUG_ENTRY(" ParseNumber()");
	if ( chTokens.size() < 1)
		return false;

	if (Token::symNumber == chTokens[0].t)
	{
		valstack.push_back(atof(chTokens[0].s.c_str()));
		chTokens.pop_front();
		return true;
	}
	if (Token::symVar == chTokens[0].t)
	{
		symtab::const_iterator var = tab.find(chTokens[0].s);
		if (var == tab.end())
		{
			fprintf(ioQQQ,"ERROR: No value found for variable $%s\n",
					  chTokens[0].s.c_str());
			cdEXIT(EXIT_FAILURE);
		}
		valstack.push_back(var->second);
		chTokens.pop_front();
		return true;
	}

	return false;
}

STATIC bool doop(vector<double> &valstack, const string &op)
{
	const double v2 = valstack.back();
	valstack.pop_back();
	const double v1 = valstack.back();
	valstack.pop_back();
	double result;
	if (op == "^")
	{
		result = pow(v1,v2);
	}
	else if (op == "*")
	{
		result = v1*v2;
	}
	else if (op == "/")
	{
		result = v1/v2;
	}
	else
	{
		fprintf(ioQQQ,"Unknown operator '%s'\n",op.c_str());
		return false;
	}
	valstack.push_back(result);
	return true;
}

STATIC bool ParseExp(deque<Token> &chTokens, vector<double> &valstack,
	const symtab& tab)
{
	// Right-associative -- need to buffer into stack
	vector<string> opstack;
	if (!ParseNumber(chTokens, valstack, tab))
		return false;

	while (1)
	{
		if ( chTokens.size() == 0 )
			break;
		
		if ( chTokens.size() < 2 )
			return false;
		
		if ( Token::symOp != chTokens[0].t || "^" != chTokens[0].s )
			break;
		
		opstack.push_back(chTokens[0].s);
		chTokens.pop_front();
	
		if (!ParseNumber(chTokens, valstack, tab))
			return false;
	}

	while (!opstack.empty())
	{	
		if (!doop(valstack, opstack.back()))
			return false;
		opstack.pop_back();
	}
	return true;
}

STATIC bool ParseProduct(deque<Token> &chTokens, vector<double> &valstack,
	const symtab& tab)
{
	// Left-associative
	if (!ParseExp(chTokens, valstack, tab))
		return false;

	while ( chTokens.size() > 0 && 
			  Token::symOp == chTokens[0].t &&
			  ( "*" == chTokens[0].s || "/" ==  chTokens[0].s ) ) 
	{
		string op = chTokens[0].s;
		chTokens.pop_front();
		
		if (!ParseExp(chTokens, valstack, tab))
			return false;
		
		if (!doop(valstack, op))
			return false;
	}
	return true;
}

STATIC bool ParseExpr(deque<Token> &chTokens, vector<double> &valstack,
	const symtab& tab)
{
	if (ParseProduct(chTokens, valstack,tab))
		return true;
	return false;
}