#ifndef BUILDER_H
#define BUILDER_H

#include <stdint.h>
#include <string>
#include <list>
#include <utility>
#include <map>
#include "build.tab.h"
#include "parser.h"

class Build;
class BuildParser;
class Function;
class FunctionFactory;
class Perform;
class PerformFactory;
class Target;
class TargetFactory;

#define YY_DECL int yylex( YYSTYPE *yylval_param, YYLTYPE *yylloc_param, BuildParser &bld )
YY_DECL;

typedef std::list<std::string> StringList;
typedef std::list<Function *> FunctionList;
typedef std::list<Perform *> PerformList;
typedef std::map<std::string,std::string> VarMap;

template<class tx, class ty, class tz>
class Triplet
{
public:
	Triplet( const tx &x, const ty &y, const tz &z ) :
		first( x ), second( y ), third( z )
	{}

	Triplet( const Triplet &src ) :
		first( src.first ), second( src.second ), third( src.third )
	{}

	tx first;
	ty second;
	tz third;
};

enum eSetHow
{
	setSet,
	setAdd
};

class BuildParser : public Parser
{
	typedef std::pair<std::string, Function *> BuildListItem;
	typedef std::list<BuildListItem> BuildList;
	typedef Triplet<std::string, std::string, int> SetVar;
	typedef std::list<SetVar> SetVarList;
public:
	BuildParser();
	virtual ~BuildParser();

	Build *load( const std::string &sFile );

private:
	void scanBegin();
	void scanEnd();

	Build *genBuild();

public: // Target functions
	bool isTarget( const char *sType );
	void newTarget();
	void setTargetRule( const char *sRule );
	void setTargetPrefix( const char *sPrefix );
	void setTargetType( const char *sType );
	void addTargetInput();
	void addTargetRequires();
	void addTargetSet( const char *sVar, const char *sVal, int nHow );

private: // Target variables
	TargetFactory &fTarget;
	class TargetInfo
	{
	public:
		std::string sRule;
		std::string sPrefix;
		std::string sType;
		BuildList lInput;
		BuildList lRequires;
		SetVarList lVar;
	};
	typedef std::pair<BuildList,TargetInfo> TargetTmp;
	typedef std::list<TargetTmp> TargetTmpList;
	TargetTmpList lTargetTmp;

public: // Function functions
	bool isFunction( const char *sFunc );
	void newFunctionCall( const char *sName );
	void addFunctionParam( const char *sParam );

private: // Function variables
	Function *pTmpFunc;
	FunctionFactory &fFunction;

public: // Perform functions
	bool isPerform( const char *sPerf );
	void newPerform( const char *sName );
	void addPerformParam( const char *sParam );

private: // Perform variables
	Perform *pTmpPerform;
	PerformFactory &fPerform;

public: // List functions
	void newList();
	void addListString( const char *str );
	void addListFunc();
	void filterList();

	StringList buildToStringList( const BuildList &lSrc, const StringList &lIn, Build *pPass=NULL );
	StringList buildToStringListDup( const BuildList &lSrc, const StringList &lIn, Build &bld, const std::string &sCont, VarMap *mExtra, Build *pPass=NULL );

private: // List variables
	BuildList lTmp;

public: // Rules functions
	void addRule( const char *sName );
	void addRuleMatches();
	void addRuleProduces();
	void addRuleRequires();
	void addRuleInputFilter();
	void addRulePerform();
	void setRuleAggregate();

private: // Rule variables
	class RuleInfo
	{
	public:
		std::string sName;
		Function *pMatches;
		BuildList lProduces;
		BuildList lRequires;
		FunctionList lFilter;
		PerformList lPerform;
		Function *pAggregate;
	};

	typedef std::list<RuleInfo> RuleTmpList;
	RuleTmpList lRuleTmp;

public: // Action functions
	void addAction();
	void addAction( const char *sName );
	void addCommand( int nType );

private: // Action variables
	typedef std::pair<int, BuildList> ActionTmpCmd;
	typedef std::list<ActionTmpCmd> ActionTmpCmdList;
	typedef std::pair<std::string, ActionTmpCmdList> ActionTmp;
	typedef std::list<ActionTmp> ActionTmpList;
	ActionTmpList lActions;

public: // Global variable functions
	void addGlobalSet( const char *sVar, const char *sValue, int nHow );

private: // Global variable variables
	SetVarList lGlobalVars;

public: // Debug
	void debugDump();
	void printBuildList( const BuildList &lst );
};

#endif