/**

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

  *

  * Copyright 2013-2014 Oracle and/or its affiliates. All rights reserved.

  *

  * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

  * Other names may be trademarks of their respective owners.

  *

  * The contents of this file are subject to the terms of either the GNU

  * General Public License Version 2 only ("GPL") or the Common

  * Development and Distribution License("CDDL") (collectively, the

  * "License"). You may not use this file except in compliance with the

  * License. You can obtain a copy of the License at

  * http://www.netbeans.org/cddl-gplv2.html

  * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

  * specific language governing permissions and limitations under the

  * License.  When distributing the software, include this License Header

  * Notice in each file and include the License file at

  * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the GPL Version 2 section of the License file that

  * accompanied this code. If applicable, add the following below the

  * License Header, with the fields enclosed by brackets [] replaced by

  * your own identifying information:

  * "Portions Copyrighted [year] [name of copyright owner]"

  *

  * Contributor(s):

  *

  * The Original Software is NetBeans. The Initial Developer of the Original

  * Software is Oracle. Portions Copyright 2013-2014 Oracle. All Rights Reserved.

  *

  * If you wish your version of this file to be governed by only the CDDL

  * or only the GPL Version 2, indicate your decision by adding

  * "[Contributor] elects to include this software in this distribution

  * under the [CDDL or GPL Version 2] license." If you do not indicate a

  * single choice of license, a recipient has the option to distribute

  * your version of this file under either the CDDL, the GPL Version 2 or

  * to extend the choice of license to its licensees as provided above.

  * However, if you add GPL Version 2 code and therefore, elected the GPL

  * Version 2 license, then the option applies only if the new code is

  * made subject to such option by the copyright holder.

  */

 package net.java.html.boot.script;

 import java.io.Closeable;

 import java.io.IOException;

 import java.io.Reader;

 import java.net.URL;

 import java.util.ArrayList;

 import java.util.List;

 import java.util.concurrent.Executor;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.script.Invocable;

 import javax.script.ScriptEngine;

 import javax.script.ScriptEngineManager;

 import javax.script.ScriptException;

 import org.netbeans.html.boot.spi.Fn;

 import org.netbeans.html.boot.spi.Fn.Presenter;

 /** Implementation of {@link Presenter} that delegates

  * to Java {@link ScriptEngine scripting} API. The presenter runs headless

  * without appropriate simulation of browser APIs. Its primary usefulness

  * is inside testing environments. 

  * <p>

  * One can load in browser simulation for example from 

  * <a href="http://www.envjs.com/">env.js</a>. The best way to achieve so,

  * is to wait until JDK-8046013 gets fixed....

  * 

  *

  * @author Jaroslav Tulach

  */

 final class ScriptPresenter 

 implements Presenter, Fn.FromJavaScript, Fn.ToJavaScript, Executor {

     private static final Logger LOG = Logger.getLogger(ScriptPresenter.class.getName());

     private final ScriptEngine eng;

     private final Executor exc;

     public ScriptPresenter(Executor exc) {

         this.exc = exc;

         try {

             eng = new ScriptEngineManager().getEngineByName("javascript");

             eng.eval("function alert(msg) { Packages.java.lang.System.out.println(msg); };");

             eng.eval("function confirm(msg) { Packages.java.lang.System.out.println(msg); return true; };");

             eng.eval("function prompt(msg, txt) { Packages.java.lang.System.out.println(msg + ':' + txt); return txt; };");

         } catch (ScriptException ex) {

             throw new IllegalStateException(ex);

         }

     }

     @Override

     public Fn defineFn(String code, String... names) {

         return defineImpl(code, names);

     }

     private FnImpl defineImpl(String code, String... names) {

         StringBuilder sb = new StringBuilder();

         sb.append("(function() {");

         sb.append("  return function(");

         String sep = "";

         if (names != null) for (String n : names) {

             sb.append(sep).append(n);

             sep = ",";

         }

         sb.append(") {\n");

         sb.append(code);

         sb.append("};");

         sb.append("})()");

         final Object fn;

         try {

             fn = eng.eval(sb.toString());

         } catch (ScriptException ex) {

             throw new IllegalStateException(ex);

         }

         return new FnImpl(this, fn);

     }

     @Override

     public void displayPage(URL page, Runnable onPageLoad) {

         try {

             eng.eval("if (typeof window !== 'undefined') window.location = '" + page + "'");

         } catch (ScriptException ex) {

             LOG.log(Level.SEVERE, "Cannot load " + page, ex);

         }

         if (onPageLoad != null) {

             onPageLoad.run();

         }

     }

     @Override

     public void loadScript(Reader code) throws Exception {

         eng.eval(code);

     }

     //

     // array conversions

     //

     final Object convertArrays(Object[] arr) throws Exception {

         for (int i = 0; i < arr.length; i++) {

             if (arr[i] instanceof Object[]) {

                 arr[i] = convertArrays((Object[]) arr[i]);

             }

         }

         final Object wrapArr = wrapArrFn().invokeImpl(null, false, arr); // NOI18N

         return wrapArr;

     }

     private FnImpl wrapArrImpl;

     private FnImpl wrapArrFn() {

         if (wrapArrImpl == null) {

             try {

                 wrapArrImpl = defineImpl("return Array.prototype.slice.call(arguments);");

             } catch (Exception ex) {

                 throw new IllegalStateException(ex);

             }

         }

         return wrapArrImpl;

     }

     final Object checkArray(Object val) throws Exception {

         final FnImpl fn = arraySizeFn();

         final Object fnRes = fn.invokeImpl(null, false, val, null);

         int length = ((Number) fnRes).intValue();

         if (length == -1) {

             return val;

         }

         Object[] arr = new Object[length];

         fn.invokeImpl(null, false, val, arr);

         return arr;

     }

     private FnImpl arraySize;

     private FnImpl arraySizeFn() {

         if (arraySize == null) {

             try {

                 arraySize = defineImpl("\n"

                     + "if (to === null) {\n"

                     + "  if (Object.prototype.toString.call(arr) === '[object Array]') return arr.length;\n"

                     + "  else return -1;\n"

                     + "} else {\n"

                     + "  var l = arr.length;\n"

                     + "  for (var i = 0; i < l; i++) to[i] = arr[i];\n"

                     + "  return l;\n"

                     + "}", "arr", "to"

                 );

             } catch (Exception ex) {

                 throw new IllegalStateException(ex);

             }

         }

         return arraySize;

     }

     @Override

     public Object toJava(Object jsArray) {

         try {

             return checkArray(jsArray);

         } catch (Exception ex) {

             throw new IllegalStateException(ex);

         }

     }

     @Override

     public Object toJavaScript(Object toReturn) {

         if (toReturn instanceof Object[]) {

             try {

                 return convertArrays((Object[])toReturn);

             } catch (Exception ex) {

                 throw new IllegalStateException(ex);

             }

         } else {

             return toReturn;

         }

     }

     @Override

     public void execute(final Runnable command) {

         if (Fn.activePresenter() == this) {

             command.run();

             return;

         }

         class Wrap implements Runnable {

             public void run() {

                 try (Closeable c = Fn.activate(ScriptPresenter.this)) {

                     command.run();

                 } catch (IOException ex) {

                     throw new IllegalStateException(ex);

                 }

             }

         }

         final Runnable wrap = new Wrap();

         if (exc == null) {

             wrap.run();

         } else {

             exc.execute(wrap);

         }

     }

     private class FnImpl extends Fn {

         private final Object fn;

         public FnImpl(Presenter presenter, Object fn) {

             super(presenter);

             this.fn = fn;

         }

         @Override

         public Object invoke(Object thiz, Object... args) throws Exception {

             return invokeImpl(thiz, true, args);

         }

             final Object invokeImpl(Object thiz, boolean arrayChecks, Object... args) throws Exception {

                 List<Object> all = new ArrayList<>(args.length + 1);

                 all.add(thiz == null ? fn : thiz);

                 for (int i = 0; i < args.length; i++) {

                     if (arrayChecks) {

                         if (args[i] instanceof Object[]) {

                             Object[] arr = (Object[]) args[i];

                             Object conv = ((ScriptPresenter)presenter()).convertArrays(arr);

                             args[i] = conv;

                         }

                         if (args[i] instanceof Character) {

                             args[i] = (int)((Character)args[i]);

                         }

                     }

                     all.add(args[i]);

                 }

                 Object ret = ((Invocable)eng).invokeMethod(fn, "call", all.toArray()); // NOI18N

                 if (ret == fn) {

                     return null;

                 }

                 if (!arrayChecks) {

                     return ret;

                 }

                 return ((ScriptPresenter)presenter()).checkArray(ret);

             }

     }

 }