/*
 *  This is a quick'n dirty hack to see whether the internal data structures are sane enough to emit some
 *  prolog code..
 * 
 * 
 */



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

namespace TUG.Mogentes.Codegen
{
    class prologCodeGenerator : SyntaxTreeVisitor
    {
        protected int indentLevel = 0;
        protected int indentTabWidth = 4;
        protected bool writeTypes = true;
        protected StringBuilder output = new StringBuilder();

        protected Dictionary<NamedTypeSymbol, string> definedTypes = new Dictionary<NamedTypeSymbol, string>();

        public void Append(string text)
        {
            output.Append(text);
        }

        public void Indent()
        {
            for (int i = 0; i < indentLevel * indentTabWidth; i++)
                output.Append(" ");
        }

        public void AppendLine(string text)
        {
            output.AppendLine(text);
            Indent();
        }


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



        public void visit<T>(CompositionList<T> compositionList, int stage) where T : SyntaxTree
        {

        }

        public void visit(OoaType anObject, int stage)
        {
            if (stage != 0)
                return;

            // VARIABLES

            List<string> varlist = new List<string>();
            List<string> init = new List<string>();

            AppendLine("");
            AppendLine("% variable defs");
            foreach (var sym in anObject.symbols.Values)
            {
                if (sym.GetType() == typeof(VariableSymbol))
                {
                    init.Add(((VariableSymbol)sym).initializer.ToString());

                    Append("var([");
                    Append(sym.tokenText);
                    Append("],");

                    varlist.Add(sym.tokenText);

                    if (sym.type is OpaqueType)
                    {
                        Append(((OpaqueType)sym.type).referencedType.tokenText);
                        AppendLine(").");
                    }
                    else
                    {
                        AppendLine("). % anonymous types not supported");
                    }
                }
            }

            /*define state vector*/
            AppendLine("");
            Append("state_def([");
            int cntr = varlist.Count;
            varlist.ForEach(i => { cntr--; Append(i); if (cntr > 0) Append(","); });
            AppendLine("]).");

            /*define start values (just a copy/paste of the initializer expressions)*/
            AppendLine("");
            Append("init([");
            cntr = init.Count;
            init.ForEach(i => { cntr--; Append(i); if (cntr > 0) Append(","); });
            AppendLine("]).");


            // ACTIONS
            AppendLine("");
            List<NamedActionSymbol> actions = new List<NamedActionSymbol>();
            foreach (var sym in anObject.symbols.Values)
            {
                if (sym.GetType() == typeof(NamedActionSymbol))
                    actions.Add((NamedActionSymbol)sym);
            }

            if (actions.Count > 0)
            {
                Append("as :- ");
                cntr = actions.Count;
                foreach (var na in actions)
                {
                    cntr--;
                    Append(na.tokenText); Append(":");
                    foreach (UlyssesStatement s in ((FunctionType)na.type).body)
                    {
                        if (s is GuardedCommandStatement)
                        {
                            Append("(");
                            Append(((GuardedCommandStatement)s).guard.ToString());
                            Append(") => (");
                            bool first = true;
                            foreach (UlyssesStatement sb in ((GuardedCommandStatement)s).body)
                            {
                                if (first)
                                    first = false;
                                else
                                    Append(",");
                                Append(sb.ToString());

                            }
                            Append(")");
                        }
                    }
                    if (cntr > 0)
                        AppendLine(",");
                }
                AppendLine(".");
            }

        }

        public void visit(BoolType anObject, int stage)
        {
        }

        public void visit(IntType intType, int p)
        {
        }

        public void visit(FloatType floatType, int p)
        {

        }

        public void visit(CharType charType, int p)
        {

        }

        public void visit(EnumType enumType, int p)
        {

        }

        public void visit(ListType listType, int p)
        {

        }

        public void visit(MapType mapType, int p)
        {

        }

        public void visit(TupleType tupleType, int p)
        {

        }

        public void visit(OoaSystem ooaSystem, int stage)
        {
            if (stage == 0)
            {
                AppendLine(":- public(as/0).");
                AppendLine(":- public(asM/0).");
                AppendLine("");
                AppendLine(":- dynamic(qstate_init/1).");
                AppendLine(":- dynamic(qstate_constraints/1).");
                AppendLine(":- public(qstate_constraints/1).");
                AppendLine(":- public(qstate_init/1).");

                AppendLine("");
                AppendLine("% defintion of maximal search depth");
                AppendLine("searchDepth(15).");
                AppendLine("");
            }
            if (stage == 2)
                writeTypes = false;

        }

        public bool visit(NamedTypeSymbol namedTypeSymbol, int p)
        {
            if (p != 0)
                return writeTypes;

            if (!definedTypes.ContainsKey(namedTypeSymbol))
            {
                definedTypes.Add(namedTypeSymbol, namedTypeSymbol.tokenText);
                int i;
                Type aType = namedTypeSymbol.type.GetType();
                string atypedef = "type(" + namedTypeSymbol.tokenText + ",";
                if (aType == typeof(IntType))
                {
                    IntType intType = (IntType)namedTypeSymbol.type;
                    Append(atypedef);
                    Append("X) :- "); Append("fd_domain(X,"); Append(intType.low.ToString()); Append(",");
                    Append(intType.high.ToString()); Append("),");
                    AppendLine("fd_labeling(X).");
                }
                else if (aType == typeof(EnumType))
                {
                    EnumType enumType = (EnumType)namedTypeSymbol.type;
                    i = enumType.enumSymbols.Count;
                    Append(atypedef);
                    Append("[");
                    foreach (var sym in enumType.enumSymbols)
                    {
                        i--;
                        Append("'");
                        Append(sym.tokenText);
                        Append("'");
                        if (i > 0)
                            Append(",");
                    }
                    AppendLine("]).");

                }
                else if (aType == typeof(BoolType))
                {
                    AppendLine(" % bool not supported yet. ");
                }
                else if (aType == typeof(FloatType))
                {
                    AppendLine(" % float not supported yet. ");
                }
                else if (aType == typeof(CharType))
                {
                    AppendLine(" % char not supported yet. ");
                }
                else if (aType == typeof(ListType))
                {
                    AppendLine(" % list not supported yet. ");
                }
                else if (aType == typeof(MapType))
                {
                    AppendLine(" % map not supported yet. ");
                }
                else if (aType == typeof(TupleType))
                {
                    AppendLine(" % tuple not supported yet. ");
                }
            }
            return writeTypes;
        }

        public bool visit(ParameterSymbol parameterSymbol, int p)
        {
            return true;
        }

        public bool visit(VariableSymbol variableSymbol, int p)
        {
            return true;
        }

        public bool visit(MethodSymbol methodSymbol, int p)
        {



            return true;
        }

        public void visit(EnumIdSymbol enumIdSymbol, int p)
        {

        }

        public void visit(AbortStatement abortStatement, int p)
        {

        }

        public void visit(SkipStatement skipStatement, int p)
        {

        }

        public void visit(KillStatement killStatement, int p)
        {

        }

        public void visit(GuardedCommandStatement guardedCommandStatement, int p)
        {

        }

        public void visit(NamedActionInclusionStatement namedActionInclusionStatement, int p)
        {

        }

        public void visit(MethodCallStatement methodCallStatement, int p)
        {

        }

        public void visit(AssignmentStatement assignmentStatement, int p)
        {

        }

        public void visit(LocalVarStatement localVarStatement, int p)
        {

        }

        public void visit(ConstantChar constantChar, int p)
        {

        }

        public void visit(ConstantInt constantInt, int p)
        {

        }

        public void visit(ConstantFloat constantFloat, int p)
        {

        }

        public void visit(ConstantNil constantNil, int p)
        {

        }

        public void visit(ConstantBool constantBool, int p)
        {

        }

        public void visit(ConstantList constantList, int p)
        {

        }

        public void visit(ConstantSet constantSet, int p)
        {

        }

        public void visit(ConstantMap constantMap, int p)
        {

        }

        public void visit(UnaryOperator unaryOperator, int p)
        {

        }

        public void visit(SetListUnaryOperator setListUnaryOperator, int p)
        {

        }

        public void visit(MapUnaryOperator mapUnaryOperator, int p)
        {

        }

        public void visit(BinaryOperator binaryOperator, int p)
        {

        }

        public void visit(BoolBinaryOperator boolBinaryOperator, int p)
        {

        }

        public void visit(NumericBinaryOperator numericBinaryOperator, int p)
        {

        }

        public void visit(SetListBinaryOperator setListBinaryOperator, int p)
        {

        }

        public void visit(MapBinaryOperator mapBinaryOperator, int p)
        {

        }

        public void visit(QualifiedIdentifier qualifiedIdentifier, int p)
        {

        }

        public void visit(Reference reference, int p)
        {

        }

        public void visit(AccessExpression accessExpression, int p)
        {

        }

        public void visit(ConditionalOperator conditionalOperator, int p)
        {

        }

        public void visit(OpaqueType namedType, int p)
        {

        }

        public bool visit(NamedActionSymbol namedActionSymbol, int p)
        {
            return true;
        }


        public void visit(ConstantTuple constantTuple, int p)
        {
        }


        #region SyntaxTreeVisitor Member


        public bool visit(FunctionType functionType, int p)
        {
            return true;
        }

        #endregion
    }
}