/*
    * 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 javax.faces.component;
  
  import java.util.ArrayList;
  import java.util.List;
  import javax.el.ValueExpression;
  import javax.faces.FacesException;
  import javax.faces.application.FacesMessage;
  import javax.faces.context.FacesContext;
  import javax.faces.convert.Converter;
  import javax.faces.convert.ConverterException;
  import javax.faces.el.EvaluationException;
  import javax.faces.el.MethodBinding;
  import javax.faces.event.AbortProcessingException;
  import javax.faces.event.FacesEvent;
  import javax.faces.event.ValueChangeEvent;
  import javax.faces.event.ValueChangeListener;
  import javax.faces.render.Renderer;
  import javax.faces.validator.Validator;
  import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFComponent;
  import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFListener;
  import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFProperty;
  
  /**
   * UICommand is a base abstraction for components that implement ActionSource.
   * <p>
   * See the javadoc for this class in the <a
   * href="http://java.sun.com/j2ee/javaserverfaces/1.2/docs/api/index.html">JSF
   * Specification</a> for further details.
   * <p>
   */
  @JSFComponent(defaultRendererType = "javax.faces.Text")
  public class UIInput extends UIOutput implements EditableValueHolder
  {
      public static final String COMPONENT_TYPE = "javax.faces.Input";
      public static final String COMPONENT_FAMILY = "javax.faces.Input";
  
      public static final String CONVERSION_MESSAGE_ID = "javax.faces.component.UIInput.CONVERSION";
      public static final String REQUIRED_MESSAGE_ID = "javax.faces.component.UIInput.REQUIRED";
      public static final String UPDATE_MESSAGE_ID = "javax.faces.component.UIInput.UPDATE";
      private static final String ERROR_HANDLING_EXCEPTION_LIST = "org.apache.myfaces.errorHandling.exceptionList";
  
      private static final Validator[] EMPTY_VALIDATOR_ARRAY = new Validator[0];
  
      private boolean _immediate;
      private boolean _immediateSet;
  
      private Object _submittedValue;
      private boolean _localValueSet = false;
  
      private boolean _valid = true;
  
      private boolean _required;
      private boolean _requiredSet;
  
      private String _converterMessage;
      private String _requiredMessage;
      private String _validatorMessage;
  
      private MethodBinding _validator;
      private List<Validator> _validatorList;
  
      private MethodBinding _valueChangeListener;
  
      /**
       * Construct an instance of the UIInput.
       */
      public UIInput()
      {
          setRendererType("javax.faces.Text");
      }
  
      @Override
      public String getFamily()
      {
          return COMPONENT_FAMILY;
      }
  
      /**
       * Store the specified object as the "local value" of this component. The
       * value-binding named "value" (if any) is ignored; the object is only
       * stored locally on this component. During the "update model" phase, if
      * there is a value-binding named "value" then this local value will be
      * stored via that value-binding and the "local value" reset to null.
      */
     public void setValue(Object value)
     {
         setLocalValueSet(true);
         super.setValue(value);
     }
     
     /**
      * Return the current value of this component.
      * <p>
      * If a submitted value has been converted but not yet pushed into the
      * model, then return that locally-cached value (see isLocalValueSet).
      * <p>
      * Otherwise, evaluate an EL expression to fetch a value from the model. 
      */
     public Object getValue()
     {
         if (isLocalValueSet()) return super.getLocalValue();
         return super.getValue();
     }
 
     /**
      * Set the "submitted value" of this component from the relevant data in the
      * current servlet request object.
      * <p>
      * If this component is not rendered, then do nothing; no output would have
      * been sent to the client so no input is expected.
      * <p>
      * Invoke the inherited functionality, which typically invokes the renderer
      * associated with this component to extract and set this component's
      * "submitted value".
      * <p>
      * If this component is marked "immediate", then immediately apply
      * validation to the submitted value found. On error, call context method
      * "renderResponse" which will force processing to leap to the "render
      * response" phase as soon as the "decode" step has completed for all other
      * components.
      */
     public void processDecodes(FacesContext context)
     {
         if (context == null)
         {
             throw new NullPointerException("context");
         }
         try
         {
             setCachedFacesContext(context);
             if (!isRendered())
             {
                 return;
             }
         }
         finally
         {
             setCachedFacesContext(null);
         }
         super.processDecodes(context);
         try
         {
             setCachedFacesContext(context);
             if (isImmediate())
             {
                 try
                 {
                     validate(context);
                 }
                 catch (RuntimeException e)
                 {
                     context.renderResponse();
                     throw e;
                 }
                 if (!isValid())
                 {
                     context.renderResponse();
                 }
             }
         }
         finally
         {
             setCachedFacesContext(null);
         }
     }
 
     public void processValidators(FacesContext context)
     {
         if (context == null)
         {
             throw new NullPointerException("context");
         }
         try
         {
             setCachedFacesContext(context);
             if (!isRendered())
             {
                 return;
             }
         }
         finally
         {
             setCachedFacesContext(null);
         }
 
         super.processValidators(context);
 
         try
         {
             setCachedFacesContext(context);
             if (!isImmediate())
             {
                 try
                 {
                     validate(context);
                 }
                 catch (RuntimeException e)
                 {
                     context.renderResponse();
                     throw e;
                 }
                 if (!isValid())
                 {
                     context.renderResponse();
                 }
             }
         }
         finally
         {
             setCachedFacesContext(null);
         }
     }
 
     public void processUpdates(FacesContext context)
     {
         if (context == null)
         {
             throw new NullPointerException("context");
         }
         try
         {
             setCachedFacesContext(context);
             if (!isRendered())
             {
                 return;
             }
         }
         finally
         {
             setCachedFacesContext(null);
         }
 
         super.processUpdates(context);
 
         try
         {
             setCachedFacesContext(context);
             try
             {
                 updateModel(context);
             }
             catch (RuntimeException e)
             {
                 context.renderResponse();
                 throw e;
             }
             if (!isValid())
             {
                 context.renderResponse();
             }
         }
         finally
         {
             setCachedFacesContext(null);
         }
     }
 
     public void decode(FacesContext context)
     {
         // We (re)set to valid, so that component automatically gets (re)validated
         setValid(true);
         super.decode(context);
     }
 
     public void broadcast(FacesEvent event) throws AbortProcessingException
     {
         // invoke standard listeners attached to this component first
         super.broadcast(event);
 
         // Check if the event is applicable for ValueChangeListener
         if (event instanceof ValueChangeEvent)
         {
             // invoke the single listener defined directly on the component
             MethodBinding valueChangeListenerBinding = getValueChangeListener();
             if (valueChangeListenerBinding != null)
             {
                 try
                 {
                     valueChangeListenerBinding.invoke(getFacesContext(),
                             new Object[]
                             { event });
                 }
                 catch (EvaluationException e)
                 {
                     Throwable cause = e.getCause();
                     if (cause != null
                             && cause instanceof AbortProcessingException)
                     {
                         throw (AbortProcessingException) cause;
                     }
                     else
                     {
                         throw e;
                     }
                 }
             }
         }
     }
 
     public void updateModel(FacesContext context)
     {
         if (!isValid())
         {
             return;
         }
         if (!isLocalValueSet())
         {
             return;
         }
         ValueExpression expression = getValueExpression("value");
         if (expression == null)
         {
             return;
         }
 
         try
         {
             expression.setValue(context.getELContext(), getLocalValue());
             setValue(null);
             setLocalValueSet(false);
         }
         catch (Exception e)
         {
             context.getExternalContext().log(e.getMessage(), e);
             _MessageUtils.addErrorMessage(context, this, UPDATE_MESSAGE_ID,
                     new Object[]
                     { _MessageUtils.getLabel(context, this) });
             setValid(false);
 
             /*
              * we are not allowed to throw exceptions here - we still need the
              * full stack-trace later on to process it later in our
              * error-handler
              */
             queueExceptionInRequest(context, expression, e);
         }
     }
 
     /**
      * For development and production, we want to offer a single point to which
      * error-handlers can attach. So we queue up all ocurring exceptions and
      * later pass them to the configured error-handler.
      */
     private void queueExceptionInRequest(FacesContext context,
             ValueExpression expression, Exception e)
     {
         List li = (List) context.getExternalContext().getRequestMap().get(ERROR_HANDLING_EXCEPTION_LIST);
         if (null == li)
         {
             li = new ArrayList();
             context.getExternalContext().getRequestMap().put(ERROR_HANDLING_EXCEPTION_LIST, li);
         }
         li.add(new FacesException(
                 "Exception while setting value for expression : "
                         + expression.getExpressionString()
                         + " of component with path : "
                         + _ComponentUtils.getPathToComponent(this), e));
     }
 
     protected void validateValue(FacesContext context, Object convertedValue)
     {
         boolean empty = convertedValue == null
                 || (convertedValue instanceof String && ((String) convertedValue)
                         .length() == 0);
 
         if (isRequired() && empty)
         {
             if (getRequiredMessage() != null)
             {
                 String requiredMessage = getRequiredMessage();
                 context.addMessage(this.getClientId(context), new FacesMessage(
                         FacesMessage.SEVERITY_ERROR, requiredMessage,
                         requiredMessage));
             }
             else
             {
                 _MessageUtils.addErrorMessage(context, this,
                         REQUIRED_MESSAGE_ID, new Object[]
                         { _MessageUtils.getLabel(context, this) });
             }
             setValid(false);
             return;
         }
 
         if (!empty)
         {
             _ComponentUtils.callValidators(context, this, convertedValue);
         }
 
     }
 
     /**
      * Determine whether the new value is valid, and queue a ValueChangeEvent if
      * necessary.
      * <p>
      * The "submitted value" is converted to the necessary type; conversion
      * failure is reported as an error and validation processing terminates for
      * this component. See documentation for method getConvertedValue for
      * details on the conversion process.
      * <p>
      * Any validators attached to this component are then run, passing the
      * converted value.
      * <p>
      * The old value of this component is then fetched (possibly involving the
      * evaluation of a value-binding expression, ie invoking a method on a user
      * object). The old value is compared to the new validated value, and if
      * they are different then a ValueChangeEvent is queued for later
      * processing.
      * <p>
      * On successful completion of this method:
      * <ul>
      * <li> isValid() is true
      * <li> isLocalValueSet() is true
      * <li> submittedValue is reset to null
      * <li> a ValueChangeEvent is queued if the new value != old value
      * </ul>
      */
     public void validate(FacesContext context)
     {
         if (context == null)
             throw new NullPointerException("context");
 
         try
         {
 
             Object submittedValue = getSubmittedValue();
             if (submittedValue == null)
                 return;
 
             Object convertedValue = getConvertedValue(context, submittedValue);
 
             if (!isValid())
                 return;
 
             validateValue(context, convertedValue);
 
             if (!isValid())
                 return;
 
             Object previousValue = getValue();
             setValue(convertedValue);
             setSubmittedValue(null);
             if (compareValues(previousValue, convertedValue))
             {
                 queueEvent(new ValueChangeEvent(this, previousValue,
                         convertedValue));
             }
         }
         catch (Exception ex)
         {
             throw new FacesException(
                     "Exception while validating component with path : "
                             + _ComponentUtils.getPathToComponent(this), ex);
         }
 
     }
 
     /**
      * Convert the provided object to the desired value.
      * <p>
      * If there is a renderer for this component, then call the renderer's
      * getConvertedValue method. While this can of course be implemented in any
      * way the renderer desires, it typically performs exactly the same
      * processing that this method would have done anyway (ie that described
      * below for the no-renderer case).
      * <p>
      * Otherwise:
      * <ul>
      * <li>If the submittedValue is not a String then just return the
      * submittedValue unconverted.
      * <li>If there is no "value" value-binding then just return the
      * submittedValue unconverted.
      * <li>Use introspection to determine the type of the target property
      * specified by the value-binding, and then use Application.createConverter
      * to find a converter that can map from String to the required type. Apply
      * the converter to the submittedValue and return the result.
      * </ul>
      */
     protected Object getConvertedValue(FacesContext context, Object submittedValue)
     {
         try
         {
             Renderer renderer = getRenderer(context);
             if (renderer != null)
             {
                 return renderer
                         .getConvertedValue(context, this, submittedValue);
             }
             else if (submittedValue instanceof String)
             {
                 Converter converter = _SharedRendererUtils
                         .findUIOutputConverter(context, this);
                 if (converter != null)
                 {
                     return converter.getAsObject(context, this,
                             (String) submittedValue);
                 }
             }
         }
         catch (ConverterException e)
         {
             String converterMessage = getConverterMessage();
             if (converterMessage != null)
             {
                 context.addMessage(getClientId(context), new FacesMessage(
                         FacesMessage.SEVERITY_ERROR, converterMessage,
                         converterMessage));
             }
             else
             {
                 FacesMessage facesMessage = e.getFacesMessage();
                 if (facesMessage != null)
                 {
                     context.addMessage(getClientId(context), facesMessage);
                 }
                 else
                 {
                     _MessageUtils.addErrorMessage(context, this,
                             CONVERSION_MESSAGE_ID, new Object[]
                             { _MessageUtils.getLabel(context, this) });
                 }
             }
             setValid(false);
         }
         return submittedValue;
     }
 
     protected boolean compareValues(Object previous, Object value)
     {
         return previous == null ? (value != null) : (!previous.equals(value));
     }
 
     /**
      * @since 1.2
      */
     public void resetValue()
     {
         setSubmittedValue(null);
         setValue(null);
         setLocalValueSet(false);
         setValid(true);
     }
 
     /**
      * A boolean value that identifies the phase during which action events should fire.
      * <p>
      * During normal event processing, action methods and action listener methods are fired during
      * the "invoke application" phase of request processing. If this attribute is set to "true",
      * these methods are fired instead at the end of the "apply request values" phase.
      * </p>
      */
     @JSFProperty
     public boolean isImmediate()
     {
         if (_immediateSet)
         {
             return _immediate;
         }
         ValueExpression expression = getValueExpression("immediate");
         if (expression != null)
         {
             return (Boolean) expression.getValue(getFacesContext()
                     .getELContext());
         }
         return false;
     }
 
     public void setImmediate(boolean immediate)
     {
         this._immediate = immediate;
         this._immediateSet = true;
     }
 
     /**
      * A boolean value that indicates whether an input value is required.
      * <p>
      * If this value is true and no input value is provided by a postback operation, then
      * the "requiredMessage" text is registered as a FacesMessage for the request, and
      * validation fails. 
      * </p>
      * <p>
      * Default value: false.
      * </p>
      */
     @JSFProperty(defaultValue = "false")
     public boolean isRequired()
     {
         if (_requiredSet)
         {
             return _required;
         }
         ValueExpression expression = getValueExpression("required");
         if (expression != null)
         {
             return (Boolean) expression.getValue(getFacesContext()
                     .getELContext());
         }
         return false;
     }
 
     public void setRequired(boolean required)
     {
         this._required = required;
         this._requiredSet = true;
     }
 
     /**
      * Text to be displayed to the user as an error message when conversion of a
      * submitted value to the target type fails.
      * <p>
      * </p>
      */
     @JSFProperty
     public String getConverterMessage()
     {
         if (_converterMessage != null)
         {
             return _converterMessage;
         }
         ValueExpression expression = getValueExpression("converterMessage");
         if (expression != null)
         {
             return (String) expression.getValue(getFacesContext()
                     .getELContext());
         }
         return null;
     }
 
     public void setConverterMessage(String converterMessage)
     {
         this._converterMessage = converterMessage;
     }
 
     /**
      * Text to be displayed to the user as an error message when this component is
      * marked as "required" but no input data is present during a postback (ie the
      * user left the required field blank).
      */
     @JSFProperty
     public String getRequiredMessage()
     {
         if (_requiredMessage != null)
         {
             return _requiredMessage;
         }
         ValueExpression expression = getValueExpression("requiredMessage");
         if (expression != null)
         {
             return (String) expression.getValue(getFacesContext()
                     .getELContext());
         }
         return null;
     }
 
     public void setRequiredMessage(String requiredMessage)
     {
         this._requiredMessage = requiredMessage;
     }
 
     /**
      * A method-binding EL expression which is invoked during the validation phase for this
      * component.
      * <p>
      * The invoked method is expected to check the submitted value for this component, and if not
      * acceptable then report a validation error for the component.
      * </p>
      * <p>
      * The method is expected to have the prototype
      * </p>
      * <code>public void aMethod(FacesContext, UIComponent,Object)</code>
      * 
      * @deprecated
      */
     @JSFProperty(stateHolder = true, returnSignature = "void", methodSignature = "javax.faces.context.FacesContext,javax.faces.component.UIComponent,java.lang.Object")
     public MethodBinding getValidator()
     {
         if (_validator != null)
         {
             return _validator;
         }
         ValueExpression expression = getValueExpression("validator");
         if (expression != null)
         {
             return (MethodBinding) expression.getValue(getFacesContext()
                     .getELContext());
         }
         return null;
     }
 
     /** See getValidator.
      *  
      * @deprecated 
      */
     public void setValidator(MethodBinding validator)
     {
         this._validator = validator;
     }
 
     /** See getValidator. */
     public void addValidator(Validator validator)
     {
         if (validator == null)
             throw new NullPointerException("validator");
         if (_validatorList == null)
             _validatorList = new ArrayList<Validator>();
 
         _validatorList.add(validator);
     }
 
     /** See getValidator. */
     public void removeValidator(Validator validator)
     {
         if (validator == null || _validatorList == null)
             return;
 
         _validatorList.remove(validator);
     }
 
     /** See getValidator. */
     public Validator[] getValidators()
     {
         return _validatorList == null ? EMPTY_VALIDATOR_ARRAY : _validatorList
                 .toArray(new Validator[_validatorList.size()]);
     }
 
     /**
      * Text which will be shown if validation fails.
      */
     @JSFProperty
     public String getValidatorMessage()
     {
         if (_validatorMessage != null)
         {
             return _validatorMessage;
         }
         ValueExpression expression = getValueExpression("validatorMessage");
         if (expression != null)
         {
             return (String) expression.getValue(getFacesContext()
                     .getELContext());
         }
         return null;
     }
 
     public void setValidatorMessage(String validatorMessage)
     {
         this._validatorMessage = validatorMessage;
     }
 
     /**
      * A method which is invoked during postback processing for the current
      * view if the submitted value for this component is not equal to the value
      * which the "value" expression for this component returns.
      * <p>
      * The phase in which this method is invoked can be controlled via the immediate
      * attribute.
      * </p>
      * 
      * @deprecated
      */
     @JSFProperty(stateHolder = true, returnSignature = "void", methodSignature = "javax.faces.event.ValueChangeEvent")
     public MethodBinding getValueChangeListener()
     {
         if (_valueChangeListener != null)
         {
             return _valueChangeListener;
         }
         ValueExpression expression = getValueExpression("valueChangeListener");
         if (expression != null)
         {
             return (MethodBinding) expression.getValue(getFacesContext()
                     .getELContext());
         }
         return null;
     }
 
     /**
      * See getValueChangeListener.
      * 
      * @deprecated
      */
     public void setValueChangeListener(MethodBinding valueChangeListener)
     {
         this._valueChangeListener = valueChangeListener;
     }
 
     /**
      * Specifies whether the component's value is currently valid, ie whether the
      * validators attached to this component have allowed it.
      */
     @JSFProperty(defaultValue = "true", tagExcluded = true)
     public boolean isValid()
     {
         return _valid;
     }
 
     public void setValid(boolean valid)
     {
         this._valid = valid;
     }
 
     /**
      * Specifies whether a local value is currently set.
      * <p>
      * If false, values are being retrieved from any attached ValueBinding.
      */
     @JSFProperty(defaultValue = "false", tagExcluded = true)
     public boolean isLocalValueSet()
     {
         return _localValueSet;
     }
 
     public void setLocalValueSet(boolean localValueSet)
     {
         this._localValueSet = localValueSet;
     }
 
     /**
      * Gets the current submitted value. This value, if non-null, is set by the
      * Renderer to store a possibly invalid value for later conversion or
      * redisplay, and has not yet been converted into the proper type for this
      * component instance. This method should only be used by the decode() and
      * validate() method of this component, or its corresponding Renderer;
      * however, user code may manually set it to null to erase any submitted
      * value.
      */
     @JSFProperty(tagExcluded = true)
     public Object getSubmittedValue()
     {
         return _submittedValue;
     }
 
     public void setSubmittedValue(Object submittedValue)
     {
         this._submittedValue = submittedValue;
     }
 
     public void addValueChangeListener(ValueChangeListener listener)
     {
         addFacesListener(listener);
     }
 
     public void removeValueChangeListener(ValueChangeListener listener)
     {
         removeFacesListener(listener);
     }
 
     /**
      * The valueChange event is delivered when the value attribute
      * is changed.
      */
     @JSFListener(event="javax.faces.event.ValueChangeEvent")
     public ValueChangeListener[] getValueChangeListeners()
     {
         return (ValueChangeListener[]) getFacesListeners(ValueChangeListener.class);
     }
 
     @Override
     public Object saveState(FacesContext facesContext)
     {
         Object[] values = new Object[14];
         values[0] = super.saveState(facesContext);
         values[1] = _immediate;
         values[2] = _immediateSet;
         values[3] = _required;
         values[4] = _requiredSet;
         values[5] = _converterMessage;
         values[6] = _requiredMessage;
         values[7] = saveAttachedState(facesContext, _validator);
         values[8] = saveAttachedState(facesContext, _validatorList);
         values[9] = _validatorMessage;
         values[10] = saveAttachedState(facesContext, _valueChangeListener);
         values[11] = _valid;
         values[12] = _localValueSet;
         values[13] = _submittedValue;
 
         return values;
     }
 
     @Override
     public void restoreState(FacesContext facesContext, Object state)
     {
         Object[] values = (Object[]) state;
         super.restoreState(facesContext, values[0]);
         _immediate = (Boolean) values[1];
         _immediateSet = (Boolean) values[2];
         _required = (Boolean) values[3];
         _requiredSet = (Boolean) values[4];
         _converterMessage = (String) values[5];
         _requiredMessage = (String) values[6];
         _validator = (MethodBinding) restoreAttachedState(facesContext,
                 values[7]);
         _validatorList = (List<Validator>) restoreAttachedState(facesContext,
                 values[8]);
         _validatorMessage = (String) values[9];
         _valueChangeListener = (MethodBinding) restoreAttachedState(
                 facesContext, values[10]);
         _valid = (Boolean) values[11];
         _localValueSet = (Boolean) values[12];
         _submittedValue = values[13];
     }
 }