/*
 * 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.commons.beanutils2.locale;

import java.beans.IndexedPropertyDescriptor;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.util.Locale;

import org.apache.commons.beanutils2.BeanUtilsBean;
import org.apache.commons.beanutils2.ContextClassLoaderLocal;
import org.apache.commons.beanutils2.ConvertUtils;
import org.apache.commons.beanutils2.ConvertUtilsBean;
import org.apache.commons.beanutils2.DynaBean;
import org.apache.commons.beanutils2.DynaClass;
import org.apache.commons.beanutils2.DynaProperty;
import org.apache.commons.beanutils2.MappedPropertyDescriptor;
import org.apache.commons.beanutils2.PropertyUtilsBean;
import org.apache.commons.beanutils2.expression.Resolver;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * <p>
 * Utility methods for populating JavaBeans properties via reflection in a locale-dependent manner.
 * </p>
 *
 * @since 1.7
 */
public class LocaleBeanUtilsBean extends BeanUtilsBean {

    /**
     * Contains {@code LocaleBeanUtilsBean} instances indexed by context classloader.
     */
    private static final ContextClassLoaderLocal<LocaleBeanUtilsBean> LOCALE_BEANS_BY_CLASSLOADER = new ContextClassLoaderLocal<LocaleBeanUtilsBean>() {
        // Creates the default instance used when the context classloader is unavailable
        @Override
        protected LocaleBeanUtilsBean initialValue() {
            return new LocaleBeanUtilsBean();
        }
    };

    /** All logging goes through this logger */
    private static final Log LOG = LogFactory.getLog(LocaleBeanUtilsBean.class);

    /**
     * Gets singleton instance
     *
     * @return the singleton instance
     */
    public static LocaleBeanUtilsBean getLocaleBeanUtilsInstance() {
        return LOCALE_BEANS_BY_CLASSLOADER.get();
    }

    /**
     * Sets the instance which provides the functionality for {@link LocaleBeanUtils}. This is a pseudo-singleton - an single instance is provided per (thread)
     * context classloader. This mechanism provides isolation for web apps deployed in the same container.
     *
     * @param newInstance a new singleton instance
     */
    public static void setInstance(final LocaleBeanUtilsBean newInstance) {
        LOCALE_BEANS_BY_CLASSLOADER.set(newInstance);
    }

    /** Convertor used by this class */
    private final LocaleConvertUtilsBean localeConvertUtils;

    /** Constructs instance with standard conversion bean */
    public LocaleBeanUtilsBean() {
        this.localeConvertUtils = new LocaleConvertUtilsBean();
    }

    /**
     * Constructs instance that uses given locale conversion
     *
     * @param localeConvertUtils use this {@code localeConvertUtils} to perform conversions
     */
    public LocaleBeanUtilsBean(final LocaleConvertUtilsBean localeConvertUtils) {
        this.localeConvertUtils = localeConvertUtils;
    }

    /**
     * Constructs instance that uses given locale conversion
     *
     * @param localeConvertUtils use this {@code localeConvertUtils} to perform conversions
     * @param convertUtilsBean   use this for standard conversions
     * @param propertyUtilsBean  use this for property conversions
     */
    public LocaleBeanUtilsBean(final LocaleConvertUtilsBean localeConvertUtils, final ConvertUtilsBean convertUtilsBean,
            final PropertyUtilsBean propertyUtilsBean) {
        super(convertUtilsBean, propertyUtilsBean);
        this.localeConvertUtils = localeConvertUtils;
    }

    /**
     * Convert the specified value to the required type.
     *
     * @param type  The Java type of target property
     * @param index The indexed subscript value (if any)
     * @param value The value to be converted
     * @return The converted value
     */
    protected Object convert(final Class<?> type, final int index, final Object value) {
        Object newValue = null;

        if (type.isArray() && index < 0) { // Scalar value into array
            if (value instanceof String) {
                final String[] values = new String[1];
                values[0] = (String) value;
                newValue = ConvertUtils.convert(values, type);
            } else if (value instanceof String[]) {
                newValue = ConvertUtils.convert((String[]) value, type);
            } else {
                newValue = value;
            }
        } else if (type.isArray()) { // Indexed value into array
            if (value instanceof String) {
                newValue = ConvertUtils.convert((String) value, type.getComponentType());
            } else if (value instanceof String[]) {
                newValue = ConvertUtils.convert(((String[]) value)[0], type.getComponentType());
            } else {
                newValue = value;
            }
        } else if (value instanceof String) {
            newValue = ConvertUtils.convert((String) value, type);
        } else if (value instanceof String[]) {
            newValue = ConvertUtils.convert(((String[]) value)[0], type);
        } else {
            newValue = value;
        }
        return newValue;
    }

    /**
     * Convert the specified value to the required type using the specified conversion pattern.
     *
     * @param type    The Java type of target property
     * @param index   The indexed subscript value (if any)
     * @param value   The value to be converted
     * @param pattern The conversion pattern
     * @return The converted value
     */
    protected Object convert(final Class<?> type, final int index, final Object value, final String pattern) {
        if (LOG.isTraceEnabled()) {
            LOG.trace("Converting value '" + value + "' to type:" + type);
        }

        Object newValue = null;

        if (type.isArray() && index < 0) { // Scalar value into array
            if (value instanceof String) {
                final String[] values = new String[1];
                values[0] = (String) value;
                newValue = getLocaleConvertUtils().convert(values, type, pattern);
            } else if (value instanceof String[]) {
                newValue = getLocaleConvertUtils().convert((String[]) value, type, pattern);
            } else {
                newValue = value;
            }
        } else if (type.isArray()) { // Indexed value into array
            if (value instanceof String) {
                newValue = getLocaleConvertUtils().convert((String) value, type.getComponentType(), pattern);
            } else if (value instanceof String[]) {
                newValue = getLocaleConvertUtils().convert(((String[]) value)[0], type.getComponentType(), pattern);
            } else {
                newValue = value;
            }
        } else if (value instanceof String) {
            newValue = getLocaleConvertUtils().convert((String) value, type, pattern);
        } else if (value instanceof String[]) {
            newValue = getLocaleConvertUtils().convert(((String[]) value)[0], type, pattern);
        } else {
            newValue = value;
        }
        return newValue;
    }

    /**
     * Calculate the property type.
     *
     * @param target   The bean
     * @param name     The property name
     * @param propName The Simple name of target property
     * @return The property's type
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     */
    protected Class<?> definePropertyType(final Object target, final String name, final String propName)
            throws IllegalAccessException, InvocationTargetException {
        Class<?> type = null; // Java type of target property

        if (target instanceof DynaBean) {
            final DynaClass dynaClass = ((DynaBean) target).getDynaClass();
            final DynaProperty dynaProperty = dynaClass.getDynaProperty(propName);
            if (dynaProperty == null) {
                return null; // Skip this property setter
            }
            type = dynaProperty.getType();
        } else {
            PropertyDescriptor descriptor = null;
            try {
                descriptor = getPropertyUtils().getPropertyDescriptor(target, name);
                if (descriptor == null) {
                    return null; // Skip this property setter
                }
            } catch (final NoSuchMethodException e) {
                return null; // Skip this property setter
            }
            if (descriptor instanceof MappedPropertyDescriptor) {
                type = ((MappedPropertyDescriptor) descriptor).getMappedPropertyType();
            } else if (descriptor instanceof IndexedPropertyDescriptor) {
                type = ((IndexedPropertyDescriptor) descriptor).getIndexedPropertyType();
            } else {
                type = descriptor.getPropertyType();
            }
        }
        return type;
    }

    /**
     * Is the pattern to be applied localized (Indicate whether the pattern is localized or not)
     *
     * @return {@code true} if pattern is localized, otherwise {@code false}
     */
    public boolean getApplyLocalized() {
        return getLocaleConvertUtils().getApplyLocalized();
    }

    /**
     * Gets the default Locale
     *
     * @return the default locale
     */
    public Locale getDefaultLocale() {
        return getLocaleConvertUtils().getDefaultLocale();
    }

    /**
     * Gets the value of the specified locale-sensitive indexed property of the specified bean, as a String using the default conversion pattern of the
     * corresponding {@link LocaleConverter}. The zero-relative index of the required value must be included (in square brackets) as a suffix to the property
     * name, or {@code IllegalArgumentException} will be thrown.
     *
     * @param bean Bean whose property is to be extracted
     * @param name {@code propertyname[index]} of the property value to be extracted
     * @return The indexed property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    @Override
    public String getIndexedProperty(final Object bean, final String name) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        return getIndexedProperty(bean, name, null);
    }

    /**
     * Gets the value of the specified locale-sensetive indexed property of the specified bean, as a String using the default conversion pattern of the
     * corresponding {@link LocaleConverter}. The index is specified as a method parameter and must *not* be included in the property name expression
     *
     * @param bean  Bean whose property is to be extracted
     * @param name  Simple property name of the property value to be extracted
     * @param index Index of the property value to be extracted
     * @return The indexed property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    @Override
    public String getIndexedProperty(final Object bean, final String name, final int index)
            throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        return getIndexedProperty(bean, name, index, null);
    }

    /**
     * Gets the value of the specified locale-sensetive indexed property of the specified bean, as a String using the specified conversion pattern. The index is
     * specified as a method parameter and must *not* be included in the property name expression
     *
     * @param bean    Bean whose property is to be extracted
     * @param name    Simple property name of the property value to be extracted
     * @param index   Index of the property value to be extracted
     * @param pattern The conversion pattern
     * @return The indexed property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    public String getIndexedProperty(final Object bean, final String name, final int index, final String pattern)
            throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        final Object value = getPropertyUtils().getIndexedProperty(bean, name, index);
        return getLocaleConvertUtils().convert(value, pattern);
    }

    /**
     * Gets the value of the specified locale-sensitive indexed property of the specified bean, as a String. The zero-relative index of the required value must
     * be included (in square brackets) as a suffix to the property name, or {@code IllegalArgumentException} will be thrown.
     *
     * @param bean    Bean whose property is to be extracted
     * @param name    {@code propertyname[index]} of the property value to be extracted
     * @param pattern The conversion pattern
     * @return The indexed property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    public String getIndexedProperty(final Object bean, final String name, final String pattern)
            throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        final Object value = getPropertyUtils().getIndexedProperty(bean, name);
        return getLocaleConvertUtils().convert(value, pattern);
    }

    /**
     * Gets the bean instance used for conversions
     *
     * @return the locale converter bean instance
     */
    public LocaleConvertUtilsBean getLocaleConvertUtils() {
        return localeConvertUtils;
    }

    /**
     * Gets the value of the specified locale-sensitive mapped property of the specified bean, as a String using the default conversion pattern of the
     * corresponding {@link LocaleConverter}. The String-valued key of the required value must be included (in parentheses) as a suffix to the property name, or
     * {@code IllegalArgumentException} will be thrown.
     *
     * @param bean Bean whose property is to be extracted
     * @param name {@code propertyname(index)} of the property value to be extracted
     * @return The mapped property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    @Override
    public String getMappedProperty(final Object bean, final String name) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        return getMappedPropertyLocale(bean, name, null);
    }

    /**
     * Gets the value of the specified mapped locale-sensitive property of the specified bean, as a String The key is specified as a method parameter and must
     * *not* be included in the property name expression
     *
     * @param bean Bean whose property is to be extracted
     * @param name Simple property name of the property value to be extracted
     * @param key  Lookup key of the property value to be extracted
     * @return The mapped property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    @Override
    public String getMappedProperty(final Object bean, final String name, final String key)
            throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        return getMappedProperty(bean, name, key, null);
    }

    /**
     * Gets the value of the specified mapped locale-sensitive property of the specified bean, as a String using the specified conversion pattern. The key is
     * specified as a method parameter and must *not* be included in the property name expression.
     *
     * @param bean    Bean whose property is to be extracted
     * @param name    Simple property name of the property value to be extracted
     * @param key     Lookup key of the property value to be extracted
     * @param pattern The conversion pattern
     * @return The mapped property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    public String getMappedProperty(final Object bean, final String name, final String key, final String pattern)
            throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        final Object value = getPropertyUtils().getMappedProperty(bean, name, key);
        return getLocaleConvertUtils().convert(value, pattern);
    }

    /**
     * Gets the value of the specified locale-sensitive mapped property of the specified bean, as a String using the specified pattern. The String-valued key of
     * the required value must be included (in parentheses) as a suffix to the property name, or {@code IllegalArgumentException} will be thrown.
     *
     * @param bean    Bean whose property is to be extracted
     * @param name    {@code propertyname(index)} of the property value to be extracted
     * @param pattern The conversion pattern
     * @return The mapped property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    public String getMappedPropertyLocale(final Object bean, final String name, final String pattern)
            throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        final Object value = getPropertyUtils().getMappedProperty(bean, name);
        return getLocaleConvertUtils().convert(value, pattern);
    }

    /**
     * Gets the value of the (possibly nested) locale-sensitive property of the specified name, for the specified bean, as a String using the default conversion
     * pattern of the corresponding {@link LocaleConverter}.
     *
     * @param bean Bean whose property is to be extracted
     * @param name Possibly nested name of the property to be extracted
     * @return The nested property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws IllegalArgumentException  if a nested reference to a property returns null
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    @Override
    public String getNestedProperty(final Object bean, final String name) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        return getNestedProperty(bean, name, null);
    }

    /**
     * Gets the value of the (possibly nested) locale-sensitive property of the specified name, for the specified bean, as a String using the specified pattern.
     *
     * @param bean    Bean whose property is to be extracted
     * @param name    Possibly nested name of the property to be extracted
     * @param pattern The conversion pattern
     * @return The nested property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws IllegalArgumentException  if a nested reference to a property returns null
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    public String getNestedProperty(final Object bean, final String name, final String pattern)
            throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        final Object value = getPropertyUtils().getNestedProperty(bean, name);
        return getLocaleConvertUtils().convert(value, pattern);
    }

    /**
     * Gets the value of the specified locale-sensitive property of the specified bean, no matter which property reference format is used, as a String using the
     * default conversion pattern of the corresponding {@link LocaleConverter}.
     *
     * @param bean Bean whose property is to be extracted
     * @param name Possibly indexed and/or nested name of the property to be extracted
     * @return The property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    @Override
    public String getProperty(final Object bean, final String name) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        return getNestedProperty(bean, name);
    }

    /**
     * Gets the value of the specified locale-sensitive property of the specified bean, no matter which property reference format is used, as a String using the
     * specified conversion pattern.
     *
     * @param bean    Bean whose property is to be extracted
     * @param name    Possibly indexed and/or nested name of the property to be extracted
     * @param pattern The conversion pattern
     * @return The nested property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    public String getProperty(final Object bean, final String name, final String pattern)
            throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        return getNestedProperty(bean, name, pattern);
    }

    /**
     * Gets the value of the specified simple locale-sensitive property of the specified bean, converted to a String using the default conversion pattern of the
     * corresponding {@link LocaleConverter}.
     *
     * @param bean Bean whose property is to be extracted
     * @param name Name of the property to be extracted
     * @return The property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    @Override
    public String getSimpleProperty(final Object bean, final String name) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        return getSimpleProperty(bean, name, null);
    }

    /**
     * Gets the value of the specified simple locale-sensitive property of the specified bean, converted to a String using the specified conversion pattern.
     *
     * @param bean    Bean whose property is to be extracted
     * @param name    Name of the property to be extracted
     * @param pattern The conversion pattern
     * @return The property's value, converted to a String
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     * @throws NoSuchMethodException     if an accessor method for this property cannot be found
     */
    public String getSimpleProperty(final Object bean, final String name, final String pattern)
            throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        final Object value = getPropertyUtils().getSimpleProperty(bean, name);
        return getLocaleConvertUtils().convert(value, pattern);
    }

    /**
     * Invoke the setter method.
     *
     * @param target   The bean
     * @param propName The Simple name of target property
     * @param key      The Mapped key value (if any)
     * @param index    The indexed subscript value (if any)
     * @param newValue The value to be set
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     */
    protected void invokeSetter(final Object target, final String propName, final String key, final int index, final Object newValue)
            throws IllegalAccessException, InvocationTargetException {

        try {
            if (index >= 0) {
                getPropertyUtils().setIndexedProperty(target, propName, index, newValue);
            } else if (key != null) {
                getPropertyUtils().setMappedProperty(target, propName, key, newValue);
            } else {
                getPropertyUtils().setProperty(target, propName, newValue);
            }
        } catch (final NoSuchMethodException e) {
            throw new InvocationTargetException(e, "Cannot set " + propName);
        }
    }

    /**
     * Sets whether the pattern is applied localized (Indicate whether the pattern is localized or not)
     *
     * @param newApplyLocalized {@code true} if pattern is localized, otherwise {@code false}
     */
    public void setApplyLocalized(final boolean newApplyLocalized) {
        getLocaleConvertUtils().setApplyLocalized(newApplyLocalized);
    }

    /**
     * Sets the default Locale.
     *
     * @param locale the default locale
     */
    public void setDefaultLocale(final Locale locale) {
        getLocaleConvertUtils().setDefaultLocale(locale);
    }

    /**
     * Sets the specified locale-sensitive property value, performing type conversions as required to conform to the type of the destination property using the
     * default conversion pattern of the corresponding {@link LocaleConverter}.
     *
     * @param bean  Bean on which setting is to be performed
     * @param name  Property name (can be nested/indexed/mapped/combo)
     * @param value Value to be set
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     */
    @Override
    public void setProperty(final Object bean, final String name, final Object value) throws IllegalAccessException, InvocationTargetException {
        setProperty(bean, name, value, null);
    }

    /**
     * Sets the specified locale-sensitive property value, performing type conversions as required to conform to the type of the destination property using the
     * specified conversion pattern.
     *
     * @param bean    Bean on which setting is to be performed
     * @param name    Property name (can be nested/indexed/mapped/combo)
     * @param value   Value to be set
     * @param pattern The conversion pattern
     * @throws IllegalAccessException    if the caller does not have access to the property accessor method
     * @throws InvocationTargetException if the property accessor method throws an exception
     */
    public void setProperty(final Object bean, String name, final Object value, final String pattern) throws IllegalAccessException, InvocationTargetException {
        // Trace logging (if enabled)
        if (LOG.isTraceEnabled()) {
            final StringBuilder sb = new StringBuilder("  setProperty(");
            sb.append(bean);
            sb.append(", ");
            sb.append(name);
            sb.append(", ");
            if (value == null) {
                sb.append("<NULL>");
            } else if (value instanceof String) {
                sb.append((String) value);
            } else if (value instanceof String[]) {
                final String[] values = (String[]) value;
                sb.append('[');
                for (int i = 0; i < values.length; i++) {
                    if (i > 0) {
                        sb.append(',');
                    }
                    sb.append(values[i]);
                }
                sb.append(']');
            } else {
                sb.append(value.toString());
            }
            sb.append(')');
            LOG.trace(sb.toString());
        }

        // Resolve any nested expression to get the actual target bean
        Object target = bean;
        final Resolver resolver = getPropertyUtils().getResolver();
        while (resolver.hasNested(name)) {
            try {
                target = getPropertyUtils().getProperty(target, resolver.next(name));
                name = resolver.remove(name);
            } catch (final NoSuchMethodException e) {
                return; // Skip this property setter
            }
        }
        if (LOG.isTraceEnabled()) {
            LOG.trace("    Target bean = " + target);
            LOG.trace("    Target name = " + name);
        }

        // Declare local variables we will require
        final String propName = resolver.getProperty(name); // Simple name of target property
        final int index = resolver.getIndex(name); // Indexed subscript value (if any)
        final String key = resolver.getKey(name); // Mapped key value (if any)

        final Class<?> type = definePropertyType(target, name, propName);
        if (type != null) {
            final Object newValue = convert(type, index, value, pattern);
            invokeSetter(target, propName, key, index, newValue);
        }
    }
}