#include "gamebuilder.h"
#include <bu/sio.h>

#include "game.h"
#include "astbranch.h"
#include "astleaf.h"
#include "astleafliteral.h"
#include "astfunction.h"
#include "command.h"
#include "situation.h"

using namespace Bu;

GameBuilder::GameBuilder() :
	pGame( NULL ),
	bGlobal( false ),
	pCurNode( NULL ),
	pCurRoot( NULL ),
	pCurCmd( NULL ),
	pCurFnc( NULL ),
	pCurSit( NULL )
{
	pGame = new Game();
}

GameBuilder::~GameBuilder()
{
}

void GameBuilder::setLiteral( const Variable &v )
{
	vLiteral = v;
}

void GameBuilder::setGameParam( const Bu::String &sName )
{
	pGame->hGlobalParam.insert( sName, vLiteral );
}

void GameBuilder::beginFunction( const Bu::String &sName )
{
	pCurNode = pCurRoot = new AstBranch( AstNode::tScope );
	pCurFnc = new AstFunction( sName );
	sio << "New function: " << sName << sio.nl;
}

void GameBuilder::addFunctionParam( const Bu::String &sName )
{
	pCurFnc->addParam( sName );
	sio << " - Param added '" << sName << "'" << sio.nl;
}

void GameBuilder::endFunctionParams()
{
	Bu::StringList lRev;
	for( Bu::StringList::const_iterator i = pCurFnc->getParamList().begin();
		 i; i++ )
	{
		lRev.prepend( *i );
	}

	for( Bu::StringList::iterator i = lRev.begin(); i; i++ )
	{
		addVarRef( *i, sidLocal );
		addNode( AstNode::tSwap );
		addNode( AstNode::tStore );
	}
}

void GameBuilder::endFunction()
{
	sio << "Function ended: " << *pCurRoot << sio.nl;
	pCurFnc->setAst( pCurRoot );
	pCurRoot = pCurNode = NULL;
	pGame->hFunction.insert( pCurFnc->getName(), pCurFnc );
}

void GameBuilder::beginSituation( const Bu::String &sName )
{
	pCurSit = new Situation( sName );
	sio << "New situation: " << sName << sio.nl;
}

void GameBuilder::beginSituationMode( Situation::Mode m )
{
	pCurNode = pCurRoot = new AstBranch( AstNode::tScope );
	eCurSitMode = m;
}

void GameBuilder::closeSituationMode()
{
	sio << "Set situation mode " << eCurSitMode << " to " << *pCurRoot << sio.nl;
	pCurSit->setAst( pCurRoot, eCurSitMode );
	pCurRoot = pCurNode = NULL;
}

void GameBuilder::endSituation()
{
	pGame->hSituation.insert( pCurSit->getName(), pCurSit );
	sio << "Situation ended." << sio.nl;
}

void GameBuilder::addNode( AstNode::Type iType )
{
	switch( iType&AstNode::tTypeMask )
	{
		case AstNode::tBranch:
			pCurNode = (AstBranch *)pCurNode->addNode( new AstBranch( iType ) );
			break;

		case AstNode::tLeaf:
			pCurNode->addNode( new AstLeaf( iType ) );
			break;
	}
}

void GameBuilder::closeNode()
{
	pCurNode = pCurNode->getParent();
}

void GameBuilder::addLiteral( const Variable &v )
{
	setLiteral( v );
	if( pCurNode )
	{
		pCurNode->addNode( new AstLeafLiteral( v ) );
	}
}

void GameBuilder::addVarRef( const Bu::String &sName, ScopeId sid )
{
	if( pCurNode )
	{
		pCurNode->addNode( new AstLeafLiteral( AstNode::tVarName, Variable::newVariableName( sName, sid ) ) );
	}
}

void GameBuilder::addFuncCall( const Bu::String &sName )
{
	if( pCurNode )
	{
		pCurNode->addNode( new AstLeafLiteral( AstNode::tFuncCall, sName ) );
	}
}

void GameBuilder::beginGlobal()
{
	bGlobal = true;
}

void GameBuilder::closeGlobal()
{
	bGlobal = false;
}

void GameBuilder::beginCommand( const Bu::String &sValue )
{
	pCurNode = pCurRoot = new AstBranch( AstNode::tScope );
	pCurCmd = new Command();
	pCurCmd->addLiteral( sValue );
}

void GameBuilder::addCommandLiteral( const Bu::String &sValue )
{
	pCurCmd->addLiteral( sValue );
}

void GameBuilder::addCommandParam( const Bu::String &sValue )
{
	pCurCmd->addParam( sValue );
}

void GameBuilder::closeCommand()
{
	pCurCmd->setAst( pCurRoot );
	pCurRoot = pCurNode = NULL;
	pCurCmd->print();
	if( bGlobal )
	{
		pGame->csGlobal.addCommand( pCurCmd );
	}
	else
	{
		delete pCurCmd;
	}
	pCurCmd = NULL;
}