/*
    * Copyright 2002-2014 the original author or authors.
    *
    * Licensed 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.springframework.web.method.support;
  
  import java.util.Collections;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import org.springframework.core.MethodParameter;
  import org.springframework.util.Assert;
  import org.springframework.web.bind.support.WebDataBinderFactory;
  import org.springframework.web.context.request.NativeWebRequest;
  
  /**
   * Resolves method parameters by delegating to a list of registered {@link HandlerMethodArgumentResolver}s.
   * Previously resolved method parameters are cached for faster lookups.
   *
   * @author Rossen Stoyanchev
   * @since 3.1
   */
  public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {
  
  	protected final Log logger = LogFactory.getLog(getClass());
  
  	private final List<HandlerMethodArgumentResolver> argumentResolvers =
  			new LinkedList<HandlerMethodArgumentResolver>();
  
  	private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =
  			new ConcurrentHashMap<MethodParameter, HandlerMethodArgumentResolver>(256);
  
  
  	/**
  	 * Return a read-only list with the contained resolvers, or an empty list.
  	 */
  	public List<HandlerMethodArgumentResolver> getResolvers() {
  		return Collections.unmodifiableList(this.argumentResolvers);
  	}
  
  	/**
  	 * Whether the given {@linkplain MethodParameter method parameter} is supported by any registered
  	 * {@link HandlerMethodArgumentResolver}.
  	 */
  	@Override
  	public boolean supportsParameter(MethodParameter parameter) {
  		return getArgumentResolver(parameter) != null;
  	}
  
  	/**
  	 * Iterate over registered {@link HandlerMethodArgumentResolver}s and invoke the one that supports it.
  	 * @throws IllegalStateException if no suitable {@link HandlerMethodArgumentResolver} is found.
  	 */
  	@Override
  	public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
  			NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
  
  		HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
  		Assert.notNull(resolver, "Unknown parameter type [" + parameter.getParameterType().getName() + "]");
  		return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
  	}
  
  	/**
  	 * Find a registered {@link HandlerMethodArgumentResolver} that supports the given method parameter.
  	 */
  	private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
  		HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
  		if (result == null) {
  			for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) {
  				if (logger.isTraceEnabled()) {
  					logger.trace("Testing if argument resolver [" + methodArgumentResolver + "] supports [" +
  							parameter.getGenericParameterType() + "]");
  				}
  				if (methodArgumentResolver.supportsParameter(parameter)) {
  					result = methodArgumentResolver;
  					this.argumentResolverCache.put(parameter, result);
  					break;
  				}
  			}
  		}
  		return result;
  	}
 
 	/**
 	 * Add the given {@link HandlerMethodArgumentResolver}.
 	 */
 	public HandlerMethodArgumentResolverComposite addResolver(HandlerMethodArgumentResolver resolver) {
 		this.argumentResolvers.add(resolver);
 		return this;
 	}
 
 	/**
 	 * Add the given {@link HandlerMethodArgumentResolver}s.
 	 */
 	public HandlerMethodArgumentResolverComposite addResolvers(List<? extends HandlerMethodArgumentResolver> resolvers) {
 		if (resolvers != null) {
 			for (HandlerMethodArgumentResolver resolver : resolvers) {
 				this.argumentResolvers.add(resolver);
 			}
 		}
 		return this;
 	}
 
 }