/**

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

 *

 * Copyright 1997-2010 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-2013 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 org.netbeans.html.json.impl;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.StringWriter;

import java.io.Writer;

import java.lang.annotation.AnnotationTypeMismatchException;

import java.lang.annotation.IncompleteAnnotationException;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.ResourceBundle;

import java.util.Set;

import java.util.WeakHashMap;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.annotation.processing.AbstractProcessor;

import javax.annotation.processing.Completion;

import javax.annotation.processing.Completions;

import javax.annotation.processing.ProcessingEnvironment;

import javax.annotation.processing.Processor;

import javax.annotation.processing.RoundEnvironment;

import javax.annotation.processing.SupportedAnnotationTypes;

import javax.annotation.processing.SupportedSourceVersion;

import javax.lang.model.SourceVersion;

import javax.lang.model.element.AnnotationMirror;

import javax.lang.model.element.AnnotationValue;

import javax.lang.model.element.Element;

import javax.lang.model.element.ElementKind;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.Modifier;

import javax.lang.model.element.PackageElement;

import javax.lang.model.element.TypeElement;

import javax.lang.model.element.VariableElement;

import javax.lang.model.type.ArrayType;

import javax.lang.model.type.DeclaredType;

import javax.lang.model.type.MirroredTypeException;

import javax.lang.model.type.TypeKind;

import javax.lang.model.type.TypeMirror;

import javax.lang.model.util.Elements;

import javax.lang.model.util.Types;

import javax.tools.Diagnostic;

import javax.tools.FileObject;

import net.java.html.json.ComputedProperty;

import net.java.html.json.Model;

import net.java.html.json.Function;

import net.java.html.json.ModelOperation;

import net.java.html.json.OnPropertyChange;

import net.java.html.json.OnReceive;

import net.java.html.json.Property;

import org.openide.util.lookup.ServiceProvider;

/** Annotation processor to process {@link Model @Model} annotations and

 * generate appropriate model classes.

 *

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

 */

@ServiceProvider(service=Processor.class)

@SupportedSourceVersion(SourceVersion.RELEASE_6)

@SupportedAnnotationTypes({

    "net.java.html.json.Model",

    "net.java.html.json.ModelOperation",

    "net.java.html.json.Function",

    "net.java.html.json.OnReceive",

    "net.java.html.json.OnPropertyChange",

    "net.java.html.json.ComputedProperty",

    "net.java.html.json.Property"

})

public final class ModelProcessor extends AbstractProcessor {

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

    private final Map<Element,String> models = new WeakHashMap<Element,String>();

    private final Map<Element,Prprt[]> verify = new WeakHashMap<Element,Prprt[]>();

    @Override

    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

        boolean ok = true;

        for (Element e : roundEnv.getElementsAnnotatedWith(Model.class)) {

            if (!processModel(e)) {

                ok = false;

            }

        }

        if (roundEnv.processingOver()) {

            models.clear();

            for (Map.Entry<Element, Prprt[]> entry : verify.entrySet()) {

                TypeElement te = (TypeElement)entry.getKey();

                String fqn = processingEnv.getElementUtils().getBinaryName(te).toString();

                Element finalElem = processingEnv.getElementUtils().getTypeElement(fqn);

                if (finalElem == null) {

                    continue;

                }

                Prprt[] props;

                Model m = finalElem.getAnnotation(Model.class);

                if (m == null) {

                    continue;

                }

                props = Prprt.wrap(processingEnv, finalElem, m.properties());

                for (Prprt p : props) {

                    boolean[] isModel = { false };

                    boolean[] isEnum = { false };

                    boolean[] isPrimitive = { false };

                    String t = checkType(p, isModel, isEnum, isPrimitive);

                    if (isEnum[0]) {

                        continue;

                    }

                    if (isPrimitive[0]) {

                        continue;

                    }

                    if (isModel[0]) {

                        continue;

                    }

                    if ("java.lang.String".equals(t)) {

                        continue;

                    }

                    error("The type " + t + " should be defined by @Model annotation", entry.getKey());

                }

            }

            verify.clear();

        }

        return ok;

    }

    private void error(String msg, Element e) {

        processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, msg, e);

    }

    private boolean processModel(Element e) {

        boolean ok = true;

        Model m = e.getAnnotation(Model.class);

        if (m == null) {

            return true;

        }

        String pkg = findPkgName(e);

        Writer w;

        String className = m.className();

        models.put(e, className);

        try {

            StringWriter body = new StringWriter();

            List<String> propsGetSet = new ArrayList<String>();

            List<String> functions = new ArrayList<String>();

            Map<String, Collection<String>> propsDeps = new HashMap<String, Collection<String>>();

            Map<String, Collection<String>> functionDeps = new HashMap<String, Collection<String>>();

            Prprt[] props = createProps(e, m.properties());

            if (!generateComputedProperties(body, props, e.getEnclosedElements(), propsGetSet, propsDeps)) {

                ok = false;

            }

            if (!generateOnChange(e, propsDeps, props, className, functionDeps)) {

                ok = false;

            }

            if (!generateProperties(e, body, props, propsGetSet, propsDeps, functionDeps)) {

                ok = false;

            }

            if (!generateFunctions(e, body, className, e.getEnclosedElements(), functions)) {

                ok = false;

            }

            if (!generateReceive(e, body, className, e.getEnclosedElements(), functions)) {

                ok = false;

            }

            if (!generateOperation(e, body, className, e.getEnclosedElements())) {

                ok = false;

            }

            FileObject java = processingEnv.getFiler().createSourceFile(pkg + '.' + className, e);

            w = new OutputStreamWriter(java.openOutputStream());

            try {

                w.append("package " + pkg + ";\n");

                w.append("import net.java.html.json.*;\n");

                w.append("public final class ").append(className).append(" implements Cloneable {\n");

                w.append("  private boolean locked;\n");

                w.append("  private net.java.html.BrwsrCtx context;\n");

                w.append("  private org.netbeans.html.json.impl.Bindings[] ko = { null };\n");

                w.append(body.toString());

                w.append("  private static Class<" + inPckName(e) + "> modelFor() { return null; }\n");

                w.append("  private ").append(className).append("(net.java.html.BrwsrCtx context) {\n");

                w.append("    this.context = context;\n");

                w.append("  };\n");

                w.append("  public ").append(className).append("() {\n");

                w.append("    this(net.java.html.BrwsrCtx.findDefault(").append(className).append(".class));\n");

                for (Prprt p : props) {

                    if (p.array()) {

                        continue;

                    }

                    boolean[] isModel = {false};

                    boolean[] isEnum = {false};

                    boolean isPrimitive[] = {false};

                    String tn = checkType(p, isModel, isEnum, isPrimitive);

                    if (isModel[0]) {

                        w.write("    prop_" + p.name() + " = new " + tn + "();\n");

                    }

                }

                w.append("  };\n");

                if (props.length > 0) {

                    w.append("  public ").append(className).append("(");

                    Prprt firstArray = null;

                    String sep = "";

                    for (Prprt p : props) {

                        if (p.array()) {

                            if (firstArray == null) {

                                firstArray = p;

                            }

                            continue;

                        }

                        String tn = typeName(e, p);

                        w.write(sep);

                        w.write(tn);

                        w.write(" " + p.name());

                        sep = ", ";

                    }

                    if (firstArray != null) {

                        String tn;

                        boolean[] isModel = {false};

                        boolean[] isEnum = {false};

                        boolean isPrimitive[] = {false};

                        tn = checkType(firstArray, isModel, isEnum, isPrimitive);

                        w.write(sep);

                        w.write(tn);

                        w.write("... " + firstArray.name());

                    }

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

                    w.append("    this(net.java.html.BrwsrCtx.findDefault(").append(className).append(".class));\n");

                    for (Prprt p : props) {

                        if (p.array()) {

                            continue;

                        }

                        w.write("    this.prop_" + p.name() + " = " + p.name() + ";\n");

                    }

                    if (firstArray != null) {

                        w.write("    this.prop_" + firstArray.name() + ".init(" + firstArray.name() + ");\n");

                    }

                    w.append("  };\n");

                }

                w.append("  private org.netbeans.html.json.impl.Bindings intKnckt() {\n");

                w.append("    if (ko[0] != null) return ko[0];\n");

                w.append("    ko[0] = org.netbeans.html.json.impl.Bindings.apply(context, this);\n");

                {

                    w.append("    org.apidesign.html.json.spi.PropertyBinding[] propArr = {\n");

                    for (int i = 0; i < propsGetSet.size(); i += 5) {

                        w.append("      ko[0].registerProperty(\"").append(propsGetSet.get(i)).append("\", this, new P(");

                        w.append((i / 5) + "), " + (propsGetSet.get(i + 2) == null) + "),\n");

                    }

                    w.append("    };\n");

                }

                {

                    w.append("    org.apidesign.html.json.spi.FunctionBinding[] funcArr = {\n");

                    for (int i = 0; i < functions.size(); i += 2) {

                        w.append("      ko[0].registerFunction(\"").append(functions.get(i)).append("\", this, new P(");

                        w.append((i / 2) + ")),\n");

                    }

                    w.append("    };\n");

                }

                w.append("    ko[0].finish(this, propArr, funcArr);\n");

                w.append("    return ko[0];\n");

                w.append("  };\n");

                w.append("  private static final class P implements org.netbeans.html.json.impl.SetAndGet<" + className + ">,\n");

                w.append("  org.netbeans.html.json.impl.Callback<" + className + ">,\n");

                w.append("  org.netbeans.html.json.impl.FromJSON<" + className + "> {\n");

                w.append("    private final int type;\n");

                w.append("    P(int t) { type = t; };\n");

                w.append("    public void setValue(" + className + " data, Object value) {\n");

                w.append("      switch (type) {\n");

                for (int i = 0; i < propsGetSet.size(); i += 5) {

                    final String set = propsGetSet.get(i + 2);

                    String tn = propsGetSet.get(i + 4);

                    String btn = findBoxedType(tn);

                    if (btn != null) {

                        tn = btn;

                    }

                    if (set != null) {

                        w.append("        case " + (i / 5) + ": data." + strip(set) + "(org.netbeans.html.json.impl.JSON.extractValue(" + tn + ".class, value)); return;\n");

                    }

                }

                w.append("      }\n");

                w.append("    }\n");

                w.append("    public Object getValue(" + className + " data) {\n");

                w.append("      switch (type) {\n");

                for (int i = 0; i < propsGetSet.size(); i += 5) {

                    final String get = propsGetSet.get(i + 1);

                    if (get != null) {

                        w.append("        case " + (i / 5) + ": return data." + strip(get) + "();\n");

                    }

                }

                w.append("      }\n");

                w.append("      throw new UnsupportedOperationException();\n");

                w.append("    }\n");

                w.append("    public void call(" + className + " model, Object data, Object ev) {\n");

                w.append("      switch (type) {\n");

                for (int i = 0; i < functions.size(); i += 2) {

                    final String name = functions.get(i);

                    w.append("        case " + (i / 2) + ": model." + name + "(data, ev); return;\n");

                }

                w.append("      }\n");

                w.append("      throw new UnsupportedOperationException();\n");

                w.append("    }\n");

                w.append("    public Class<" + className + "> factoryFor() { return " + className + ".class; }\n");

                w.append("    public " + className + " read(net.java.html.BrwsrCtx c, Object json) { return new " + className + "(c, json); }\n");

                w.append("    public " + className + " cloneTo(Object o, net.java.html.BrwsrCtx c) { return ((" + className + ")o).clone(c); }\n");

                w.append("  }\n");

                w.append("  static { org.netbeans.html.json.impl.JSON.register(new P(0)); }\n");

                w.append("  private ").append(className).append("(net.java.html.BrwsrCtx c, Object json) {\n");

                w.append("    this.context = c;\n");

                int values = 0;

                for (int i = 0; i < propsGetSet.size(); i += 5) {

                    Prprt p = findPrprt(props, propsGetSet.get(i));

                    if (p == null) {

                        continue;

                    }

                    values++;

                }

                w.append("    Object[] ret = new Object[" + values + "];\n");

                w.append("    org.netbeans.html.json.impl.JSON.extract(context, json, new String[] {\n");

                for (int i = 0; i < propsGetSet.size(); i += 5) {

                    Prprt p = findPrprt(props, propsGetSet.get(i));

                    if (p == null) {

                        continue;

                    }

                    w.append("      \"").append(propsGetSet.get(i)).append("\",\n");

                }

                w.append("    }, ret);\n");

                for (int i = 0, cnt = 0, prop = 0; i < propsGetSet.size(); i += 5) {

                    final String pn = propsGetSet.get(i);

                    Prprt p = findPrprt(props, pn);

                    if (p == null) {

                        continue;

                    }

                    boolean[] isModel = { false };

                    boolean[] isEnum = { false };

                    boolean isPrimitive[] = { false };

                    String type = checkType(props[prop++], isModel, isEnum, isPrimitive);

                    if (p.array()) {

                        w.append("    if (ret[" + cnt + "] instanceof Object[]) {\n");

                        w.append("      for (Object e : ((Object[])ret[" + cnt + "])) {\n");

                        if (isModel[0]) {

                            w.append("        this.prop_").append(pn).append(".add(org.netbeans.html.json.impl.JSON.read");

                            w.append("(c, " + type + ".class, e));\n");

                        } else if (isEnum[0]) {

                            w.append("        this.prop_").append(pn);

                            w.append(".add(e == null ? null : ");

                            w.append(type).append(".valueOf(org.netbeans.html.json.impl.JSON.stringValue(e)));\n");

                        } else {

                            if (isPrimitive(type)) {

                                w.append("        this.prop_").append(pn).append(".add(org.netbeans.html.json.impl.JSON.numberValue(e).");

                                w.append(type).append("Value());\n");

                            } else {

                                w.append("        this.prop_").append(pn).append(".add((");

                                w.append(type).append(")e);\n");

                            }

                        }

                        w.append("      }\n");

                        w.append("    }\n");

                    } else {

                        if (isEnum[0]) {

                            w.append("    try {\n");

                            w.append("    this.prop_").append(pn);

                            w.append(" = ret[" + cnt + "] == null ? null : ");

                            w.append(type).append(".valueOf(org.netbeans.html.json.impl.JSON.stringValue(ret[" + cnt + "]));\n");

                            w.append("    } catch (IllegalArgumentException ex) {\n");

                            w.append("      ex.printStackTrace();\n");

                            w.append("    }\n");

                        } else if (isPrimitive(type)) {

                            w.append("    this.prop_").append(pn);

                            w.append(" = ret[" + cnt + "] == null ? ");

                            if ("char".equals(type)) {

                                w.append("0 : (org.netbeans.html.json.impl.JSON.charValue(");

                            } else if ("boolean".equals(type)) {

                                w.append("false : (org.netbeans.html.json.impl.JSON.boolValue(");

                            } else {

                                w.append("0 : (org.netbeans.html.json.impl.JSON.numberValue(");

                            }

                            w.append("ret[" + cnt + "])).");

                            w.append(type).append("Value();\n");

                        } else if (isModel[0]) {

                            w.append("    this.prop_").append(pn).append(" = org.netbeans.html.json.impl.JSON.read");

                            w.append("(c, " + type + ".class, ");

                            w.append("ret[" + cnt + "]);\n");

                        }else {

                            w.append("    this.prop_").append(pn);

                            w.append(" = (").append(type).append(')');

                            w.append("ret[" + cnt + "];\n");

                        }

                    }

                    cnt++;

                }

                w.append("  };\n");

                writeToString(props, w);

                writeClone(className, props, w);

                w.write("  /** Activates this model instance in the current {@link \n"

                    + "net.java.html.json.Models#bind(java.lang.Object, net.java.html.BrwsrCtx) browser context}. \n"

                    + "In case of using Knockout technology, this means to \n"

                    + "bind JSON like data in this model instance with Knockout tags in \n"

                    + "the surrounding HTML page.\n"

                    + "*/\n"

                );

                w.write("  public " + className + " applyBindings() {\n");

                w.write("    intKnckt().applyBindings();\n");

                w.write("    return this;\n");

                w.write("  }\n");

                w.write("  public boolean equals(Object o) {\n");

                w.write("    if (o == this) return true;\n");

                w.write("    if (o instanceof org.netbeans.html.json.impl.WrapperObject) {\n");

                w.write("      ((org.netbeans.html.json.impl.WrapperObject)o).setRealObject(intKnckt().koData());\n");

                w.write("      return false;\n");

                w.write("    }\n");

                w.write("    if (!(o instanceof " + className + ")) return false;\n");

                w.write("    " + className + " p = (" + className + ")o;\n");

                for (Prprt p : props) {

                    w.write("    if (!org.netbeans.html.json.impl.JSON.isSame(prop_" + p.name() + ", p.prop_" + p.name() + ")) return false;\n");

                }

                w.write("    return true;\n");

                w.write("  }\n");

                w.write("  public int hashCode() {\n");

                w.write("    int h = " + className + ".class.getName().hashCode();\n");

                for (Prprt p : props) {

                    w.write("    h = org.netbeans.html.json.impl.JSON.hashPlus(prop_" + p.name() + ", h);\n");

                }

                w.write("    return h;\n");

                w.write("  }\n");

                w.write("}\n");

            } finally {

                w.close();

            }

        } catch (IOException ex) {

            error("Can't create " + className + ".java", e);

            return false;

        }

        return ok;

    }

    private boolean generateProperties(

        Element where,

        Writer w, Prprt[] properties,

        Collection<String> props, 

        Map<String,Collection<String>> deps,

        Map<String,Collection<String>> functionDeps

    ) throws IOException {

        boolean ok = true;

        for (Prprt p : properties) {

            final String tn;

            tn = typeName(where, p);

            String[] gs = toGetSet(p.name(), tn, p.array());

            String castTo;

            if (p.array()) {

                w.write("  private org.netbeans.html.json.impl.JSONList<" + tn + "> prop_" + p.name() + " = new org.netbeans.html.json.impl.JSONList<" + tn + ">(ko, \""

                    + p.name() + "\"");

                Collection<String> dependants = deps.get(p.name());

                if (dependants != null) {

                    for (String depProp : dependants) {

                        w.write(", ");

                        w.write('\"');

                        w.write(depProp);

                        w.write('\"');

                    }

                }

                w.write(")");

                dependants = functionDeps.get(p.name());

                if (dependants != null) {

                    w.write(".onChange(new Runnable() { public void run() {\n");

                    for (String call : dependants) {

                        w.append("  ").append(call);

                    }

                    w.write("  }})");

                }

                w.write(";\n");

                castTo = "java.util.List";

                w.write("  public java.util.List<" + tn + "> " + gs[0] + "() {\n");

                w.write("    if (locked) throw new IllegalStateException();\n");

                w.write("    return prop_" + p.name() + ";\n");

                w.write("  }\n");

            } else {

                castTo = tn;

                w.write("  private " + tn + " prop_" + p.name() + ";\n");

                w.write("  public " + tn + " " + gs[0] + "() {\n");

                w.write("    if (locked) throw new IllegalStateException();\n");

                w.write("    return prop_" + p.name() + ";\n");

                w.write("  }\n");

                w.write("  public void " + gs[1] + "(" + tn + " v) {\n");

                w.write("    if (locked) throw new IllegalStateException();\n");

                w.write("    if (org.netbeans.html.json.impl.JSON.isSame(prop_" + p.name() + ", v)) return;\n");

                w.write("    prop_" + p.name() + " = v;\n");

                w.write("    org.netbeans.html.json.impl.Bindings b = ko[0];\n");

                w.write("    if (b != null) {\n");

                w.write("      b.valueHasMutated(\"" + p.name() + "\");\n");

                Collection<String> dependants = deps.get(p.name());

                if (dependants != null) {

                    for (String depProp : dependants) {

                        w.write("      b.valueHasMutated(\"" + depProp + "\");\n");

                    }

                }

                w.write("    }\n");

                dependants = functionDeps.get(p.name());

                if (dependants != null) {

                    for (String call : dependants) {

                        w.append("  ").append(call);

                    }

                }

                w.write("  }\n");

            }

            props.add(p.name());

            props.add(gs[2]);

            props.add(gs[3]);

            props.add(gs[0]);

            props.add(castTo);

        }

        return ok;

    }

    private boolean generateComputedProperties(

        Writer w, Prprt[] fixedProps,

        Collection<? extends Element> arr, Collection<String> props,

        Map<String,Collection<String>> deps

    ) throws IOException {

        boolean ok = true;

        for (Element e : arr) {

            if (e.getKind() != ElementKind.METHOD) {

                continue;

            }

            if (e.getAnnotation(ComputedProperty.class) == null) {

                continue;

            }

            if (!e.getModifiers().contains(Modifier.STATIC)) {

                error("Method " + e.getSimpleName() + " has to be static when annotated by @ComputedProperty", e);

                ok = false;

                continue;

            }

            ExecutableElement ee = (ExecutableElement)e;

            final TypeMirror rt = ee.getReturnType();

            final Types tu = processingEnv.getTypeUtils();

            TypeMirror ert = tu.erasure(rt);

            String tn = fqn(ert, ee);

            boolean array = false;

            final TypeMirror toCheck;

            if (tn.equals("java.util.List")) {

                array = true;

                toCheck = ((DeclaredType)rt).getTypeArguments().get(0);

            } else {

                toCheck = rt;

            }

            final String sn = ee.getSimpleName().toString();

            if (toCheck.getKind().isPrimitive()) {

                // OK

            } else {

                TypeMirror stringType = processingEnv.getElementUtils().getTypeElement("java.lang.String").asType();

                TypeMirror enumType = processingEnv.getElementUtils().getTypeElement("java.lang.Enum").asType();

                if (tu.isSubtype(toCheck, stringType)) {

                    // OK

                } else if (tu.isSubtype(tu.erasure(toCheck), tu.erasure(enumType))) {

                    // OK

                } else if (isModel(toCheck)) {

                    // OK

                } else {

                    ok = false;

                    error(sn + " cannot return " + toCheck, e);

                }

            }

            String[] gs = toGetSet(sn, tn, array);

            w.write("  public " + tn + " " + gs[0] + "() {\n");

            w.write("    if (locked) throw new IllegalStateException();\n");

            int arg = 0;

            for (VariableElement pe : ee.getParameters()) {

                final String dn = pe.getSimpleName().toString();

                if (!verifyPropName(pe, dn, fixedProps)) {

                    ok = false;

                }

                final String dt = fqn(pe.asType(), ee);

                String[] call = toGetSet(dn, dt, false);

                w.write("    " + dt + " arg" + (++arg) + " = ");

                w.write(call[0] + "();\n");

                Collection<String> depends = deps.get(dn);

                if (depends == null) {

                    depends = new LinkedHashSet<String>();

                    deps.put(dn, depends);

                }

                depends.add(sn);

            }

            w.write("    try {\n");

            w.write("      locked = true;\n");

            w.write("      return " + fqn(ee.getEnclosingElement().asType(), ee) + '.' + e.getSimpleName() + "(");

            String sep = "";

            for (int i = 1; i <= arg; i++) {

                w.write(sep);

                w.write("arg" + i);

                sep = ", ";

            }

            w.write(");\n");

            w.write("    } finally {\n");

            w.write("      locked = false;\n");

            w.write("    }\n");

            w.write("  }\n");

            props.add(e.getSimpleName().toString());

            props.add(gs[2]);

            props.add(null);

            props.add(gs[0]);

            props.add(tn);

        }

        return ok;

    }

    private static String[] toGetSet(String name, String type, boolean array) {

        String n = Character.toUpperCase(name.charAt(0)) + name.substring(1);

        String bck2brwsrType = "L" + type.replace('.', '_') + "_2";

        if ("int".equals(type)) {

            bck2brwsrType = "I";

        }

        if ("double".equals(type)) {

            bck2brwsrType = "D";

        }

        String pref = "get";

        if ("boolean".equals(type)) {

            pref = "is";

            bck2brwsrType = "Z";

        }

        final String nu = n.replace('.', '_');

        if (array) {

            return new String[] { 

                "get" + n,

                null,

                "get" + nu + "__Ljava_util_List_2",

                null

            };

        }

        return new String[]{

            pref + n, 

            "set" + n, 

            pref + nu + "__" + bck2brwsrType,

            "set" + nu + "__V" + bck2brwsrType

        };

    }

    private String typeName(Element where, Prprt p) {

        String ret;

        boolean[] isModel = { false };

        boolean[] isEnum = { false };

        boolean isPrimitive[] = { false };

        ret = checkType(p, isModel, isEnum, isPrimitive);

        if (p.array()) {

            String bt = findBoxedType(ret);

            if (bt != null) {

                return bt;

            }

        }

        return ret;

    }

    private static String findBoxedType(String ret) {

        if (ret.equals("boolean")) {

            return Boolean.class.getName();

        }

        if (ret.equals("byte")) {

            return Byte.class.getName();

        }

        if (ret.equals("short")) {

            return Short.class.getName();

        }

        if (ret.equals("char")) {

            return Character.class.getName();

        }

        if (ret.equals("int")) {

            return Integer.class.getName();

        }

        if (ret.equals("long")) {

            return Long.class.getName();

        }

        if (ret.equals("float")) {

            return Float.class.getName();

        }

        if (ret.equals("double")) {

            return Double.class.getName();

        }

        return null;

    }

    private boolean verifyPropName(Element e, String propName, Prprt[] existingProps) {

        StringBuilder sb = new StringBuilder();

        String sep = "";

        for (Prprt Prprt : existingProps) {

            if (Prprt.name().equals(propName)) {

                return true;

            }

            sb.append(sep);

            sb.append('"');

            sb.append(Prprt.name());

            sb.append('"');

            sep = ", ";

        }

        error(

            propName + " is not one of known properties: " + sb

            , e

        );

        return false;

    }

    private static String findPkgName(Element e) {

        for (;;) {

            if (e.getKind() == ElementKind.PACKAGE) {

                return ((PackageElement)e).getQualifiedName().toString();

            }

            e = e.getEnclosingElement();

        }

    }

    private boolean generateFunctions(

        Element clazz, StringWriter body, String className, 

        List<? extends Element> enclosedElements, List<String> functions

    ) {

        for (Element m : enclosedElements) {

            if (m.getKind() != ElementKind.METHOD) {

                continue;

            }

            ExecutableElement e = (ExecutableElement)m;

            Function onF = e.getAnnotation(Function.class);

            if (onF == null) {

                continue;

            }

            if (!e.getModifiers().contains(Modifier.STATIC)) {

                error("@OnFunction method needs to be static", e);

                return false;

            }

            if (e.getModifiers().contains(Modifier.PRIVATE)) {

                error("@OnFunction method cannot be private", e);

                return false;

            }

            if (e.getReturnType().getKind() != TypeKind.VOID) {

                error("@OnFunction method should return void", e);

                return false;

            }

            String n = e.getSimpleName().toString();

            body.append("  private void ").append(n).append("(Object data, Object ev) {\n");

            body.append("    ").append(((TypeElement)clazz).getQualifiedName()).append(".").append(n).append("(");

            body.append(wrapParams(e, null, className, "ev", "data"));

            body.append(");\n");

            body.append("  }\n");

            functions.add(n);

            functions.add(n + "__VLjava_lang_Object_2Ljava_lang_Object_2");

        }

        return true;

    }

    private boolean generateOnChange(Element clazz, Map<String,Collection<String>> propDeps,

        Prprt[] properties, String className, 

        Map<String, Collection<String>> functionDeps

    ) {

        for (Element m : clazz.getEnclosedElements()) {

            if (m.getKind() != ElementKind.METHOD) {

                continue;

            }

            ExecutableElement e = (ExecutableElement) m;

            OnPropertyChange onPC = e.getAnnotation(OnPropertyChange.class);

            if (onPC == null) {

                continue;

            }

            for (String pn : onPC.value()) {

                if (findPrprt(properties, pn) == null && findDerivedFrom(propDeps, pn).isEmpty()) {

                    error("No Prprt named '" + pn + "' in the model", clazz);

                    return false;

                }

            }

            if (!e.getModifiers().contains(Modifier.STATIC)) {

                error("@OnPrprtChange method needs to be static", e);

                return false;

            }

            if (e.getModifiers().contains(Modifier.PRIVATE)) {

                error("@OnPrprtChange method cannot be private", e);

                return false;

            }

            if (e.getReturnType().getKind() != TypeKind.VOID) {

                error("@OnPrprtChange method should return void", e);

                return false;

            }

            String n = e.getSimpleName().toString();

            for (String pn : onPC.value()) {

                StringBuilder call = new StringBuilder();

                call.append("  ").append(clazz.getSimpleName()).append(".").append(n).append("(");

                call.append(wrapPropName(e, className, "name", pn));

                call.append(");\n");

                Collection<String> change = functionDeps.get(pn);

                if (change == null) {

                    change = new ArrayList<String>();

                    functionDeps.put(pn, change);

                }

                change.add(call.toString());

                for (String dpn : findDerivedFrom(propDeps, pn)) {

                    change = functionDeps.get(dpn);

                    if (change == null) {

                        change = new ArrayList<String>();

                        functionDeps.put(dpn, change);

                    }

                    change.add(call.toString());

                }

            }

        }

        return true;

    }

    private boolean generateOperation(Element clazz, 

        StringWriter body, String className, 

        List<? extends Element> enclosedElements

    ) {

        for (Element m : enclosedElements) {

            if (m.getKind() != ElementKind.METHOD) {

                continue;

            }

            ExecutableElement e = (ExecutableElement)m;

            ModelOperation mO = e.getAnnotation(ModelOperation.class);

            if (mO == null) {

                continue;

            }

            if (!e.getModifiers().contains(Modifier.STATIC)) {

                error("@ModelOperation method needs to be static", e);

                return false;

            }

            if (e.getModifiers().contains(Modifier.PRIVATE)) {

                error("@ModelOperation method cannot be private", e);

                return false;

            }

            if (e.getReturnType().getKind() != TypeKind.VOID) {

                error("@ModelOperation method should return void", e);

                return false;

            }

            List<String> args = new ArrayList<String>();

            {

                body.append("  public void ").append(m.getSimpleName()).append("(");

                String sep = "";

                boolean checkFirst = true;

                for (VariableElement ve : e.getParameters()) {

                    final TypeMirror type = ve.asType();

                    CharSequence simpleName;

                    if (type.getKind() == TypeKind.DECLARED) {

                        simpleName = ((DeclaredType)type).asElement().getSimpleName();

                    } else {

                        simpleName = type.toString();

                    }

                    if (simpleName.toString().equals(className)) {

                        checkFirst = false;

                    } else {

                        if (checkFirst) {

                            error("First parameter of @ModelOperation method must be " + className, m);

                            return false;

                        }

                        args.add(ve.getSimpleName().toString());

                        body.append(sep).append("final ");

                        body.append(ve.asType().toString()).append(" ");

                        body.append(ve.toString());

                        sep = ", ";

                    }

                }

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

                body.append("    org.netbeans.html.json.impl.JSON.runInBrowser(this.context, new Runnable() { public void run() {\n");

                body.append("      ").append(clazz.getSimpleName()).append(".").append(m.getSimpleName()).append("(");

                body.append(className).append(".this");

                for (String s : args) {

                    body.append(", ").append(s);

                }

                body.append(");\n");

                body.append("    }});\n");

                body.append("  }\n");

            }

        }

        return true;

    }

    private boolean generateReceive(

        Element clazz, StringWriter body, String className, 

        List<? extends Element> enclosedElements, List<String> functions

    ) {

        for (Element m : enclosedElements) {

            if (m.getKind() != ElementKind.METHOD) {

                continue;

            }

            ExecutableElement e = (ExecutableElement)m;

            OnReceive onR = e.getAnnotation(OnReceive.class);

            if (onR == null) {

                continue;

            }

            if (!e.getModifiers().contains(Modifier.STATIC)) {

                error("@OnReceive method needs to be static", e);

                return false;

            }

            if (e.getModifiers().contains(Modifier.PRIVATE)) {

                error("@OnReceive method cannot be private", e);

                return false;

            }

            if (e.getReturnType().getKind() != TypeKind.VOID) {

                error("@OnReceive method should return void", e);

                return false;

            }

            if (!onR.jsonp().isEmpty() && !"GET".equals(onR.method())) {

                error("JSONP works only with GET transport method", e);

            }

            String dataMirror = findDataSpecified(e, onR);

            if ("PUT".equals(onR.method()) && dataMirror == null) {

                error("PUT method needs to specify a data() class", e);

                return false;

            }

            if ("POST".equals(onR.method()) && dataMirror == null) {

                error("POST method needs to specify a data() class", e);

                return false;

            }

            String modelClass = null;

            boolean expectsList = false;

            List<String> args = new ArrayList<String>();

            {

                for (VariableElement ve : e.getParameters()) {

                    TypeMirror modelType = null;

                    final TypeMirror type = ve.asType();

                    CharSequence simpleName;

                    if (type.getKind() == TypeKind.DECLARED) {

                        simpleName = ((DeclaredType)type).asElement().getSimpleName();

                    } else {

                        simpleName = type.toString();

                    }

                    if (simpleName.toString().equals(className)) {

                        args.add(className + ".this");

                    } else if (isModel(ve.asType())) {

                        modelType = ve.asType();

                    } else if (ve.asType().getKind() == TypeKind.ARRAY) {

                        modelType = ((ArrayType)ve.asType()).getComponentType();

                        expectsList = true;

                    } else if (ve.asType().toString().equals("java.lang.String")) {

                        modelType = ve.asType();

                    }

                    if (modelType != null) {

                        if (modelClass != null) {

                            error("There can be only one model class among arguments", e);

                        } else {

                            modelClass = modelType.toString();

                            if (expectsList) {

                                args.add("arr");