package org.tinyjee.maven.dim.extensions;
   
   import org.apache.maven.doxia.logging.Log;
   import org.codehaus.plexus.util.FileUtils;
   import org.tinyjee.maven.dim.spi.Globals;
   import org.tinyjee.maven.dim.spi.UrlFetcher;
   import org.tinyjee.maven.dim.utils.AbstractAliasHandler;
   
   import java.io.File;
  import java.io.PrintWriter;
  import java.io.StringWriter;
  import java.net.URL;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import static org.tinyjee.maven.dim.IncludeMacroSignature.PARAM_SOURCE_CONTENT;
  import static org.tinyjee.maven.dim.spi.ResourceResolver.findSource;
  
  /**
   * ScriptInvoker is a 'source-class' compatible helper class providing a runtime environment that allows to load and execute
   * script code using the JSR-223 interface (scripting for java).
   * <p/>
   * Scripts can provide input for velocity templates or they can produce content directly. When invoked, this extension first
   * populates all given macro parameters within the script context, evaluates the script and copies any changes or newly allocated
   * variables back into the original parameters map.
   * When an additional {@code source} was specified these resulting parameters are available in the template via {@code $paramName}.
   * <br/>
   * Any text output that is produced by scripts is set into "{@code source-content}" and is displayed when <b>no</b> {@code source} is given.
   * <p/>
   * The following global variables are exposed in the script context, in addition to the standard template parameters:
   * <ul>
   * <li>"{@code globals}" points to an instance of "{@link Globals}" which allows to access base path, path resolution logic,
   * loading &amp; attaching content, etc.</li>
   * <li>"{@code scriptName}" is a string that is filled with the absolute path to the script file.</li>
   * </ul>
   * <p/>
   * This extension is only useful when JSR-223 is available. Starting from Java 6, JavaScript is the only script engine
   * that is available by default. Adding other script engines to the dependency set of module or site-plugin enables scripting
   * languages like: Groovy, Ruby, Python and others that offer integration with JSR-223.
   * <p/>
   * <b>Usage:</b><div><code>
   * %{include|source=template.vm|source-class=org.tinyjee.maven.dim.extensions.ScriptInvoker|script=my-script.js}
   * <br/>
   * %{include|source-class=org.tinyjee.maven.dim.extensions.ScriptInvoker|script=my-script.js}
   * </code></div>
   * or when using the alias:<div><code>
   * %{include|source=template.vm|source-script=my-script.js}
   * <br/>
   * %{include|source-script=my-script.js}
   * </code></div>
   * <p/>
   * <b>Notes:</b>
   * <ul>
   * <li>Under normal circumstances it is preferable to create your own 'source-class' compatible helper class using Java as
   * it adds unit testing and compiler checks. Scripting however, when combined with "{@code site:run}" allows to create content with
   * scripts very quickly as no additional compilation step is needed to see live changes to the site.</li>
   * <li>Scripts run in a request scope with global bindings (global variables) being shared amongst executions and script engines.
   * Whether this has an effect on the scripts depends on the implementation of the script interpreter and the language itself.</li>
   * </ul>
   *
   * @author Juergen_Kellerer, 2011-10-15
   */
  public class ScriptInvoker extends HashMap<String, Object> {
  
  	private static final long serialVersionUID = 8955658194210732920L;
  
  	private static final Pattern EVAL_PREFIX_PATTERN = Pattern.compile("^eval\\[([^\\[\\]\\s]+)\\]:(.+)$");
  
  	/**
  	 * Implements the "{@link org.tinyjee.maven.dim.extensions.ScriptInvoker#PARAM_ALIAS}" alias functionality.
  	 */
  	public static class AliasHandler extends AbstractAliasHandler {
  		/**
  		 * Constructs the handler (Note: Is called by {@link org.tinyjee.maven.dim.spi.RequestParameterTransformer#TRANSFORMERS}).
  		 */
  		public AliasHandler() {
  			super(PARAM_ALIAS, PARAM_SCRIPT, ScriptInvoker.class.getName());
  		}
  	}
  
  	/**
  	 * Defines a shortcut for the request properties 'source-class' and 'script'.
  	 * <p/>
  	 * If this parameter is present inside the request parameters list, the system will effectively behave as if
  	 * 'source-class' and 'script' where set separately.
  	 */
  	public static final String PARAM_ALIAS = "source-script";
  
  	/**
  	 * Sets the URL or local path to the script file to load and evaluate.
  	 * <p/>
  	 * The specified file is resolved in exactly the same way as when using the parameter "<code>source</code>" (see Macro reference).
  	 * <p/>
  	 * <i>Notes:</i><ul>
  	 * <li>In addition to setting a file path, the parameter can be used to define an inline script snippet using the syntax
  	 * "{@code eval[type]:script...}".
  	 * E.g. for javascript this looks like {@code %{include|source-script=eval[js]:print("Hello World");}}.</li>
 	 * <li>When no further source is specified, any text output produced by the script (e.g. via {@code print "some text"})
 	 * is included into the current page. STDERR is always sent to both locations, the build logs and the page. Unhandled script errors
 	 * will break the build.</li>
 	 * <li>As velocity template processing is applied at a later stage, the script output is processed by velocity unless the parameter
 	 * "{@code source-is-template}" is set to <i>false</i> or another "{@code source}" was specified. Thus a script can dynamically
 	 * generate a velocity template and provide the parameters for the template context (though this might be kind of a overkill).</li>
 	 * </ul>
 	 */
 	public static final String PARAM_SCRIPT = "script";
 
 	/**
 	 * Defines the invocation interface to enable pluging a executor.
 	 */
 	interface ScriptExecutor {
 		void execute(Map<String, Object> context, String scriptExtension, String scriptContent, String scriptName) throws Exception;
 	}
 
 	private static ScriptExecutor executor;
 
 	private static synchronized ScriptExecutor getExecutor() {
 		if (executor == null) {
 			try {
 				final String executorClass = System.getProperty("dim.script.invoker.engine.class",
 						"org.tinyjee.maven.dim.extensions.ScriptExecutorJSR223");
 				executor = (ScriptExecutor) Class.forName(executorClass).newInstance();
 			} catch (Throwable e) {
 				StringWriter buffer = new StringWriter();
 				e.printStackTrace(new PrintWriter(buffer));
 				final String errorMessage = e.toString(), stackTrace = buffer.toString();
 
 				executor = new ScriptExecutor() {
 					public void execute(Map<String, Object> context,
 					                    String scriptExtension, String scriptContent, String scriptName) throws Exception {
 						final Log log = Globals.getLog();
 						log.error("Failed executing script '" + scriptName + "':\n----\n" + scriptContent + "\n----\n, " +
 								"caused by: " + errorMessage + "\n" + stackTrace);
 						context.put(PARAM_SOURCE_CONTENT, "Failed executing script '" + scriptName + "', caused by: " + errorMessage);
 					}
 				};
 			}
 		}
 		return executor;
 	}
 
 	/**
 	 * Constructs a new Script Invoker.
 	 *
 	 * @param baseDir       the base dir to of the maven module.
 	 * @param requestParams the request params of the macro call.
 	 * @throws Exception In case of loading or transforming fails.
 	 */
 	public ScriptInvoker(File baseDir, Map<String, Object> requestParams) throws Exception {
 
 		putAll(requestParams);
 
 		final String script = (String) get(PARAM_SCRIPT);
 		if (script == null) throw new IllegalArgumentException("No script (parameter '" + PARAM_SCRIPT + "') was defined.");
 
 		final String scriptExtension, scriptContent, scriptName;
 
 		final Matcher evalMatcher = EVAL_PREFIX_PATTERN.matcher(script);
 		if (evalMatcher.matches()) {
 			scriptExtension = evalMatcher.group(1);
 			scriptContent = evalMatcher.group(2);
 			scriptName = baseDir + File.separator + "local." + scriptExtension;
 		} else {
 			final URL scriptURL = findSource(baseDir, script);
 			scriptContent = UrlFetcher.readerToString(UrlFetcher.getReadableSource(scriptURL), true);
 			scriptName = "file".equals(scriptURL.getProtocol()) ? new File(scriptURL.toURI()).toString() : scriptURL.toString();
 			scriptExtension = FileUtils.extension(scriptName);
 		}
 
 		put("globals", Globals.getInstance());
 		put("scriptName", scriptName);
 
 		getExecutor().execute(this, scriptExtension, scriptContent, scriptName);
 	}
 }