/*

    * 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.wicket.markup.html.form;

  import java.text.Format;

  import java.text.SimpleDateFormat;

  import java.util.ArrayList;

  import java.util.Collections;

  import java.util.HashMap;

  import java.util.Iterator;

  import java.util.LinkedHashSet;

  import java.util.List;

  import java.util.Locale;

  import java.util.Map;

  import java.util.Set;

  import org.apache.wicket.Application;

  import org.apache.wicket.Component;

  import org.apache.wicket.Localizer;

  import org.apache.wicket.MarkupContainer;

  import org.apache.wicket.Page;

  import org.apache.wicket.WicketRuntimeException;

  import org.apache.wicket.markup.ComponentTag;

  import org.apache.wicket.markup.html.border.Border;

  import org.apache.wicket.model.IModel;

  import org.apache.wicket.model.IPropertyReflectionAwareModel;

  import org.apache.wicket.util.convert.ConversionException;

  import org.apache.wicket.util.convert.IConverter;

  import org.apache.wicket.util.lang.Classes;

  import org.apache.wicket.util.string.PrependingStringBuffer;

  import org.apache.wicket.util.string.StringList;

  import org.apache.wicket.util.string.Strings;

  import org.apache.wicket.util.string.interpolator.MapVariableInterpolator;

  import org.apache.wicket.validation.IErrorMessageSource;

  import org.apache.wicket.validation.INullAcceptingValidator;

  import org.apache.wicket.validation.IValidatable;

  import org.apache.wicket.validation.IValidationError;

  import org.apache.wicket.validation.IValidator;

  import org.apache.wicket.validation.IValidatorAddListener;

  import org.apache.wicket.validation.ValidationError;

  import org.apache.wicket.version.undo.Change;

  import org.slf4j.Logger;

  import org.slf4j.LoggerFactory;

  public abstract class FormComponent extends LabeledWebMarkupContainer

  	implements

  		IFormVisitorParticipant

  {

  	private static final Logger logger = LoggerFactory.getLogger(FormComponent.class);

	

  	public static abstract class AbstractVisitor implements IVisitor

  	{
		

 		public Object formComponent(IFormVisitorParticipant component)

 		{

 			if (component instanceof FormComponent)

 			{

 				onFormComponent((FormComponent)component);

 			}

 			return Component.IVisitor.CONTINUE_TRAVERSAL;

 		}

 		protected abstract void onFormComponent(FormComponent formComponent);

 	}

	

 	public static interface IVisitor

 	{
		

 		public Object formComponent(IFormVisitorParticipant formComponent);

 	}

	

 	private class MessageSource implements IErrorMessageSource

 	{

 		private final Set/* <String> */triedKeys = new LinkedHashSet();

		

 		public String getMessage(String key)

 		{

 			final FormComponent formComponent = FormComponent.this;

 			// retrieve prefix that will be used to construct message keys

 			String prefix = formComponent.getValidatorKeyPrefix();

 			if (Strings.isEmpty(prefix))

 			{

 				prefix = "";

 			}

 			final Localizer localizer = formComponent.getLocalizer();

 			String resource = prefix + getId() + "." + key;

 			// First use the parent for resolving so that

 			// form1.textfield1.Required can be used.

 			// Note: It is important that the default value of "" is provided

 			// to getString() not to throw a MissingResourceException or to

 			// return a default string like "[Warning: String ..."

 			String message = getString(localizer, resource, formComponent.getParent());

 			// If not found, than ...

 			if (Strings.isEmpty(message))

 			{

 				// Try a variation of the resource key

 				resource = prefix + key;

 				message = getString(localizer, resource, formComponent.getParent());

 			}

 			if (Strings.isEmpty(message))

 			{

 				// If still empty then use default

 				resource = prefix + getId() + "." + key;

 				// Note: It is important that the default value of "" is

 				// provided

 				// to getString() not to throw a MissingResourceException or to

 				// return a default string like "[Warning: String ..."

 				message = getString(localizer, resource, formComponent);

 				// If not found, than ...

 				if (Strings.isEmpty(message))

 				{

 					// Try a variation of the resource key

 					resource = prefix + key;

 					message = getString(localizer, resource, formComponent);

 				}

 			}

 			// convert empty string to null in case our default value of "" was

 			// returned from localizer

 			if (Strings.isEmpty(message))

 			{

 				message = null;

 			}

 			return message;

 		}

 		private String getString(Localizer localizer, String key, Component component)

 		{

 			triedKeys.add(key);

 			return localizer.getString(key, component, "");

 		}

		

 		public String substitute(String string, Map vars) throws IllegalStateException

 		{

 			return new MapVariableInterpolator(string, addDefaultVars(vars), Application.get()

 				.getResourceSettings()

 				.getThrowExceptionOnMissingResource()).toString();

 		}

		

 		private Map addDefaultVars(Map params)

 		{

 			// create and fill the new params map

 			final HashMap fullParams;

 			if (params == null)

 			{

 				fullParams = new HashMap(6);

 			}

 			else

 			{

 				fullParams = new HashMap(params.size() + 6);

 				fullParams.putAll(params);

 			}

 			// add the input param if not already present

 			if (!fullParams.containsKey("input"))

 			{

 				fullParams.put("input", getInput());

 			}

 			// add the name param if not already present

 			if (!fullParams.containsKey("name"))

 			{

 				fullParams.put("name", getId());

 			}

 			// add the label param if not already present

 			if (!fullParams.containsKey("label"))

 			{

 				fullParams.put("label", getLabel());

 			}

 			return fullParams;

 		}


		

 		private Object getLabel()

 		{

 			final FormComponent fc = FormComponent.this;

 			Object label = null;

 			// first try the label model ...

 			if (fc.getLabel() != null)

 			{

 				label = fc.getLabel().getObject();

 			}

 			// ... then try a resource of format [form-component-id] with

 			// default of '[form-component-id]'

 			if (label == null)

 			{

 				label = fc.getLocalizer().getString(fc.getId(), fc.getParent(), fc.getId());

 			}

 			return label;

 		}

 	}

	

 	private final class RequiredStateChange extends Change

 	{

 		private static final long serialVersionUID = 1L;

 		private final boolean required = isRequired();

		

 		public void undo()

 		{

 			setRequired(required);

 		}

 	}

	

 	private class ValidatableAdapter implements IValidatable

 	{

		

 		public void error(IValidationError error)

 		{

 			FormComponent.this.error(error);

 		}

		

 		public Object getValue()

 		{

 			return getConvertedInput();

 		}

 		public boolean isValid()

 		{

 			return FormComponent.this.isValid();

 		}

 	}

	

 	public static String VALUE_SEPARATOR = ";";

 	private static final String[] EMPTY_STRING_ARRAY = new String[] { "" };

	

 	private static final short FLAG_PERSISTENT = FLAG_RESERVED2;

	

 	private static final short FLAG_REQUIRED = FLAG_RESERVED3;

 	private static final String NO_RAW_INPUT = "[-NO-RAW-INPUT-]";

 	private static final long serialVersionUID = 1L;

	

 	protected static final short FLAG_CONVERT_EMPTY_INPUT_STRING_TO_NULL = FLAG_RESERVED1;

	

 	public static final void visitFormComponentsPostOrder(Component component,

 		final FormComponent.IVisitor visitor)

 	{

 		if (visitor == null)

 		{

 			throw new IllegalArgumentException("Argument `visitor` cannot be null");

 		}

 		visitFormComponentsPostOrderHelper(component, visitor);

 	}

 	private static final Object visitFormComponentsPostOrderHelper(Component component,

 		final FormComponent.IVisitor visitor)

 	{

 		if (component instanceof MarkupContainer)

 		{

 			final MarkupContainer container = (MarkupContainer)component;

 			if (container.size() > 0)

 			{

 				boolean visitChildren = true;

 				if (container instanceof IFormVisitorParticipant)

 				{

 					visitChildren = ((IFormVisitorParticipant)container).processChildren();

 				}

 				if (visitChildren)

 				{

 					final Iterator children = container.iterator();

 					while (children.hasNext())

 					{

 						final Component child = (Component)children.next();

 						Object value = visitFormComponentsPostOrderHelper(child, visitor);

 						if (value == Component.IVisitor.STOP_TRAVERSAL)

 						{

 							return value;

 						}

 					}

 				}

 			}

 		}

 		if (component instanceof FormComponent)

 		{

 			final FormComponent fc = (FormComponent)component;

 			return visitor.formComponent(fc);

 		}

 		return null;

 	}

 	private transient Object convertedInput;

	

 	private String rawInput = NO_RAW_INPUT;

	

 	private String typeName;

	

 	private Object validators = null;

	

 	public FormComponent(final String id)

 	{

 		super(id);

 		// the form decides whether form components are versioned or not

 		// see Form.setVersioned

 		setVersioned(false);

 	}

	

 	public FormComponent(final String id, IModel model)

 	{

 		super(id, model);

 		// the form decides whether form components are versioned or not

 		// see Form.setVersioned

 		setVersioned(false);

 	}

	

 	public final FormComponent add(final IValidator validator)

 	{

 		if (validator == null)

 		{

 			throw new IllegalArgumentException("validator argument cannot be null");

 		}

 		// add the validator

 		validators_add(validator);

 		// see whether the validator listens for add events

 		if (validator instanceof IValidatorAddListener)

 		{

 			((IValidatorAddListener)validator).onAdded(this);

 		}

 		// return this for chaining

 		return this;

 	}

	

 	public boolean checkRequired()

 	{

 		if (isRequired())

 		{

 			final String input = getInput();

 			// when null, check whether this is natural for that component, or

 			// whether - as is the case with text fields - this can only happen

 			// when the component was disabled

 			if (input == null && !isInputNullable())

 			{

 				// this value must have come from a disabled field

 				// do not perform validation

 				return true;

 			}

 			// peform validation by looking whether the value is null or empty

 			return !Strings.isEmpty(input);

 		}

 		return true;

 	}

	

 	public final void clearInput()

 	{

 		rawInput = NO_RAW_INPUT;

 	}

	

 	public void error(IValidationError error)

 	{

 		if (error == null)

 		{

 			throw new IllegalArgumentException("Argument [[error]] cannot be null");

 		}

 		MessageSource source = new MessageSource();

 		String message = error.getErrorMessage(source);

 		if (message == null)

 		{

 			StringBuffer buffer = new StringBuffer();

 			buffer.append("Could not locate error message for component: ");

 			buffer.append(Classes.simpleName(getClass()));

 			buffer.append("@");

 			buffer.append(getPageRelativePath());

 			buffer.append(" and error: ");

 			buffer.append(error.toString());

 			buffer.append(". Tried keys: ");

 			Iterator/* <String> */keys = source.triedKeys.iterator();

 			while (keys.hasNext())

 			{

 				buffer.append(keys.next());

 				if (keys.hasNext())

 				{

 					buffer.append(", ");

 				}

 			}

 			buffer.append(".");

 			message = buffer.toString();

 			logger.warn(message);

 		}

 		error(new ValidationErrorFeedback(error, message));

 	}

	

 	public final Object getConvertedInput()

 	{

 		return convertedInput;

 	}

	

 	public final void setConvertedInput(Object convertedInput)

 	{

 		this.convertedInput = convertedInput;

 	}

	

 	public Form getForm()

 	{

 		class FindFormVisitor implements Component.IVisitor

 		{

 			Form form = null;

 			public Object component(Component component)

 			{

 				form = (Form)component;

 				return Component.IVisitor.STOP_TRAVERSAL;

 			}

 		}

 		Form form = (Form)findParent(Form.class);

 		if (form == null)

 		{

 			// check whether the form is a child of a surrounding border

 			final Border border = (Border)findParent(Border.class);

 			if (border != null)

 			{

 				FindFormVisitor formVisitor = new FindFormVisitor();

 				border.visitChildren(Form.class, formVisitor);

 				form = formVisitor.form;

 			}

 			if (form == null)

 			{

 				throw new WicketRuntimeException("Could not find Form parent for " + this);

 			}

 		}

 		return form;

 	}

	

 	public String getInput()

 	{

 		String[] input = getInputAsArray();

 		if (input == null || input.length == 0)

 		{

 			return null;

 		}

 		else

 		{

 			return trim(input[0]);

 		}

 	}

	

 	public String[] getInputAsArray()

 	{

 		String[] values = getRequest().getParameters(getInputName());

 		if (!isInputNullable())

 		{

 			if (values != null && values.length == 1 && values[0] == null)

 			{

 				// we the key got passed in (otherwise values would be null),

 				// but the value was set to null.

 				// As the servlet spec isn't clear on what to do with 'empty'

 				// request values - most return an empty string, but some null -

 				// we have to workaround here and deliberately set to an empty

 				// string if the the component is not nullable (text components)

 				return EMPTY_STRING_ARRAY;

 			}

 		}

 		return values;

 	}

	

 	public String getInputName()

 	{

 		// TODO: keep this in sync with AbstractSubmitLink#getInputName

 		String id = getId();

 		final PrependingStringBuffer inputName = new PrependingStringBuffer(id.length());

 		Component c = this;

 		while (true)

 		{

 			inputName.prepend(id);

 			c = c.getParent();

 			if (c == null || (c instanceof Form && ((Form)c).isRootForm()) || c instanceof Page)

 			{

 				break;

 			}

 			inputName.prepend(Component.PATH_SEPARATOR);

 			id = c.getId();

 		}

 		// having input name "submit" causes problems with javascript, so we

 		// create a unique string to replace it by prepending a path separator

 		if (inputName.equals("submit"))

 		{

 			inputName.prepend(Component.PATH_SEPARATOR);

 		}

 		return inputName.toString();

 	}

	

 	public final String getRawInput()

 	{

 		return NO_RAW_INPUT.equals(rawInput) ? null : rawInput;

 	}

	

 	public final Class getType()

 	{

 		return typeName == null ? null : Classes.resolveClass(typeName);

 	}

	

 	public String getValidatorKeyPrefix()

 	{

 		Form form = (Form)findParent(Form.class);

 		if (form != null)

 		{

 			return getForm().getValidatorKeyPrefix();

 		}

 		return null;

 	}

	

 	public final List getValidators()

 	{

 		final int size = validators_size();

 		if (size == 0)

 		{

 			return Collections.EMPTY_LIST;

 		}

 		else

 		{

 			final List list = new ArrayList(size);

 			for (int i = 0; i < size; i++)

 			{

 				list.add(validators_get(i));

 			}

 			return Collections.unmodifiableList(list);

 		}

 	}

	

 	public final String getValue()

 	{

 		if (NO_RAW_INPUT.equals(rawInput))

 		{

 			return getModelValue();

 		}

 		else

 		{

 			if (getEscapeModelStrings() && rawInput != null)

 			{

 				return Strings.escapeMarkup(rawInput).toString();

 			}

 			return rawInput;

 		}

 	}

	

 	public final boolean hasRawInput()

 	{

 		return !NO_RAW_INPUT.equals(rawInput);

 	}

	

 	public final void inputChanged()

 	{

 		if (isVisibleInHierarchy() && isEnabled())

 		{

 			// Get input as String array

 			final String[] input = getInputAsArray();