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


namespace TUG.Mogentes
{
    public enum StatementKind
    {
        GuardedCommand,
        MethodCall,
        Assignment,
        SeqBlock,
        NondetBlock,
        PrioBlock,
        Skip, Abort, Kill,
        QualConstraint
    }


    ///////////////////////////////////////////////
    ///  basic Statement
    ///  
    public abstract class Statement : UlyssesBasicClass, IAst
    {
        private StatementKind m_kind;
        private int m_line;
        private int m_pos;

        public StatementKind kind { get { return m_kind; } }
        public int line { get { return m_line; } }
        public int pos { get { return m_pos; } }

        public Statement(StatementKind aKind, int aline, int apos)
        {
            m_kind = aKind;
            m_line = aline;
            m_pos = apos;
        }

        public Statement(Statement toCopy)
        {
            m_kind = toCopy.m_kind;
            m_line = toCopy.m_line;
            m_pos = toCopy.m_pos;
        }

        public virtual Statement Clone()
        {
            throw new NotImplementedException();
        }

        public AstNodeTypeEnum nodeType { get { return AstNodeTypeEnum.statement; } }

        public virtual void Accept(IAstVisitor visitor)
        {
            throw new NotImplementedException();
        }
    }


    ///////////////////////////////////////////////
    ///  Qualitative Constraints
    ///  
    public enum QualitativeConstraintOperation { Equal, Deriv, Sum, Prod, Diff }
    public sealed class QualitativeConstraintStatement : Statement
    {
        private Identifier m_variable0;
        private Identifier m_variable1;
        private Identifier m_variable2;
        private QualitativeConstraintOperation m_operation;
        public bool tag = false; // says that this is an obs assignment (important for prolog code target)

        public Identifier variable0 { get { return m_variable0; } }
        public Identifier variable1 { get { return m_variable1; } }
        public Identifier variable2 { get { return m_variable2; } }
        public QualitativeConstraintOperation operation { get { return m_operation; } }

        public QualitativeConstraintStatement(Identifier var0, Identifier var1, QualitativeConstraintOperation op, int aline, int apos)
            : base(StatementKind.QualConstraint, aline, apos)
        {
            if (op == QualitativeConstraintOperation.Diff
                || op == QualitativeConstraintOperation.Prod
                || op == QualitativeConstraintOperation.Sum)
                throw new ArgumentException();
            m_variable0 = var0;
            m_variable1 = var1;
            m_variable2 = null;
            m_operation = op;
        }

        public QualitativeConstraintStatement(QualitativeConstraintStatement toCopy)
            : base(toCopy)
        {
            m_variable0 = toCopy.m_variable0;
            m_variable1 = toCopy.m_variable1;
            m_variable2 = toCopy.m_variable2;
            m_operation = toCopy.m_operation;
            tag = toCopy.tag;
        }


        public QualitativeConstraintStatement(Identifier var0, Identifier var1, Identifier var2, QualitativeConstraintOperation op, int aline, int apos)
            : base(StatementKind.QualConstraint, aline, apos)
        {
            if (op == QualitativeConstraintOperation.Deriv
                || op == QualitativeConstraintOperation.Equal)
                throw new ArgumentException();
            m_variable0 = var0;
            m_variable1 = var1;
            m_variable2 = var2;
            m_operation = op;
        }

        public override void Accept(IAstVisitor visitor)
        {
            visitor.visit(this);
        }

        public override Statement Clone()
        {
            return new QualitativeConstraintStatement(this);
        }

        public void SetVariable0(Identifier newVal)
        {
            m_variable0 = newVal;
        }

        public void SetVariable1(Identifier newVal)
        {
            m_variable1 = newVal;
        }

        public void SetVariable2(Identifier newVal)
        {
            m_variable2 = newVal;
        }
    }

    ///////////////////////////////////////////////
    ///  Blocks
    ///  
    public abstract class Block : Statement, IScope
    {
        private SymbolTable m_symbols;
        private LinkedList<Statement> m_statements;
        private Expression m_filter; /*gets transformed to guarded command in resolvevisitor!*/
        private IScope m_parentScope;

        public SymbolTable symbols { get { return m_symbols; } }
        public LinkedList<Statement> statements { get { return m_statements; } }
        public Expression filter { get { return m_filter; } }

        public Block(StatementKind aKind, int aline, int apos)
            : base(aKind, aline, apos)
        {
            m_symbols = new SymbolTable();
            m_statements = new LinkedList<Statement>();
        }

        public Block(Block toCopy)
            : base(toCopy)
        {
            m_symbols = new SymbolTable(toCopy.m_symbols);
            m_statements = new LinkedList<Statement>(toCopy.m_statements);
            m_parentScope = toCopy.m_parentScope;
            m_filter = toCopy.m_filter;
        }

        public override Statement Clone()
        {
            throw new NotImplementedException();
        }

        public void AddStatement(Statement toAdd)
        {
            m_statements.AddLast(toAdd);
        }

        public void SetStatements(LinkedList<Statement> newStatements)
        {
            m_statements = newStatements;
        }

        public void AddIdentifier(Identifier anIdentifier)
        {
            m_symbols.AddIdentifier(anIdentifier);
        }

        public Identifier ResolveIdentifier(string aName)
        {
            if (m_symbols.Defined(aName))
                return m_symbols.Get(aName);
            else
                return null;
        }

        public IScope GetParentScope()
        {
            return m_parentScope;
        }

        public void SetParentScope(IScope parentScope)
        {
            m_parentScope = parentScope;
        }

        public void AddIdentifier(Identifier anIdentifier, object tag)
        {
            m_symbols.AddIdentifier(anIdentifier);
        }


        internal void SetFilter(Expression sexpr)
        {
            m_filter = sexpr;
        }
    }

    public sealed class NondetBlock : Block
    {
        public NondetBlock(int aline, int apos)
            : base(StatementKind.NondetBlock, aline, apos)
        { }

        public NondetBlock(Block aParent, int aline, int apos)
            : base(StatementKind.NondetBlock, aline, apos)
        {
            if (aParent != null)
                aParent.AddStatement(this);
        }

        public NondetBlock(NondetBlock toCopy)
            : base(toCopy)
        { }

        public override Statement Clone()
        {
            return new NondetBlock(this);
        }

        public override void Accept(IAstVisitor visitor)
        {
            visitor.visit(this);
        }
    }

    public sealed class SeqBlock : Block
    {
        public SeqBlock(int aline, int apos)
            : base(StatementKind.SeqBlock, aline, apos)
        { }

        public SeqBlock(Block aParent, int aline, int apos)
            : base(StatementKind.SeqBlock, aline, apos)
        {
            if (aParent != null)
                aParent.AddStatement(this);
        }

        public SeqBlock(SeqBlock toCopy)
            : base(toCopy)
        { }

        public override Statement Clone()
        {
            return new SeqBlock(this);
        }

        public override void Accept(IAstVisitor visitor)
        {
            visitor.visit(this);
        }
    }

    public sealed class PrioBlock : Block
    {
        public PrioBlock(int aline, int apos)
            : base(StatementKind.PrioBlock, aline, apos)
        { }

        public PrioBlock(Block aParent, int aline, int apos)
            : base(StatementKind.PrioBlock, aline, apos)
        {
            if (aParent != null)
                aParent.AddStatement(this);
        }

        public PrioBlock(PrioBlock toCopy)
            : base(toCopy)
        { }

        public override Statement Clone()
        {
            return new PrioBlock(this);
        }

        public override void Accept(IAstVisitor visitor)
        {
            visitor.visit(this);
        }
    }



    ///////////////////////////////////////////////
    ///  Guarded Command
    ///  
    public sealed class GuardedCommand : Statement
    {
        private Expression m_guard;
        private Block m_body;
        private bool m_isQualitative;

        public Expression guard { get { return m_guard; } }
        public Block body { get { return m_body; } }
        public bool isQualitative { get { return m_isQualitative; } }

        public GuardedCommand(Expression aGuard, Block aBlock, int aline, int apos)
            : base(StatementKind.GuardedCommand, aline, apos)
        {
            m_guard = aGuard;
            m_body = aBlock;
            m_isQualitative = false;
        }

        public GuardedCommand(GuardedCommand toCopy)
            : base(toCopy)
        {
            m_guard = toCopy.m_guard;
            m_body = toCopy.m_body;
            m_isQualitative = toCopy.m_isQualitative;
        }

        public override Statement Clone()
        {
            return new GuardedCommand(this);
        }

        public override void Accept(IAstVisitor visitor)
        {
            visitor.visit(this);
        }

        public void SetGuard(Expression newGuard)
        {
            if (newGuard == null)
                throw new ArgumentException();
            m_guard = newGuard;
        }

        public void SetBody(Block newBody)
        {
            if (newBody == null)
                throw new ArgumentException();
            m_body = newBody;
        }

        public void SetIsQualitative(bool newVal)
        {
            m_isQualitative = newVal;
        }
    }


    ///////////////////////////////////////////////
    ///  Assignment
    ///  
    public sealed class Assignment : Statement, IScope
    {
        private LinkedList<Expression> m_places;
        private LinkedList<Expression> m_values;
        private Expression m_nondetExpression;
        private IScope m_prarentScope;
        private SymbolTable m_symbols; // needed for nondeterminsitic assignment (we most likely will have new variables)

        public LinkedList<Expression> places { get { return m_places; } }
        public LinkedList<Expression> values { get { return m_values; } }
        public Expression nondetExpression { get { return m_nondetExpression; } }
        public SymbolTable symbols { get { return m_symbols; } }

        public Assignment(Expression place, Expression value, Expression nondetExpression, int aline, int apos)
            : base(StatementKind.Assignment, aline, apos)
        {
            m_places = new LinkedList<Expression>();
            m_values = new LinkedList<Expression>();
            if (place != null)
                m_places.AddFirst(place);
            if (value != null)
                m_values.AddFirst(value);
            m_nondetExpression = nondetExpression;
            m_symbols = new SymbolTable();
        }

        public Assignment(Assignment toCopy)
            : base(toCopy)
        {
            m_places = new LinkedList<Expression>(toCopy.m_places);
            m_values = new LinkedList<Expression>(toCopy.m_values);
            m_nondetExpression = toCopy.m_nondetExpression;
            m_symbols = new SymbolTable(toCopy.symbols);
        }

        public override Statement Clone()
        {
            return new Assignment(this);
        }

        public void AddPlace(Expression aPlace)
        {
            m_places.AddLast(aPlace);
        }

        public void AddValue(Expression aValue)
        {
            m_values.AddLast(aValue);
        }

        public void SetNondetExpression(Expression anExpr)
        {
            m_nondetExpression = anExpr;
        }

        public override void Accept(IAstVisitor visitor)
        {
            visitor.visit(this);
        }

        #region IScope Member

        public Identifier ResolveIdentifier(string aName)
        {
            if (m_symbols.Defined(aName))
                return m_symbols.Get(aName);
            else
                return null;
        }

        public IScope GetParentScope()
        {
            return m_prarentScope;
        }

        public void SetParentScope(IScope parentScope)
        {
            m_prarentScope = parentScope;
        }

        public void AddIdentifier(Identifier anIdentifier, object tag)
        {
            m_symbols.AddIdentifier(anIdentifier);
        }

        #endregion
    }


    ///////////////////////////////////////////////
    ///  Methodcall
    ///  
    public sealed class Call : Statement
    {
        private Expression m_callExpression;

        public Expression callExpression { get { return m_callExpression; } }

        public Call(Expression callExpression, int aline, int apos)
            : base(StatementKind.MethodCall, aline, apos)
        {
            m_callExpression = callExpression;
        }

        public Call(Call toCopy)
            : base(toCopy)
        {
            m_callExpression = toCopy.m_callExpression;
        }

        public override Statement Clone()
        {
            return new Call(this);
        }

        public override void Accept(IAstVisitor visitor)
        {
            visitor.visit(this);
        }

        public void SetCallExpression(Expression newExpression)
        {
            //if (newExpression == null)
            //    throw new ArgumentException();
            m_callExpression = newExpression;
        }
    }


    ///////////////////////////////////////////////
    ///  Simple Statements
    ///  
    public sealed class SkipStatement : Statement
    {
        public SkipStatement(int aline, int apos)
            : base(StatementKind.Skip, aline, apos)
        { }

        public SkipStatement(SkipStatement copy)
            : base(copy)
        { }

        public override Statement Clone()
        {
            return new SkipStatement(this);
        }

        public override void Accept(IAstVisitor visitor)
        {
            visitor.visit(this);
        }
    }

    public sealed class AbortStatement : Statement
    {
        public AbortStatement(int aline, int apos)
            : base(StatementKind.Abort, aline, apos)
        { }

        public AbortStatement(AbortStatement toCopy)
            : base(toCopy)
        { }

        public override Statement Clone()
        {
            return new AbortStatement(this);
        }

        public override void Accept(IAstVisitor visitor)
        {
            visitor.visit(this);
        }
    }

    public sealed class KillStatement : Statement
    {
        public Identifier someOne;

        public KillStatement(Identifier toKill, int aline, int apos)
            : base(StatementKind.Kill, aline, apos)
        {
            someOne = toKill;
        }

        public KillStatement(KillStatement toCopy)
            : base(toCopy)
        {
            someOne = toCopy.someOne;
        }

        public override Statement Clone()
        {
            return new KillStatement(this);
        }

        public override void Accept(IAstVisitor visitor)
        {
            visitor.visit(this);
        }

        public void SetIdentifier(Identifier target)
        {
            someOne = target;
        }
    }
}