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

/*
 * Prolog Code Generator
 */

using System;
using System.Collections.Generic;
using System.Text;
using TUG.Mogentes.Codegen;


namespace TUG.Mogentes.Codegen.Prolog
{
    public class OoaPrologStatement : OoaStatementVisitor
    {
        public class Factory
        {
            public virtual OoaPrologStatement create(
                OoaPrologExpression.Factory exprFactory,
                OoaPrologIdentifier.Factory idFactory,
                OoaPrologType.Factory typeFactory) 
            {
                return new OoaPrologStatement(exprFactory, idFactory, typeFactory); 
            }
        }

        protected OoaCodeEmitter m_emitter = new OoaCodeEmitter();

        public override void visit(NondetBlock nondetBlock)
        {
            int y = 0;
            foreach (var x in nondetBlock.statements)
            {
                if (y != 0)
                    m_emitter.Append("; ");
                else
                    y++;
                m_emitter.Append("(");
                VisitSub(x, nondetBlock);
                m_emitter.Append(")");
            }
        }

        public override void visit(SeqBlock seqBlock)
        {
            int y = 0;
            if (seqBlock.symbols.symbolList.Count > 0)
            {
                m_emitter.Append("([");
                foreach (var sym in seqBlock.symbols.symbolList)
                {
                    if (y != 0)
                        m_emitter.AppendLine(", ");
                    else
                        y++;

                    OoaPrologType atype = createTypeVisitor();
                    sym.type.Accept(atype);
                    OoaPrologIdentifier anIdent = createIdentifierVisitor();
                    sym.Accept(anIdent);
                    m_emitter.Append(String.Format("{0}:{1}", anIdent.ToString(), atype.ToString()));
                }
                m_emitter.Append("]: ");
            }

            y = 0;
            foreach (var x in seqBlock.statements)
            {
                if (y != 0)
                    m_emitter.AppendLine(", ");
                else
                    y++;
                m_emitter.Append("(");
                VisitSub(x, seqBlock);
                m_emitter.Append(")");
            }

            if (seqBlock.symbols.symbolList.Count > 0)
                m_emitter.Append(")");
        }

        public override void visit(PrioBlock prioBlock)
        {
            int y = 0;
            foreach (var x in prioBlock.statements)
            {
                if (y != 0)
                    m_emitter.Append("// ");
                else
                    y++;
                m_emitter.Append("(");
                VisitSub(x, prioBlock);
                m_emitter.Append(")");
            }
        }

        public override void visit(GuardedCommand guardedCommand)
        {
            OoaPrologExpression expr = createExpressionVisitor();
            guardedCommand.guard.Accept(expr);

            m_emitter.AppendLineIncIndent(String.Format("({0}{2}) {1} ", expr.ToString(), guardedCommand.isQualitative ? "~>" : "=>", expr.tmpVariables[0]));
            m_emitter.AppendLineIncIndent("(");
            VisitSub(guardedCommand.body, guardedCommand);
            m_emitter.DecIndent();
            m_emitter.AppendLine("");
            m_emitter.Append(")");
        }

        public override void visit(Assignment assignment)
        {
            if (assignment.nondetExpression != null)
                throw new NotImplementedException();

            LinkedListNode<Expression> aPlace = assignment.places.First;
            LinkedListNode<Expression> aValue = assignment.values.First;
            List<string> assignments = new List<string>();

            while (aPlace != null)
            {
                OoaPrologExpression prologPlace = createExpressionVisitor(true);
                aPlace.Value.Accept(prologPlace);
                System.Diagnostics.Debug.Assert(prologPlace.tmpVariables.Count == 1);

                OoaPrologExpression prologValue = createExpressionVisitor();
                aValue.Value.Accept(prologValue);
                System.Diagnostics.Debug.Assert(prologValue.tmpVariables.Count == 1);

                m_emitter.Append(prologValue.ToString());

                if (aPlace.Value.kind == ExpressionKind.Access &&
                    ((AccessExpression)aPlace.Value).right.kind == ExpressionKind.Identifier &&
                    ((IdentifierExpression)((AccessExpression)aPlace.Value).right).identifier.kind == IdentifierKind.AttributeIdentifier)
                {
                    //access to attribute is always 'self.XY'...
                    assignments.Add(String.Format("{0} := {1}", prologPlace.tmpVariables[0], prologValue.tmpVariables[0]));
                }
                else
                    if (prologPlace.tmpVariables[0] == "RESULT")
                        assignments.Add(String.Format("unify( RESULT = {0})", prologValue.tmpVariables[0]));
                    else if (aPlace.Value.type.kind == TypeKind.IntType)
                        assignments.Add(String.Format("{0} #= {1}", prologPlace.tmpVariables[0], prologValue.tmpVariables[0]));
                    else
                        assignments.Add(String.Format("{0} = {1}", prologPlace.tmpVariables[0], prologValue.tmpVariables[0]));

                if (prologPlace.ToString().Length > 0)
                {
                    string place = prologPlace.ToString();
                    place = place.Trim();
                    if (place.EndsWith(","))
                        place = place.Substring(0, place.Length - 1);

                    assignments.Add(place);
                }

                aPlace = aPlace.Next;
                aValue = aValue.Next;
            }

            int pos = 0;
            foreach (var s in assignments)
            {
                if (pos != 0)
                    m_emitter.Append(",");
                pos++;
                m_emitter.Append(s);
            }
        }

        public override void visit(Call call)
        {
            Expression ce = call.callExpression;
            string callstatement = String.Empty;
            StringBuilder parameter = new StringBuilder();
            bool hideCall = false;

            if (ce.kind == ExpressionKind.Identifier)
                callstatement = ((IdentifierExpression)ce).identifier.tokenText;
            else if (ce.kind == ExpressionKind.Call)
            {
                CallExpression parens = (CallExpression)ce;

                OoaPrologExpression prologexpr = createExpressionVisitor();
                parens.child.Accept(prologexpr);

                if (parens.child.kind == ExpressionKind.Identifier &&
                    ((IdentifierExpression)parens.child).identifier.kind == IdentifierKind.NamedActionIdentifier)
                {
                    // we need to hide internal actions
                    NamedActionIdentifier namedactionid = (NamedActionIdentifier)((IdentifierExpression)parens.child).identifier;
                    hideCall = ((FunctionType)namedactionid.type).functionType == FunctionTypeEnum.Internal;
                }

                m_emitter.Append(prologexpr.ToString());
                callstatement = prologexpr.tmpVariables[0];
                int i = 0;
                foreach (var arg in parens.arguments)
                {
                    if (i != 0)
                        parameter.Append(", ");
                    else
                        i++;
                    OoaPrologExpression paramexpr = createExpressionVisitor();
                    arg.Accept(paramexpr);
                    m_emitter.Append(paramexpr.ToString());
                    parameter.Append(paramexpr.tmpVariables[0]);
                }
            }
            else
                throw new NotImplementedException();
            if (hideCall)
                m_emitter.Append("i(");
            if (parameter.Length > 0)
                m_emitter.AppendLine(String.Format("{0}({1})", callstatement, parameter));
            else
                m_emitter.AppendLine(String.Format("{0}", callstatement, parameter));
            if (hideCall)
                m_emitter.Append(")");
        }

        public override void visit(SkipStatement skipStatement)
        {
            m_emitter.Append("skip");
        }

        public override void visit(AbortStatement abortStatement)
        {
            throw new NotImplementedException();
        }

        public override void visit(KillStatement killStatement)
        {
            throw new NotImplementedException();
        }

        public override void visit(QualitativeConstraintStatement qalitativeConstraintStatement)
        {
            if (qalitativeConstraintStatement.tag)
            {
                m_emitter.Append("% observable assignment in actionhead");
                return;
            }

            OoaPrologIdentifier id1 = createIdentifierVisitor();
            OoaPrologIdentifier id2 = createIdentifierVisitor();
            OoaPrologIdentifier id3 = createIdentifierVisitor();


            switch (qalitativeConstraintStatement.operation)
            {
                case QualitativeConstraintOperation.Deriv:
                    qalitativeConstraintStatement.variable0.Accept(id1);
                    qalitativeConstraintStatement.variable1.Accept(id2);
                    m_emitter.Append(String.Format("{0} := dt {1}", id1.ToString(), id2.ToString()));
                    break;
                case QualitativeConstraintOperation.Diff:
                    qalitativeConstraintStatement.variable0.Accept(id1);
                    qalitativeConstraintStatement.variable1.Accept(id2);
                    qalitativeConstraintStatement.variable2.Accept(id3);
                    m_emitter.Append(String.Format("{0} := {1} - {2}", id1.ToString(), id2.ToString(), id3.ToString()));
                    break;
                case QualitativeConstraintOperation.Equal:
                    qalitativeConstraintStatement.variable0.Accept(id1);
                    qalitativeConstraintStatement.variable1.Accept(id2);
                    m_emitter.Append(String.Format("{0} := {1}", id1.ToString(), id2.ToString()));
                    break;

                case QualitativeConstraintOperation.Prod:
                    qalitativeConstraintStatement.variable0.Accept(id1);
                    qalitativeConstraintStatement.variable1.Accept(id2);
                    qalitativeConstraintStatement.variable2.Accept(id3);
                    m_emitter.Append(String.Format("{0} := {1} * {2}", id1.ToString(), id2.ToString(), id3.ToString()));
                    break;

                case QualitativeConstraintOperation.Sum:
                    qalitativeConstraintStatement.variable0.Accept(id1);
                    qalitativeConstraintStatement.variable1.Accept(id2);
                    qalitativeConstraintStatement.variable2.Accept(id3);
                    m_emitter.Append(String.Format("{0} := {1} + {2}", id1.ToString(), id2.ToString(), id3.ToString()));
                    break;

                default:
                    throw new NotImplementedException();
            }
        }


        public override string ToString()
        {
            return m_emitter.ToString();
        }

        protected OoaPrologExpression createExpressionVisitor() { return m_exprFactory.create(m_idFactory, m_typeFactory); }
        protected OoaPrologExpression createExpressionVisitor(bool lhs) { return m_exprFactory.create(m_idFactory, m_typeFactory, lhs); }
        protected OoaPrologIdentifier createIdentifierVisitor() { return m_idFactory.create(); }
        protected OoaPrologType createTypeVisitor() { return m_typeFactory.create(m_idFactory); }

        private readonly OoaPrologExpression.Factory m_exprFactory;
        private readonly OoaPrologIdentifier.Factory m_idFactory;
        private readonly OoaPrologType.Factory m_typeFactory;

        protected OoaPrologStatement(
                OoaPrologExpression.Factory exprFactory,
                OoaPrologIdentifier.Factory idFactory,
                OoaPrologType.Factory typeFactory)
            : base()
        {
            m_exprFactory = exprFactory;
            m_idFactory = idFactory;
            m_typeFactory = typeFactory;
        }
    }

}