#include "stdafx.h"

#include <Delegate.h>

Delegate::Delegate( const NamespaceScopes &namespaceScopes, const std::string &name, Procedure::Kind procKind, const char *paramStr, const Type &returnType, int nowLine )
	: Procedure( namespaceScopes, name, procKind, false )
{
	this->returnType = returnType;
	params.Analyze( paramStr, nowLine );
}

void Delegates::Collect( const BasicSource &source )
{
	int i2;
	char temporary[VN_SIZE];

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

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

	for( int i=0; i<source.GetLength(); 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 ){
				SetError(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 ) )
			{
				SetError(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 ) ) )
			{
				SetError(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.GetBuffer(), i );

			char paramStr[8192];
			i += GetStringInPare( paramStr, source.GetBuffer() + i );

			// 戻り値
			Type returnType;
			if( source[i] == 1 && source[i+1] == ESC_AS )
			{
				i += 2;
				char typeName[VN_SIZE];
				GetCommandToken( typeName, source.GetBuffer(), i );
				compiler.StringToType( typeName, returnType );
			}

			this->Put( new Delegate( namespaceScopes, name, procKind, paramStr, returnType, nowLine ) );
		}
	}
}

void Delegates::GenerateSourceCode( std::string &destSource )
{
	destSource = "";

	SourceTemplate sourceTemplate( "\\SubOperation\\templates\\delegate_class.tab" );

	this->Iterator_Reset();
	while( this->Iterator_HasNext() )
	{
		const Delegate &dg = *this->Iterator_GetNext();

		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() ) );

		std::string paramsStr = dg.Params().GetString();

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

			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#",
				(string)"Sub Call(" + paramsStr + ")"
			) );

			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#", paramsStr ) );

		destSource += sourceTemplate.GetResult( values );
	}
}