#include <ast/statements/SingleStatement.h>
#include <ast/Option.h>
#include <ast/Param.h>
#include <ast/Arg.h>
#include <ast/common/CastHelper.h>

namespace cli {

SingleStatement::SingleStatement ( std::unique_ptr < Arg > name, ext::vector < std::unique_ptr < Param > > params, ext::vector < std::unique_ptr < Option > > options ) : m_name ( std::move ( name ) ), m_params ( std::move ( params ) ), m_options ( std::move ( options ) ) {
	for ( const std::unique_ptr < Option > & option : m_options ) {
		option->eval ( * this );
	}
}

std::shared_ptr < abstraction::OperationAbstraction > SingleStatement::translateAndEval ( const std::shared_ptr < abstraction::OperationAbstraction > & prev, Environment & environment ) const {
	ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > params;
	for ( const std::unique_ptr < Param > & param : m_params ) {
		params.push_back ( param->translateAndEval ( prev, environment ) );
	}

	ext::vector < std::string > paramTypes;
	for ( const std::shared_ptr < abstraction::OperationAbstraction > & param : params ) {
		paramTypes.push_back ( param->getReturnType ( ) );
	}

	std::string name = m_name->eval ( environment );

	bool downcast = false;
	bool normalize = false;

	std::shared_ptr < abstraction::OperationAbstraction > algo = abstraction::Registry::getAlgorithmAbstraction ( name, paramTypes, downcast, normalize );

	unsigned i = 0;
	ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > casted_params;
	for ( const std::shared_ptr < abstraction::OperationAbstraction > & param : params ) {
		if ( abstraction::Registry::isCastNoOp ( algo->getParamType ( i ), param->getReturnType ( ) ) ) {
			casted_params.push_back ( param );
		} else {
			casted_params.push_back ( CastHelper::castHelper ( param, algo->getParamType ( i ) ) );
		}
		++ i;
	}

	i = 0;
	for ( const std::shared_ptr < abstraction::OperationAbstraction > & param : casted_params ) {
		if ( ! algo->attachInput ( param, i ) )
			throw exception::CommonException ( "Can't connect param at " + ext::to_string ( i ) + " of algorithm " + name + " with result of type " + param->getReturnType ( ) + "." );
		++ i;
	}

	if ( ! algo->eval ( ) )
		throw exception::CommonException ( "Eval of algorithm " + name + " failed." );

	if ( downcast ) {
		std::shared_ptr < abstraction::OperationAbstraction > downcaster = abstraction::Registry::getDowncastAbstraction ( algo->getRuntimeReturnType ( ), algo->getReturnType ( ) );
		if ( ! downcaster->attachInput ( algo, 0 ) )
			throw exception::CommonException ( "Can't connect param at 0 of downcast of algorithm " + name + " with result of type " + algo->getReturnType ( ) + "." );
		if ( ! downcaster->eval ( ) )
			throw exception::CommonException ( "Eval of downcast of algorithm " + name + " failed." );

		algo = downcaster;
	}

	if ( normalize ) {
		std::shared_ptr < abstraction::OperationAbstraction > normalized = abstraction::Registry::getNormalizeAbstraction ( algo->getReturnType ( ) );
		if ( ! normalized->attachInput ( algo, 0 ) )
			throw exception::CommonException ( "Can't connect param at 0 of normalize of algorithm " + name + " with result of type " + algo->getReturnType ( ) + "." );
		if ( ! normalized->eval ( ) )
			throw exception::CommonException ( "Eval of normalize of algorithm " + name + " failed." );

		algo = normalized;
	}

	return algo;
}

} /* namespace cli */