/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
    *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  package org.apache.myfaces.orchestra.dynaForm.jsf.component;
  
  import org.apache.myfaces.orchestra.dynaForm.jsf.guiBuilder.Slipstream;
  import org.apache.myfaces.orchestra.dynaForm.jsf.guiBuilder.impl.jsf.JsfGuiBuilder;
  import org.apache.myfaces.orchestra.dynaForm.jsf.guiBuilder.impl.jsf.JsfGuiBuilderFactory;
  import org.apache.myfaces.orchestra.dynaForm.jsf.guiBuilder.impl.jsf.NewComponentListener;
  import org.apache.myfaces.orchestra.dynaForm.lib.ViewType;
  import org.apache.myfaces.orchestra.dynaForm.lib._FacesUtils;
  import org.apache.myfaces.orchestra.dynaForm.metadata.Extractor;
  import org.apache.myfaces.orchestra.dynaForm.metadata.MetaData;
  import org.apache.myfaces.orchestra.dynaForm.metadata.MetaField;
  import org.apache.myfaces.orchestra.dynaForm.metadata.impl.MetaDataImpl;
  import org.apache.myfaces.orchestra.dynaForm.metadata.impl.jsf.JsfExclusiveExtractor;
  import org.apache.myfaces.orchestra.dynaForm.metadata.impl.jsf.JsfExtractor;
  import org.apache.myfaces.orchestra.dynaForm.metadata.impl.jsf.JsfRequestFieldExtractor;
  import org.apache.myfaces.orchestra.dynaForm.uri.FacesUriResolver;
  import org.apache.myfaces.orchestra.dynaForm.uri.UriResolver;
  
  import javax.el.ELContext;
  import javax.faces.component.UIColumn;
  import javax.faces.component.UIComponent;
  import javax.faces.component.UIComponentBase;
  import javax.faces.component.UIData;
  import javax.faces.context.FacesContext;
  import javax.faces.el.ValueBinding;
  import javax.persistence.Transient;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  /**
   * A DynaForm component dynamically creates child jsf component objects to render
   * all the persistent fields of an arbitrary java object.
   * <p>
   * This component can be nested within a UIData. In this case the data model of the
   * UIData is assumed to be a list of persistent objects, each of which is of the 
   * type specified by the "uri" attribute of this component. A UIColumn component
   * is generated for each persistent property of the class specified by "uri".
   * <p>
   * This component can also be used as a child of something other than a UIData,
   * in which case it simply outputs a (label, field) pair of components for each
   * persistent property of the class specified by the "uri" parameter. It is up
   * to the parent component to lay out these component pairs appropriately. 
   * <p>
   * The standard "value" property must be an EL expression that returns the object
   * whose properties are to be displayed or edited. When used within a UIData,
   * this will normally return the "var" property of the datatable.
   * <p>
   * For documentation on the configurable properties of this component, see:
   * <ul>
   * <li>uri: {@link #setUri(String)}
   * <li>valueBindingPrefix: {@link #setValueBindingPrefix(String)}
   * <li>displayOnly: {@link #setDisplayOnly(boolean)}
   * <li>bundle: {@link #setBundle(String)}
   * <li>exclusiveFields: {@link #setUri(String)}
   * <li>idAsDisplayOnly: {@link #setIdAsDisplayOnly(boolean)}
   * </ul>
   * <p>
   * Note that this class has no Renderer; this class dynamically modifies the component
   * tree to add components, but has no actual representation itself and therefore needs
   * no renderer. See method initView.
   */
  public class DynaForm extends UIComponentBase
  {
      public static final String COMPONENT_TYPE = "org.apache.myfaces.orchestra.dynaForm.DynaForm";
      public static final String DEFAULT_RENDERER_TYPE = "org.apache.myfaces.orchestra.dynaForm.DynaForm";
      public static final String COMPONENT_FAMILY = "org.apache.myfaces.orchestra.dynaForm.DynaForm";
  
      public static final String DYNA_FORM_CREATED = "org.apache.myfaces.dynaForm.CREATED";
      public static final String DYNA_FORM_URI = "org.apache.myfaces.dynaForm.URI";
  
      private String uri;
      private String bundle;
      private String valueBindingPrefix;
      private Boolean displayOnly;
      private Boolean exclusiveFields;
      private Boolean idAsDisplayOnly;
      private NewComponentListener newComponentListener;
  
      // TODO: why is this property marked with a JPA Transient annotation?
      @Transient
     private transient UriResolver.Configuration configuration = null;
     @Transient
     private transient DynaConfigs formConfigs = null;
     @Transient
     private transient ELContext elcontext;
 
     /**
      * Create a UIColumn component to wrap a (label, value) pair of JSF components
      * that represent a single persistent property. This class is used when the
      * DynaForm is generating a "row per object" layout for a list of persistent
      * objects.
      * <p>
      * TODO: before writing out the component, look for an existing component with that
      * fieldname inside the parent. If it exists, then just skip the component creation.
      * This allows the user to do custom layout for some of the fields. This might also
      * make the @UIComponent annotation obsolete. 
      */
     protected static class AddComponentToTable implements NewComponentListener
     {
         // TODO: fieldName is an unused parameter
         @SuppressWarnings("unchecked")
         public void newComponent(UIComponent destCmp,
                                  MetaField field, String fieldName,
                                  UIComponent label, UIComponent component)
         {
             UIColumn column = new UIColumn();
             if (component.getId() != null)
             {
                 column.setId("col" + component.getId());
             }
             column.getChildren().add(component);
             column.setHeader(label);
             column.getAttributes().put(DynaForm.DYNA_FORM_CREATED, Boolean.TRUE);
 
             _FacesUtils.copyRendered(component, column);
 
             destCmp.getChildren().add(column);
         }
 
         public boolean containsComponent(UIComponent destCmp, String id)
         {
             return destCmp.findComponent(id) != null;
         }
     }
 
     /**
      * Simply attach a (label, value) pair of JSF components that represent a
      * single persistent property.
      * <p>
      * This class is used when the DynaForm is generating a plain "form style"
      * layout for a single persistent object.
      */
     protected static class AddComponentSimple implements NewComponentListener
     {
         @SuppressWarnings("unchecked")
         public void newComponent(UIComponent destCmp,
                                  MetaField field, String fieldName,
                                  UIComponent label, UIComponent component)
         {
             _FacesUtils.copyRendered(component, label);
 
             destCmp.getChildren().add(label);
             destCmp.getChildren().add(component);
         }
 
         public boolean containsComponent(UIComponent destCmp, String id)
         {
             return destCmp.findComponent(id) != null;
         }
     }
 
     public DynaForm()
     {
         super();
     }
 
     @Override
     public String getFamily()
     {
         return COMPONENT_FAMILY;
     }
 
     /**
      *  @see #setNewComponentListener(org.apache.myfaces.orchestra.dynaForm.jsf.guiBuilder.impl.jsf.NewComponentListener)
      */
     public NewComponentListener getNewComponentListener()
     {
         if (newComponentListener != null)
         {
             return newComponentListener;
         }
 
         ValueBinding vb = getValueBinding("newComponentListener");
         return vb != null ? (NewComponentListener) vb.getValue(getFacesContext()) : null;
     }
 
     /**
      * Normally DynaForm will try to figure out how to add components to the JSF tree.
      * In case you would like to customize that, you cann provide your own {@link NewComponentListener}.
      */
     public void setNewComponentListener(NewComponentListener newComponentListener)
     {
         this.newComponentListener = newComponentListener;
     }
 
     /**
      * @see #setUri
      */
     public String getUri()
     {
         if (uri != null)
         {
             return uri;
         }
         ValueBinding vb = getValueBinding("uri");
         return vb != null ? (String) vb.getValue(getFacesContext()) : null;
     }
 
     /**
      * Specifies how to obtain the metadata for the value object.
      * <p>
      * This is a string of form "inspector:classname". The inspector part ndicates
      * which of the configured Extractor implementations should be used to obtain the
      * metadata for this class. The classname is of course the concrete class of the
      * specified object.
      * <p>
      * For example, "ejb:fqn.to.model.Entity" means use the EJB3-based extractor
      * implementation to obtain metadata about the given entity
      * <p>
      * TODO: why can't value.getClass() be used for the classname part of the uri?
      * Maybe because the value EL expression can map to a null property when creating
      * a new instance?
      * <p>
      *
      * @see org.apache.myfaces.orchestra.dynaForm.uri.UriResolver
      */
     public void setUri(String uri)
     {
         this.uri = uri;
     }
 
     /**
      * @see #setValueBindingPrefix
      */
     public String getValueBindingPrefix()
     {
         if (valueBindingPrefix != null)
         {
             return valueBindingPrefix;
         }
         ValueBinding vb = getValueBinding("valueBindingPrefix");
         return vb != null ? (String) vb.getValue(getFacesContext()) : null;
     }
 
     /**
      * Specify how to get and set the model value for each persistent property
      * of the value object.
      * <p>
      * When the JSF components that correspond to the individual persistent
      * properties of the value object are created, they need EL expressions to
      * tell them how to access the corresponding model value.
      * <p>
      * The EL expression used for each created component is of form
      * <code>#{valueBindingPrefix.propname}</code>.
      * <p>
      * Of course valueBindingPrefix will normally refer to the same object
      * that the "value" property refers to. In fact, there probably isn't any
      * other sane value for this property.
      * <p>
      * TODO: Can we get rid of this attribute? Either call
      * <code>getValueBinding().getExpressionString()</code> or create a special
      * ValueBinding subclass that takes a "base object" parameter which we can
      * point at the result of evaluating the main value expression.
      */
     public void setValueBindingPrefix(String valueBindingPrefix)
     {
         this.valueBindingPrefix = valueBindingPrefix;
     }
 
     /**
      * @see #setBundle
      */
     public String getBundle()
     {
         if (bundle != null)
         {
             return bundle;
         }
         ValueBinding vb = getValueBinding("bundle");
         return vb != null ? (String) vb.getValue(getFacesContext()) : null;
     }
 
     /**
      * The bundle to use to convert property names to localised label strings.
      * <p>
      * For each persistent property on the value object, a pair of components
      * (label and value) are created. The label text is computed by using the
      * persistent property name as a key into the specified bundle.
      * <p>
      * This must be the name of a managed bean that implements Map.
      */
     public void setBundle(String bundle)
     {
         this.bundle = bundle;
     }
 
     /**
      * Display the whole form in read only mode, ie all the JSF components
      * generated to display persistent properties are "read only".
      */
     public void setDisplayOnly(boolean displayOnly)
     {
         this.displayOnly = displayOnly;
     }
 
     /**
      * @see #setDisplayOnly(boolean)
      */
     public boolean isDisplayOnly()
     {
         if (displayOnly != null)
         {
             return displayOnly.booleanValue();
         }
         ValueBinding vb = getValueBinding("displayOnly");
         if (vb != null)
         {
             Boolean ret = (Boolean) vb.getValue(getFacesContext());
             if (ret != null)
             {
                 return ret.booleanValue();
             }
         }
 
         return false;
     }
 
     /**
      * Display id fields (ie the key fields of the persistent object) in the form
      * in read only mode.
      * <p>
      * Defaults to false.
      * <p>
      * When editing existing objects this should be set to true, as it is not possible
      * to modify the key of an existing entity. When creating a new instance this should
      * be set to true if the key is an auto-generated surrogate key, but false if the
      * key to this entity is a "business key".
      */
     public void setIdAsDisplayOnly(boolean idAsDisplayOnly)
     {
         this.idAsDisplayOnly = idAsDisplayOnly;
     }
 
     /**
      * @see #setIdAsDisplayOnly(boolean)
      */
     public boolean isIdAsDisplayOnly()
     {
         if (idAsDisplayOnly != null)
         {
             return idAsDisplayOnly.booleanValue();
         }
         ValueBinding vb = getValueBinding("idAsDisplayOnly");
         if (vb != null)
         {
             Boolean ret = (Boolean) vb.getValue(getFacesContext());
             if (ret != null)
             {
                 return ret.booleanValue();
             }
         }
 
         return false;
     }
 
     /**
      * Process only fields listed by their facets
      * <p>
      * TODO: document this properly. What does this do exactly??
      */
     public void setExclusiveFields(boolean exclusiveFields)
     {
         this.exclusiveFields = exclusiveFields;
     }
 
     /**
      * @see #setExclusiveFields(boolean)
      */
     public boolean isExclusiveFields()
     {
         if (exclusiveFields != null)
         {
             return exclusiveFields.booleanValue();
         }
         ValueBinding vb = getValueBinding("exclusiveFields");
         if (vb != null)
         {
             Boolean ret = (Boolean) vb.getValue(getFacesContext());
             if (ret != null)
             {
                 return ret.booleanValue();
             }
         }
 
         return false;
     }
 
     @Override
     public void restoreState(FacesContext context, Object stateArray)
     {
         Object[] states = (Object[]) stateArray;
         super.restoreState(context, states[0]);
         uri = (String) states[1];
         // var = (String) states[2];
         displayOnly = (Boolean) states[2];
         bundle = (String) states[3];
         valueBindingPrefix = (String) states[4];
         idAsDisplayOnly = (Boolean) states[5];
         exclusiveFields = (Boolean) states[6];
         newComponentListener = (NewComponentListener) restoreAttachedState(context, states[7]);
     }
 
     @Override
     public Object saveState(FacesContext context)
     {
         return new Object[]
             {
                 super.saveState(context),
                 uri,
                 // var,
                 displayOnly,
                 bundle,
                 valueBindingPrefix,
                 idAsDisplayOnly,
                 exclusiveFields,
                 saveAttachedState(context, newComponentListener)
             };
     }
 
     /**
      * Get the overall configuration based on the current value of the uri property.
      * <p>
      * This returns an object that simply pairs an Extractor object with the remaining
      * part of the URI. The Extractor instance selected is specified by the "protocol"
      * part of the URI.
      *
      * @see org.apache.myfaces.orchestra.dynaForm.uri.UriResolver
      */
     protected UriResolver.Configuration getConfiguration()
     {
         if (configuration == null)
         {
             configuration = new FacesUriResolver().resolveUri(getUri());
         }
         return configuration;
     }
 
     public Extractor getExtractor()
     {
         return getConfiguration().getExtractor();
     }
 
     /**
      * try to find a parent dyna form+
      */
     protected DynaForm findParentDynaForm(DynaForm start)
     {
         UIComponent component = start.getParent();
         while (component != null)
         {
             if (component instanceof DynaForm)
             {
                 return (DynaForm) component;
             }
             component = component.getParent();
         }
 
         return null;
     }
 
     /**
      * Find the dynaForm component
      */
     public static DynaForm getDynaForm(UIComponent component)
     {
         if (component == null)
         {
             throw new IllegalArgumentException("component==null not allowed");
         }
 
         UIComponent dynaFormComponent = component;
         while (dynaFormComponent != null && (!(dynaFormComponent instanceof DynaForm)))
         {
             dynaFormComponent = dynaFormComponent.getParent();
         }
         if (dynaFormComponent == null)
         {
             throw new IllegalArgumentException(
                 "component with id '" + component.getId() + "' not contained in an dynaForm");
         }
 
         return (DynaForm) dynaFormComponent;
     }
 
     /**
      * get access to the special form configurations
      */
     public DynaConfigs getFormConfigs()
     {
         if (formConfigs != null)
         {
             return formConfigs;
         }
 
         for (Object obj : getChildren())
         {
             if (obj instanceof DynaConfigs)
             {
                 formConfigs = (DynaConfigs) obj;
                 return formConfigs;
             }
         }
 
         return null;
     }
 
     /**
      * Note that this method should only be called when _FacesUtils.useValueExpression is true.
      * <p>
      * This is needed when using either JSF1.2 or (JSF1.1 + facelets). 
      * <p>
      * It is still not clear why we need this anyway; instead of storing a context for later
      * use, why not just use the context available at the time an expression must be evaluated?
      */
     public ELContext getELContext()
     {
         return elcontext;
     }
 
     public void setELContext(ELContext elcontext)
     {
         this.elcontext = elcontext;
     }
 
     @Override
     public boolean isRendered()
     {
         // ensure we are not treated as a rendering component
         return false;
     }
 
     /**
      * Dynamically compute and add child components to the current tree.
      * <p>
      * This method is required to be invoked from the TagHandler when an instance of
      * this component is created. Components are created based upon the class specified
      * by the "uri" property, and added as children of the parent component of this component.
      * <p>
      * This component itself never has any components, and never generates any output
      * into the response stream.
      * <p>
      * It would be much nicer if this component could be the parent of the components it
      * dynamically creates, but that doesn't work well with an h:panelGrid or h:dataTable
      * component as the parent; a panelGrid counts its children while a dataTable counts
      * its UIColumn children. To make things work, the created components must therefore
      * be direct children of the parent. Note that this component is also a child of the
      * parent, but because it marks itself as rendered=false it does not affect the
      * behaviour of parent components that count their (rendered) children.
      * <p>
      * Note also that although this method is capable of deleting previously-created
      * components and creating a new set, at the moment this method is only invoked
      * by the taghandler when this component is created. That means that the "uri"
      * parameter is only used on first access to the view, and is ignored thereafter.
      */
     @SuppressWarnings("unchecked")
     public void initView(FacesContext context)
     {
         UIComponent layoutComponent = getParent();
         ViewType viewType = getViewType(layoutComponent);
 
         // check if the uri has changed since the last rendering. This can happen
         // if the uri points to a value-binding
         String previousUri = (String) getAttributes().get(DynaForm.DYNA_FORM_URI);
         if (previousUri != null && !previousUri.equals(getUri()))
         {
             removeDynaFormCreatedComponents(layoutComponent);
         }
 
         // create & add components
         // boolean needAdd = processPreviouslyAdded(context, layoutComponent);
         // if (needAdd)
         {
             getAttributes().put(DynaForm.DYNA_FORM_URI, getUri());
             addComponents(context, this, layoutComponent, viewType);
         }
     }
 
     public void removeDynaFormCreatedComponents(UIComponent base)
     {
         @SuppressWarnings("unchecked")
         List<UIComponent> children = base.getChildren();
         if (children == null || children.size() < 1 )
         {
             return;
         }
 
         Iterator<UIComponent> iterChildren = children.iterator();
         while (iterChildren.hasNext())
         {
             UIComponent component = (UIComponent) iterChildren.next();
 
             if (Boolean.TRUE.equals(component.getAttributes().get(DynaForm.DYNA_FORM_CREATED)))
             {
                 iterChildren.remove();
             }
             else
             {
                 removeDynaFormCreatedComponents(component);
             }
         }
     }
 
     /**
      * determine the current view type
      * <ul>
      * <li>"list" means: the layout component "is a" or "is embedded in an" list component (UIData)</li>
      * <li>"form" means: anything else</li>
      * </ul>
      */
     protected ViewType getViewType(UIComponent startComponent)
     {
         UIComponent component = startComponent;
         while (component != null && !(component instanceof DynaForm))
         {
             if (isTable(component))
             {
                 return ViewType.LIST;
             }
 
             component = component.getParent();
         }
 
         return ViewType.FORM;
     }
 
     /**
      * create and add the components to the layout component.
      *
      * TODO: clean this method up. It still had artefacts from when this code was in a separate
      * Renderer class.
      */
     protected void addComponents(final FacesContext context,
                                  final DynaForm dynaForm, final UIComponent layoutComponent,
                                  final ViewType viewType)
     {
         MetaData metaData = extractMetaData(dynaForm);
 
         Slipstream slipstream = new Slipstream();
         slipstream.setDynaForm(this);
         slipstream.setModelMetaData(metaData);
 
         if (dynaForm.getBundle() != null)
         {
             // get the bundle and attach it
             ValueBinding vb = context.getApplication().createValueBinding("#{" + dynaForm.getBundle() + "}");
             @SuppressWarnings("unchecked")
             Map<String, String> bundleMap = (Map<String, String>) vb.getValue(context);
             slipstream.setLabelBundle(bundleMap);
         }
 
         JsfGuiBuilder guiBuilder = createGuiBuilder(context);
 
         guiBuilder.setDestCmp(layoutComponent);
         guiBuilder.setELContext(dynaForm.getELContext());
         guiBuilder.setContext(context);
 
         if (dynaForm.getNewComponentListener() != null)
         {
             guiBuilder.setNewComponentListener(dynaForm.getNewComponentListener());
         }
         else if (isTable(layoutComponent))
         {
             guiBuilder.setNewComponentListener(new AddComponentToTable());
         }
         else
         {
             guiBuilder.setNewComponentListener(new AddComponentSimple());
         }
 
         String valueBindingPrefix = getValueBindingPrefix(dynaForm, layoutComponent);
         if (valueBindingPrefix == null)
         {
             throw new UnsupportedOperationException("can't determine the value binding prefix");
         }
         guiBuilder.setBackingEntityPrefix(valueBindingPrefix);
 
         slipstream.setGuiBuilder(guiBuilder);
         slipstream.process();
     }
 
     private boolean isTable(UIComponent layoutComponent)
     {
         return layoutComponent instanceof UIData || UIData.COMPONENT_FAMILY.equals(layoutComponent.getFamily());
     }
 
     protected String getValueBindingPrefix(DynaForm dynaForm, UIComponent layoutComponent)
     {
         String valueBindingPrefix = dynaForm.getValueBindingPrefix();
         if (valueBindingPrefix == null)
         {
             valueBindingPrefix = (String) layoutComponent.getAttributes().get("var");
         }
 
         return valueBindingPrefix;
     }
 
     private MetaData extractMetaData(final DynaForm dynaForm)
     {
         MetaDataImpl metaData = new MetaDataImpl();
 
         try
         {
             // lookup which fields to process
             new JsfRequestFieldExtractor().getMetaData(metaData, dynaForm);
 
             if (dynaForm.isExclusiveFields())
             {
                 // the same as above, but keep their ordering and some additional metadata
                 new JsfExclusiveExtractor().getMetaData(metaData, dynaForm);
                 metaData.setLockFields(true);
             }
 
             // use the users extractor
             dynaForm.getExtractor().getMetaData(metaData, dynaForm.getConfiguration().getEntity());
 
             // processs the jsf stuff
             new JsfExtractor().getMetaData(metaData, dynaForm);
 
         }
         finally
         {
             metaData.setLockFields(false);
         }
 
         return metaData;
     }
 
     protected JsfGuiBuilder createGuiBuilder(final FacesContext facesContext)
     {
         return JsfGuiBuilderFactory.create(facesContext);
     }
 
     /**
      * check if we already added components to the layout component.<br />
      * <p/>
      * if this is the case then:
      * <ul>
      * <li>keep them cached and avoid readd</li>
      * <li><strike>in development mode: remove the components</strike></li>
      * <li><strike>in production mode: keep them cached</strike></li>
      * </ul>
      * <p/>
      * TODO: need to figure out whats the best way to recreate the components
      *
      * @return true if we have to add our components again
      */
     protected boolean processPreviouslyAdded(FacesContext context,
                                              UIComponent root)
     {
         @SuppressWarnings("unchecked")
         List<UIComponent> rootComponentChildren = root.getChildren();
         if (rootComponentChildren != null)
         {
             for (Object component : rootComponentChildren)
             {
                 UIComponent child = (UIComponent) component;
                 if (Boolean.TRUE.equals(child.getAttributes().get(
                     DynaForm.DYNA_FORM_CREATED)))
                 {
                     return false;
                 }
 
                 if (!processPreviouslyAdded(context, child))
                 {
                     return false;
                 }
             }
         }
 
         return true;
     }
 }