/*

    * 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.IConverterLocator;

  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.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<T> extends LabeledWebMarkupContainer

  	implements

  		IFormVisitorParticipant,

  		IFormModelUpdateListener

  {

  	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<String>();

		

 		public String getMessage(String key)

 		{

 			final FormComponent<T> formComponent = FormComponent.this;

 			// Use the following log4j config for detailed logging on the property resolution

 			// process

 			// log4j.logger.org.apache.wicket.resource.loader=DEBUG

 			// log4j.logger.org.apache.wicket.Localizer=DEBUG

 			final Localizer localizer = formComponent.getLocalizer();

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

 			String prefix = formComponent.getValidatorKeyPrefix();

 			String message = null;

 			// first try the full form of key [form-component-id].[key]

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

 			message = getString(localizer, resource, formComponent);

 			// if not found, try a more general form (without prefix)

 			// [form-component-id].[prefix].[key]

 			if (Strings.isEmpty(message) && Strings.isEmpty(prefix))

 			{

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

 				message = getString(localizer, resource, formComponent);

 			}

 			// If not found try a more general form [prefix].[key]

 			if (Strings.isEmpty(message))

 			{

 				resource = prefix(prefix, key);

 				message = getString(localizer, key, formComponent);

 			}

 			// If not found try the most general form [key]

 			if (Strings.isEmpty(message) && Strings.isEmpty(prefix))

 			{

 				// Try a variation of the resource key

 				message = getString(localizer, key, 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 prefix(String prefix, String key)

 		{

 			if (!Strings.isEmpty(prefix))

 			{

 				return prefix + "." + key;

 			}

 			else

 			{

 				return key;

 			}

 		}

		

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

 		{

 			triedKeys.add(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 ..."

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

 		}

		

 		public String substitute(String string, Map<String, Object> vars)

 			throws IllegalStateException

 		{

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

 				.getResourceSettings()

 				.getThrowExceptionOnMissingResource()).toString();

 		}

		

 		private Map<String, Object> addDefaultVars(Map<String, Object> params)

 		{

 			// create and fill the new params map

 			final HashMap<String, Object> fullParams;

 			if (params == null)

 			{

 				fullParams = new HashMap<String, Object>(6);

 			}

 			else

 			{

 				fullParams = new HashMap<String, Object>(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 String getLabel()

 		{

 			final FormComponent<T> fc = FormComponent.this;

 			String 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();

		

 		@Override

 		public void undo()

 		{

 			setRequired(required);

 		}

 	}

	

 	private class ValidatableAdapter implements IValidatable<T>

 	{
		

 		public void error(IValidationError error)

 		{

 			FormComponent.this.error(error);

 		}

		

 		public T 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<? extends Component> children = container.iterator();

 					while (children.hasNext())

 					{

 						final Component child = 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;

 	}

	

 	public static final void visitComponentsPostOrder(Component component,

 		final Component.IVisitor<Component> visitor)

 	{

 		if (visitor == null)

 		{

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

 		}

 		visitComponentsPostOrderHelper(component, visitor);

 	}

	

 	private static final Object visitComponentsPostOrderHelper(Component component,

 		final Component.IVisitor<Component> 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<? extends Component> children = container.iterator();

 					while (children.hasNext())

 					{

 						final Component child = children.next();

 						Object value = visitComponentsPostOrderHelper(child, visitor);

 						if (value == Component.IVisitor.STOP_TRAVERSAL)

 						{

 							return value;

 						}

 						else if (value == Component.IVisitor.CONTINUE_TRAVERSAL)

 						{

 							// noop

 						}

 						else if (value == Component.IVisitor.CONTINUE_TRAVERSAL_BUT_DONT_GO_DEEPER)

 						{

 							// noop

 						}

 						else

 						{

 							return value;

 						}

 					}

 				}

 			}

 		}

 		return visitor.component(component);

 	}

 	private transient T 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<T> model)

 	{

 		super(id, model);

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

 		// see Form.setVersioned

 		setVersioned(false);

 	}

	

 	public final FormComponent<T> add(final IValidator<T> 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;

 	}

	

 	public final FormComponent<T> add(final IValidator<T>... validators)

 	{

 		if (validators == null)

 		{

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

 		}

 		for (IValidator<T> validator : validators)

 		{

 			add(validator);

 		}

 		// 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() && !isEnabledInHierarchy())

 			{

 				// 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 T getConvertedInput()

 	{

 		return convertedInput;

 	}

	

 	public final void setConvertedInput(T convertedInput)

 	{

 		this.convertedInput = convertedInput;

 	}

	

 	public Form<?> getForm()

 	{

 		Form<?> form = Form.findForm(this);

 		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);

 		}

 		Form<?> form = findParent(Form.class);

 		if (form != null)

 		{

 			return form.getInputNamePrefix() + inputName.toString();

 		}

 		else

 		{

 			return inputName.toString();

 		}

 	}

	

 	public final String getRawInput()