/*
    * 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.guiBuilder;
  
  import org.apache.myfaces.orchestra.dynaForm.metadata.FieldRepresentation;
  import org.apache.myfaces.orchestra.dynaForm.metadata.MetaField;
  import org.apache.myfaces.orchestra.dynaForm.metadata.RelationType;
  import org.apache.myfaces.orchestra.dynaForm.metadata.utils.TypeInfos;
  import org.apache.myfaces.orchestra.lib.OrchestraException;
  
  import javax.faces.component.UIComponent;
  import java.util.Date;
  import java.util.Map;
  
  /**
   * A factory for creating gui-framework-specific representations of
   * data to be displayed to a user.
   * <p>
   * A concrete subclass of this type is needed for each specific
   * UI framework. Component-based frameworks (such as JSF) may create
   * component objects and add them to a "component tree", while other
   * frameworks may simply write data to the current response stream.
   * <p>
   * This base class defines the abstract factory methods, and also
   * provides a number of utility classes for the concrete subclasses
   * to use. 
   */
  public abstract class GuiBuilder
  {
      private UIComponent destCmp;
  
      private boolean idAsDisplayOnly;
      private boolean displayOnly;
      private Map<String, String> labelBundle;
  
      public void setDestCmp(UIComponent destCmp)
      {
          this.destCmp = destCmp;
      }
  
      public UIComponent getDestCmp()
      {
          return destCmp;
      }
  
      /**
       * Returns true if this field should be rendered display only.
       */
      public boolean isFieldDisplayOnly(MetaField field)
      {
          return displayOnly || (isIdAsDisplayOnly() && field.isId());
      }
  
      /**
       * Set to true if the guiBuilder should build a read-only form only.
       */
      public void setFormDisplayOnly(boolean displayOnly)
      {
          this.displayOnly = displayOnly;
      }
  
      /**
       * @see #setIdAsDisplayOnly(boolean)
       */
      public boolean isIdAsDisplayOnly()
      {
          return idAsDisplayOnly;
      }
  
      /**
       * set if the guiBuilder should build all id fields display only
       */
      public void setIdAsDisplayOnly(boolean idAsDisplayOnly)
      {
          this.idAsDisplayOnly = idAsDisplayOnly;
      }
  
      /**
       * @see #setLabelBundle(Map)
       */
      public Map<String, String> getLabelBundle()
      {
          return labelBundle;
     }
 
     /**
      * The resource bundle to be used when translating field names into
      * text labels.
      * <p>
      * A labelBundle is optional; if not specified then the field name will
      * be used as the label. In addition, if a field-name is not defined in
      * the resource bundle then the raw field-name will also be used.
      */
     public void setLabelBundle(Map<String, String> labelBundle)
     {
         this.labelBundle = labelBundle;
     }
 
     /**
      * Output text using the field as value provider.
      */
     public abstract void createOutputText(MetaField field);
 
     /**
      * input field
      */
     public abstract void createInputText(MetaField field);
 
     /**
      * input date
      */
     public abstract void createInputDate(MetaField field);
 
     /**
      * select one menu
      */
     public abstract void createSelectOneMenu(MetaField field);
 
     /**
      * enter a number
      */
     public abstract void createInputNumber(MetaField field);
 
     /**
      * select a boolean
      */
     public abstract void createInputBoolean(MetaField field);
 
     /**
      * search for component
      */
     public abstract void createSearchFor(MetaField field);
 
     /**
      * search for component
      */
     public abstract void createSearchForSelectMenu(MetaField field);
 
     // public abstract void createSearchForSelectMenu(MetaField field);
 
     /**
      * this is when the user passed in a component to use for the this field
      */
     public abstract void createNative(MetaField field);
 
     /**
      * actuallly build the fields gui component
      */
     protected boolean buildField(MetaField field)
     {
         Class<?> fieldType = field.getType();
 
         if (field.getWantedComponent() != null)
         {
             createNative(field);
             return true;
         }
 
         if (!field.getWantedComponentType().equals(FieldRepresentation.Automatic))
         {
             switch (field.getWantedComponentType())
             {
                 case OutputText:
                     createOutputText(field);
                     return true;
 
                 case InputText:
                     createInputText(field);
                     return true;
 
                 case InputDate:
                     createInputDate(field);
                     return true;
 
                 case SelectOneMenu:
                     if (RelationType.MANY_TO_ONE.equals(field.getRelationType()))
                     {
                         createSearchForSelectMenu(field);
                     }
                     else
                     {
                         // TODO: will not work now
                         createSelectOneMenu(field);
                     }
                     return true;
 
                     /*
                  case SelectSearchMenu:
                      createSearchForSelectMenu(field);
                      return true;
                  */
 
                 case InputNumber:
                     createInputNumber(field);
                     return true;
 
                 case InputBoolean:
                     createInputBoolean(field);
                     return true;
                     
                 default:
                     throw new OrchestraException("Unhandled wantedComponentType");
                         
             }
         }
 
         if (Boolean.TRUE.equals(field.getDisplayOnly()))
         {
             createOutputText(field);
             return true;
         }
 
         if (field.getAllowedSelections() != null)
         {
             createSelectOneMenu(field);
             return true;
         }
 
         if (RelationType.MANY_TO_ONE.equals(field.getRelationType()))
         {
             createSearchFor(field);
             return true;
         }
 
         if (fieldType == null)
         {
             throw new IllegalArgumentException("No type for field '" + field.getName() + "' detected.");
         }
 
         if (Date.class.isAssignableFrom(fieldType))
         {
             createInputDate(field);
             return true;
         }
 
         TypeInfos.Info typeInfo = TypeInfos.getInfo(fieldType);
         if (typeInfo != null && typeInfo.isNumber())
         {
             createInputNumber(field);
             return true;
         }
 
         if (String.class.isAssignableFrom(fieldType))
         {
             createInputText(field);
             return true;
         }
 
         if (Boolean.class.isAssignableFrom(fieldType) || boolean.class.equals(fieldType))
         {
             createInputBoolean(field);
             return true;
         }
 
         return false;
     }
 
     /**
      * Localise a text string using the resource-bundle specified for the dynaform.
      * <p>
      * If the key is null, or there is no resource-bundle, or there is no entry in
      * the resource bundle for the specified key, then return the dflt string. 
      */
     protected String translateText(String key, String dflt)
     {
         if (key == null)
         {
             return dflt;
         }
 
         Map<String, String> bundle = getLabelBundle();
         if (bundle == null)
         {
             return dflt;
         }
         
         Object val = bundle.get(key);
         if (val != null)
         {
             return val.toString();
         }
         
         return dflt;
     }
 }