/*
	This file is part of cpp-ethereum.

	cpp-ethereum is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	cpp-ethereum is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
 * @author Christian <c@ethdev.com>
 * @date 2014
 * Solidity abstract syntax tree.
 */

#include <algorithm>

#include <libsolidity/AST.h>
#include <libsolidity/ASTVisitor.h>
#include <libsolidity/Exceptions.h>

namespace dev {
namespace solidity {

void ContractDefinition::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		listAccept(m_definedStructs, _visitor);
		listAccept(m_stateVariables, _visitor);
		listAccept(m_definedFunctions, _visitor);
	}
	_visitor.endVisit(*this);
}

void StructDefinition::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		listAccept(m_members, _visitor);
	}
	_visitor.endVisit(*this);
}

void ParameterList::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		listAccept(m_parameters, _visitor);
	}
	_visitor.endVisit(*this);
}

void FunctionDefinition::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		m_parameters->accept(_visitor);
		if (m_returnParameters)
			m_returnParameters->accept(_visitor);
		m_body->accept(_visitor);
	}
	_visitor.endVisit(*this);
}

void VariableDeclaration::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		if (m_typeName)
			m_typeName->accept(_visitor);
	}
	_visitor.endVisit(*this);
}

void TypeName::accept(ASTVisitor& _visitor)
{
	_visitor.visit(*this);
	_visitor.endVisit(*this);
}

void ElementaryTypeName::accept(ASTVisitor& _visitor)
{
	_visitor.visit(*this);
	_visitor.endVisit(*this);
}

void UserDefinedTypeName::accept(ASTVisitor& _visitor)
{
	_visitor.visit(*this);
	_visitor.endVisit(*this);
}

void Mapping::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		m_keyType->accept(_visitor);
		m_valueType->accept(_visitor);
	}
	_visitor.endVisit(*this);
}

void Statement::accept(ASTVisitor& _visitor)
{
	_visitor.visit(*this);
	_visitor.endVisit(*this);
}

void Block::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		listAccept(m_statements, _visitor);
	}
	_visitor.endVisit(*this);
}

void IfStatement::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		m_condition->accept(_visitor);
		m_trueBody->accept(_visitor);
		if (m_falseBody)
			m_falseBody->accept(_visitor);
	}
	_visitor.endVisit(*this);
}

void BreakableStatement::accept(ASTVisitor& _visitor)
{
	_visitor.visit(*this);
	_visitor.endVisit(*this);
}

void WhileStatement::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		m_condition->accept(_visitor);
		m_body->accept(_visitor);
	}
	_visitor.endVisit(*this);
}

void Continue::accept(ASTVisitor& _visitor)
{
	_visitor.visit(*this);
	_visitor.endVisit(*this);
}

void Break::accept(ASTVisitor& _visitor)
{
	_visitor.visit(*this);
	_visitor.endVisit(*this);
}

void Return::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		if (m_expression)
			m_expression->accept(_visitor);
	}
	_visitor.endVisit(*this);
}

void VariableDefinition::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		m_variable->accept(_visitor);
		if (m_value)
			m_value->accept(_visitor);
	}
	_visitor.endVisit(*this);
}

void Assignment::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		m_leftHandSide->accept(_visitor);
		m_rightHandSide->accept(_visitor);
	}
	_visitor.endVisit(*this);
}

void UnaryOperation::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		m_subExpression->accept(_visitor);
	}
	_visitor.endVisit(*this);
}

void BinaryOperation::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		m_left->accept(_visitor);
		m_right->accept(_visitor);
	}
	_visitor.endVisit(*this);
}

void FunctionCall::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		m_expression->accept(_visitor);
		listAccept(m_arguments, _visitor);
	}
	_visitor.endVisit(*this);
}

void MemberAccess::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		m_expression->accept(_visitor);
	}
	_visitor.endVisit(*this);
}

void IndexAccess::accept(ASTVisitor& _visitor)
{
	if (_visitor.visit(*this)) {
		m_base->accept(_visitor);
		m_index->accept(_visitor);
	}
	_visitor.endVisit(*this);
}

void Identifier::accept(ASTVisitor& _visitor)
{
	_visitor.visit(*this);
	_visitor.endVisit(*this);
}

void ElementaryTypeNameExpression::accept(ASTVisitor& _visitor)
{
	_visitor.visit(*this);
	_visitor.endVisit(*this);
}

void Literal::accept(ASTVisitor& _visitor)
{
	_visitor.visit(*this);
	_visitor.endVisit(*this);
}

void Statement::expectType(Expression& _expression, const Type& _expectedType)
{
	if (!_expression.checkTypeRequirements()->isImplicitlyConvertibleTo(_expectedType))
		BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("Type not implicitly convertible "
															 "to expected type."));
	//@todo provide more information to the exception
}

ptr<Type> Block::checkTypeRequirements()
{
	for (ptr<Statement> const& statement : m_statements)
		statement->checkTypeRequirements();
	return ptr<Type>();
}

ptr<Type> IfStatement::checkTypeRequirements()
{
	expectType(*m_condition, BoolType());
	m_trueBody->checkTypeRequirements();
	if (m_falseBody) m_falseBody->checkTypeRequirements();
	return ptr<Type>();
}

ptr<Type> WhileStatement::checkTypeRequirements()
{
	expectType(*m_condition, BoolType());
	m_body->checkTypeRequirements();
	return ptr<Type>();
}

ptr<Type> Continue::checkTypeRequirements()
{
	return ptr<Type>();
}

ptr<Type> Break::checkTypeRequirements()
{
	return ptr<Type>();
}

ptr<Type> Return::checkTypeRequirements()
{
	BOOST_ASSERT(m_returnParameters != nullptr);
	if (m_returnParameters->getParameters().size() != 1)
		BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("Different number of arguments in "
															 "return statement than in returns "
															 "declaration."));
	// this could later be changed such that the paramaters type is an anonymous struct type,
	// but for now, we only allow one return parameter

	expectType(*m_expression, *m_returnParameters->getParameters().front()->getType());
	return ptr<Type>();
}

ptr<Type> VariableDefinition::checkTypeRequirements()
{
	// Variables can be declared without type (with "var"), in which case the first assignment
	// setsthe type.
	// Note that assignments before the first declaration are legal because of the special scoping
	// rules inherited from JavaScript.
	if (m_value) {
		if (m_variable->getType()) {
			expectType(*m_value, *m_variable->getType());
		} else {
			// no type declared and no previous assignment, infer the type
			m_variable->setType(m_value->checkTypeRequirements());
		}
	}
	return ptr<Type>();
}

ptr<Type> Assignment::checkTypeRequirements()
{
	//@todo lefthandside actually has to be assignable
	// add a feature to the type system to check that
	expectType(*m_rightHandSide, *m_leftHandSide->checkTypeRequirements());
	m_type = m_leftHandSide->getType();
	if (m_assigmentOperator != Token::ASSIGN) {
		// complex assignment
		if (!m_type->acceptsBinaryOperator(Token::AssignmentToBinaryOp(m_assigmentOperator)))
			BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("Operator not compatible with type."));
	}
	return m_type;
}

ptr<Type> UnaryOperation::checkTypeRequirements()
{
	// INC, DEC, NOT, BIT_NOT, DELETE
	m_type = m_subExpression->checkTypeRequirements();
	if (m_type->acceptsUnaryOperator(m_operator))
		BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("Unary operator not compatible with type."));
	return m_type;
}

ptr<Type> BinaryOperation::checkTypeRequirements()
{
	m_right->checkTypeRequirements();
	m_left->checkTypeRequirements();

	if (m_right->getType()->isImplicitlyConvertibleTo(*m_left->getType()))
		m_commonType = m_left->getType();
	else if (m_left->getType()->isImplicitlyConvertibleTo(*m_right->getType()))
		m_commonType = m_right->getType();
	else
		BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("No common type found in binary operation."));

	if (Token::IsCompareOp(m_operator)) {
		m_type = std::make_shared<BoolType>();
	} else {
		BOOST_ASSERT(Token::IsBinaryOp(m_operator));
		m_type = m_commonType;
		if (!m_commonType->acceptsBinaryOperator(m_operator))
			BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("Operator not compatible with type."));
	}
	return m_type;
}

ptr<Type> FunctionCall::checkTypeRequirements()
{
	m_expression->checkTypeRequirements();
	for (ptr<Expression> const& argument : m_arguments)
		argument->checkTypeRequirements();

	ptr<Type> expressionType = m_expression->getType();
	Type::Category const category = expressionType->getCategory();
	if (category == Type::Category::TYPE) {
		TypeType* type = dynamic_cast<TypeType*>(expressionType.get());
		BOOST_ASSERT(type != nullptr);
		//@todo for structs, we have to check the number of arguments to be equal to the
		// number of non-mapping members
		if (m_arguments.size() != 1)
			BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("More than one argument for "
																 "explicit type conersion."));
		if (!m_arguments.front()->getType()->isExplicitlyConvertibleTo(*type->getActualType()))
			BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("Explicit type conversion not "
																 "allowed."));
		m_type = type->getActualType();
	} else if (category == Type::Category::FUNCTION) {
		//@todo would be nice to create a struct type from the arguments
		// and then ask if that is implicitly convertible to the struct represented by the
		// function parameters
		FunctionType* function = dynamic_cast<FunctionType*>(expressionType.get());
		BOOST_ASSERT(function != nullptr);
		FunctionDefinition const& fun = function->getFunction();
		vecptr<VariableDeclaration> const& parameters = fun.getParameters();
		if (parameters.size() != m_arguments.size())
			BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("Wrong argument count for "
																 "function call."));
		for (size_t i = 0; i < m_arguments.size(); ++i) {
			if (!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameters[i]->getType()))
				BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("Invalid type for argument in "
																	 "function call."));
		}

		// @todo actually the return type should be an anonymous struct,
		// but we change it to the type of the first return value until we have structs
		if (fun.getReturnParameterList()->getParameters().empty())
			m_type = std::make_shared<VoidType>();
		else
			m_type = fun.getReturnParameterList()->getParameters().front()->getType();
	} else {
		BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("Type does not support invocation."));
	}
	return m_type;
}

ptr<Type> MemberAccess::checkTypeRequirements()
{
	BOOST_ASSERT(false); // not yet implemented
	// m_type = ;
	return m_type;
}

ptr<Type> IndexAccess::checkTypeRequirements()
{
	BOOST_ASSERT(false); // not yet implemented
	// m_type = ;
	return m_type;
}

ptr<Type> Identifier::checkTypeRequirements()
{
	BOOST_ASSERT(m_referencedDeclaration != nullptr);
	//@todo these dynamic casts here are not really nice...
	// is i useful to have an AST visitor here?
	// or can this already be done in NameAndTypeResolver?
	// the only problem we get there is that in
	// var x;
	// x = 2;
	// var y = x;
	// the type of x is not yet determined.
	VariableDeclaration* variable = dynamic_cast<VariableDeclaration*>(m_referencedDeclaration);
	if (variable != nullptr) {
		if (variable->getType().get() == nullptr)
			BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("Variable referenced before type "
																 "could be determined."));
		m_type = variable->getType();
		return m_type;
	}
	//@todo can we unify these with TypeName::toType()?
	StructDefinition* structDef = dynamic_cast<StructDefinition*>(m_referencedDeclaration);
	if (structDef != nullptr) {
		// note that we do not have a struct type here
		m_type = std::make_shared<TypeType>(std::make_shared<StructType>(*structDef));
		return m_type;
	}
	FunctionDefinition* functionDef = dynamic_cast<FunctionDefinition*>(m_referencedDeclaration);
	if (functionDef != nullptr) {
		// a function reference is not a TypeType, because calling a TypeType converts to the type.
		// Calling a function (e.g. function(12), otherContract.function(34)) does not do a type
		// conversion.
		m_type = std::make_shared<FunctionType>(*functionDef);
		return m_type;
	}
	ContractDefinition* contractDef = dynamic_cast<ContractDefinition*>(m_referencedDeclaration);
	if (contractDef != nullptr) {
		m_type = std::make_shared<TypeType>(std::make_shared<ContractType>(*contractDef));
		return m_type;
	}
	BOOST_ASSERT(false); // declaration reference of unknown/forbidden type
	return m_type;
}

ptr<Type> ElementaryTypeNameExpression::checkTypeRequirements()
{
	m_type = std::make_shared<TypeType>(Type::fromElementaryTypeName(m_typeToken));
	return m_type;
}

ptr<Type> Literal::checkTypeRequirements()
{
	m_type = Type::forLiteral(*this);
	return m_type;
}

} }