/*
 *  Copyright 2016 Anyware Services
 *
 *  Licensed 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.ametys.plugins.core.ui.script;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;

import javax.script.ScriptException;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.components.ContextHelper;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.graalvm.polyglot.HostAccess;
import org.graalvm.polyglot.PolyglotException;
import org.graalvm.polyglot.Source;
import org.graalvm.polyglot.Value;

import org.ametys.core.right.RightManager;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.util.DateUtils;
import org.ametys.core.util.I18nUtils;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Handler to describe and execute server scripts
 */
public class ScriptHandler extends AbstractLogEnabled implements Component, Serviceable, Contextualizable
{
    /** Avalon role. */
    public static final String ROLE = ScriptHandler.class.getName();
    
    /** Right for script execution */
    protected static final String RIGHT_EXECUTE_SCRIPTS = "CORE_Rights_ExecuteScript";
    
    private static final String __SCRIPT_INSERT_CLEANUP_MANAGER = "var __cleanup_manager = { _registered:[], register: function (f) { this._registered.push(f) }, cleanup : function () { this._registered.forEach(function (f) {f()} ) } };";
    private static final String __SCRIPT_INSERT_RUN_MAIN = "var __result; try { __result = main(); } finally { __cleanup_manager.cleanup() } __result";

    /** The script binding extension point */
    protected ScriptBindingExtensionPoint _scriptBindingEP;
    
    /** The right manager */
    protected RightManager _rightManager;
    
    /** The current user provider*/
    protected CurrentUserProvider _currentUserProvider;
    
    /** The i18n utils */
    protected I18nUtils _i18nUtils;
    
    /** The avalon context */
    protected Context _context;

    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _scriptBindingEP = (ScriptBindingExtensionPoint) serviceManager.lookup(ScriptBindingExtensionPoint.ROLE);
        _rightManager = (RightManager) serviceManager.lookup(RightManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) serviceManager.lookup(CurrentUserProvider.ROLE);
        _i18nUtils = (I18nUtils) serviceManager.lookup(I18nUtils.ROLE);
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    /**
     * Builds the {@link ScriptExecArguments} object from the untyped JS object (seen as a Map in Java)
     * @param arguments The untyped JS object
     * @return the {@link ScriptExecArguments}
     */
    protected ScriptExecArguments buildExecArguments(Map<String, Object> arguments)
    {
        String script = (String) arguments.get("script");
        return () -> script;
    }
    
    /**
     * Execute a script in the js admin console.
     * @param script The script as a String.
     * @return A map of information on the script execution.
     * @throws ScriptException If an error occurs
     */
    @Callable(right = RIGHT_EXECUTE_SCRIPTS, context =  "/${WorkspaceName}")
    public final Map<String, Object> executeScript(String script) throws ScriptException
    {
        return executeScript(Map.of("script", script));
    }

    /**
     * Execute a script in the js console.
     * @param arguments The map of arguments. Must contains at least the argument "script"
     * @return A map of information on the script execution.
     * @throws ScriptException If an error occurs
     */
    @Callable(right = RIGHT_EXECUTE_SCRIPTS, context =  "/${WorkspaceName}")
    public Map<String, Object> executeScript(Map<String, Object> arguments) throws ScriptException
    {
        ScriptExecArguments execArgs = buildExecArguments(arguments);
        String workspaceName = getWorkspaceName();
        return _executeScript(execArgs, null, workspaceName);
    }
    
    /**
     * Execute a script in the js console.
     * @param script The script as a String.
     * @param scriptVariables map of variables that will be added to the script.
     * @param workspaceName The workspace name
     * @return A map of information on the script execution.
     * @throws ScriptException If an error occurs
     */
    public Map<String, Object> executeScript(String script, Map<String, Object> scriptVariables, String workspaceName) throws ScriptException
    {
        ScriptExecArguments execArgs = buildExecArguments(Map.of("script", script));
        return _executeScript(execArgs, scriptVariables, workspaceName);
    }
    
    /**
     * Execute a script in the js admin console.
     * @param arguments The arguments for script execution
     * @param scriptVariables map of variables that will be added to the script.
     * @param workspaceName The workspace name
     * @return A map of information on the script execution.
     * @throws ScriptException If an error occurs
     */
    protected Map<String, Object> _executeScript(ScriptExecArguments arguments, Map<String, Object> scriptVariables, String workspaceName) throws ScriptException
    {
        String nonEmptyWorkspaceName = StringUtils.isEmpty(workspaceName) ? "admin" : workspaceName;
        
        Map<String, Object> results = new HashMap<>();
        
        results.put("start", DateUtils.dateToString(new Date()));
        
        var output = new ByteArrayOutputStream();
        var errorOutput = new ByteArrayOutputStream();
        
        HostAccess hostAccess = HostAccess.newBuilder(HostAccess.ALL)
                // JS arrays must be converted into Java Lists
                .targetTypeMapping(List.class, Object.class, null, v -> v)
                .build();
        org.graalvm.polyglot.Context polyglotContext = org.graalvm.polyglot.Context.newBuilder("js")
                .allowAllAccess(true)
                .allowHostAccess(hostAccess)
                .option("engine.WarnInterpreterOnly", "false")
                .out(output)
                .err(errorOutput)
                .build();
        
        final String scriptName = "generated script";
        
        Map<String, Object> variables = new HashMap<>();
        if (scriptVariables != null)
        {
            variables.putAll(scriptVariables);
        }
        
        List<ScriptBinding> scriptBindings = _scriptBindingEP.getScriptBindings(nonEmptyWorkspaceName);
        
        try (polyglotContext)
        {
            List<String> scriptTexts = new ArrayList<>();
            String script = arguments.script();
            scriptTexts.add(script);
            scriptTexts.add(__SCRIPT_INSERT_CLEANUP_MANAGER);
            _setScriptBindings(variables, scriptTexts, scriptBindings, arguments);
            scriptTexts.add(__SCRIPT_INSERT_RUN_MAIN);
            
            // Create bindings
            Value jsBindings = polyglotContext.getBindings("js");
            for (Entry<String, Object> entry : variables.entrySet())
            {
                jsBindings.putMember(entry.getKey(), entry.getValue());
            }
            
            // Execute script
            String scriptText = StringUtils.join(scriptTexts, "\n");
            Source source = Source.newBuilder("js", scriptText, scriptName)
                    .build();
            Object scriptResult = polyglotContext.eval(source).as(Object.class);
            if (scriptResult != null)
            {
                results.put("result", processScriptResult(results, scriptResult, arguments));
            }
        }
        catch (Throwable t)
        {
            Throwable e = t;
            if (t instanceof PolyglotException)
            {
                e = new PolyglotWithCauseException((PolyglotException) t);
            }
            
            results.put("message", StringUtils.defaultString(e.getMessage()));
            results.put("stacktrace", ExceptionUtils.getStackTrace(e));
            getLogger().error("An exception occurred while running script", e);
        }
        finally
        {
            results.put("end", DateUtils.dateToString(new Date()));
            // Script output and error.
            results.put("output", output.toString()); // #toString() without Charset arg in order to use the platform's default character set (which is used by GraalVM)
            results.put("error", errorOutput.toString()); // #toString() without Charset arg in order to use the platform's default character set (which is used by GraalVM)
            
            for (String extensionId : _scriptBindingEP.getExtensionsIds())
            {
                ScriptBinding scriptBinding = _scriptBindingEP.getExtension(extensionId);
                
                scriptBinding.cleanVariables(variables);
            }
        }
        
        return results;
    }

    private void _setScriptBindings(Map<String, Object> variables, List<String> scriptText, List<ScriptBinding> scriptBindings, ScriptExecArguments execArgs)
    {
        scriptText.add("Ametys = {};" 
                + "Ametys.namespace = function(namespace, attributes) {" 
                + "    var namespaces = namespace.split(\".\");" 
                + "    var prefix = \"\";" 
                + "    for (var i = 0; i < namespaces.length; i++)" 
                + "    {" 
                + "        var ns = (prefix ? prefix + \".\" : \"\") + namespaces[i]; " 
                + "        eval(\"try {\" + ns + \" = \" + ns + \" || {} } catch (e) {\" + ns + \" = {}}\");" 
                + "        prefix = ns;" 
                + "    }"
                + "    var newNamespace = eval(namespace);"
                + "    if (attributes)"
                + "    {"
                + "        for (var i in attributes)"
                + "        {"
                + "            newNamespace[i] = attributes[i];"
                + "        }"
                + "    }"
                + "    return newNamespace;"
                + "}");
        
        for (ScriptBinding scriptBinding : scriptBindings)
        {
            Map<String, Object> scriptBindingVariables = scriptBinding.getVariables(execArgs);
            if (scriptBindingVariables != null)
            {
                variables.putAll(scriptBindingVariables);
            }
            
            String scriptVariables = scriptBinding.getVariablesScripts();
            if (scriptVariables != null)
            {
                scriptText.add(scriptVariables);
            }
        }

        for (ScriptBinding scriptBinding : scriptBindings)
        {
            String scriptBindingFunctions = scriptBinding.getFunctions();
            if (scriptBindingFunctions != null)
            {
                scriptText.add(scriptBindingFunctions);
            }
        }
    }
    
    /**
     * Process the result of the script
     * @param results The results map, available to fill
     * @param scriptResult The result of the script
     * @param execArgs The script execution arguments
     * @return The processed result
     */
    protected Object processScriptResult(Map<String, Object> results, Object scriptResult, ScriptExecArguments execArgs)
    {
        return getProcessor().process(results, scriptResult);
    }
    
    /**
     * Returns the {@link ResultProcessor} used to process script result.
     * @return the {@link ResultProcessor}.
     */
    protected ResultProcessor getProcessor()
    {
        return new ResultProcessor(); 
    }
    
    private void _addToBinding(List<Map<String, Object>> descriptionsList, Map<? extends Object, ScriptBindingDocumentation> descriptions, String type)
    {
        if (descriptions != null)
        {
            for (Entry<? extends Object, ScriptBindingDocumentation> description : descriptions.entrySet())
            {
                Object name = description.getKey();
                String id = type + "-" + name;
                
                Map<String, Object> scriptVariable = new HashMap<>();
                scriptVariable.put("id", id);
                scriptVariable.put("type", type);
                scriptVariable.putAll(description.getValue().asMap());
                
                if (descriptionsList.stream().map(e -> e.get("id")).anyMatch(i -> id.equals(i)))
                {
                    getLogger().warn("Multiple ScriptBinding use the same " + type + " name : '" + name + "'. Only one of these " + type + "s will be available and the associated documentation may not match.");
                }
                else
                {
                    descriptionsList.add(scriptVariable);
                }
            }
        }
    }
    
    /**
     * Get the list of variables and functions descriptions currently registered for the Scripts.
     * @return The list of variables and functions, as describes by the script bindings available.
     */
    @Callable
    public List<Map<String, Object>> getScriptBindingDescription()
    {
        List<Map<String, Object>> descriptionsList = new ArrayList<>();
        
        List<ScriptBinding> scriptBindings = _scriptBindingEP.getScriptBindings(getWorkspaceName());
        for (ScriptBinding scriptBinding : scriptBindings)
        {
            _addToBinding(descriptionsList, scriptBinding.getVariablesDescriptions(), "variable");
            _addToBinding(descriptionsList, scriptBinding.getFunctionsDescriptions(), "function");
            _addToBinding(descriptionsList, scriptBinding.getTutorials(), "tutorial");
        }
        
        return descriptionsList;
    }
    
    /**
     * Gets the workspace name
     * @return the workspace name
     */
    protected String getWorkspaceName()
    {
        // By default, if there is no workspace, such as a script executed from a scheduled task,
        // we want the script to be iso-functional with a script executed from the admin
        return Optional.of(_context)
                .map(ContextHelper::getRequest)
                .map(req -> req.getAttribute("workspaceName"))
                .filter(String.class::isInstance)
                .map(String.class::cast)
                .orElse("admin");
    }
    
    /**
     * A processor for scripts results.
     */
    protected static class ResultProcessor
    {
        /**
         * Processes the script result.
         * @param results the current results map.
         * @param scriptResult the actual script Result.
         * @return the processed script result.
         */
        protected Object process(Map<String, Object> results, Object scriptResult)
        {
            if (scriptResult instanceof Collection)
            {
                // Collection
                List<Object> elements = new ArrayList<>();
                for (Object obj : (Collection<?>) scriptResult)
                {
                    elements.add(process(results, obj));
                }
                
                return elements;
            }
            else if (scriptResult instanceof Iterator)
            {
                List<Object> objs = new ArrayList<>();
                Iterator it = (Iterator) scriptResult;
                while (it.hasNext())
                {
                    objs.add(process(results, it.next()));
                }
                
                return objs;
            }
            else if (scriptResult instanceof Map)
            {
                // Map
                Map<Object, Object> elements = new HashMap<>();
                for (Object key : ((Map) scriptResult).keySet())
                {
                    Object value = ((Map) scriptResult).get(key);
                    Object elementKey = process(results, key);
                    Object elementValue = process(results, value);
                    elements.put(elementKey, elementValue);
                }
                
                return elements;
            }
            else
            {
                return _processSingleObject(scriptResult);
            }
        }
        
        /**
         * Transform an object that is not a collection
         * @param scriptResult the result object
         * @return the object transformed for return
         */
        protected Object _processSingleObject(Object scriptResult)
        {
            return scriptResult != null ? scriptResult.toString() : null;
        }
    }
    
    private static final class PolyglotWithCauseException extends RuntimeException
    {
        PolyglotException _initial;
        
        PolyglotWithCauseException(PolyglotException initial)
        {
            super(initial.getMessage());
            _initial = initial;
        }

        private String _getStackTrace()
        {
            StringBuffer sb = new StringBuffer();
            
            if (_initial.isHostException())
            {
                sb.append(StringUtils.substringBefore(ExceptionUtils.getStackTrace(_initial), "Caused by host exception:"));
                
                Throwable subException = _initial.asHostException(); 
                if (subException.getCause() != null)
                {
                    sb.append("Caused by: ");
                    sb.append(ExceptionUtils.getStackTrace(subException.getCause()));
                }
            }
            else
            {
                sb.append(ExceptionUtils.getStackTrace(_initial));
            }
            
            return sb.toString();
        }
        
        @Override
        public void printStackTrace(PrintStream s)
        {
            s.append(_getStackTrace());
        }
        
        @Override
        public void printStackTrace(PrintWriter s)
        {
            s.append(_getStackTrace());
        }
    }
}