/**
  *
  *                      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 TUG.Mogentes.Codegen;
using Antlr.Runtime;

namespace TUG.Mogentes
{

    public enum IdentifierKind
    {
        TypeIdentifier,         // some named type
        EnumIdentifier,         // identifier of enumerated type
        LandmarkIdentifier,     // landmark
        AttributeIdentifier,    // global attribute
        LocalVariableIdentifier,// local variable
        ParameterIdentifier,     // method/named action argument
        ExpressionVariableIdentifier, // var in an expression
        MethodIdentifier,       // a method
        NamedActionIdentifier,  // a named action
        Module,                 // the main module - actually this has no name...
        List,
        Constant
    }


    /* ABSTRACT class Identifier.
     * */
    public abstract class Identifier : UlyssesBasicClass, IAst, IComparable
    {
        protected int m_line;
        protected int m_column;
        protected IScope m_definingScope;
        protected IdentifierKind m_identifierKind;
        protected string m_tokenText;
        protected UlyssesType m_Type;

        // basic attributes of an Identifier
        public IdentifierKind kind { get { return m_identifierKind; } } // kind of identifier
        public UlyssesType type { get { return m_Type; } }   // type of identifier
        public IScope definingScope { get { return m_definingScope; } } // scope where it's defined

        // from lexer
        public string tokenText { get { return m_tokenText; } }
        public int line { get { return m_line; } }
        public int column { get { return m_column; } }

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


        public Identifier(IToken aToken,
                          UlyssesType aType,
                          IdentifierKind aKind,
                          IScope aDefiningScope)
        {
            m_tokenText = aToken.Text;
            m_line = aToken.Line;
            m_column = aToken.CharPositionInLine;
            m_Type = aType;
            m_identifierKind = aKind;
            m_definingScope = aDefiningScope;
        }

        public Identifier(string name, UlyssesType aType, IdentifierKind aKind, IScope aDefiningScope)
        {
            m_tokenText = name;
            m_line = 0;
            m_column = 0;
            m_Type = aType;
            m_identifierKind = aKind;
            m_definingScope = aDefiningScope;
        }

        public Identifier(Identifier toCopy)
        {
            m_tokenText = toCopy.m_tokenText;
            m_line = toCopy.m_line;
            m_column = toCopy.m_column;
            m_Type = toCopy.m_Type;
            m_identifierKind = toCopy.m_identifierKind;
            m_definingScope = toCopy.m_definingScope;
        }

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


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

        public void SetType(UlyssesType aType)
        {
            if (aType == null)
                throw new ArgumentException("New type can not be null.");

            m_Type = aType;
        }

        public void SetTokenText(string aText)
        {
            m_tokenText = aText;
        }

        public override string ToString()
        {
            return tokenText;
        }

        public int CompareTo(object obj)
        {
            if (obj is Identifier)
                return tokenText.CompareTo(obj.ToString());
            else
                throw new InvalidCastException();
        }
    }


    ///////////////////////////////////////////////
    ///  Value Identifiers
    ///  
    public abstract class ValueIdentifier : Identifier
    {
        public ValueIdentifier(IToken aToken,
                          UlyssesType aType,
                          IdentifierKind aKind,
                          IScope aDefiningScope)
            : base(aToken, aType, aKind, aDefiningScope)
        { }

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


    public sealed class ConstantIdentifier : ValueIdentifier
    {
        private Expression m_value;

        public Expression Value { get { return m_value; } }

        public ConstantIdentifier(IToken aToken,
                          Expression value,
                          IScope aDefiningScope)
            : base(aToken, null, IdentifierKind.Constant, aDefiningScope)
        {
            m_value = value;
        }

        public ConstantIdentifier(ConstantIdentifier toCopy)
            : base(toCopy)
        {
            m_value = toCopy.m_value;
        }

        public void SetValue(Expression aValue)
        {
            m_value = aValue;
        }

        public override Identifier Clone()
        {
            return this;
        }

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

    public sealed class EnumIdentifier : ValueIdentifier
    {
        private int value;
        private bool haveValue;

        public int Value { get { return value; } }
        public bool HaveValue { get { return haveValue; } }


        public EnumIdentifier(IToken aToken,
                          EnumType aType,
                          IScope aDefiningScope)
            : base(aToken, aType, IdentifierKind.EnumIdentifier, aDefiningScope)
        {
            haveValue = false;
        }


        public EnumIdentifier(IToken aToken,
                          int aValue,
                          EnumType aType,
                          IScope aDefiningScope)
            : base(aToken, aType, IdentifierKind.EnumIdentifier, aDefiningScope)
        {
            haveValue = true;
            value = aValue;
        }


        public EnumIdentifier(EnumIdentifier toCopy)
            : base(toCopy)
        {
            value = toCopy.value;
            haveValue = toCopy.haveValue;
        }


        public override Identifier Clone()
        {
            return this;
        }

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


    public sealed class LandmarkIdentifier : ValueIdentifier
    {
        public LandmarkIdentifier(IToken aToken,
                          QrType aType,
                          IScope aDefiningScope)
            : base(aToken, aType, IdentifierKind.LandmarkIdentifier, aDefiningScope)
        { }

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

        public override Identifier Clone()
        {
            return this;
        }

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




    ///////////////////////////////////////////////
    ///  Variable Identifiers
    ///  

    public abstract class ValueReferenceIdentifier : Identifier
    {
        public ValueReferenceIdentifier(IToken aToken,
                          UlyssesType aType,
                          IdentifierKind aKind,
                          IScope aDefiningScope)
            : base(aToken, aType, aKind, aDefiningScope)
        { }

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

        public ValueReferenceIdentifier(string name, UlyssesType aType, IdentifierKind aKind, IScope aDefiningScope) :
            base(name, aType, aKind, aDefiningScope)
        { }

    }


    public sealed class AttributeIdentifier : ValueReferenceIdentifier
    {
        private Expression m_initializer;
        private bool m_isStatic;
        private bool m_isObservable;    // used for qualitative values
        private bool m_isControllable;  // used for qualitative values

        public Expression initializer { get { return m_initializer; } }
        public bool isStatic { get { return m_isStatic; } }
        public bool isObservable { get { return m_isObservable; } }
        public bool isControllable { get { return m_isControllable; } }

        public AttributeIdentifier(IToken aToken,
                          UlyssesType aType,
                          IScope aDefiningScope,
                          Expression anInitializer,
                          bool isStatic,
                          bool isObservable,
                          bool isControllable)
            : base(aToken, aType, IdentifierKind.AttributeIdentifier, aDefiningScope)
        {
            m_initializer = anInitializer;
            m_isStatic = isStatic;
            m_isControllable = isControllable;
            m_isObservable = isObservable;
        }

        public AttributeIdentifier(AttributeIdentifier toCopy)
            : base(toCopy)
        {
            m_initializer = toCopy.initializer;
            m_isStatic = toCopy.m_isStatic;
            m_isControllable = toCopy.m_isControllable;
            m_isObservable = toCopy.m_isObservable;
        }


        public override Identifier Clone()
        {
            return new AttributeIdentifier(this);
        }

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

        public void SetInitializer(Expression newExpr)
        {
            if (newExpr == null)
                throw new ArgumentException();
            m_initializer = newExpr;
        }
    }


    public class LocalVariableIdentifier : ValueReferenceIdentifier
    {
        public LocalVariableIdentifier(IToken aToken,
                          UlyssesType aType,
                          IScope aDefiningScope)
            : base(aToken, aType, IdentifierKind.LocalVariableIdentifier, aDefiningScope)
        { }

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

        public override Identifier Clone()
        {
            return new LocalVariableIdentifier(this);
        }

        public LocalVariableIdentifier(string name, UlyssesType aType, IdentifierKind aKind, IScope aDefiningScope)
            : base(name, aType, aKind, aDefiningScope)
        { }

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

    }


    public sealed class ParameterIdentifier : LocalVariableIdentifier
    {
        public ParameterIdentifier(IToken aToken,
                          UlyssesType aType,
                          IScope aDefiningScope)
            : base(aToken, aType, aDefiningScope)
        {
            m_identifierKind = IdentifierKind.ParameterIdentifier;
        }

        public ParameterIdentifier(string name, UlyssesType aType, IScope aDefiningScope)
            : base(name, aType, IdentifierKind.ParameterIdentifier, aDefiningScope)
        { }

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

        public override Identifier Clone()
        {
            return new ParameterIdentifier(this);
        }

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

    }


    public sealed class ExpressionVariableIdentifier : LocalVariableIdentifier
    {
        private bool m_isInitialized;

        public bool initialized { get { return m_isInitialized; } }

        public ExpressionVariableIdentifier(IToken aToken,
                          UlyssesType aType,
                          IScope aDefiningScope)
            : base(aToken, aType, aDefiningScope)
        {
            m_identifierKind = IdentifierKind.ExpressionVariableIdentifier;
        }

        public ExpressionVariableIdentifier(string name, int line, int col)
            : base(name, null, IdentifierKind.ExpressionVariableIdentifier, null)
        {
            m_line = line;
            m_column = col;
            m_isInitialized = false;
        }

        public ExpressionVariableIdentifier(ExpressionVariableIdentifier toCopy)
            : base(toCopy)
        {
            m_line = toCopy.m_line;
            m_column = toCopy.m_column;
            m_isInitialized = toCopy.m_isInitialized;
        }

        public override Identifier Clone()
        {
            return new ExpressionVariableIdentifier(this);
        }

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

        public void SetInitialized(bool newValue)
        {
            m_isInitialized = newValue;
        }

    }


    ///////////////////////////////////////////////
    ///  Type Identifier
    ///  

    public class TypeIdentifier : Identifier
    {
        public string prefix;

        protected TypeIdentifier(IToken aToken,
                          UlyssesType aType,
                            IdentifierKind someKind,
                          IScope aDefiningScope)
            : base(aToken, aType, someKind, aDefiningScope)
        { }

        protected TypeIdentifier(string aToken,
                          UlyssesType aType,
                            IdentifierKind someKind,
                          IScope aDefiningScope)
            : base(aToken, aType, someKind, aDefiningScope)
        { }


        public TypeIdentifier(IToken aToken,
                          UlyssesType aType,
                          IScope aDefiningScope)
            : base(aToken, aType, IdentifierKind.TypeIdentifier, aDefiningScope)
        { }


        public TypeIdentifier(string aName,
                          UlyssesType aType,
                          IScope aDefiningScope)
            : base(aName, aType, IdentifierKind.TypeIdentifier, aDefiningScope)
        { }

        public TypeIdentifier(TypeIdentifier toCopy)
            : base(toCopy)
        {
            this.prefix = toCopy.prefix;
        }

        public override Identifier Clone()
        {
            return new TypeIdentifier(this);
        }

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

    public sealed class SelfTypeIdentifier : TypeIdentifier
    {
        public SelfTypeIdentifier(string aName,
                          UlyssesType aType,
                          IScope aDefiningScope)
            : base(aName, aType, aDefiningScope)
        { }

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


    ///////////////////////////////////////////////
    ///  Scope Identifiers
    ///  
    public abstract class Scope : TypeIdentifier, IScope
    {
        protected SymbolTable m_symbolTable;

        public Scope(IToken aToken,
                     UlyssesType aType,
                     IdentifierKind aKind,
                     IScope aDefiningScope)
            : base(aToken, aType, aKind, aDefiningScope)
        {
            m_symbolTable = new SymbolTable();
        }


        public Scope(string aName,
                     UlyssesType aType,
                     IdentifierKind aKind,
                     IScope aDefiningScope)
            : base(aName, aType, aKind, aDefiningScope)
        {
            m_symbolTable = new SymbolTable();
        }

        public Scope(Scope toCopy)
            : base(toCopy)
        {
            m_symbolTable = toCopy.symbolTable;
        }


        public SymbolTable symbolTable { get { return m_symbolTable; } }

        public IScope GetParentScope()
        {
            return m_definingScope;
        }

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

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

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

    }

    public abstract class FunctionIdentifier : Scope
    {
        private Block m_body;
        private List<ParameterIdentifier> m_parameter = new List<ParameterIdentifier>();

        public Block body { get { return m_body; } }
        public List<ParameterIdentifier> parameter { get { return m_parameter; } }


        public FunctionIdentifier(IToken aToken,
                          UlyssesType aType,
                          IdentifierKind aKind,
                          IScope aDefiningScope)
            : base(aToken, aType, aKind, aDefiningScope)
        { }

        public FunctionIdentifier(FunctionIdentifier toCopy)
            : base(toCopy)
        {
            m_body = toCopy.m_body;
            m_parameter = new List<ParameterIdentifier>(toCopy.m_parameter);
        }

        public void SetBody(Block body)
        {
            m_body = body;
        }

        public void AddParameter(ParameterIdentifier aParameter)
        {
            m_parameter.Add(aParameter);
            AddIdentifier(aParameter, null);
        }
    }


    public sealed class MethodIdentifier : FunctionIdentifier
    {
        public MethodIdentifier(IToken aToken,
                          UlyssesType aType,
                          IScope aDefiningScope)
            : base(aToken, aType, IdentifierKind.MethodIdentifier, aDefiningScope)
        { }

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

        public override Identifier Clone()
        {
            return new MethodIdentifier(this);
        }

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

    public sealed class NamedActionIdentifier : FunctionIdentifier
    {
        public NamedActionIdentifier(IToken aToken,
                          UlyssesType aType,
                          IScope aDefiningScope)
            : base(aToken, aType, IdentifierKind.NamedActionIdentifier, aDefiningScope)
        { }

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

        public override Identifier Clone()
        {
            return new NamedActionIdentifier(this);
        }

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

    public class Module : Scope
    {
        //protected List<OpaqueType> m_typesToFixUp;
        //protected List<Expression> m_referencesToResolve;

        //public List<OpaqueType> typesToFixUp { get { return m_typesToFixUp; } }
        //public List<Expression> referencesToResolve { get { return m_referencesToResolve; } }

        public Module()
            : base("@Module", null, IdentifierKind.Module, null)
        {
            //m_typesToFixUp = new List<OpaqueType>();
            // m_referencesToResolve = new List<Expression>();
        }

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

    public sealed class MainModule : Module
    {
        private IdentifierList m_systemDescription;
        private ActionSystem m_instance;

        public IdentifierList systemDescription { get { return m_systemDescription; } }
        public ActionSystem instance { get { return m_instance; } }

        public MainModule()
            : base()
        {
            m_systemDescription = null;
        }

        public void SetSystemDescription(IdentifierList aDescr)
        {
            m_systemDescription = aDescr;
        }

        public void SetInstance(ActionSystem anObject)
        {
            m_instance = anObject;
        }

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



    ///////////////////////////////////////////////
    ///  Identifier List
    ///  
    public enum IdentifierListType { normal, nondeterministic, seqential, prioritized }
    public abstract class IdentifierList : Identifier
    {
        private LinkedList<Identifier> m_list;
        private IdentifierListType m_type;

        public LinkedList<Identifier> identifiers { get { return m_list; } }
        public IdentifierListType listType { get { return m_type; } }

        public IdentifierList(IdentifierListType aConcatType)
            : base("list", null, IdentifierKind.List, null)
        {
            m_list = new LinkedList<Identifier>();
            m_type = aConcatType;
        }

        public void AddElement(Identifier toAdd)
        {
            m_list.AddLast(toAdd);
        }
    }


    public sealed class NondetIdentifierList : IdentifierList
    {
        public NondetIdentifierList()
            : base(IdentifierListType.nondeterministic)
        { }

        public NondetIdentifierList(IdentifierList aParent)
            : base(IdentifierListType.nondeterministic)
        {
            if (aParent != null)
                aParent.AddElement(this);
        }

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

    public sealed class SeqIdentifierList : IdentifierList
    {
        public SeqIdentifierList()
            : base(IdentifierListType.seqential)
        { }

        public SeqIdentifierList(IdentifierList aParent)
            : base(IdentifierListType.seqential)
        {
            if (aParent != null)
                aParent.AddElement(this);
        }

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

    }

    public sealed class PrioIdentifierList : IdentifierList
    {
        public PrioIdentifierList()
            : base(IdentifierListType.prioritized)
        { }

        public PrioIdentifierList(IdentifierList aParent)
            : base(IdentifierListType.prioritized)
        {
            if (aParent != null)
                aParent.AddElement(this);
        }

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

    public sealed class UnspecIdentifierList : IdentifierList
    {
        public UnspecIdentifierList()
            : base(IdentifierListType.normal)
        { }
        public UnspecIdentifierList(IdentifierList aParent)
            : base(IdentifierListType.normal)
        {
            if (aParent != null)
                aParent.AddElement(this);
        }

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



}