#include "stdafx.h"

using namespace ActiveBasic::Compiler;

void LexicalAnalyzer::CollectDelegates( const char *source, Delegates &delegates )
{
	int i2;
	char temporary[VN_SIZE];

	// 名前空間管理
	NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
	namespaceScopes.clear();

	// Importsされた名前空間の管理
	NamespaceScopesCollection &importedNamespaces = compiler.GetNamespaceSupporter().GetImportedNamespaces();
	importedNamespaces.clear();

	int length = lstrlen( source );
	for( int i=0; i<length; i++ )
	{
		if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
			for(i+=2,i2=0;;i2++,i++){
				if( IsCommandDelimitation( source[i] ) ){
					temporary[i2]=0;
					break;
				}
				temporary[i2]=source[i];
			}
			namespaceScopes.push_back( temporary );

			continue;
		}
		else if( source[i] == 1 && source[i+1] == ESC_ENDNAMESPACE ){
			if( namespaceScopes.size() <= 0 ){
				compiler.errorMessenger.Output(12, "End Namespace", i );
			}
			else{
				namespaceScopes.pop_back();
			}

			i += 2;
			continue;
		}
		else if( source[i] == 1 && source[i+1] == ESC_IMPORTS ){
			for(i+=2,i2=0;;i2++,i++){
				if( IsCommandDelimitation( source[i] ) ){
					temporary[i2]=0;
					break;
				}
				temporary[i2]=source[i];
			}
			if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
			{
				compiler.errorMessenger.Output(64,temporary,i );
			}

			continue;
		}
		else if( source[i] == 1 && source[i+1] == ESC_CLEARNAMESPACEIMPORTED ){
			importedNamespaces.clear();
			continue;
		}

		else if( source[i] == 1 && source[i+1] == ESC_DELEGATE )
		{
			int nowLine = i;

			i += 2;
			if( !( source[i] == 1 && ( source[i+1] == ESC_SUB || source[i+1] == ESC_FUNCTION ) ) )
			{
				compiler.errorMessenger.Output(1,NULL,i);
				continue;
			}

			Procedure::Kind procKind = Procedure::Sub;
			if( source[i+1] == ESC_FUNCTION )
			{
				procKind = Procedure::Function;
			}
			i += 2;

			// 名前
			char name[VN_SIZE];
			GetIdentifierToken( name, source, i );

			if( source[i] != '(' )
			{
				compiler.errorMessenger.Output(1,NULL,nowLine);
				continue;
			}

			// パラメータ文字列
			char paramStr[8192];
			i += GetStringInPare( paramStr, source + i, true );

			// 戻り値の型の文字列
			char returnTypeName[VN_SIZE] = "";
			if( source[i] == 1 && source[i+1] == ESC_AS )
			{
				i += 2;
				GetCommandToken( returnTypeName, source, i );

				if( procKind != Procedure::Function )
				{
					compiler.errorMessenger.Output(38,name,nowLine);
				}
			}
			else
			{
				if( procKind == Procedure::Function )
				{
					compiler.errorMessenger.Output(-104,name,nowLine);
					lstrcpy( returnTypeName, "Double" );
				}
			}

			delegates.Put( new Delegate( namespaceScopes, importedNamespaces, name, procKind, paramStr, returnTypeName, nowLine ) );
		}
	}
}

std::string LexicalAnalyzer::GenerateDelegatesSourceCode( const Delegates &delegates )
{
	std::string destSource = "";

	SourceTemplate sourceTemplate( ActiveBasic::Common::Environment::GetAbdevSystemDirPath() + "\\templates\\delegate_class.tab" );

	delegates.Iterator_Reset();
	while( delegates.Iterator_HasNext() )
	{
		const Delegate &dg = *delegates.Iterator_GetNext();

		if( !dg.isTargetObjectModule )
		{
			// 静的リンクライブラリの場合は飛ばす（既にインスタンスが定義済みであるため）
			continue;
		}

		std::map<std::string,std::string> values;

		if( dg.GetNamespaceScopes().size() )
		{
			std::string namespaceScopesCommandStr = "";
			std::string endNamespaceScopesCommandStr = "";
			BOOST_FOREACH( const std::string &namespaceStr, dg.GetNamespaceScopes() )
			{
				if( namespaceScopesCommandStr.size() )
				{
					namespaceScopesCommandStr += ":";
					endNamespaceScopesCommandStr += ":";
				}
				namespaceScopesCommandStr += "Namespace " + namespaceStr;
				endNamespaceScopesCommandStr += "End Namespace";
			}

			values.insert( std::map<std::string,std::string>::value_type(
				"#namespace_begin#",
				namespaceScopesCommandStr
			) );
			values.insert( std::map<std::string,std::string>::value_type(
				"#namespace_end#",
				endNamespaceScopesCommandStr
			) );
		}
		else
		{
			values.insert( std::map<std::string,std::string>::value_type( "#namespace_begin#", "" ) );
			values.insert( std::map<std::string,std::string>::value_type( "#namespace_end#", "" ) );
		}

		values.insert( std::map<std::string,std::string>::value_type( "#name#", dg.GetName() ) );

		if( dg.IsFunction() )
		{
			values.insert( std::map<std::string,std::string>::value_type(
				"#call_method_begin#",
				(std::string)"Function Call(" + dg.GetParamStr() + ") As " + dg.GetReturnTypeName()
			) );

			values.insert( std::map<std::string,std::string>::value_type(
				"#call_method_end#",
				"End Function"
			) );

			values.insert( std::map<std::string,std::string>::value_type( "#result#", "Call=" ) );
		}
		else
		{
			values.insert( std::map<std::string,std::string>::value_type(
				"#call_method_begin#",
				(std::string)"Sub Call(" + dg.GetParamStr() + ")"
			) );

			values.insert( std::map<std::string,std::string>::value_type(
				"#call_method_end#",
				"End Sub"
			) );

			values.insert( std::map<std::string,std::string>::value_type( "#result#", "" ) );
		}

		values.insert( std::map<std::string,std::string>::value_type( "#params#", dg.GetParamStr() ) );

		destSource += sourceTemplate.GetResult( values );
	}
/*
	std::ofstream ofs( ( Jenga::Common::Environment::GetAppDir() + "\\generated_delegate_code.log" ).c_str() );
	ofs << destSource;
	ofs.close();
	*/

	return destSource;
}

void LexicalAnalyzer::RefleshDelegateParameterAndReturnType( Delegate &dg )
{
	compiler.GetNamespaceSupporter().SetImportedNamespaces( dg.GetImportedNamespaces() );
	compiler.GetNamespaceSupporter().SetLivingNamespaceScopes( dg.GetNamespaceScopes() );

	// パラメータを解析
	Jenga::Common::Strings parameterStrings;
	SplitParameter( dg.GetParamStr(), parameterStrings );
	int sourceIndex;
	ActiveBasic::Compiler::LexicalAnalyzer::AnalyzeParameter( dg.GetParameters(), parameterStrings, sourceIndex );
	dg.SetSourceIndex( sourceIndex );

	// 動的パラメータを作る
	dg.GetDynamicParams() = dg.GetParameters();
	dg.GetDynamicParams().insert( dg.GetDynamicParams().begin(), new Parameter( "_System_LocalThis", Type( DEF_PTR_VOID ) ) );

	if( dg.IsFunction() )
	{
		// 戻り値を取得
		Type returnType;
		if( !compiler.StringToType( dg.GetReturnTypeName(), returnType ) )
		{
			compiler.errorMessenger.Output(3,dg.GetReturnTypeName(),sourceIndex);
		}
		else
		{
			dg.SetReturnType( returnType );
		}
	}
}

void LexicalAnalyzer::RefleshDelegatesParameterAndReturnType( Delegates &delegates )
{
	delegates.Iterator_Reset();
	while( delegates.Iterator_HasNext() )
	{
		Delegate &dg = *delegates.Iterator_GetNext();
		RefleshDelegateParameterAndReturnType( dg );
	}
}