/*
	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.
 */

#pragma once

#include <string>
#include <vector>
#include <memory>

#include <libsolidity/BaseTypes.h>
#include <libsolidity/Token.h>

namespace dev {
namespace solidity {

// Used as pointers to AST nodes, to be replaced by more clever pointers, e.g. pointers which do
// not do reference counting but point to a special memory area that is completely released
// explicitly.
template <class T>
using ptr = std::shared_ptr<T>;
template <class T>
using vecptr = std::vector<ptr<T>>;

class VariableDeclaration;
class StructDefinition;
class FunctionDefinition;
class TypeName;
class Block;
class Expression;

class ASTNode
{
public:
	explicit ASTNode(Location const& _location)
		: m_location(_location)
	{}

	virtual ~ASTNode() {}

	Location getLocation() const { return m_location; }
private:
	Location m_location;
};

class ContractDefinition : public ASTNode
{
public:
	ContractDefinition(Location const& _location,
					   std::string const& _name,
					   vecptr<StructDefinition> const& _definedStructs,
					   vecptr<VariableDeclaration> const& _stateVariables,
					   vecptr<FunctionDefinition> const& _definedFunctions)
		: ASTNode(_location), m_name(_name),
		  m_definedStructs(_definedStructs),
		  m_stateVariables(_stateVariables),
		  m_definedFunctions(_definedFunctions)
	{}

private:
	std::string m_name;
	vecptr<StructDefinition> m_definedStructs;
	vecptr<VariableDeclaration> m_stateVariables;
	vecptr<FunctionDefinition> m_definedFunctions;
};

class StructDefinition : public ASTNode
{
public:
	StructDefinition(Location const& _location,
					 std::string const& _name,
					 vecptr<VariableDeclaration> const& _members)
		: ASTNode(_location), m_name(_name), m_members(_members)
	{}
private:
	std::string m_name;
	vecptr<VariableDeclaration> m_members;
};

/// Used as function parameter list and return list
/// None of the parameters is allowed to contain mappings (not even recursively
/// inside structs)
class ParameterList : public ASTNode
{
public:
	ParameterList(Location const& _location, vecptr<VariableDeclaration> const& _parameters)
		: ASTNode(_location), m_parameters(_parameters)
	{}
private:
	vecptr<VariableDeclaration> m_parameters;
};

class FunctionDefinition : public ASTNode
{
public:
	FunctionDefinition(Location const& _location, std::string const& _name, bool _isPublic,
					   ptr<ParameterList> const& _parameters,
					   bool _isDeclaredConst,
					   ptr<ParameterList> const& _returnParameters,
					   ptr<Block> const& _body)
		: ASTNode(_location), m_name(_name), m_isPublic(_isPublic), m_parameters(_parameters),
		  m_isDeclaredConst(_isDeclaredConst), m_returnParameters(_returnParameters),
		  m_body(_body)
	{}
private:
	std::string m_name;
	bool m_isPublic;
	ptr<ParameterList> m_parameters;
	bool m_isDeclaredConst;
	ptr<ParameterList> m_returnParameters;
	ptr<Block> m_body;
};

class VariableDeclaration : public ASTNode
{
public:
	VariableDeclaration(Location const& _location,
						ptr<TypeName> const& _type,
						std::string const& _name)
		: ASTNode(_location), m_type(_type), m_name(_name)
	{}
private:
	ptr<TypeName> m_type; ///< can be empty ("var")
	std::string m_name;
};

/// types
/// @{

class TypeName : public ASTNode
{
public:
	explicit TypeName(Location const& _location) : ASTNode(_location) {}
};

/// any pre-defined type that is not a mapping
class ElementaryTypeName : public TypeName
{
public:
	explicit ElementaryTypeName(Location const& _location, Token::Value _type)
		: TypeName(_location), m_type(_type)
	{}
private:
	Token::Value m_type;
};

class UserDefinedTypeName : public TypeName
{
public:
	UserDefinedTypeName(Location const& _location, std::string const& _name)
		: TypeName(_location), m_name(_name)
	{}
private:
	std::string m_name;
};

class Mapping : public TypeName
{
public:
	Mapping(Location const& _location, ptr<ElementaryTypeName> const& _keyType,
			ptr<TypeName> const& _valueType)
		: TypeName(_location), m_keyType(_keyType), m_valueType(_valueType)
	{}
private:
	ptr<ElementaryTypeName> m_keyType;
	ptr<TypeName> m_valueType;
};

/// @}

/// Statements
/// @{

class Statement : public ASTNode
{
public:
	explicit Statement(Location const& _location) : ASTNode(_location) {}
};

class Block : public Statement
{
public:
	Block(Location const& _location, vecptr<Statement> const& _statements)
		: Statement(_location), m_statements(_statements)
	{}
private:
	vecptr<Statement> m_statements;
};

class IfStatement : public Statement
{
public:
	IfStatement(Location const& _location, ptr<Expression> const& _condition,
				ptr<Statement> const& _trueBody, ptr<Statement> const& _falseBody)
		: Statement(_location), m_condition(_condition),
		  m_trueBody(_trueBody), m_falseBody(_falseBody)
	{}
private:
	ptr<Expression> m_condition;
	ptr<Statement> m_trueBody;
	ptr<Statement> m_falseBody;
};

class BreakableStatement : public Statement
{
public:
	BreakableStatement(Location const& _location) : Statement(_location) {}
};

class WhileStatement : public BreakableStatement
{
public:
	WhileStatement(Location const& _location, ptr<Expression> const& _condition,
				   ptr<Statement> const& _body)
		: BreakableStatement(_location), m_condition(_condition), m_body(_body)
	{}
private:
	ptr<Expression> m_condition;
	ptr<Statement> m_body;
};

class Continue : public Statement
{
public:
	Continue(Location const& _location) : Statement(_location) {}
};

class Break : public Statement
{
public:
	Break(Location const& _location) : Statement(_location) {}
};

class Return : public Statement
{
public:
	Return(Location const& _location, ptr<Expression> _expression)
		: Statement(_location), m_expression(_expression)
	{}
private:
	ptr<Expression> m_expression;
};

class VariableDefinition : public Statement
{
public:
	VariableDefinition(Location const& _location, ptr<VariableDeclaration> _variable,
					   ptr<Expression> _value)
		: Statement(_location), m_variable(_variable), m_value(_value)
	{}
private:
	ptr<VariableDeclaration> m_variable;
	ptr<Expression> m_value; ///< can be missing
};

class Expression : public Statement
{
public:
	Expression(Location const& _location) : Statement(_location) {}
};

/// @}

/// Expressions
/// @{

class Assignment : public Expression
{
public:
	Assignment(Location const& _location, ptr<Expression> const& _leftHandSide,
			   Token::Value _assignmentOperator, ptr<Expression> const& _rightHandSide)
		: Expression(_location), m_leftHandSide(_leftHandSide),
		  m_assigmentOperator(_assignmentOperator), m_rightHandSide(_rightHandSide)
	{}
private:
	ptr<Expression> m_leftHandSide;
	Token::Value m_assigmentOperator;
	ptr<Expression> m_rightHandSide;
};

class UnaryOperation : public Expression
{
public:
	UnaryOperation(Location const& _location, Token::Value _operator,
				   ptr<Expression> const& _subExpression, bool _isPrefix)
		: Expression(_location), m_operator(_operator),
		  m_subExpression(_subExpression), m_isPrefix(_isPrefix)
	{}

private:
	Token::Value m_operator;
	ptr<Expression> m_subExpression;
	bool m_isPrefix;
};

class BinaryOperation : public Expression
{
public:
	BinaryOperation(Location const& _location, ptr<Expression> const& _left,
					Token::Value _operator, ptr<Expression> const& _right)
		: Expression(_location), m_left(_left), m_operator(_operator), m_right(_right)
	{}
private:
	ptr<Expression> m_left;
	Token::Value m_operator;
	ptr<Expression> m_right;
};

/// Can be ordinary function call, type cast or struct construction.
class FunctionCall : public Expression
{
public:
	FunctionCall(Location const& _location, ptr<Expression> const& _expression,
				 vecptr<Expression> const& _arguments)
		: Expression(_location), m_expression(_expression), m_arguments(_arguments)
	{}
private:
	ptr<Expression> m_expression;
	vecptr<Expression> m_arguments;
};

class MemberAccess : public Expression
{
public:
	MemberAccess(Location const& _location, ptr<Expression> _expression,
				 std::string const& _memberName)
		: Expression(_location), m_expression(_expression), m_memberName(_memberName)
	{}
private:
	ptr<Expression> m_expression;
	std::string m_memberName;
};

class IndexAccess : public Expression
{
public:
	IndexAccess(Location const& _location, ptr<Expression> const& _base,
				ptr<Expression> const& _index)
		: Expression(_location), m_base(_base), m_index(_index)
	{}
private:
	ptr<Expression> m_base;
	ptr<Expression> m_index;
};

class PrimaryExpression : public Expression
{
public:
	PrimaryExpression(Location const& _location) : Expression(_location) {}
};

class Identifier : public PrimaryExpression
{
public:
	Identifier(Location const& _location, std::string const& _name)
		: PrimaryExpression(_location), m_name(_name) {}
private:
	std::string m_name;
};

class ElementaryTypeNameExpression : public PrimaryExpression
{
public:
	ElementaryTypeNameExpression(Location const& _location, Token::Value _type)
		: PrimaryExpression(_location), m_type(_type) {}
private:
	Token::Value m_type;
};

class Literal : public PrimaryExpression
{
public:
	Literal(Location const& _location, Token::Value _token, std::string const& _value)
		: PrimaryExpression(_location), m_token(_token), m_value(_value)
	{}
private:
	Token::Value m_token;
	std::string m_value;
};

/// @}


} }