/**

  * Back 2 Browser Bytecode Translator

  * Copyright (C) 2012 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

  *

  * This program is free software: you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation, version 2 of the License.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program. Look for COPYING file in the top folder.

  * If not, see http://opensource.org/licenses/GPL-2.0.

  */

 package org.apidesign.bck2brwsr.htmlpage;

 import java.io.BufferedReader;

 import java.io.IOException;

 import java.io.InputStreamReader;

 import java.lang.reflect.Method;

 import java.util.List;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javafx.scene.web.WebEngine;

 import netscape.javascript.JSObject;

 import org.apidesign.bck2brwsr.core.ExtraJavaScript;

 import org.apidesign.bck2brwsr.core.JavaScriptBody;

 /** Provides binding between models and 

  *

  * @author Jaroslav Tulach <jtulach@netbeans.org>

  */

 @ExtraJavaScript(resource = "/org/apidesign/bck2brwsr/htmlpage/knockout-2.2.1.js")

 public class Knockout {

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

     /** used by tests */

     static Knockout next;

     private final Object model;

     static {

         BufferedReader r = new BufferedReader(new InputStreamReader(Knockout.class.getResourceAsStream("knockout-2.2.1.js")));

         StringBuilder sb = new StringBuilder();

         for (;;) {

             try {

                 String l = r.readLine();

                 if (l == null) {

                     break;

                 }

                 sb.append(l).append('\n');

             } catch (IOException ex) {

                 throw new IllegalStateException(ex);

             }

         }

         web().executeScript(sb.toString());

         Object ko = web().executeScript("ko");

         assert ko != null : "Knockout library successfully defined 'ko'";

         Console.register(web());

     }

     Knockout(Object model) {

         this.model = model == null ? this : model;

     }

     public Object koData() {

         return model;

     }

     private static final JSObject KObject;

     static {

         KObject = (JSObject) web().executeScript(

             "(function(scope) {"

             + "  var kCnt = 0; "

             + "  scope.KObject = {};"

             + "  scope.KObject.create= function(value) {"

             + "    var cnt = ++kCnt;"

             + "    var ret = {};"

             + "    ret.toString = function() { return 'KObject' + cnt + ' value: ' + value + ' props: ' + Object.keys(this); };"

             + "    return ret;"

             + "  };"

             + "  scope.KObject.array= function() {"

             + "    return Array.prototype.slice.call(arguments);"

             + "  };"

             + "  scope.KObject.expose = function(bindings, model, prop, sig) {"

             + "    bindings[prop] = function(data, ev) {"

 //            + "         console.log(\"  callback on prop: \" + prop);"

             + "      model[sig](data, ev);"

             + "    };"

             + "  };"

             + "})(window); window.KObject"

             );

     }

     static Object toArray(Object[] arr) {

         return KObject.call("array", arr);

     }

     public static <M> Knockout applyBindings(

         Object model, String[] propsGettersAndSetters,

         String[] methodsAndSignatures

     ) {

         Object bindings = KObject.call("create", model);

         applyImpl(propsGettersAndSetters, model.getClass(), bindings, model, methodsAndSignatures);

         return new Knockout(bindings);

     }

     public static <M> Knockout applyBindings(

         Class<M> modelClass, M model, String[] propsGettersAndSetters,

         String[] methodsAndSignatures

     ) {

         Object bindings = next;

         next = null;

         if (bindings == null) {

             bindings = KObject.call("create", model);

         }

         applyImpl(propsGettersAndSetters, modelClass, bindings, model, methodsAndSignatures);

         applyBindings(bindings);

         return new Knockout(bindings);

     }

     public void valueHasMutated(String prop) {

         LOG.log(Level.FINE, "property mutated: {0}", prop);

         try {

             JSObject koProp = (JSObject) ((JSObject) model).getMember(prop);

             koProp.call("valueHasMutated");

         } catch (Throwable t) {

             LOG.log(Level.WARNING, "valueHasMutated failed for {0}", model);

         }

     }

     @JavaScriptBody(args = { "id", "ev" }, body = "ko.utils.triggerEvent(window.document.getElementById(id), ev.substring(2));")

     public static void triggerEvent(String id, String ev) {

         JSObject js = (JSObject) web().executeScript("(function () {"

             + "  var x = {}; "

             + "  x.trigger= function(id, ev) { "

             + "    ko.utils.triggerEvent(window.document.getElementById(id), ev.substring(2));;\n"

             + "  };"

             + "  return x;"

             + "})()");

         js.call("trigger", id, ev);

     }

     @JavaScriptBody(args = { "bindings", "model", "prop", "getter", "setter", "primitive", "array" }, body =

           "var bnd = {\n"

         + "  'read': function() {\n"

         + "    var v = model[getter]();\n"

         + "    if (array) v = v.koArray();\n"

         + "    return v;\n"

         + "  },\n"

         + "  'owner': bindings\n"

         + "};\n"

         + "if (setter != null) {\n"

         + "  bnd['write'] = function(val) {\n"

         + "    model[setter](primitive ? new Number(val) : val);\n"

         + "  };\n"

         + "}\n"

         + "bindings[prop] = ko['computed'](bnd);"

     )

     private static void bind(

         Object bindings, Object model, String prop, String getter, String setter, boolean primitive, boolean array

     ) {

         WebEngine e = web();

         JSObject bnd = (JSObject) e.executeScript("var x = {}; x.bnd = "

         + "new Function('ko', 'bindings', 'model', 'prop', 'getter', 'setter', 'primitive', 'array', '"

         + "var bnd = {"

         + "  read: function() {"

         + "    try {"

         + "      var v = model[getter]();"

 //        + "      console.log(\" getter value \" + v + \" for property \" + prop);"

         + "      try { v = v.koData(); } catch (ignore) {"

 //        + "        console.log(\"Cannot convert to koData: \" + ignore);"

         + "      };"

 //        + "      console.log(\" getter ret value \" + v);"

 //        + "      for (var pn in v) {"

 //        + "         console.log(\"  prop: \" + pn + \" + in + \" + v + \" = \" + v[pn]);"

 //        + "         if (typeof v[pn] == \"function\") console.log(\"  its function value:\" + v[pn]());"

 //        + "      }"

 //        + "      console.log(\" all props printed for \" + (typeof v));"

         + "      return v;"

         + "    } catch (e) {"

         + "      alert(\"Cannot call \" + getter + \" on \" + model + \" error: \" + e);"

         + "    }"

         + "  },"

         + "  owner: bindings,"

         + "  deferEvaluation: true"

         + "};"

         + "if (setter != null) {"

         + "  bnd.write = function(val) {"

         + "    model[setter](primitive ? new Number(val) : val);"

         + "  };"

         + "};"

         + "bindings[prop] = ko.computed(bnd);'"

         + "); x;");

         Object ko = e.executeScript("ko");

         try {

             KOProperty kop = new KOProperty(model, strip(getter), strip(setter));

             bnd.call("bnd", ko, bindings, kop, prop, "get", "set", primitive, array);

             ((JSObject)bindings).setMember("koModel", model);

             LOG.log(Level.FINE, "binding defined for {0}: {1}", new Object[]{prop, ((JSObject)bindings).getMember(prop)});

         } catch (Throwable ex) {

             LOG.log(Level.WARNING, "binding failed for {0} on {1}", new Object[]{prop, bindings});

         }

     }

     private static String strip(String mangled) {

         if (mangled == null) {

             return null;

         }

         int under = mangled.indexOf("__");

         return mangled.substring(0, under);

     }

     @JavaScriptBody(args = { "bindings", "model", "prop", "sig" }, body = 

         "bindings[prop] = function(data, ev) { model[sig](data, ev); };"

     )

     private static void expose(

         Object bindings, Object model, String prop, String sig

     ) {

         try {

             KOFunction f = new KOFunction(model, strip(sig));

             KObject.call("expose", bindings, f, prop, "call");

         } catch (Throwable ex) {

             LOG.log(Level.SEVERE, "Cannot define binding for " + prop + " in model " + model, ex);

         }

     }

     @JavaScriptBody(args = { "bindings" }, body = "ko.applyBindings(bindings);")

     private static void applyBindings(Object bindings) {

         JSObject ko = (JSObject) web().executeScript("ko");

         ko.call("applyBindings", bindings);

     }

     private static WebEngine web() {

         return (WebEngine) System.getProperties().get("webEngine");

     }

     private static void applyImpl(

         String[] propsGettersAndSetters,

         Class<?> modelClass,

         Object bindings,

         Object model,

         String[] methodsAndSignatures

     ) throws IllegalStateException, SecurityException {

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

             try {

                 Method getter = modelClass.getMethod(propsGettersAndSetters[i + 3]);

                 bind(bindings, model, propsGettersAndSetters[i],

                     propsGettersAndSetters[i + 1],

                     propsGettersAndSetters[i + 2],

                     getter.getReturnType().isPrimitive(),

                     List.class.isAssignableFrom(getter.getReturnType()));

             } catch (NoSuchMethodException ex) {

                 throw new IllegalStateException(ex.getMessage());

             }

         }

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

             expose(

                 bindings, model, methodsAndSignatures[i], methodsAndSignatures[i + 1]);

         }

     }

 }