/**
  *
  *                      OOAS Compiler (Deprecated)
  *
  * Copyright 2015, Institute for Software Technology, Graz University of
  * Technology. Portions are copyright 2015 by the AIT Austrian Institute
  * of Technology. All rights reserved.
  *
  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.
  *
  * Please notice that this version of the OOAS compiler is considered de-
  * precated. Only the Java version is maintained.
  *
  * Contributors:
  *               Willibald Krenn (TU Graz/AIT)
  *               Stefan Tiran (TU Graz/AIT)
  */

using System;
using System.Collections.Generic;
using System.Text;

namespace TUG.Mogentes
{
    /*Notice: The visitor must implement the traversal!*/
    public interface IAstVisitor
    {
        string returnVisitorName();

        /*Identifiers*/
        void visit(EnumIdentifier enumIdentifier);
        void visit(LandmarkIdentifier landmarkIdentifier);
        void visit(AttributeIdentifier attributeIdentifier);
        void visit(ExpressionVariableIdentifier expressionVariableIdentifier);
        void visit(ParameterIdentifier parameterIdentifier);
        void visit(LocalVariableIdentifier localVariableIdentifier);
        void visit(TypeIdentifier typeIdentifier);
        void visit(SelfTypeIdentifier typeIdentifier);
        void visit(MethodIdentifier methodIdentifier);
        void visit(NamedActionIdentifier namedActionIdentifier);
        void visit(MainModule mainModule);
        void visit(Module module);
        void visit(NondetIdentifierList nondetIdentifierList);
        void visit(SeqIdentifierList seqIdentifierList);
        void visit(PrioIdentifierList prioIdentifierList);
        void visit(UnspecIdentifierList unspecIdentifierList);


        /*Statements*/
        void visit(NondetBlock nondetBlock);
        void visit(SeqBlock seqBlock);
        void visit(PrioBlock prioBlock);
        void visit(GuardedCommand guardedCommand);
        void visit(Assignment assignment);
        void visit(Call call);
        void visit(SkipStatement skipStatement);
        void visit(AbortStatement abortStatement);
        void visit(KillStatement killStatement);


        /*Expressions*/
        void visit<T>(ValueExpression<T> valueExpression);
        void visit(UnresolvedIdentifierExpression unresolvedIdentifierExpression);
        void visit(IdentifierExpression identifierExpression);
        void visit(ListConstructor listConstructor);
        void visit(SetConstructor setConstructor);
        void visit(MapConstructor mapConstructor);
        void visit(TupleConstructor tupleConstructor);
        void visit(AccessExpression accessExpression);
        void visit(BinaryOperator binaryOperator);
        void visit(TernaryOperator ternaryOperator);
        void visit(TupleMapAccessExpression tupleMapAccessExpression);
        void visit(CallExpression callExpression);
        void visit(ForallQuantifier quantifier);
        void visit(ExistsQuantifier quantifier);
        void visit(UnaryOperator unaryOperator);
        void visit(TypeExpression typeExpression);
        void visit(NullType nullType);

        /*Types*/
        void visit(CharType charType);
        void visit(IntType intType);
        void visit(BoolType boolType);
        void visit(FloatType floatType);
        void visit(EnumType enumType);
        void visit(ListType listType);
        void visit(MapType mapType);
        void visit(QrType qrType);
        void visit(TupleType tupleType);
        void visit(FunctionType functionType);
        void visit(OoActionSystemType ooActionSystemType);
        void visit(OpaqueType opaqueType);

        void visit(AnyType anyType);

        void visit(ObjectConstructor objectConstructor);

        void visit(QValConstructor qValConstructor);

        void visit(QualitativeConstraintStatement qalitativeConstraintStatement);

        void visit(ConstantIdentifier constantIdentifier);
    }

    public delegate IAstVisitor CreateVisitor(ParserState aState);

    public abstract class OoaCompleteAstTraversalVisitor : IAstVisitor
    {
        protected C5.HashSet<object> m_visited = new C5.HashSet<object>();
        protected ParserState m_ParserState;
        protected bool m_DuplicateVisit;

        protected void VisitSub(IAst subElement, IAst parent)
        {
            if (subElement == null)
                return;
            if (m_visited.Contains(subElement))
                return;
            if (!(subElement is OpaqueType) && !m_DuplicateVisit)
                m_visited.Add(subElement);
            VisitAstElement(subElement, parent);
        }

        /// <summary>
        ///  Is called once per Ast element. Makes sense to override it in a 
        ///  subclass..
        /// </summary>
        /// <param name="element">to be visited</param>
        /// <param name="parent">parent of the element in the ast</param>
        protected virtual void VisitAstElement(IAst element, IAst parent)
        {
            element.Accept(this);
        }

        public OoaCompleteAstTraversalVisitor(ParserState aState)
        {
            m_ParserState = aState;
        }

        public OoaCompleteAstTraversalVisitor(ParserState aState, bool completeTraversal)
            : this(aState)
        {
            m_DuplicateVisit = completeTraversal;
        }

        public string returnVisitorName()
        {
            return this.GetType().ToString();
        }

        public override string ToString()
        {
            return returnVisitorName();
        }

        public virtual void visit(EnumIdentifier enumIdentifier)
        {
            VisitSub(enumIdentifier.type, enumIdentifier);
        }

        public virtual void visit(ConstantIdentifier constantIdentifier)
        {
            if (constantIdentifier.type != null)
                VisitSub(constantIdentifier.type, constantIdentifier);
            VisitSub(constantIdentifier.Value, constantIdentifier);
        }


        public virtual void visit(LandmarkIdentifier landmarkIdentifier)
        {
            VisitSub(landmarkIdentifier.type, landmarkIdentifier);
        }

        public virtual void visit(AttributeIdentifier attributeIdentifier)
        {
            VisitSub(attributeIdentifier.type, attributeIdentifier);
            VisitSub(attributeIdentifier.initializer, attributeIdentifier);
        }

        public virtual void visit(ExpressionVariableIdentifier expressionVariableIdentifier)
        {
            VisitSub(expressionVariableIdentifier.type, expressionVariableIdentifier);
        }

        public virtual void visit(ParameterIdentifier parameterIdentifier)
        {
            VisitSub(parameterIdentifier.type, parameterIdentifier);
        }

        public virtual void visit(LocalVariableIdentifier localVariableIdentifier)
        {
            VisitSub(localVariableIdentifier.type, localVariableIdentifier);
        }

        public virtual void visit(TypeIdentifier typeIdentifier)
        {
            VisitSub(typeIdentifier.type, typeIdentifier);
        }

        public virtual void visit(SelfTypeIdentifier aself)
        {
            visit((TypeIdentifier)aself);
        }

        public virtual void visit(MethodIdentifier methodIdentifier)
        {
            VisitSub(methodIdentifier.type, methodIdentifier);
            foreach (var sym in methodIdentifier.symbolTable.symbolList)
                VisitSub(sym, methodIdentifier);
            foreach (var par in methodIdentifier.parameter)
                VisitSub(par, methodIdentifier);
            VisitSub(methodIdentifier.body, methodIdentifier);
        }

        public virtual void visit(NamedActionIdentifier namedActionIdentifier)
        {
            VisitSub(namedActionIdentifier.type, namedActionIdentifier);
            foreach (var sym in namedActionIdentifier.symbolTable.symbolList)
                VisitSub(sym, namedActionIdentifier);
            foreach (var par in namedActionIdentifier.parameter)
                VisitSub(par, namedActionIdentifier);
            VisitSub(namedActionIdentifier.body, namedActionIdentifier);
        }

        public virtual void visit(MainModule mainModule)
        {
            foreach (var sym in mainModule.symbolTable.symbolList)
                VisitSub(sym, mainModule);
            bool haveInstance = mainModule.instance != null;
            if (haveInstance)
                VisitSub(mainModule.instance, mainModule);
            else
                VisitSub(mainModule.systemDescription, mainModule);
        }

        public virtual void visit(Module module)
        {
            foreach (var sym in module.symbolTable.symbolList)
                VisitSub(sym, module);
        }

        public virtual void visit(NondetIdentifierList nondetIdentifierList)
        {
            foreach (var id in nondetIdentifierList.identifiers)
                VisitSub(id, nondetIdentifierList);
        }

        public virtual void visit(SeqIdentifierList seqIdentifierList)
        {
            foreach (var id in seqIdentifierList.identifiers)
                VisitSub(id, seqIdentifierList);
        }

        public virtual void visit(PrioIdentifierList prioIdentifierList)
        {
            foreach (var id in prioIdentifierList.identifiers)
                VisitSub(id, prioIdentifierList);
        }

        public virtual void visit(UnspecIdentifierList unspecIdentifierList)
        {
            foreach (var id in unspecIdentifierList.identifiers)
                VisitSub(id, unspecIdentifierList);
        }

        public virtual void visit(NondetBlock nondetBlock)
        {
            foreach (var id in nondetBlock.symbols.symbolList)
                VisitSub(id, nondetBlock);

            foreach (var stmnt in nondetBlock.statements)
                VisitSub(stmnt, nondetBlock);
        }

        public virtual void visit(SeqBlock seqBlock)
        {
            foreach (var id in seqBlock.symbols.symbolList)
                VisitSub(id, seqBlock);

            if (seqBlock.filter != null)
                VisitSub(seqBlock.filter, seqBlock);

            foreach (var stmnt in seqBlock.statements)
                VisitSub(stmnt, seqBlock);
        }

        public virtual void visit(PrioBlock prioBlock)
        {
            foreach (var id in prioBlock.symbols.symbolList)
                VisitSub(id, prioBlock);

            foreach (var stmnt in prioBlock.statements)
                VisitSub(stmnt, prioBlock);
        }

        public virtual void visit(GuardedCommand guardedCommand)
        {
            VisitSub(guardedCommand.guard, guardedCommand);
            VisitSub(guardedCommand.body, guardedCommand);
        }

        public virtual void visit(Assignment assignment)
        {
            foreach (var vexp in assignment.places)
                VisitSub(vexp, assignment);
            foreach (var expr in assignment.values)
                VisitSub(expr, assignment);

            VisitSub(assignment.nondetExpression, assignment);
        }

        public virtual void visit(Call call)
        {
            VisitSub(call.callExpression, call);
        }

        public virtual void visit(SkipStatement skipStatement)
        { }

        public virtual void visit(AbortStatement abortStatement)
        { }

        public virtual void visit(KillStatement killStatement)
        {
            VisitSub(killStatement.someOne, killStatement);
        }

        public virtual void visit<T>(ValueExpression<T> valueExpression)
        { }

        public virtual void visit(UnresolvedIdentifierExpression unresolvedIdentifierExpression)
        {
            VisitSub(unresolvedIdentifierExpression.type, unresolvedIdentifierExpression);
        }

        public virtual void visit(IdentifierExpression identifierExpression)
        {
            VisitSub(identifierExpression.type, identifierExpression);
            VisitSub(identifierExpression.identifier, identifierExpression);
        }

        public virtual void visit(TypeExpression typeExpression)
        {
            VisitSub(typeExpression.type, typeExpression);
        }

        public virtual void visit(ListConstructor listConstructor)
        {
            foreach (var lvar in listConstructor.comprehensionVariables.symbolList)
                VisitSub(lvar, listConstructor);

            foreach (var elems in listConstructor.elements)
                VisitSub(elems, listConstructor);

            if (listConstructor.comprehension != null)
                VisitSub(listConstructor.comprehension, listConstructor);
        }

        public virtual void visit(SetConstructor setConstructor)
        {
            foreach (var svar in setConstructor.comprehensionVariables.symbolList)
                VisitSub(svar, setConstructor);

            foreach (var elems in setConstructor.items)
                VisitSub(elems, setConstructor);

            VisitSub(setConstructor.comprehension, setConstructor);
        }

        public virtual void visit(MapConstructor mapConstructor)
        {
            /*foreach (var lvar in mapConstructor.localVariables.symbolList)
                VisitSub(lvar, mapConstructor);*/

            foreach (var elem in mapConstructor.items)
            {
                VisitSub(elem.key, mapConstructor);
                VisitSub(elem.value, mapConstructor);
            }
        }

        public virtual void visit(TupleConstructor tupleConstructor)
        {
            /*foreach (var lvar in tupleConstructor.localVariables.symbolList)
                VisitSub(lvar, tupleConstructor);*/

            foreach (var elem in tupleConstructor.values)
                VisitSub(elem, tupleConstructor);
        }

        public virtual void visit(AccessExpression accessExpression)
        {
            VisitSub(accessExpression.left, accessExpression);
            VisitSub(accessExpression.right, accessExpression);
        }

        public virtual void visit(BinaryOperator binaryOperator)
        {
            VisitSub(binaryOperator.left, binaryOperator);
            VisitSub(binaryOperator.right, binaryOperator);
        }

        public virtual void visit(TernaryOperator ternaryOperator)
        {
            VisitSub(ternaryOperator.left, ternaryOperator);
            VisitSub(ternaryOperator.mid, ternaryOperator);
            VisitSub(ternaryOperator.right, ternaryOperator);
        }

        public virtual void visit(TupleMapAccessExpression tupleMapAccessExpression)
        {
            VisitSub(tupleMapAccessExpression.argument, tupleMapAccessExpression);
            VisitSub(tupleMapAccessExpression.child, tupleMapAccessExpression);
        }

        public virtual void visit(CallExpression callExpression)
        {
            if (callExpression.arguments != null)
                foreach (var arg in callExpression.arguments)
                    VisitSub(arg, callExpression);
            VisitSub(callExpression.child, callExpression);
        }

        public virtual void visit(ForallQuantifier quantifier)
        {
            foreach (var lvar in quantifier.symbols.symbolList)
                VisitSub(lvar, quantifier);

            VisitSub(quantifier.child, quantifier);
        }

        public virtual void visit(ExistsQuantifier quantifier)
        {
            foreach (var lvar in quantifier.symbols.symbolList)
                VisitSub(lvar, quantifier);

            VisitSub(quantifier.child, quantifier);
        }

        public virtual void visit(UnaryOperator unaryOperator)
        {
            VisitSub(unaryOperator.child, unaryOperator);
            if (unaryOperator.kind == ExpressionKind.Cast)
                VisitSub(unaryOperator.type, unaryOperator);
        }



        public virtual void visit(CharType charType)
        {
        }

        public virtual void visit(IntType intType)
        {
        }

        public virtual void visit(BoolType boolType)
        {
        }

        public virtual void visit(FloatType floatType)
        {
        }

        public virtual void visit(EnumType enumType)
        {
            foreach (var sym in enumType.listOfEnumSymbols)
                VisitSub(sym, enumType);
        }

        public virtual void visit(ListType listType)
        {
            VisitSub(listType.innerType, listType);
        }

        public virtual void visit(MapType mapType)
        {
            VisitSub(mapType.fromType, mapType);
            VisitSub(mapType.toType, mapType);
        }

        public virtual void visit(QrType qrType)
        {
            foreach (var m in qrType.landmarks)
                VisitSub(m, qrType);
        }

        public virtual void visit(TupleType tupleType)
        {
            foreach (var t in tupleType.innerTypes)
                VisitSub(t, tupleType);
        }

        public virtual void visit(FunctionType functionType)
        {
            foreach (var a in functionType.parameter)
                VisitSub(a, functionType);
            VisitSub(functionType.returnType, functionType);
        }

        public virtual void visit(OoActionSystemType ooActionSystemType)
        {
            foreach (var s in ooActionSystemType.symbols.symbolList)
                VisitSub(s, ooActionSystemType);

            VisitSub(ooActionSystemType.doOdBlock, ooActionSystemType);
        }

        public virtual void visit(OpaqueType opaqueType)
        {
            VisitSub(opaqueType.resolvedType, opaqueType);
        }

        public virtual void visit(NullType nullType)
        { }

        public virtual void visit(AnyType anyType)
        { }

        public virtual void visit(ObjectConstructor objectConstructor)
        {
            VisitSub(objectConstructor.type, objectConstructor);
        }

        public virtual void visit(QValConstructor qValConstructor)
        {
        }

        public virtual void visit(QualitativeConstraintStatement qalitativeConstraintStatement)
        {
            VisitSub(qalitativeConstraintStatement.variable0, qalitativeConstraintStatement);
            VisitSub(qalitativeConstraintStatement.variable1, qalitativeConstraintStatement);
            if (qalitativeConstraintStatement.variable2 != null)
                VisitSub(qalitativeConstraintStatement.variable2, qalitativeConstraintStatement);
        }

    }



    /// <summary>
    /// Visitor that restricts itself to expressions
    /// </summary>
    public class OoaExpressionVisitor : OoaCompleteAstTraversalVisitor
    {

        protected override void VisitAstElement(IAst element, IAst parent)
        {
            // we are only interested in an expression.
            if (element.nodeType == AstNodeTypeEnum.expression)
                base.VisitAstElement(element, parent);
        }

        public OoaExpressionVisitor()
            : base(null)
        { }

    }

    /// <summary>
    /// Visitor that restricts itself to statements
    /// </summary>
    public class OoaStatementVisitor : OoaCompleteAstTraversalVisitor
    {
        protected override void VisitAstElement(IAst element, IAst parent)
        {
            // we are only interested in an expression.
            if (element.nodeType == AstNodeTypeEnum.statement)
                base.VisitAstElement(element, parent);
        }

        public OoaStatementVisitor()
            : base(null)
        { }

    }



    /// <summary>
    /// Visitor that restricts itself to types
    /// </summary>
    public class OoaTypeVisitor : OoaCompleteAstTraversalVisitor
    {
        protected override void VisitAstElement(IAst element, IAst parent)
        {
            // we are only interested in an expression.
            if (element.nodeType == AstNodeTypeEnum.type)
                base.VisitAstElement(element, parent);
        }

        public OoaTypeVisitor()
            : base(null)
        { }
    }


    /// <summary>
    /// Visitor that restricts itself to identifier
    /// </summary>
    public class OoaIdentifierVisitor : OoaCompleteAstTraversalVisitor
    {
        protected override void VisitAstElement(IAst element, IAst parent)
        {
            // we are only interested in an expression.
            if (element.nodeType == AstNodeTypeEnum.identifier)
                base.VisitAstElement(element, parent);
        }

        public OoaIdentifierVisitor()
            : base(null)
        { }

    }



}