/**
  *
  *                  OOAS Compiler - C++ AST
  *
  * Copyright 2015, AIT Austrian Institute of Technology.
  * All rights reserved.
  *
  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.
  *
  * If you modify the file please update the list of contributors below to in-
  * clude your name. Please also stick to the coding convention of using TABs
  * to do the basic (block-level) indentation and spaces for anything after
  * that. (Enable the display of special chars and it should be pretty obvious
  * what this means.) Also, remove all trailing whitespace.
  *
  * Contributors:
  *               Willibald Krenn (AIT)
  *               Stephan Zimmerer (AIT)
  *               Christoph Czurda (AIT)
  *
  */



#pragma once

#include <ast/CompleteAstTraversalVisitor.hpp>
#include <ast/Ast.hpp>
#include <unordered_map>
#include <ast/expressions/Quantifier.hpp>

namespace Ast {

/**
 * Based on the OoaDeepCloneVisitor from the Java frontend. Takes a shallow
 * copy of an AST element and makes it a deep copy.
 */
class DeepCloneVisitor final :
	public CompleteAstTraversalVisitor
{
protected:
	Ast* m_cloneAst;
	std::unordered_map<void*, void*> m_mapping;
	Identifier* m_selfreplacement;
	bool m_allowLinksToNonClonedParents;
	bool m_quantifierState;

	void updateScope(IScope* aScope);
	void checkScope(IScope* aScope);
	Expression* eClone(Expression* anExpr);
	Statement* sClone(Statement* aStatement);
	void symTabClone(SymbolTable* aTable);
	void cloneBlock(Block* aBlock);
	void cloneQuantifier(Quantifier* qf);
	void cloneExpressionList(ExpressionList& aList);

	void error() {
		m_context->logError("Internal error: Cannot clone a type");
		abort();
	}

public:
	DeepCloneVisitor(
			CallContext* context,
			Ast* cloneAst,
			bool linksToNonClonedParents = true,
			const std::unordered_map<void*, void*>* initMapping = nullptr,
			Identifier* selfreplace = nullptr)
	:
		CompleteAstTraversalVisitor( context, false),
		m_cloneAst (cloneAst),
		m_mapping(),
		m_selfreplacement (selfreplace),
		m_allowLinksToNonClonedParents (linksToNonClonedParents),
		m_quantifierState (false)
	{
		if (initMapping != nullptr)
			m_mapping.insert(initMapping->begin(), initMapping->end());
	}

	std::string returnVisitorName() override {return "DeepCloneVisitor";}

	void visit(BoolType* ) override         { error(); }
	void visit(EnumType* ) override         { error(); }
	void visit(FunctionType* ) override { error(); }
	void visit(IntType* ) override           { error(); }
	void visit(ListType* ) override         { error(); }
	void visit(NullType* ) override         { error(); }
	void visit(ActionSystemType* ) override       { error(); }
	void visit(TupleType* ) override                       { error(); }

	void visit(EnumIdentifier* ) override             { error(); }
	void visit(ExpressionVariableIdentifier* ) override { error(); }
	void visit(LocalVariableIdentifier* ) override           { error(); }
	void visit(MainModule* ) override                     { error(); }
	void visit(MethodIdentifier* ) override         { error(); }
	void visit(Module* ) override                             { error(); }
	void visit(NondetIdentifierBlock* ) override{ error(); }
	void visit(ParameterIdentifier* ) override   { error(); }
	void visit(PrioIdentifierBlock* ) override   { error(); }
	void visit(SeqIdentifierBlock* ) override      { error(); }
	void visit(TypeIdentifier* ) override             { error(); }
	void visit(UnspecIdentifierBlock* ) override { error(); }


	void visit(NamedActionIdentifier* namedActionIdentifier) override;
	void visit(ObjectConstructor* objectConstructor) override;


//	void visit(AbortStatement* abortStatement) override { }
	void visit(BoolValueExpression* ) override {};
	void visit(IntValueExpression* ) override  {};
	void visit(RefValueExpression* ) override  {};
	void visit(Skip* ) override { }
	void visit(Break* ) override { error(); }
	void visit(TypeExpression* ) override { /*we do not clone types*/ }


	void visit(NondetBlock* nondetBlock) override;
	void visit(SeqBlock* seqBlock) override;
	void visit(PrioBlock* prioBlock) override;
	void visit(AccessExpression* accessExpression) override;
	void visit(BinaryOperator* binaryOperator) override;
	void visit(Assignment* assignment) override;
	void visit(AttributeIdentifier* attributeIdentifier) override;
	void visit(Call* call) override;

	void visit(CallExpression* callExpression) override;
	void visit(ExistsQuantifier* quantifier) override;
	void visit(ForallQuantifier* quantifier) override;
	void visit(GuardedCommand* guardedCommand) override;
	void visit(IdentifierExpression* identifierExpression) override;
	void visit(ListConstructor* listConstructor) override;
	void visit(SetConstructor* setConstructor) override;
	void visit(TernaryOperator* ternaryOperator) override;
	void visit(TupleConstructor* tupleConstructor) override;
	void visit(TupleMapAccessExpression* tupleMapAccessExpression) override;
	void visit(UnaryOperator* unaryOperator) override;
};

} /* namespace Ast */