/**
  *
  *                      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 Emitter ===
 *
 */

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


namespace TUG.Mogentes.Codegen
{
    public class OoaPrologVisitor : OoaCompleteAstTraversalVisitor
    {
        protected OoaCodeEmitter m_emitter;

        private string PrologIdentifier(Identifier id)
        {
            OoaPrologIdentifier identifierVisitor = m_idFactory.create();
            id.Accept(identifierVisitor);
            return identifierVisitor.ToString();
        }

        protected void ExportMethodsAndActions(MainModule mainModule)
        {
            StringBuilder varActions = new StringBuilder();
            m_emitter.AppendLine();
            m_emitter.AppendLine("% action system");
            m_emitter.AppendLineIncIndent("as :- ");

            /* export methods */
            m_emitter.AppendLine("methods (");
            ExportMethods(mainModule);
            m_emitter.AppendLine("), ");
            m_emitter.AppendLine("actions (");
            ExportNamedActions(mainModule, varActions);
            m_emitter.AppendLine("), ");
            m_emitter.AppendLine("dood (");

            ExportDoOdBlock(mainModule.instance.doOdBlock, m_emitter);


            m_emitter.AppendLine("), qdes (none)");
            m_emitter.DecIndent();
            m_emitter.AppendLine(".");
            m_emitter.AppendLine("");

            m_emitter.Append(varActions.ToString());
        }

        private void ExportMethods(MainModule mainModule)
        {
            int y = 0;
            foreach (var x in mainModule.instance.symbols.symbolList)
            {
                if (x.kind == IdentifierKind.MethodIdentifier)
                {
                    if (y != 0)
                        m_emitter.AppendLine(", ");
                    else
                        y++;

                    MethodIdentifier theMethod = (MethodIdentifier)x;
                    OoaPrologIdentifier pIdent = m_idFactory.create();
                    theMethod.Accept(pIdent);

                    /* method */
                    StringBuilder parameter = new StringBuilder();
                    if (theMethod.parameter.Count > 0 || ((FunctionType)theMethod.type).returnType != null)
                    {
                        parameter.Append("(");
                        int z = 0;
                        foreach (var param in theMethod.parameter)
                        {
                            if (z != 0)
                            {
                                parameter.Append(", ");
                            }
                            else
                                z++;
                            OoaPrologIdentifier pParamIdent = m_idFactory.create();
                            param.Accept(pParamIdent);
                            parameter.Append(pParamIdent.ToString());
                        }


                        if (((FunctionType)theMethod.type).returnType != null)
                        {
                            if (z != 0)
                                parameter.Append(", ");
                            parameter.Append("RESULT");
                        }
                        parameter.Append(")");
                    }
                    m_emitter.AppendLineIncIndent(String.Format("{0}{1} = (", pIdent.ToString(), parameter.ToString()));

                    OoaPrologStatement pBody = createStatementVisitor();
                    ((MethodIdentifier)x).body.Accept(pBody);
                    m_emitter.Append(pBody.ToString());
                    m_emitter.Append(")");
                    m_emitter.DecIndent();
                }
            }
            if (y == 0)
                m_emitter.Append(" none ");
        }

        private void ExportNamedActions(MainModule mainModule, StringBuilder varActions)
        {
            int y = 0;
            foreach (var x in mainModule.instance.symbols.symbolList)
            {
                if (x.kind == IdentifierKind.NamedActionIdentifier)
                {
                    if (y != 0)
                        m_emitter.AppendLine(", ");
                    else
                        y++;
                    NamedActionIdentifier action = (NamedActionIdentifier)x;
                    OoaPrologIdentifier pIdent = m_idFactory.create();
                    action.Accept(pIdent);

                    if (((FunctionType)action.type).functionType != FunctionTypeEnum.Continuous)
                    {
                        /* discrete actions */
                        StringBuilder parameter = new StringBuilder();
                        StringBuilder parametertype = new StringBuilder();
                        if (action.parameter.Count > 0)
                        {
                            parameter.Append("(");
                            parametertype.Append("(");
                            int z = 0;
                            foreach (var param in action.parameter)
                            {
                                if (z != 0)
                                {
                                    parameter.Append(", ");
                                    parametertype.Append(", ");
                                }
                                else
                                    z++;
                                OoaPrologIdentifier pParamIdent = m_idFactory.create();
                                param.Accept(pParamIdent);
                                parameter.Append(pParamIdent.ToString());

                                OoaPrologType pParamType = createTypeVisitor();  // bugfix me!
                                param.type.Accept(pParamType);
                                parametertype.Append(pParamType.ToString());

                            }
                            parametertype.Append(")");
                            parameter.Append(")");
                        }
                        //if (parametertype.Length > 0)
                        //    varActions.AppendLine(String.Format("{0}{1}.", pIdent.ToString(), parametertype.ToString()));
                        m_emitter.AppendLineIncIndent(String.Format("{0}{1}::", pIdent.ToString(), parameter.ToString()));
                    }
                    else
                    {
                        /* observable state vars outside... */
                        StringBuilder parameter = new StringBuilder();
                        int z = 0;
                        foreach (var stmt in ((GuardedCommand)action.body.statements.First.Value).body.statements)
                        {
                            QualitativeConstraintStatement qstmt = (QualitativeConstraintStatement)stmt;
                            if (qstmt.operation == QualitativeConstraintOperation.Equal
                                && qstmt.variable1.kind == IdentifierKind.AttributeIdentifier
                                && ((AttributeIdentifier)qstmt.variable1).isObservable)
                            {
                                if (z != 0)
                                    parameter.Append(", ");
                                else
                                    z++;
                                qstmt.tag = true;
                                OoaPrologIdentifier pParamIdent1 = m_idFactory.create();
                                OoaPrologIdentifier pParamIdent2 = m_idFactory.create();
                                qstmt.variable0.Accept(pParamIdent1);
                                qstmt.variable1.Accept(pParamIdent2);
                                parameter.Append(String.Format("{0}({1})", pParamIdent2.ToString(), pParamIdent1.ToString()));
                            }
                        }
                        m_emitter.AppendLineIncIndent(String.Format("[{0}]::", parameter.ToString()));
                    }

                    OoaPrologStatement pBody = createStatementVisitor();
                    ((NamedActionIdentifier)x).body.Accept(pBody);
                    m_emitter.Append(pBody.ToString());
                    m_emitter.DecIndent();

                }
            }
        }

        private void ExportDoOdBlock(Block block, OoaCodeEmitter m_emitter)
        {
            OoaPrologStatement statement = createStatementVisitor();
            block.Accept(statement);
            m_emitter.Append(statement.ToString());
        }

        protected int ExportControllableActions(MainModule mainModule)
        {
            m_emitter.AppendLine("");
            m_emitter.AppendLine("%emit controllable actions");
            m_emitter.Append("input([");
            int y = 0;
            foreach (var x in mainModule.instance.symbols.symbolList)
            {
                if (x.kind == IdentifierKind.NamedActionIdentifier)
                {
                    if (((FunctionType)((NamedActionIdentifier)x).type).functionType == FunctionTypeEnum.Controllable)
                    {
                        if (y != 0)
                            m_emitter.Append(", ");
                        else
                            y++;
                        OoaPrologIdentifier pIdent = m_idFactory.create();

                        ((NamedActionIdentifier)x).Accept(pIdent);
                        m_emitter.Append(pIdent.ToString());
                    }
                }
            }
            m_emitter.AppendLine("]).");
            return y;
        }

        protected int ExportObservableActions(MainModule mainModule)
        {
            m_emitter.AppendLine("");
            m_emitter.AppendLine("%emit observable actions");
            m_emitter.Append("output([");
            int y = 0;
            foreach (var x in mainModule.instance.symbols.symbolList)
            {
                if (x.kind == IdentifierKind.NamedActionIdentifier)
                {
                    if (((FunctionType)((NamedActionIdentifier)x).type).functionType == FunctionTypeEnum.Observable)
                    {
                        if (y != 0)
                            m_emitter.Append(", ");
                        else
                            y++;
                        OoaPrologIdentifier pIdent = m_idFactory.create();

                        ((NamedActionIdentifier)x).Accept(pIdent);
                        m_emitter.Append(pIdent.ToString());
                    }
                }
            }
            m_emitter.AppendLine("]).");
            return y;
        }

        protected void ExportInitialState(MainModule mainModule)
        {
            m_emitter.AppendLine("");
            m_emitter.AppendLine("%emit initial state");
            List<string> initPreds = new List<string>();
            List<string> initVars = new List<string>();
            int y = 0;
            foreach (var x in mainModule.instance.symbols.symbolList)
            {
                if (x.kind == IdentifierKind.AttributeIdentifier)
                {
                    OoaPrologExpression anExprVis = createExpressionVisitor();
                    ((AttributeIdentifier)x).initializer.Accept(anExprVis);
                    System.Diagnostics.Debug.Assert(anExprVis.tmpVariables.Count == 1);
                    string initPredName = String.Format("attr_{0}_init({1})", x.tokenText, anExprVis.tmpVariables[0]);
                    m_emitter.AppendLine(String.Format("{0} :- {1} 1=1.", initPredName, anExprVis.ToString()));
                    initPreds.Add(initPredName);
                    initVars.Add(anExprVis.tmpVariables[0]);
                }
            }


            m_emitter.Append("init([");
            y = 0;
            foreach (var x in initVars)
            {
                if (y != 0)
                    m_emitter.Append(",");
                else
                    y++;
                m_emitter.Append(x);
            }
            m_emitter.Append("]) :-");
            y = 0;
            foreach (var x in initPreds)
            {
                if (y != 0)
                    m_emitter.Append(",");
                else
                    y++;
                m_emitter.Append(x);
            }
            m_emitter.AppendLine(".");
        }

        protected int ExportState(MainModule mainModule)
        {
            m_emitter.AppendLine("");
            m_emitter.AppendLine("%emit state definition");
            m_emitter.Append("state_def([");
            int y = 0;
            foreach (var x in mainModule.instance.symbols.symbolList)
            {
                if (x.kind == IdentifierKind.AttributeIdentifier)
                {
                    if (y != 0)
                        m_emitter.Append(", ");
                    else
                        y++;
                    OoaPrologIdentifier pid = m_idFactory.create();
                    x.Accept(pid);
                    m_emitter.Append(pid.ToString());
                }
            }
            m_emitter.AppendLine("]).");
            return y;
        }

        protected void ExportVariables(MainModule mainModule)
        {
            m_emitter.AppendLine("");
            m_emitter.AppendLine("%emit type of state variables");
            Dictionary<string, StringBuilder> varlist = new Dictionary<string, StringBuilder>();
            foreach (var x in mainModule.instance.symbols.symbolList)
            {
                if (x.kind == IdentifierKind.AttributeIdentifier)
                {
                    OoaPrologIdentifier pid = m_idFactory.create();
                    OoaPrologType ptype = createTypeVisitor();
                    x.Accept(pid);
                    x.type.Accept(ptype);

                    string key = x.type.kind != TypeKind.QrType ? ptype.ToString() : "qvar";
                    if (varlist.ContainsKey(key))
                    {
                        varlist[key].Append(String.Format(", {0}", pid.ToString()));
                    }
                    else
                    {
                        varlist.Add(key, new StringBuilder(String.Format("[{0}", pid.ToString())));
                    }
                }
            }
            foreach (var key in varlist.Keys)
                m_emitter.AppendLine(String.Format("var({0}], {1}).", varlist[key], key));
        }

        protected void ExportTypes(MainModule mainModule)
        {
            foreach (var x in mainModule.symbolTable.symbolList)
            {
                if (x.kind == IdentifierKind.TypeIdentifier)
                    OoaPrologType.EmitType(((TypeIdentifier)x).type, m_idFactory);
            }
        }


        public override void visit(MainModule mainModule)
        {
            m_emitter.AppendLine("% Argos Generated");
            m_emitter.AppendLine(String.Format("%{0}", Mogentes.Program.GetProgramVersion().ToString().Replace(Environment.NewLine, Environment.NewLine + "%")));
            m_emitter.AppendLine("% Code-Gen Version: 0.2");
            m_emitter.Append("%        Generated: "); m_emitter.AppendLine(System.DateTime.Now.ToString());
            m_emitter.AppendLine("%------------------------------------------------------------------------");
            m_emitter.AppendLine("");
            String nameSpace = TUG.Mogentes.Program.Options.nameSpace;
            m_emitter.AppendLine(":- module("+nameSpace+", [var/2, input/1, searchDepth/1, qspace/2]).");
            m_emitter.AppendLine(":- use_module(library(file_systems)).");
            m_emitter.AppendLine(":- use_module(library(process)).");
            m_emitter.AppendLine(":- use_module(library(clpfd)).");
            m_emitter.AppendLine(":- use_module(library(clpb)).");
            m_emitter.AppendLine(":- use_module(library(lists)).");
            m_emitter.AppendLine(":- use_module(library(avl)).");
            m_emitter.AppendLine(":- use_module(library(ordsets)).");
            m_emitter.AppendLine(":- use_module(library(system)).");
            //m_emitter.AppendLine(":- use_module(library(gauge)).");
            m_emitter.AppendLine(":- use_module(library(terms)).");
            m_emitter.AppendLine(":- use_module(library(sets)).");
            m_emitter.AppendLine(":- use_module(library(random)).");

            m_emitter.AppendLine(":- use_module(ulysseslib, _, [ulyssesListHead/2, ulyssesListLength/2, ulyssesListTail/2, ulyssesListConc/3, ulyssesTupleAccess/3, ulyssesListAccess/3, ulyssesListWrite/4, ulyssesMapAccess/3]).");

            m_emitter.AppendLine(":- public(as/0).");
            m_emitter.AppendLine(":- dynamic(as/0).");
            m_emitter.AppendLine(":- dynamic(qstate_init/1).");
            m_emitter.AppendLine(":- dynamic(qstate_constraints/1).");
            m_emitter.AppendLine(":- public(qstate_init/1).");
            m_emitter.AppendLine(":- public(qstate_constraints/1).");

            /*definition of search depth*/
            m_emitter.AppendLine("");
            m_emitter.AppendLine("% maximal search depth (change at will)");
            m_emitter.AppendLine("searchDepth("+TUG.Mogentes.Program.Options.searchDepth+").");
            m_emitter.AppendLine("");

            /*definition of types*/
            ExportTypes(mainModule);
            /* variable definition */
            ExportVariables(mainModule);

            /* state definition */
            ExportState(mainModule);
            /* initial state */
            ExportInitialState(mainModule);
            /* input actions (controllables) */
            ExportControllableActions(mainModule);
            /* output actions (observables) */
            ExportObservableActions(mainModule);
            /* named actions */
            ExportMethodsAndActions(mainModule);

            /* all types */
            m_emitter.AppendLine("%definition of types");
            m_emitter.AppendLine(OoaPrologType.typeDefinitions.ToString());
            m_emitter.AppendLine(createTypeVisitor().GetInternalTypeDefinitions());
        }


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

        protected OoaPrologIdentifier createIdentifierVisitor() { return m_idFactory.create(); }
        protected OoaPrologType createTypeVisitor() { return m_typeFactory.create(m_idFactory); }
        protected OoaPrologExpression createExpressionVisitor() { return m_exprFactory.create(m_idFactory, m_typeFactory); }
        protected OoaPrologStatement createStatementVisitor() { return m_stmtFactory.create(m_exprFactory, m_idFactory, m_typeFactory); }

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

        protected OoaPrologVisitor(
            ParserState aState, 
            OoaPrologExpression.Factory exprFactory,
            OoaPrologIdentifier.Factory idFactory,
            OoaPrologStatement.Factory  stmtFactory,
            OoaPrologType.Factory       tpeFactory) 
            : base(aState)
        {
            m_emitter = new OoaCodeEmitter();
            m_exprFactory = exprFactory;
            m_idFactory = idFactory;
            m_stmtFactory = stmtFactory;
            m_typeFactory = tpeFactory;
        }

        public OoaPrologVisitor(ParserState aState)
            : this(
                aState,
                new OoaPrologExpression.Factory(),
                new OoaPrologIdentifier.Factory(),
                new OoaPrologStatement.Factory(),
                new OoaPrologType.Factory())
        { }
    }
}