/**
    * This file Copyright (c) 2003-2016 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.module.groovy.console;
  
  import info.magnolia.context.Context;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.i18nsystem.SimpleTranslator;
  import info.magnolia.module.groovy.support.classes.MgnlGroovyClassLoader;
  import info.magnolia.objectfactory.Components;
  import info.magnolia.ui.api.message.Message;
  import info.magnolia.ui.api.message.MessageType;
  import info.magnolia.ui.framework.message.MessagesManager;
  
  import java.io.ByteArrayInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.StringWriter;
  import java.io.Writer;
  import java.util.Objects;
  import java.util.concurrent.Callable;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.Future;
  
  import org.apache.commons.lang3.CharEncoding;
  import org.codehaus.groovy.control.CompilationFailedException;
  import org.codehaus.groovy.runtime.InvokerHelper;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.vaadin.event.UIEvents.PollEvent;
  import com.vaadin.event.UIEvents.PollListener;
  import com.vaadin.ui.UI;
  
  import groovy.lang.Binding;
  import groovy.lang.GroovyCodeSource;
  import groovy.lang.GroovyShell;
  import groovy.lang.Script;
  
  /**
   * Groovy console using {@link MgnlGroovyClassLoader} to parse Groovy source.
   */
  public class MgnlGroovyConsole extends GroovyShell {
  
      private static final Logger log = LoggerFactory.getLogger(MgnlGroovyConsole.class);
  
      private static final MgnlGroovyClassLoader GROOVY_CLASS_LOADER = new MgnlGroovyClassLoader();
  
      private static final int POLL_INTERVAL = 1000;
  
      private MessagesManager messagesManager;
  
      private SimpleTranslator i18n;
  
      /**
       * @deprecated since 2.4.6, please use {@link MgnlGroovyConsole#MgnlGroovyConsole(Binding, MessagesManager, SimpleTranslator))}
       */
      public MgnlGroovyConsole(Binding binding) {
          this(binding, Components.getComponent(MessagesManager.class), Components.getComponent(SimpleTranslator.class));
      }
  
      public MgnlGroovyConsole(Binding binding, MessagesManager messagesManager, SimpleTranslator simpleTranslator) {
          super(binding);
          this.messagesManager = messagesManager;
          this.i18n = simpleTranslator;
      }
 
     /**
      * Creates and run a {@link Script} synchronously.
      * {@link MgnlContext} is wrapped into a {@link MgnlGroovyConsoleContext} for the script running time
      * and then set back to its original value.
      * 
      * @deprecated since 2.4.6, please use {@link #runAsync(String, ScriptCallback)} instead.
      */
     @Deprecated
     public Object evaluate(InputStream in, String fileName, Writer out) throws CompilationFailedException {
         Context originalCtx = MgnlContext.getInstance();
         MgnlGroovyConsoleContext groovyCtx = new MgnlGroovyConsoleContext(originalCtx);
         MgnlContext.setInstance(groovyCtx);
 
         Script script = null;
         try {
             script = createScript(in, out);
             script.setProperty("ctx", MgnlContext.getInstance());
             return script.run();
         } catch (IOException e) {
             throw new RuntimeException(e);
         } finally {
             if (script != null) {
                 InvokerHelper.removeClass(script.getClass());
             }
             MgnlContext.setInstance(originalCtx);
         }
     }
 
     /**
      * Runs a {@link Script} asynchronously in a separate thread from the UI one.
      * This prevents AdminCentral from being frozen until the script is done, in case of long running scripts.
      * <p>
      * {@link MgnlContext} is wrapped into a {@link MgnlGroovyConsoleContext} within the thread running the script.
      *
      * @throws IOException
      * @throws InterruptedException
      */
     public void runAsync(String source, UI ui, ScriptCallback callback) throws IOException, InterruptedException {
         Writer out = new StringWriter();
         final Script script = createScript(source, out);
 
         final Context originalCtx = MgnlContext.getInstance();
         final MgnlGroovyConsoleContext groovyCtx = new MgnlGroovyConsoleContext(originalCtx);
 
         ExecutorService executorService = Executors.newSingleThreadExecutor();
 
         final Future<Object> task = executorService.submit(new Callable<Object>() {
             @Override
             public Object call() throws Exception {
                 // this context is local to the thread running the script
                 // which is separate from the UI one, so no need to reset it.
                 MgnlContext.setInstance(groovyCtx);
                 script.setProperty("ctx", groovyCtx);
                 return script.run();
             }
         });
 
         // Allow a quick task to finish w/o starting polling. If done, just return.
         // Otherwise users would likely get the impression of a sluggish console which needs one or two seconds
         // just to return e.g. ctx.getJCRSession('website') or 1+1
         Thread.sleep(200);
         if (task.isDone()) {
             handleScriptDone(callback, task, ui, out, messagesManager, i18n, false);
             return;
         }
 
         // Remove any PollListener(s) possibly registered by us in a previous script run
         for (Object listener : ui.getListeners(PollEvent.class)) {
             if (listener instanceof ScriptDonePollListener) {
                 ui.removePollListener((ScriptDonePollListener) listener);
             }
         }
 
         // if some other component already set a poll interval but it's less than ours, we go for the higher value
         if (ui.getPollInterval() < POLL_INTERVAL) {
             ui.setPollInterval(POLL_INTERVAL);
         }
         ui.addPollListener(new ScriptDonePollListener(task, ui, out, callback, messagesManager, i18n));
     }
 
     private Script createScript(String code, Writer out) throws CompilationFailedException, IOException {
         return createScript(new ByteArrayInputStream(code.getBytes()), out);
     }
 
     private Script createScript(InputStream in, Writer out) throws CompilationFailedException, IOException {
         Script script = parse(new InputStreamReader(in, CharEncoding.UTF_8), generateScriptName());
         script.setProperty("out", out);
         script.setProperty("err", out);
         return script;
     }
 
     /**
      * Parses the given script and returns it ready to be run. When running in a secure environment
      * (-Djava.security.manager) codeSource.getCodeSource() determines what policy grants should be given to the script.
      *
      * @param codeSource
      * @return ready to run script
      */
     @Override
     public Script parse(final GroovyCodeSource codeSource) throws CompilationFailedException {
         return InvokerHelper.createScript(parseClass(codeSource), getContext());
     }
 
     @Override
     public String generateScriptName() {
         // needed to expose it publicly (it's protected in parent class)
         return super.generateScriptName();
     }
 
     /**
      * Parses the groovy code contained in codeSource and returns a java class.
      */
     private Class parseClass(final GroovyCodeSource codeSource) throws CompilationFailedException {
         // Don't cache scripts
         return GROOVY_CLASS_LOADER.parseClass(codeSource, false);
     }
 
     /**
      * Callback to handle script progress and result asynchronously.
      */
     public interface ScriptCallback {
         /**
          * Called when the script is completed successfully.
          *
          * @param result the script outcome, including everything which has been printed to stdout during execution.
          */
         void onSuccess(String result);
 
         /**
          * Called when the script is completed with an error.
          *
          * @param e the error occurred during script execution
          */
         void onFailure(Throwable e);
 
         /**
          * Called when the script is running at each poll interval.
          *
          * @param out the script output thus far
          */
         void onProgress(Writer out);
 
         /**
          * Called when the script is completed, either successfully or with an error.
          */
         boolean requiresNotificationMessageUponCompletion();
     }
 
     private static void handleScriptDone(ScriptCallback callback, final Future<Object> scriptTask, UI ui, Writer out, MessagesManager messagesManager, SimpleTranslator i18n, boolean sendNotificationMessage) {
         try {
             String resultAsString = scriptTask.get() == null ? "" : Objects.toString(scriptTask.get());
             String completeOutput;
             if (out.toString().isEmpty()) {
                 completeOutput = resultAsString;
             } else {
                 completeOutput = out.toString().concat("\n").concat(resultAsString);
             }
 
             log.debug("Script run successfully with result {}", completeOutput);
             callback.onSuccess(completeOutput);
             if (sendNotificationMessage) {
                 messagesManager.sendLocalMessage(new Message(MessageType.INFO, i18n.translate("groovy.script.console.done.success"), completeOutput));
             }
 
         } catch (InterruptedException | ExecutionException e) {
             log.error("An error occurred while running a Groovy script", e);
             callback.onFailure(e);
 
             if (sendNotificationMessage) {
                 messagesManager.sendLocalMessage(new Message(MessageType.WARNING, i18n.translate("groovy.script.console.done.error"), e.getMessage()));
             }
         } finally {
             log.debug("Stop polling");
             ui.setPollInterval(-1);
         }
     }
 
     @SuppressWarnings("serial")
     private static final class ScriptDonePollListener implements PollListener {
         private Future<Object> scriptTask;
         private UI ui;
         private ScriptCallback callback;
         private Writer out;
         private MessagesManager messagesManager;
         private SimpleTranslator i18n;
 
         public ScriptDonePollListener(Future<Object> scriptTask, UI ui, Writer out, ScriptCallback callback, MessagesManager messagesManager, SimpleTranslator i18n) {
             this.scriptTask = scriptTask;
             this.ui = ui;
             this.callback = callback;
             this.out = out;
             this.messagesManager = messagesManager;
             this.i18n = i18n;
         }
 
         @Override
         public void poll(PollEvent event) {
             if (scriptTask.isDone()) {
                 handleScriptDone(callback, scriptTask, ui, out, messagesManager, i18n, callback.requiresNotificationMessageUponCompletion());
             } else {
                 // make sure we keep on polling until done.
                 // it may happen that a different component using polling ends before us and stops before we're done.
                 // if some other component already set a poll interval but it's less than ours, we go for the higher value
                 if (ui.getPollInterval() < POLL_INTERVAL) {
                     ui.setPollInterval(POLL_INTERVAL);
                 }
                 callback.onProgress(out);
             }
         }
     }
 }