/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.commons.jexl3.internal;
  
  import org.apache.commons.jexl3.JexlContext;
  import org.apache.commons.jexl3.JexlInfo;
  import org.apache.commons.jexl3.JxltEngine;
  import org.apache.commons.jexl3.internal.TemplateEngine.Block;
  import org.apache.commons.jexl3.internal.TemplateEngine.BlockType;
  import org.apache.commons.jexl3.internal.TemplateEngine.TemplateExpression;
  import org.apache.commons.jexl3.parser.ASTJexlScript;
  import org.apache.commons.jexl3.JexlException;
  import org.apache.commons.jexl3.JexlOptions;
  import org.apache.commons.jexl3.parser.ASTArguments;
  import org.apache.commons.jexl3.parser.ASTFunctionNode;
  import org.apache.commons.jexl3.parser.ASTIdentifier;
  import org.apache.commons.jexl3.parser.ASTNumberLiteral;
  import org.apache.commons.jexl3.parser.JexlNode;
  
  import java.io.Reader;
  import java.io.Writer;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.TreeMap;
  
  /**
   * A Template instance.
   */
  public final class TemplateScript implements JxltEngine.Template {
      /** The prefix marker. */
      private final String prefix;
      /** The array of source blocks. */
      private final Block[] source;
      /** The resulting script. */
      private final ASTJexlScript script;
      /** The TemplateEngine expressions called by the script. */
      private final TemplateExpression[] exprs;
      /** The engine. */
      private final TemplateEngine jxlt;
  
      /**
       * Creates a new template from an character input.
       * @param engine the template engine
       * @param jexlInfo the source info
       * @param directive the prefix for lines of code; can not be "$", "${", "#" or "#{"
                    since this would preclude being able to differentiate directives and jxlt expressions
       * @param reader    the input reader
       * @param parms     the parameter names
       * @throws NullPointerException     if either the directive prefix or input is null
       * @throws IllegalArgumentException if the directive prefix is invalid
       */
      public TemplateScript(final TemplateEngine engine,
                            final JexlInfo jexlInfo,
                            final String directive,
                            final Reader reader,
                            final String... parms) {
          if (directive == null) {
              throw new NullPointerException("null prefix");
          }
          final String engineImmediateCharString = Character.toString(engine.getImmediateChar());
          final String engineDeferredCharString = Character.toString(engine.getDeferredChar());
  
          if (engineImmediateCharString.equals(directive)
                  || engineDeferredCharString.equals(directive)
                  || (engineImmediateCharString + "{").equals(directive)
                  || (engineDeferredCharString + "{").equals(directive)) {
              throw new IllegalArgumentException(directive + ": is not a valid directive pattern");
          }
          if (reader == null) {
              throw new NullPointerException("null input");
          }
          this.jxlt = engine;
          this.prefix = directive;
          final List<Block> blocks = jxlt.readTemplate(prefix, reader);
          final List<TemplateExpression> uexprs = new ArrayList<>();
          final StringBuilder strb = new StringBuilder();
          int nuexpr = 0;
          int codeStart = -1;
          int line = 1;
          for (int b = 0; b < blocks.size(); ++b) {
              final Block block = blocks.get(b);
              final int bl = block.getLine();
              while(line < bl) {
                 strb.append("//\n");
                 line += 1;
             }
             if (block.getType() == BlockType.VERBATIM) {
                 strb.append("jexl:print(");
                 strb.append(nuexpr++);
                 strb.append(");\n");
                 line += 1;
             } else {
                 // keep track of first block of code, the frame creator
                 if (codeStart < 0) {
                     codeStart = b;
                 }
                 final String body = block.getBody();
                 strb.append(body);
                 for(int c = 0; c < body.length(); ++c) {
                     if (body.charAt(c) == '\n') {
                         line += 1;
                     }
                 }
             }
         }
         // create the script
         final JexlInfo info = jexlInfo == null? jxlt.getEngine().createInfo() : jexlInfo;
         // allow lambda defining params
         final Scope scope = parms == null ? null : new Scope(null, parms);
         script = jxlt.getEngine().parse(info.at(1, 1), false, strb.toString(), scope).script();
         // seek the map of expression number to scope so we can parse Unified
         // expression blocks with the appropriate symbols
         final Map<Integer, JexlNode.Info> minfo = new TreeMap<>();
         collectPrintScope(script.script(), minfo);
         // jexl:print(...) expression counter
         int jpe = 0;
         // create the exprs using the intended scopes
         for (final Block block : blocks) {
             if (block.getType() == BlockType.VERBATIM) {
                 final JexlNode.Info ji = minfo.get(jpe);
                 TemplateExpression te;
                 // no node info means this verbatim is surrounded by comments markers;
                 // expr at this index is never called
                 if (ji != null) {
                     te = jxlt.parseExpression(ji, block.getBody(), scopeOf(ji));
                 } else {
                     te = jxlt.new ConstantExpression(block.getBody(), null);
                 }
                 uexprs.add(te);
                 jpe += 1;
             }
         }
         source = blocks.toArray(new Block[0]);
         exprs = uexprs.toArray(new TemplateExpression[0]);
     }
 
     /**
      * Private ctor used to expand deferred expressions during prepare.
      * @param engine    the template engine
      * @param thePrefix the directive prefix
      * @param theSource the source
      * @param theScript the script
      * @param theExprs  the expressions
      */
     TemplateScript(final TemplateEngine engine,
                    final String thePrefix,
                    final Block[] theSource,
                    final ASTJexlScript theScript,
                    final TemplateExpression[] theExprs) {
         jxlt = engine;
         prefix = thePrefix;
         source = theSource;
         script = theScript;
         exprs = theExprs;
     }
 
     /**
      * Gets the scope from an info.
      * @param info the node info
      * @return the scope
      */
     private static Scope scopeOf(final JexlNode.Info info) {
         JexlNode walk = info.getNode();
         while(walk != null) {
             if (walk instanceof ASTJexlScript) {
                 return ((ASTJexlScript) walk).getScope();
             }
             walk = walk.jjtGetParent();
         }
         return null;
     }
 
     /**
      * Collects the scope surrounding a call to jexl:print(i).
      * <p>This allows to later parse the blocks with the known symbols
      * in the frame visible to the parser.
      * @param node the visited node
      * @param minfo the map of printed expression number to node info
      */
     private static void collectPrintScope(final JexlNode node, final Map<Integer, JexlNode.Info> minfo) {
         final int nc = node.jjtGetNumChildren();
         if (node instanceof ASTFunctionNode && nc == 2) {
             // 0 must be the prefix jexl:
             final ASTIdentifier nameNode = (ASTIdentifier) node.jjtGetChild(0);
             if ("print".equals(nameNode.getName()) && "jexl".equals(nameNode.getNamespace())) {
                 final ASTArguments argNode = (ASTArguments) node.jjtGetChild(1);
                 if (argNode.jjtGetNumChildren() == 1) {
                     // seek the epression number
                     final JexlNode arg0 = argNode.jjtGetChild(0);
                     if (arg0 instanceof ASTNumberLiteral) {
                         final int exprNumber = ((ASTNumberLiteral) arg0).getLiteral().intValue();
                         minfo.put(exprNumber, new JexlNode.Info(nameNode));
                         return;
                     }
                 }
             }
         }
         for (int c = 0; c < nc; ++c) {
             collectPrintScope(node.jjtGetChild(c), minfo);
         }
     }
 
     /**
      * @return script
      */
     ASTJexlScript getScript() {
         return script;
     }
 
     /**
      * @return exprs
      */
     TemplateExpression[] getExpressions() {
         return exprs;
     }
 
     @Override
     public String toString() {
         final StringBuilder strb = new StringBuilder();
         for (final Block block : source) {
             block.toString(strb, prefix);
         }
         return strb.toString();
     }
 
     @Override
     public String asString() {
         final StringBuilder strb = new StringBuilder();
         int e = 0;
         for (final Block block : source) {
             if (block.getType() == BlockType.DIRECTIVE) {
                 strb.append(prefix);
                 strb.append(block.getBody());
             } else {
                 exprs[e++].asString(strb);
             }
         }
         return strb.toString();
     }
 
     @Override
     public TemplateScript prepare(final JexlContext context) {
         final Engine jexl = jxlt.getEngine();
         final JexlOptions options = jexl.evalOptions(script, context);
         final Frame frame = script.createFrame((Object[]) null);
         final TemplateInterpreter.Arguments targs = new TemplateInterpreter
                 .Arguments(jxlt.getEngine())
                 .context(context)
                 .options(options)
                 .frame(frame);
         final Interpreter interpreter = jexl.createTemplateInterpreter(targs);
         final TemplateExpression[] immediates = new TemplateExpression[exprs.length];
         for (int e = 0; e < exprs.length; ++e) {
             try {
                 immediates[e] = exprs[e].prepare(interpreter);
             } catch (final JexlException xjexl) {
                 final JexlException xuel = TemplateEngine.createException(xjexl.getInfo(), "prepare", exprs[e], xjexl);
                 if (jexl.isSilent()) {
                     if (jexl.logger.isWarnEnabled()) {
                         jexl.logger.warn(xuel.getMessage(), xuel.getCause());
                     }
                     return null;
                 }
                 throw xuel;
             }
         }
         return new TemplateScript(jxlt, prefix, source, script, immediates);
     }
 
     @Override
     public void evaluate(final JexlContext context, final Writer writer) {
         evaluate(context, writer, (Object[]) null);
     }
 
     @Override
     public void evaluate(final JexlContext context, final Writer writer, final Object... args) {
         final Engine jexl = jxlt.getEngine();
         final JexlOptions options = jexl.evalOptions(script, context);
         final Frame frame = script.createFrame(args);
         final TemplateInterpreter.Arguments targs = new TemplateInterpreter
                 .Arguments(jexl)
                 .context(context)
                 .options(options)
                 .frame(frame)
                 .expressions(exprs)
                 .writer(writer);
         final Interpreter interpreter = jexl.createTemplateInterpreter(targs);
         interpreter.interpret(script);
     }
 
     @Override
     public Set<List<String>> getVariables() {
         final Engine.VarCollector collector = jxlt.getEngine().varCollector();
         for (final TemplateExpression expr : exprs) {
             expr.getVariables(collector);
         }
         return collector.collected();
     }
 
     @Override
     public String[] getParameters() {
         return script.getParameters();
     }
 
     @Override
     public Map<String, Object> getPragmas() {
         return script.getPragmas();
     }
 }