* This generator creates a View implementation from an XML/XHTML template.

*

* The template contains a mix of XHTML tags and special tags for the construction of subviews,

* which come from a tag library.

*

* The format/architecture is based loosely on facelets/JSF, but since we're generating widgets and

* not text, some things are changed.

*

* Any HTML element can be "converted" into a special tag by specifying kc="ns:tag" which means the

* template parser treats the whole tag as if it were an <ns:tag ... > element.

*

* Tags which are not part of HTML are converted into a View or Widget subclass,

* and the attributes of that tag are used to initialize the new view object.

*

* The view provides attributes in the form of setters;

*

* - If a setter takes an Action object, the tag attribute value may be

*   one or more assignments or method calls seperated by a semicolon.  The

*   generated code constructs an Action object which executes those

*   statements.  The first statement to fail terminates the action sequence;

*   asynchronous operations ARE supported.  It may also be an expression

*   for an Action to copy to that place.

* - If a setter takes a Value object, or a type which isn't automatically

*   converted from a string by the generated (a non-primitive type), then

*   the XML attribute value should be an EL-style expression, either

*   "${...}" or "#{...}".  The expression is evaluated during the template's

*   LOAD phase and the view's setter is called with the result.  If "#{...}"

*   is used, then the view's getter is called during the SAVE phase, and the

*   setter of the given expression is called with that result.

* - Other values are converted to the target type on a best-effort basis; for

*   example an integer, float, or boolean value may be parsed.

*

* Some tag attributes are processed specially:

*

* - The special attribute "binding" allows you to store a reference to the

*   view object into the given EL expression.  The setter for the expression

*   is called after constructing the view object from the tag.

* - The special attributes "onclick" and "onchange" will automatically create

*   a ClickListener or a ChangeListener on view objects that implements

*   SourcesClickEvents or SourcesChangeEvents.  The attribute value follows

*   the syntax of an Action, as above.

* - The special attributes "class" and "style" will automatically call

*   the addStyleName() or DOM.setElementAttribute() to apply the given

*   CSS class or style string to the created view object.

*

* When a tag is converted and it contains elements inside it, the following

* rules apply:

*

* - If the inner tags match methods like setX or addX on the view, those

*   setters/adders are called once for each element.  The parameters to

*   the setter or added are calculated as follows:

*       - Attribute names are matched to parameter names and are

*         reordered to match the parameter list

*       - The special attribute name "class" can be used to match a

*         method parameter "styleName" because "class" is a java

*         reserved word.

*       - The attributes are processed and converted according to the

*         same rules as calling setters on widgets and views (see above).

*       - If all parameters are matched to an attribute but one, and the

*         element has a body (either text or child elements), the body

*         may be used to fill that parameter as follows:

*            - If the parameter is a View, Widget, or ViewFactory, the body is

*              treated as a sub-template

*            - If the missing parameter is a string, and the method takes just

*              one parameter or one parameter plus an AsyncCallback, then the

*              text contents of the element are assumed to be the value of that

*              parameter

* - If the View or Widget being constructed has a setView() or setViewFactory(),

*   the child elements are converted to a sub-template and passed as a view

*   instance or factory.

*

* The Expression Language has the following features:

*

* - "#{...}" is evaluated during load to set the target attribute, and

*   during save the attribute is copied back into the same location by

*   changing getters to setters.

* - "%{...}" is a constant read-only expression, evaluated just once

*   during initialization

* - "${...}" refers to a read-only expression, which is evaluated during

*   load, after the base class load() if any.

* - "@{...}" is an "early load" read-only expression, which is evaluated

*   during load, before the base class load() if any.  If there is no

*   base class load this is equivalent to "${...}"

* - An identifier refers to a property of the template object, accessed by

*   capitalizing the identifier and prepending "get", "is", or "set" according

*   to standard bean accessor rules.  Any view with an id="x" attribute is also

*   available using the assigned id as an identifier.

* - Dotted expressions can be used to fetch sub-properties; e.g. "a.b.c"

*   translates to "this.getA().getB().getC()".  The last property may

*   be asynchronous, but not the intermediate ones (until support for that is

*   added, I suppose).

* - Boolean expressions can be constructed using &&, ||, !=, ==, and !.

* - It also supports the aliases "and", "or", and "not" for &&, ||, and !.

* - Primitive int values can be made using numbers, like: 123

* - Primitive long values can be made using the L suffix, like: 1234L

* - Primitive double values can be made using a decimal number, like: 12.34

* - Literal strings can be entered using double quotes, like: "hello"

* - Various automatic conversions will be attempted

*

* Phases:

*

* - Construction: on creation, all the view objects are constructed and

*   any properties of the views that don't take an expression are

*   set.

* - Load: when it is time to display the data from the database, and after

*   executing any action, load() is called, which reads all the expression

*   values and stores them into properties on the views.

* - Save: before any action is performed, all the #{...} expressions are

*   set to the matching property from the view object.

*

* Included tags:

*

* <k:view/> All the tags outside this are ignored; this is useful to take pieces of a complete

* HTML document and make a control out of it without making the page an invalid HTML document.

*

* <k:list value="#{...}"/> The children of the list are repeated once for each item in the

* collection

*

* <k:when test="${...}"/> If the condition is false, the contents are removed

*

* <k:when test="${! ...}"/> If the condition is true, the contents are removed

*

* UI pre-defined tags:

*

* <ui:button onclick="${...}"/>

*

* Plus new tags can be defined by creating a tag library file which specifies a mapping from a tag

* to a View class. The class is constructed and configured at runtime.  See the included

* META-INF folder for examples.

*

*/

  public static class ActionInfo {

        final String action;

        final boolean object;

        final boolean async;

        final boolean saveBefore;

        final boolean loadAfter;

        final String targetView;

    final String origExpr;

    final int timeout;

       

        private ActionInfo(String origExpr, String action, boolean object, boolean async, String targetView, boolean saveBefore, boolean loadAfter, int timeout) {

          this.origExpr = origExpr;

            this.action = action;

            this.object = object;

            this.async = async;

            this.saveBefore = saveBefore;

            this.loadAfter = loadAfter;

            this.targetView = targetView;

            this.timeout = timeout;

        }

       

        /**

         * One or more statements that perform the required action.

         *

         * When async == true this will return success or failure to

         * a callback parameter named "callback".

         *

         * When async == false this will not invoke any callback.

         */

        public String getAction() {

            return action;

        }

        public boolean isAsync() {

            return async;

        }

        public boolean issaveBefore() {

            return saveBefore;

        }

        public boolean isloadAfter() {

            return loadAfter;

        }

        public int getTimeout() {

      return timeout;

    }

       

        /**

         * @param callbackExpr AsyncCallback to return errors or success to

         * @param callbackOptional True if the callback expression doesn't have to be called (i.e. group.<Void>member() or AsyncCallbackFactory.<Void>defaultNewInstance() calls)

         * @return one or more statements separated by a semicolon to execute this action.

         */

        public String toString(String callbackExpr, boolean callbackOptional) {

            if(object || async || saveBefore) {

                if(saveBefore || loadAfter) {

                    return "ViewAction.performOnView("+(action==null?"null":toActionCtor())+", "+targetView+", "+saveBefore+", "+loadAfter+(timeout>0?", "+timeout:"")+", "+callbackExpr+");";

                } else if(action == null) {

                    return "";

                } else {

                    return toActionCtor()+".perform("+callbackExpr+");";

                }

            } else {

                String syncAction=action;

                if(syncAction == null) syncAction = "";

                else syncAction = "try { "+syncAction+" } catch(Throwable t) { "+callbackExpr+".onFailure(t); return; }";

                if(loadAfter) {

                    // Not async, and no load before

                    return syncAction+targetView+".load("+callbackExpr+");";

                } else if(callbackOptional) {

                    // Not async, no load before, no save after

                    return syncAction;

                } else {

                    // Not async, no load before, no save after, still have to call the callback, though.

                    return syncAction+callbackExpr+".onSuccess(null);";

                }

            }

        }

        public String toViewAction() {

            if(saveBefore || loadAfter)

                return "new ViewAction("+toActionCtor()+", "+targetView+", "+saveBefore+", "+loadAfter+(timeout>0?", "+timeout:"")+")";

            else

                return toActionCtor();

        }

        private String toActionCtor() {

            String actionObj = object ? action

                : async ? "new Action(\""+escape(origExpr)+"\") { public void perform(AsyncCallback callback) { "+(timeout>0?"if(callback instanceof AsyncCallbackExtensions) ((AsyncCallbackExtensions)callback).resetTimeout("+timeout+"); ":"")+action+" }}"

                : "new Action(\""+escape(origExpr)+"\") { public void perform(AsyncCallback callback) { try { "+action+" callback.onSuccess(null); } catch(Throwable t) { callback.onFailure(t); }}}";

            return actionObj;

        }

    }

    protected static String escapeMultiline(String input) {

        return escape(input).replace("\\n", "\\n\"+\n\"");

    }

    public static interface TagHandlerApi {

     

    }

    public static interface TagHandler {

    }

    public static class SimpleTagHandler implements TagHandler {

      final String contentAttribute;

      final String viewClassName;

      final Map<String,String> defaults;

     

    public SimpleTagHandler(String viewClassName, String contentAttribute, Map<String, String> defaults) {

      super();

      this.viewClassName = viewClassName;

      this.contentAttribute = contentAttribute;

      this.defaults = defaults;

    }

    public GeneratorTypeInfo getViewClass(TypeOracle types) throws NotFoundException {

      return JTypeWrapper.wrap(types.getType(getViewClassName()));

    }

    public String getContentAttribute() {

      return contentAttribute;

    }

    public String getViewClassName() {

      return viewClassName;

    }

    public Map<String, String> getDefaults() {

      return defaults;

    }

    }

    public static class TagLibrary {

      final HashMap<String,TagHandler> tags = new HashMap<String,TagHandler>();

     

      void addSimpleTagHandler(String tag, String viewClassName, String contentAttribute, Map<String, String> defaults) {

        tags.put(tag, new SimpleTagHandler(viewClassName, contentAttribute, defaults));

      }

    public TagHandler getHandler(String tag) {

      return tags.get(tag);

    }

    }

   

    /**

   * Provide access to a non-async value in transition in order

   * to perform some kind of transformation on it.

   * @author dobes

   *

   */

    public static class OperatorInfo {

    public String onGetExpr(String expr) throws UnableToCompleteException {

      return expr;

    }

    public String onSetExpr(String expr) throws UnableToCompleteException {

      return expr;

    }

  }

 

    //    static class Prof {

//      static String msg;

//      static long startTime;

//      static long elapsed() { return (new Date().getTime() - startTime); }

//      static void start(String msg) {

//        if(msg == null) {

//          long t = elapsed();

//          if(t > 100) {

//            System.out.println(elapsed()+"ms ...");

//          }

//        }

//        stop();

//        Prof.msg = msg;

//      }

//      static void stop() {

//        if(msg != null) {

//          System.out.println(elapsed()+"ms - "+msg);

//          msg = null;

//        }

//        Prof.startTime = new Date().getTime();

//      }

//    }

    public static class GeneratorInstance extends BaseGenerator.GeneratorInstance {

      public static final String KIYAA_CORE_TAGS_NAMESPACE = "http://habitsoft.com/kiyaa/core";

        public static final String KIYAA_VIEW_TAGS_NAMESPACE = "http://habitsoft.com/kiyaa/ui";

        public static final String SUBVIEW_CLASS_NAME_ATTRIBUTE = "subviewClassName";

    public static final String PARENT_VIEW_FIELD_NAME = "_pv";

      public static final String ROOT_VIEW_FIELD_NAME = "_root";

        static final String XHTML_NAMESPACE = "http://www.w3.org/1999/xhtml";

        static boolean tagLibrariesLoaded=false;

        static long lastTagLibraryLoad = 0;

        static HashMap<String, TagLibrary> tagLibraries = new HashMap<String, TagLibrary>();

        static HashMap<String, String> namespaces = new HashMap<String, String>();

        protected ClassGenerator rootClassGenerator;

        protected Element rootElement;

        protected int subviewNumber;

       

        public static class SubviewToGenerate {

          public String name;

          public Element element;         

          public GeneratedClassInfo parentViewClass;

      public SubviewToGenerate(String name, Element element, GeneratedClassInfo parentViewClass) {

        super();

        this.name = name;

        this.element = element;

        this.parentViewClass = parentViewClass;

      }

         

        }

        protected LinkedList<SubviewToGenerate> subviewsToGenerate = new LinkedList<SubviewToGenerate>();

       

        @Override

    public void init() throws UnableToCompleteException {

            super.init();

            // Caching these classes seem to occasionally create some weirdness; we need to

            // re-load the tag libraries each time there is a new compile operation, or we

            // should change it so we can "refresh" them without reparsing the xml files.

            if(!tagLibrariesLoaded) {

              loadTagLibraries();

              tagLibrariesLoaded = true;

              lastTagLibraryLoad = System.currentTimeMillis();

            } else {

              //refreshTagLibraryClasses();

            }

           

            rootClassGenerator = new ClassGenerator();

            String templatePath = getSimpleClassName(baseType, ".") + ".xhtml";

            final TemplatePath annotation = baseType.getAnnotation(TemplatePath.class);

            if(annotation != null) {

                templatePath = annotation.value();

                //System.out.println("Found TemplatePath annotation on "+baseType+" with value "+templatePath);

            }

           

            rootElement = loadAndParseTemplate(templatePath);

            if (rootElement.getAttribute("with-model") != null) {

                final String modelViewClassName = ModelView.class.getName();

                this.composerFactory.addImplementedInterface(modelViewClassName);

            }

        }

    protected Element loadAndParseTemplate(String templatePath) throws Error,

        UnableToCompleteException {

      XMLReader reader;

      try {

        reader = XMLReaderFactory.createXMLReader();

      } catch (SAXException caught1) {

        throw new Error(caught1);

      }

      // Load XHTML declaration from the jar file, otherwise fail if someone wants to load a DTD

            reader.setEntityResolver(new XhtmlEntityResolver(new FailingEntityResolver()));

            nu.xom.Builder b = new nu.xom.Builder(reader);

            Document d;

            java.io.File f;

            JClassType topLevelClass = baseType;

            while(topLevelClass.getEnclosingType() != null) topLevelClass = topLevelClass.getEnclosingType();

      try {

        Class<?> clazzInstance = Class.forName(topLevelClass.getQualifiedSourceName());

                URL resource = clazzInstance.getResource(templatePath);

                if(resource == null) {

                    logger.log(TreeLogger.ERROR, "No template found at "+templatePath);

                    throw new UnableToCompleteException();

                }

                f = new File(resource.toURI());

      } catch (ClassNotFoundException caught1) {

          logger.log(TreeLogger.ERROR, "Couldn't find class "+topLevelClass+" in order to determine path to template file.", caught1);

        throw new UnableToCompleteException();

      } catch (URISyntaxException caught) {

                logger.log(TreeLogger.ERROR, "Invalid template path: "+templatePath, caught);

        throw new UnableToCompleteException();

      }

            //java.io.File f = new File(new File(baseType.getCompilationUnit().getLocation()).getParentFile(), templatePath);

            try {

                logger.log(TreeLogger.TRACE, "Looking for template as a file with path " + f.getPath(), null);

                if (!f.exists()) {

                    logger.log(TreeLogger.WARN, "Looking for template as a file with path " + f.getPath()

                                    + " failed; looking for template as a resource with path " + templatePath, null);

                    final InputStream resourceAsStream = getClass().getResourceAsStream(templatePath);

                    try {

                        d = b.build(resourceAsStream);

                    } finally {

                        resourceAsStream.close();

                    }

                } else {

                    d = b.build(f);

                }

            } catch (Exception caught) {

                logger.log(TreeLogger.ERROR, "Failed to load template '" + templatePath + ": "+caught.toString(), null);

                throw new UnableToCompleteException();