/*
    * 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;
  
  import java.beans.BeanInfo;
  import java.beans.IntrospectionException;
  import java.beans.Introspector;
  import java.beans.PropertyDescriptor;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.util.AbstractMap;
  import java.util.AbstractSet;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;
  import java.util.function.Function;
  
  /**
   * An implementation of Map for JavaBeans which uses introspection to get and put properties in the bean.
   * <p>
   * If an exception occurs during attempts to get or set a property then the property is considered non existent in the Map
   * </p>
   */
  public class BeanMap extends AbstractMap<String, Object> implements Cloneable {
  
      /**
       * Map entry used by {@link BeanMap}.
       */
      protected static class Entry extends AbstractMap.SimpleEntry<String, Object> {
  
          private static final long serialVersionUID = 1L;
  
          /**
           * The owner.
           */
          private final BeanMap owner;
  
          /**
           * Constructs a new {@code Entry}.
           *
           * @param owner the BeanMap this entry belongs to
           * @param key   the key for this entry
           * @param value the value for this entry
           */
          protected Entry(final BeanMap owner, final String key, final Object value) {
              super(key, value);
              this.owner = owner;
          }
  
          /**
           * Sets the value.
           *
           * @param value the new value for the entry
           * @return the old value for the entry
           */
          @Override
          public Object setValue(final Object value) {
              final String key = getKey();
              final Object oldValue = owner.get(key);
  
              owner.put(key, value);
              final Object newValue = owner.get(key);
              super.setValue(newValue);
              return oldValue;
          }
      }
  
      /**
       * An empty array. Used to invoke accessors via reflection.
       */
      public static final Object[] NULL_ARGUMENTS = {};
  
      /**
       * Maps primitive Class types to transformers. The transformer transform strings into the appropriate primitive wrapper.
       *
       * N.B. private & unmodifiable replacement for the (public & static) defaultTransformers instance.
       */
      private static final Map<Class<? extends Object>, Function<?, ?>> typeTransformers = Collections.unmodifiableMap(createTypeTransformers());
  
      private static Map<Class<? extends Object>, Function<?, ?>> createTypeTransformers() {
         final Map<Class<? extends Object>, Function<?, ?>> defTransformers = new HashMap<>();
         defTransformers.put(Boolean.TYPE, input -> Boolean.valueOf(input.toString()));
         defTransformers.put(Character.TYPE, input -> Character.valueOf(input.toString().charAt(0)));
         defTransformers.put(Byte.TYPE, input -> Byte.valueOf(input.toString()));
         defTransformers.put(Short.TYPE, input -> Short.valueOf(input.toString()));
         defTransformers.put(Integer.TYPE, input -> Integer.valueOf(input.toString()));
         defTransformers.put(Long.TYPE, input -> Long.valueOf(input.toString()));
         defTransformers.put(Float.TYPE, input -> Float.valueOf(input.toString()));
         defTransformers.put(Double.TYPE, input -> Double.valueOf(input.toString()));
         return defTransformers;
     }
 
     private transient Object bean;
 
     private final transient HashMap<String, Method> readMethods = new HashMap<>();
 
     private final transient HashMap<String, Method> writeMethods = new HashMap<>();
 
     private final transient HashMap<String, Class<? extends Object>> types = new HashMap<>();
 
     /**
      * Constructs a new empty {@code BeanMap}.
      */
     public BeanMap() {
     }
 
     // Map interface
 
     /**
      * Constructs a new {@code BeanMap} that operates on the specified bean. If the given bean is {@code null}, then this map will be empty.
      *
      * @param bean the bean for this map to operate on
      */
     public BeanMap(final Object bean) {
         this.bean = bean;
         initialize();
     }
 
     /**
      * This method reinitializes the bean map to have default values for the bean's properties. This is accomplished by constructing a new instance of the bean
      * which the map uses as its underlying data source. This behavior for {@code clear()} differs from the Map contract in that the mappings are not actually
      * removed from the map (the mappings for a BeanMap are fixed).
      */
     @Override
     public void clear() {
         if (bean == null) {
             return;
         }
         Class<? extends Object> beanClass = null;
         try {
             beanClass = bean.getClass();
             bean = beanClass.newInstance();
         } catch (final Exception e) {
             throw new UnsupportedOperationException("Could not create new instance of class: " + beanClass, e);
         }
     }
 
     /**
      * Clone this bean map using the following process:
      *
      * <ul>
      * <li>If there is no underlying bean, return a cloned BeanMap without a bean.
      * <li>Since there is an underlying bean, try to instantiate a new bean of the same type using Class.newInstance().
      * <li>If the instantiation fails, throw a CloneNotSupportedException
      * <li>Clone the bean map and set the newly instantiated bean as the underlying bean for the bean map.
      * <li>Copy each property that is both readable and writable from the existing object to a cloned bean map.
      * <li>If anything fails along the way, throw a CloneNotSupportedException.
      * </ul>
      *
      * @return a cloned instance of this bean map
      * @throws CloneNotSupportedException if the underlying bean cannot be cloned
      */
     @Override
     public Object clone() throws CloneNotSupportedException {
         final BeanMap newMap = (BeanMap) super.clone();
         if (bean == null) {
             // no bean, just an empty bean map at the moment. return a newly
             // cloned and empty bean map.
             return newMap;
         }
         Object newBean = null;
         final Class<? extends Object> beanClass = bean.getClass(); // Cannot throw Exception
         try {
             newBean = beanClass.newInstance();
         } catch (final Exception e) {
             // unable to instantiate
             final CloneNotSupportedException cnse = new CloneNotSupportedException(
                     "Unable to instantiate the underlying bean \"" + beanClass.getName() + "\": " + e);
             cnse.initCause(e);
             throw cnse;
         }
         try {
             newMap.setBean(newBean);
         } catch (final Exception e) {
             final CloneNotSupportedException cnse = new CloneNotSupportedException("Unable to set bean in the cloned bean map: " + e);
             cnse.initCause(e);
             throw cnse;
         }
         try {
             // copy only properties that are readable and writable. If its
             // not readable, we can't get the value from the old map. If
             // its not writable, we can't write a value into the new map.
             readMethods.keySet().forEach(key -> {
                 if (getWriteMethod(key) != null) {
                     newMap.put(key, get(key));
                 }
             });
         } catch (final Exception e) {
             final CloneNotSupportedException cnse = new CloneNotSupportedException("Unable to copy bean values to cloned bean map: " + e);
             cnse.initCause(e);
             throw cnse;
         }
         return newMap;
     }
 
     /**
      * Returns true if the bean defines a property with the given name.
      * <p>
      * The given name must be a {@code String}; if not, this method returns false. This method will also return false if the bean does not define a property
      * with that name.
      * </p>
      * <p>
      * Write-only properties will not be matched as the test operates against property read methods.
      * </p>
      *
      * @param name the name of the property to check
      * @return false if the given name is null or is not a {@code String}; false if the bean does not define a property with that name; or true if the bean does
      *         define a property with that name
      */
     @Override
     public boolean containsKey(final Object name) {
         return getReadMethod(name) != null;
     }
 
     /**
      * Converts the given value to the given type. First, reflection is used to find a public constructor declared by the given class that takes one argument,
      * which must be the precise type of the given value. If such a constructor is found, a new object is created by passing the given value to that
      * constructor, and the newly constructed object is returned.
      * <p>
      * If no such constructor exists, and the given type is a primitive type, then the given value is converted to a string using its {@link Object#toString()
      * toString()} method, and that string is parsed into the correct primitive type using, for instance, {@link Integer#valueOf(String)} to convert the string
      * into an {@code int}.
      * </p>
      * <p>
      * If no special constructor exists and the given type is not a primitive type, this method returns the original value.
      * </p>
      *
      * @param <R>     The return type.
      * @param newType the type to convert the value to
      * @param value   the value to convert
      * @return the converted value
      * @throws NumberFormatException     if newType is a primitive type, and the string representation of the given value cannot be converted to that type
      * @throws InstantiationException    if the constructor found with reflection raises it
      * @throws InvocationTargetException if the constructor found with reflection raises it
      * @throws IllegalAccessException    never
      * @throws IllegalArgumentException  never
      */
     protected <R> Object convertType(final Class<R> newType, final Object value)
             throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
 
         // try call constructor
         try {
             final Constructor<R> constructor = newType.getConstructor(value.getClass());
             return constructor.newInstance(value);
         } catch (final NoSuchMethodException e) {
             // try using the transformers
             final Function<Object, R> transformer = getTypeTransformer(newType);
             if (transformer != null) {
                 return transformer.apply(value);
             }
             return value;
         }
     }
 
     /**
      * Creates an array of parameters to pass to the given mutator method. If the given object is not the right type to pass to the method directly, it will be
      * converted using {@link #convertType(Class,Object)}.
      *
      * @param method the mutator method
      * @param value  the value to pass to the mutator method
      * @return an array containing one object that is either the given value or a transformed value
      * @throws IllegalAccessException   if {@link #convertType(Class,Object)} raises it
      * @throws IllegalArgumentException if any other exception is raised by {@link #convertType(Class,Object)}
      * @throws ClassCastException       if an error occurs creating the method args
      */
     protected Object[] createWriteMethodArguments(final Method method, Object value) throws IllegalAccessException, ClassCastException {
         try {
             if (value != null) {
                 final Class<? extends Object>[] paramTypes = method.getParameterTypes();
                 if (paramTypes != null && paramTypes.length > 0) {
                     final Class<? extends Object> paramType = paramTypes[0];
                     if (!paramType.isAssignableFrom(value.getClass())) {
                         value = convertType(paramType, value);
                     }
                 }
             }
 
             return new Object[] { value };
         } catch (final InvocationTargetException | InstantiationException e) {
             throw new IllegalArgumentException(e.getMessage(), e);
         }
     }
 
     /**
      * Convenience method for getting an iterator over the entries.
      *
      * @return an iterator over the entries
      */
     public Iterator<Map.Entry<String, Object>> entryIterator() {
         final Iterator<String> iter = keyIterator();
         return new Iterator<Map.Entry<String, Object>>() {
             @Override
             public boolean hasNext() {
                 return iter.hasNext();
             }
 
             @Override
             public Map.Entry<String, Object> next() {
                 final String key = iter.next();
                 final Object value = get(key);
                 // This should not cause any problems; the key is actually a
                 // string, but it does no harm to expose it as Object
                 return new Entry(BeanMap.this, key, value);
             }
 
             @Override
             public void remove() {
                 throw new UnsupportedOperationException("remove() not supported for BeanMap");
             }
         };
     }
 
     /**
      * Gets a Set of MapEntry objects that are the mappings for this BeanMap.
      * <p>
      * Each MapEntry can be set but not removed.
      * </p>
      *
      * @return the unmodifiable set of mappings
      */
     @Override
     public Set<Map.Entry<String, Object>> entrySet() {
         return Collections.unmodifiableSet(new AbstractSet<Map.Entry<String, Object>>() {
             @Override
             public Iterator<Map.Entry<String, Object>> iterator() {
                 return entryIterator();
             }
 
             @Override
             public int size() {
                 return BeanMap.this.readMethods.size();
             }
         });
     }
 
     /**
      * Called during a successful {@link #put(String,Object)} operation. Default implementation does nothing. Override to be notified of property changes in the
      * bean caused by this map.
      *
      * @param key      the name of the property that changed
      * @param oldValue the old value for that property
      * @param newValue the new value for that property
      */
     protected void firePropertyChange(final Object key, final Object oldValue, final Object newValue) {
         // noop
     }
 
     /**
      * Gets the value of the bean's property with the given name.
      * <p>
      * The given name must be a {@link String} and must not be null; otherwise, this method returns {@code null}. If the bean defines a property with the given
      * name, the value of that property is returned. Otherwise, {@code null} is returned.
      * </p>
      * <p>
      * Write-only properties will not be matched as the test operates against property read methods.
      * </p>
      *
      * @param name the name of the property whose value to return
      * @return the value of the property with that name
      */
     @Override
     public Object get(final Object name) {
         if (bean != null) {
             final Method method = getReadMethod(name);
             if (method != null) {
                 try {
                     return method.invoke(bean, NULL_ARGUMENTS);
                 } catch (final IllegalAccessException | NullPointerException | InvocationTargetException | IllegalArgumentException e) {
                     logWarn(e);
                 }
             }
         }
         return null;
     }
 
     /**
      * Gets the bean currently being operated on. The return value may be null if this map is empty.
      *
      * @return the bean being operated on by this map
      */
     public Object getBean() {
         return bean;
     }
 
     // Helper methods
 
     /**
      * Gets the accessor for the property with the given name.
      *
      * @param name the name of the property
      * @return null if the name is null; null if the name is not a {@link String}; null if no such property exists; or the accessor method for that property
      */
     protected Method getReadMethod(final Object name) {
         return readMethods.get(name);
     }
 
     /**
      * Gets the accessor for the property with the given name.
      *
      * @param name the name of the property
      * @return the accessor method for the property, or null
      */
     public Method getReadMethod(final String name) {
         return readMethods.get(name);
     }
 
     /**
      * Gets the type of the property with the given name.
      *
      * @param name the name of the property
      * @return the type of the property, or {@code null} if no such property exists
      */
     public Class<?> getType(final String name) {
         return types.get(name);
     }
 
     /**
      * Gets a transformer for the given primitive type.
      *
      * @param <R>  The transformer result type.
      * @param type the primitive type whose transformer to return
      * @return a transformer that will convert strings into that type, or null if the given type is not a primitive type
      */
     protected <R> Function<Object, R> getTypeTransformer(final Class<R> type) {
         return (Function<Object, R>) typeTransformers.get(type);
     }
 
     /**
      * Gets the mutator for the property with the given name.
      *
      * @param name the name of the
      * @return null if the name is null; null if the name is not a {@link String}; null if no such property exists; null if the property is read-only; or the
      *         mutator method for that property
      */
     protected Method getWriteMethod(final Object name) {
         return writeMethods.get(name);
     }
 
     /**
      * Gets the mutator for the property with the given name.
      *
      * @param name the name of the property
      * @return the mutator method for the property, or null
      */
     public Method getWriteMethod(final String name) {
         return writeMethods.get(name);
     }
 
     private void initialize() {
         if (getBean() == null) {
             return;
         }
 
         final Class<? extends Object> beanClass = getBean().getClass();
         try {
             // BeanInfo beanInfo = Introspector.getBeanInfo( bean, null );
             final BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);
             final PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
             if (propertyDescriptors != null) {
                 for (final PropertyDescriptor propertyDescriptor : propertyDescriptors) {
                     if (propertyDescriptor != null) {
                         final String name = propertyDescriptor.getName();
                         final Method readMethod = propertyDescriptor.getReadMethod();
                         final Method writeMethod = propertyDescriptor.getWriteMethod();
                         final Class<? extends Object> aType = propertyDescriptor.getPropertyType();
 
                         if (readMethod != null) {
                             readMethods.put(name, readMethod);
                         }
                         if (writeMethod != null) {
                             writeMethods.put(name, writeMethod);
                         }
                         types.put(name, aType);
                     }
                 }
             }
         } catch (final IntrospectionException e) {
             logWarn(e);
         }
     }
 
     /**
      * Convenience method for getting an iterator over the keys.
      * <p>
      * Write-only properties will not be returned in the iterator.
      * </p>
      *
      * @return an iterator over the keys
      */
     public Iterator<String> keyIterator() {
         return readMethods.keySet().iterator();
     }
 
     // Implementation methods
 
     /**
      * Gets the keys for this BeanMap.
      * <p>
      * Write-only properties are <strong>not</strong> included in the returned set of property names, although it is possible to set their value and to get
      * their type.
      * </p>
      *
      * @return BeanMap keys. The Set returned by this method is not modifiable.
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
     // The set actually contains strings; however, because it cannot be
     // modified there is no danger in selling it as Set<Object>
     @Override
     public Set<String> keySet() {
         return Collections.unmodifiableSet((Set) readMethods.keySet());
     }
 
     /**
      * Logs the given exception to {@code System.out}. Used to display warnings while accessing/mutating the bean.
      *
      * @param ex the exception to log
      */
     protected void logInfo(final Exception ex) {
         // Deliberately do not use LOG4J or Commons Logging to avoid dependencies
         System.out.println("INFO: Exception: " + ex);
     }
 
     /**
      * Logs the given exception to {@code System.err}. Used to display errors while accessing/mutating the bean.
      *
      * @param ex the exception to log
      */
     protected void logWarn(final Exception ex) {
         // Deliberately do not use LOG4J or Commons Logging to avoid dependencies
         System.out.println("WARN: Exception: " + ex);
         ex.printStackTrace();
     }
 
     /**
      * Sets the bean property with the given name to the given value.
      *
      * @param name  the name of the property to set
      * @param value the value to set that property to
      * @return the previous value of that property
      * @throws IllegalArgumentException if the given name is null; if the given name is not a {@link String}; if the bean doesn't define a property with that
      *                                  name; or if the bean property with that name is read-only
      * @throws ClassCastException       if an error occurs creating the method args
      */
     @Override
     public Object put(final String name, final Object value) throws IllegalArgumentException, ClassCastException {
         if (bean != null) {
             final Object oldValue = get(name);
             final Method method = getWriteMethod(name);
             if (method == null) {
                 throw new IllegalArgumentException("The bean of type: " + bean.getClass().getName() + " has no property called: " + name);
             }
             try {
                 final Object[] arguments = createWriteMethodArguments(method, value);
                 method.invoke(bean, arguments);
 
                 final Object newValue = get(name);
                 firePropertyChange(name, oldValue, newValue);
             } catch (final InvocationTargetException | IllegalAccessException e) {
                 throw new IllegalArgumentException(e.getMessage(), e);
             }
             return oldValue;
         }
         return null;
     }
 
     /**
      * Puts all of the writable properties from the given BeanMap into this BeanMap. Read-only and Write-only properties will be ignored.
      *
      * @param map the BeanMap whose properties to put
      */
     public void putAllWriteable(final BeanMap map) {
         map.readMethods.keySet().forEach(key -> {
             if (getWriteMethod(key) != null) {
                 put(key, map.get(key));
             }
         });
     }
 
     // Implementation classes
 
     /**
      * Reinitializes this bean. Called during {@link #setBean(Object)}. Does introspection to find properties.
      */
     protected void reinitialise() {
         readMethods.clear();
         writeMethods.clear();
         types.clear();
         initialize();
     }
 
     /**
      * Sets the bean to be operated on by this map. The given value may be null, in which case this map will be empty.
      *
      * @param newBean the new bean to operate on
      */
     public void setBean(final Object newBean) {
         bean = newBean;
         reinitialise();
     }
 
     /**
      * Returns the number of properties defined by the bean.
      *
      * @return the number of properties defined by the bean
      */
     @Override
     public int size() {
         return readMethods.size();
     }
 
     /**
      * Renders a string representation of this object.
      *
      * @return a {@code String} representation of this object
      */
     @Override
     public String toString() {
         return "BeanMap<" + bean + ">";
     }
 
     /**
      * Convenience method for getting an iterator over the values.
      *
      * @return an iterator over the values
      */
     public Iterator<Object> valueIterator() {
         final Iterator<?> iter = keyIterator();
         return new Iterator<Object>() {
             @Override
             public boolean hasNext() {
                 return iter.hasNext();
             }
 
             @Override
             public Object next() {
                 final Object key = iter.next();
                 return get(key);
             }
 
             @Override
             public void remove() {
                 throw new UnsupportedOperationException("remove() not supported for BeanMap");
             }
         };
     }
 
     /**
      * Gets the values for the BeanMap.
      *
      * @return values for the BeanMap. The returned collection is not modifiable.
      */
     @Override
     public Collection<Object> values() {
         final ArrayList<Object> answer = new ArrayList<>(readMethods.size());
         valueIterator().forEachRemaining(answer::add);
         return Collections.unmodifiableList(answer);
     }
 }