#include "parser.h"

#include <QRegExp>

#include <iostream>

using namespace std;

Parser::Parser()

{

	initCommand();

}

void Parser::initCommand()

{

	com="";

	paramList.clear();

	resetError();

}

void Parser::parseAtom (const QString &s)

{

	initCommand();

	input=s;

	QRegExp re;

	int pos;

	// Get command

	re.setPattern ("\\b(.*)(\\s|\\()");

	re.setMinimal (true);

	pos=re.search (s);

	if (pos>=0)

		com=re.cap(1);

	// Get parameters

	paramList.clear();

	re.setPattern ("\\((.*)\\)");

	pos=re.search (s);

	//cout << "  s="<<s.ascii()<<endl;

	//cout << "com="<<com.ascii()<<"  pos="<<pos<<endl<<endl;

	if (pos>=0)

	{

		QString s=re.cap(1);

		QString a;

		bool inquote=false;

		pos=0;

		if (!s.isEmpty())

		{

			while (pos<s.length())

			{

				if (s.at(pos)=='\"') 

				{

					if (inquote)

						inquote=false;

					else	

						inquote=true;

				}

				if (s.at(pos)==',' && !inquote)

				{

					a=s.left(pos);

					paramList.append(a);

					s=s.right(s.length()-pos-1);

					pos=0;

				} else

					pos++;

			}

			paramList.append (s);

		}	

	}	

}

QString Parser::command()

{

	return com;

}

QStringList Parser::parameters()

{

	return paramList;

}

int Parser::paramCount()

{

	return paramList.count();

}

QString Parser::errorMessage()

{

	QString l;

	switch (errLevel)

	{

		case NoError: l="No Error";

		case Warning: l="Warning";

		case Aborted: l="Aborted";

	}

	return QString ("Error Level: %1\n    Command: %2\nDescription: %3")

		.arg(l).arg(com).arg(errDescription);

}

QString Parser::errorDescription()

{

	return errDescription;

}

ErrorLevel Parser::errorLevel()

{

	return errLevel;

}

void Parser::setError(ErrorLevel level, const QString &description)

{

	errDescription=description;

	errLevel=level;

}

void Parser::resetError ()

{

	errMessage="";

	errDescription="";

	errLevel=NoError;

}

bool Parser::checkParamCount (QList <int> plist)

{

	QStringList expList;

	QString expected;

	for (int i=0; i<plist.count();i++)

	{

		if (checkParamCount (plist[i])) 

		{

			resetError();

			return true;

		}

		expList.append(QString().setNum(plist[i]));

	}	

	expected=expList.join(",");	

	errDescription=QString("Wrong number of parameters: Expected %1, but found %2").arg(expected).arg(paramList.count());

	return false;

}

bool Parser::checkParamCount (const int &expected)

{

	if (paramList.count()!=expected)

	{

		errLevel=Aborted;

		errDescription=QString("Wrong number of parameters: Expected %1, but found %2").arg(expected).arg(paramList.count());

		return false;

	} 

	return true;	

}

bool Parser::checkParamIsInt(const int &index)

{

	bool ok;

	if (index > paramList.count())

	{

		errLevel=Aborted;

		errDescription=QString("Parameter index %1 is outside of parameter list").arg(index);

		return false;

	} else

	{

		paramList[index].toInt (&ok, 10);

		if (!ok)

		{

			errLevel=Aborted;

			errDescription=QString("Parameter %1 is not an integer").arg(index);

			return false;

		} 

	}	

	return true;

}

int Parser::parInt (bool &ok,const uint &index)

{

	if (checkParamIsInt (index))

		return paramList[index].toInt (&ok, 10);

	ok=false;

	return 0;

}

QString Parser::parString (bool &ok,const int &index)

{

	// return the string at index, this could be also stored in

	// a variable later

	QString r;

	QRegExp re("\"(.*)\"");

	int pos=re.search (paramList[index]);

	if (pos>=0)

		r=re.cap (1);

	else	

		r="";

	ok=true;

	return r;

}

bool Parser::parBool (bool &ok,const int &index)

{

	// return the bool at index, this could be also stored in

	// a variable later

	QString r;

	ok=true;

	QString p=paramList[index];

	if (p=="true" || p=="1")

		return true;

	else if	(p=="false" || p=="0")

		return false;

	ok=false;

	return ok;

}

QColor Parser::parColor(bool &ok,const int &index)

{

	// return the QColor at index

	ok=true;

	return QColor (paramList[index]);

}

void Parser::setScript(const QString &s)

{

	script=s;

}	

QString Parser::getScript()

{

	return script;

}	

void Parser::startScript()

{

}