/**

  * Copyright 2010 The Kuali Foundation Licensed under the

  * Educational Community 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.osedu.org/licenses/ECL-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.kuali.student.common.ui.client.configurable.mvc;

 import org.kuali.student.common.assembly.data.Metadata;

 import org.kuali.student.common.assembly.data.MetadataInterrogator;

 import org.kuali.student.common.ui.client.application.Application;

 import org.kuali.student.common.ui.client.configurable.mvc.binding.ModelWidgetBinding;

 import org.kuali.student.common.ui.client.configurable.mvc.binding.MultiplicityCompositeBinding;

 import org.kuali.student.common.ui.client.configurable.mvc.multiplicity.MultiplicityComposite;

 import org.kuali.student.common.ui.client.mvc.Callback;

 import org.kuali.student.common.ui.client.mvc.HasCrossConstraints;

 import org.kuali.student.common.ui.client.mvc.HasDataValue;

 import org.kuali.student.common.ui.client.widgets.KSCheckBox;

 import org.kuali.student.common.ui.client.widgets.KSTextBox;

 import org.kuali.student.common.ui.client.widgets.RichTextEditor;

 import org.kuali.student.common.ui.client.widgets.field.layout.element.FieldElement;

 import org.kuali.student.common.ui.client.widgets.field.layout.element.MessageKeyInfo;

 import org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract;

 import com.google.gwt.user.client.ui.HasText;

 import com.google.gwt.user.client.ui.HasValue;

 import com.google.gwt.user.client.ui.Widget;

 /**

  * This is a field descriptor that defines ui fields.

  * A field descriptor is defined by its fieldKey and its metadata, the field key is the key that is used

  * to identify it during validation and save processing and maps directly to a field which exists in the

  * model definition for the model it relates to.  The fieldKey must match something within the model to

  * be a valid field.  <br>The metadata is its piece of information in the model definition which is used to

  * generate the field's widget and determine what the validation on this field is (also if this field

  * is backed by a search it will use the lookup metadata defined in its metadata to generate the appropriate

  * search widget).  It also determines if a requiredness indicator appears (constraint minOccurs > 1).

  * <br><br>

  * A field descriptor can be fully customized to any need, the widget can be chosen to be

  * defined directly instead of using one that is auto generated by the metadata - if this is done make sure

  * the data type it is using works with what is in the metadata and that it implements one of these standard 

  * interfaces:<br>

  * HasText<br>

  * KSSelectItemWidgetAbstract<br>

  * HasDataValue<br>

  * HasValue<br>

  * or, you MUST override the ModelWidgetBinding by calling setModelWidgetBinding

  * <br>

  * Setting the ModelWidgetBinding allows you to manipulate the widget's data and model data as you see fit

  * before a save when model data is loaded into the widget.

  * <br>

  * <br>

  * General layout of a field generated by FieldDescriptor, all elements are conditional based on the field's

  * configuration: <br>

  * <b>[label][requiredness indicator][help]<br>

  * [input widget]<br>

  * [constraint text]<br></b>

  * <br>

  * The messageKeyInfo passed in is used to generate the messages needed for a field these include:<br>

  * Field Label<br>

  * Help text<br>

  * Instructions<br>

  * Example text<br>

  * Constraint text<br>

  * Watermark text - only if the widget one that accepts text input<br><br>

  * These are generated by a single key, the additional text is determined by special suffixes on keys within

  * the messages data - example - you pass in "sampleField" for the message key - it is automatically determined

  * that if there is a message in the message data named "sampleField-instruct", instructions will be added to the field

  * in the appropriate location.<br>

  * List of the appended keys for use in messages data:<br>

  * "-help" for help text<br>

  * "-instruct" for instructions<br>

  * "-examples" for examples<br>

  * "-constraints" for constraint text<br>

  * "-watermark" for watermark text<br>

  * 

  * @author Kuali Student Team

  * @see FieldElement

  * @see Section

  * @see BaseSection

  * @see Configurer

  */

 public class FieldDescriptor {

     protected String fieldKey;

         protected Metadata metadata;

     @SuppressWarnings("unchecked")

         private ModelWidgetBinding modelWidgetBinding;

     private Callback<Boolean> validationRequestCallback;

     private boolean dirty = false;

     private boolean hasHadFocus = false;

     private final FieldElement fieldElement;

     private String modelId;

     private MessageKeyInfo messageKey;

     private boolean optional = false;

     private boolean ignoreShowRequired = false; 

     /**

      * @param fieldKey - key for this field which matches a field in the overall model definition that this

      * field will be used for

      * @param messageKey - key object used for determing field labels

      * @param metadata - metadata used to determine requiredness, validation, and autogenerated widget

      */

     public FieldDescriptor(String fieldKey, MessageKeyInfo messageKey, Metadata metadata) {

             this.fieldKey = fieldKey;

             this.metadata = metadata;

             if(messageKey == null){

                     messageKey = new MessageKeyInfo("");

             }

             setMessageKey(messageKey);

             fieldElement = new FieldElement(fieldKey, messageKey, createFieldWidget(), metadata);

             setupField();

             //Add mapping from path to field definition

             if((getFieldWidget() instanceof HasDataValue || getFieldWidget() instanceof KSTextBox || getFieldWidget() instanceof HasValue)&&!(this instanceof FieldDescriptorReadOnly)){

                     Application.getApplicationContext().putPathToFieldMapping(null, Application.getApplicationContext().getParentPath()+fieldKey, this);

                 }

             //Add cross constraints

             if(fieldElement.getFieldWidget() instanceof HasCrossConstraints){

                     HasCrossConstraints crossConstraintWidget = (HasCrossConstraints) fieldElement.getFieldWidget();

                     if(crossConstraintWidget!=null&&crossConstraintWidget.getCrossConstraints()!=null){

                             for(String path:crossConstraintWidget.getCrossConstraints()){

                                 Application.getApplicationContext().putCrossConstraint(null, path, crossConstraintWidget);

                             }

                     }

             }

     }

     /**

      * @param fieldKey - key for this field which matches a field in the overall model definition that this

      * field will be used for

      * @param messageKey - key object used for determing field labels

      * @param metadata - metadata used to determine requiredness and validation

      * @param fieldWidget - widget to use instead of an automatically determined one

      */

     public FieldDescriptor(String fieldKey, MessageKeyInfo messageKey, Metadata metadata, Widget fieldWidget){

             this.fieldKey = fieldKey;

             this.metadata = metadata;

             if(messageKey == null){

                     messageKey = new MessageKeyInfo("");

             }

         setMessageKey(messageKey);

             addStyleToWidget(fieldWidget);

             fieldElement = new FieldElement(fieldKey, messageKey, fieldWidget, metadata);

         setupField();

             //Add mapping from path to field definition if the definition has a data value

             if((fieldWidget instanceof HasDataValue || fieldWidget instanceof KSTextBox) &&!(this instanceof FieldDescriptorReadOnly)){

                     Application.getApplicationContext().putPathToFieldMapping(null, Application.getApplicationContext().getParentPath()+fieldKey, this);

                 }

             //Add cross constraints

             if(fieldElement.getFieldWidget() instanceof HasCrossConstraints){

                     HasCrossConstraints crossConstraintWidget = (HasCrossConstraints) fieldElement.getFieldWidget();

                     if(crossConstraintWidget!=null&&crossConstraintWidget.getCrossConstraints()!=null){

                             for(String path:crossConstraintWidget.getCrossConstraints()){

                                 Application.getApplicationContext().putCrossConstraint(null, path, crossConstraintWidget);

                             }

                     }

             }

     }

     protected void addStyleToWidget(Widget w){

             if(fieldKey != null && !fieldKey.isEmpty() && w != null){

                     String style = this.fieldKey.replaceAll("/", "-");

                     w.addStyleName(style);

             }

     }

     protected void setupField() {

             if(metadata != null){

                     if(MetadataInterrogator.isRequired(metadata)){

                             fieldElement.setRequiredString("requiredMarker", "ks-form-module-elements-required");

                     }

                     else if(MetadataInterrogator.isRequiredForNextState(metadata)){

                             String nextState = MetadataInterrogator.getNextState(metadata);

                             if(nextState != null){

                                     if(nextState.equalsIgnoreCase("SUBMITTED")){

                                             fieldElement.setRequiredString("requiredOnSubmit", "ks-form-required-for-submit");

                                     }

                                     else if(nextState.equalsIgnoreCase("APPROVED")){

                                             fieldElement.setRequiredString("reqApproval", "ks-form-required-for-submit");

                                     }

                                         else if(nextState.equalsIgnoreCase("ACTIVE")){

                                                 fieldElement.setRequiredString("reqActivate", "ks-form-required-for-submit");

                                     }

                                         else if(nextState.equalsIgnoreCase("SUSPENDED") ||

                                                         nextState.equalsIgnoreCase("RETIRED")){

                                                 fieldElement.setRequiredString("reqDeactivate", "ks-form-required-for-submit");

                                         }

                                         else {

                                                 fieldElement.setRequiredString("requiredOnSubmit", "ks-form-required-for-submit");

                                         }

                             }

                     } else{

                 fieldElement.clearRequiredText();

             }

             }

     }

     /**

      * @see FieldElement#hideLabel()

      */

     public void hideLabel(){

             fieldElement.hideLabel();

     }

     public boolean isLabelShown(){

             return fieldElement.isLabelShown();

     }

     public FieldElement getFieldElement(){

             return fieldElement;

     }

         public String getFieldKey() {

         return fieldKey;

     }

     public void setFieldKey(String fieldKey) {

                 this.fieldKey = fieldKey;

         }

     public String getFieldLabel() {

         return fieldElement.getFieldName();

     }

     public Widget getFieldWidget(){

         if (fieldElement.getFieldWidget() == null){

             Widget w = createFieldWidget();

             fieldElement.setWidget(w);

         }

         return fieldElement.getFieldWidget();

     }

     protected Widget createFieldWidget() {

             if (metadata == null) {

                     // backwards compatibility for old ModelDTO code

                     // for now, default to textbox if not specified

                     Widget result = new KSTextBox();

                     addStyleToWidget(result);

                     return result;

             } else {

                     Widget result = DefaultWidgetFactory.getInstance().getWidget(this);

                     addStyleToWidget(result);

                     return result;

             }

     }

     public ModelWidgetBinding<?> getModelWidgetBinding() {

         if(modelWidgetBinding == null){

             if(fieldElement.getFieldWidget() instanceof RichTextEditor){

                     modelWidgetBinding = org.kuali.student.common.ui.client.configurable.mvc.binding.RichTextBinding.INSTANCE;

             } else if (fieldElement.getFieldWidget() instanceof KSCheckBox){

                     modelWidgetBinding = org.kuali.student.common.ui.client.configurable.mvc.binding.HasValueBinding.INSTANCE;

             } else if(fieldElement.getFieldWidget() instanceof MultiplicityComposite){

                         modelWidgetBinding = MultiplicityCompositeBinding.INSTANCE;

                 } else if (fieldElement.getFieldWidget()instanceof HasText) {

                     modelWidgetBinding = org.kuali.student.common.ui.client.configurable.mvc.binding.HasTextBinding.INSTANCE;

             } else if (fieldElement.getFieldWidget() instanceof KSSelectItemWidgetAbstract){

                 modelWidgetBinding = org.kuali.student.common.ui.client.configurable.mvc.binding.SelectItemWidgetBinding.INSTANCE;

             } else if (fieldElement.getFieldWidget() instanceof HasDataValue){

                     modelWidgetBinding = org.kuali.student.common.ui.client.configurable.mvc.binding.HasDataValueBinding.INSTANCE;

             } else if (fieldElement.getFieldWidget() instanceof HasValue){

                     modelWidgetBinding = org.kuali.student.common.ui.client.configurable.mvc.binding.HasValueBinding.INSTANCE;

             }

         }

         return modelWidgetBinding;

     }

     /**

      * Allows additional processing to happen when a validation check is being processed when the input

      * widget loses focus defined in the callback

      * @param callback

      */

     public void setValidationCallBack(Callback<Boolean> callback){

         validationRequestCallback = callback;

     }

     public Callback<Boolean> getValidationRequestCallback(){

         return validationRequestCallback;

     }

         /**

          * Returns true if this field is marked as dirty.  In KS, dirty is when the field has been changed

          * in some way - however not completely accurate

          * @return

          */

         public boolean isDirty() {

                 return dirty;

         }

         public void setDirty(boolean dirty) {

                 this.dirty = dirty;

         }

         /**

          * Return true if the field has been touched by the user in some fashion, this is set by the field's section

          * @return

          */

         public boolean hasHadFocus() {

                 return hasHadFocus;

         }

         public void setHasHadFocus(boolean hasHadFocus) {

                 this.hasHadFocus = hasHadFocus;

         }

     public Metadata getMetadata() {

                 return metadata;

         }

     public void setMetadata(Metadata metadata) {

                 this.metadata = metadata;

         setupField();

         }

     public void setFieldWidget(Widget fieldWidget) {

                 this.fieldElement.setWidget(fieldWidget);

         }

         public String getModelId() {

                 return modelId;

         }

         public void setModelId(String modelId) {

                 this.modelId = modelId;

         }

     /**

      * Sets the ModelWidgetBinding for this field.  Changing this changes the way data from the server and

      * passed to the server is processed with the widget.  Set this when some special processing or handling

      * has to happen with the data in either phase.

      * @param widgetBinding

      */

     public void setWidgetBinding(ModelWidgetBinding widgetBinding) {

         this.modelWidgetBinding = widgetBinding;

     }

     public MessageKeyInfo getMessageKey() {

         return messageKey;

     }

     public void setMessageKey(MessageKeyInfo messageKey) {

         this.messageKey = messageKey;

     }

         /**

          * Sets the optional flag

          * Fields that are optional should not be displayed if there is no data in some cases,

          * it is up to the section implementation whether or not to honor this flag

          * @param optional

          */

         public void setOptional(boolean optional){

                 this.optional = optional;

         }

         /**

          * Fields that are optional should not be displayed if there is no data in some cases,

          * it is up to the section implementation whether or not to honor this flag

          */

         public boolean isOptional(){

                 return optional;

         }

         /**

          * @return true if this field is visible to the user

          */

         public boolean isVisible() {

                 if (metadata != null){

                         return metadata.isCanView();

                 } else {

                         return true;

                 }

         }

         /**

          * Reset the requiredness of the field descriptor. Note doing this will also dynamically change

          * the underlying metadata so ui validation for requiredness works as well.

          * 

          */

         public void setRequired(Boolean isRequired){ 

                 fieldElement.setRequiredString("requiredMarker", "ks-form-module-elements-required");

                 fieldElement.setRequired(isRequired);

                 //FIXME: This could be problematic if minOccurs should be something other than 1

                 if (isRequired){

                         getMetadata().getConstraints().get(0).setMinOccurs(1);

                 } else {

                         getMetadata().getConstraints().get(0).setMinOccurs(0);

                 }

         }

     public boolean isIgnoreShowRequired() {

         return ignoreShowRequired;

     }

     public void setIgnoreShowRequired(boolean ignoreShowRequired) {

         this.ignoreShowRequired = ignoreShowRequired;

     }

 }