/*

  * 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];

     }

 }