/**
    * This file Copyright (c) 2016-2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.config;
  
  import static java.util.regex.Pattern.compile;
  
  import java.lang.reflect.Field;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.LinkedHashMap;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.base.Joiner;
  import com.google.common.base.Objects;
  import com.thoughtworks.proxy.factory.CglibProxyFactory;
  import com.thoughtworks.proxy.factory.InvokerReference;
  import com.thoughtworks.proxy.kit.ReflectionUtils;
  import com.thoughtworks.proxy.kit.SimpleInvoker;
  
  import net.sf.cglib.proxy.Enhancer;
  
  /**
   * Provides a mutable wrapper.
   * <p>
   * For a given object (normally a POJO) this utility generates a wrapper (via Java Dynamic Proxies or CGLIB) which initially
   * has the state identical to the one of the source due to the default method call delegation. However, the wrapper can be deliberately modified without
   * a fear of affecting the source object thanks to the wrappers internal state which automatically absorbs all the changes coming through setter calls or some such.
   * </p>
   * <p>
   * Besides merely acting as a wrapper, the proxy object is also supplied with an implementation of the {@link Mutable} interface, which simplifies
   * dynamic mutator implementations.
   * </p>
   *
   * @see Mutator
   * @param <T> type of the object being wrapped
   * @param <U> type of the resulting wrapper (must be extending {@code T})
   */
  @SuppressWarnings("unchecked")
  public class MutableWrapper<T, U extends T> {
  
      private static final Logger log = LoggerFactory.getLogger(MutableWrapper.class);
  
  
      /**
       * Takes an arbitrary source object {@code T} and produces a proxied wrapper of type {@code U} which may extend {@code T}.
       * <p>
       * Once the source object is wrapped via this API - all the sub-objects retrieved via getters will get automatically (and recursively)
       * wrapped as well.
       * </p>
       * <p>
       * Returned instance's state can be modified without a risk of affecting the {@code source} instance's state.
       * Modification can be done via setters (should {@code T} have any) or via {@link Mutable} interface which
       * the returned wrapper implements.
       * </p>
      */
     public static <T, U extends T> U wrapAs(T source, Class<U> type) {
         return new MutableWrapper<T, U>(type).createWrapper(source);
     }
 
     /**
      * Does the same as {@link Mutable#wrapAs(Object, Class)} but uses a provided instance's type
      * as a default target type.
      */
     public static <U> U wrap(U source) {
         if (source == null) {
             return null;
         }
         return MutableWrapper.wrapAs(source, (Class<U>) source.getClass());
     }
 
     /**
      * Merely attempts to cast an instance to {@link Mutable}.
      * @throws IllegalArgumentException if {@code instance} does not implement {@link Mutable}
      * (i.e. if instance has not been wrapped with {@link MutableWrapper} previously).
      *
      */
     public static <U> Mutable<U> asMutable(U instance) {
         if (instance instanceof Mutable) {
             return (Mutable<U>) instance;
         }
 
         throw new IllegalArgumentException("Provided instance is not instance of Mutable: " + String.valueOf(instance));
     }
 
     protected static Method setProperty;
     protected static Method getObject;
     protected static Method getInvoker;
 
     static {
         try {
             setProperty = Mutable.class.getMethod("setProperty", String.class, Object.class);
             getObject = Mutable.class.getMethod("getObject");
             getInvoker = ProxyWithBeanPropertyMethodInvoker.class.getMethod("getInvoker");
         } catch (NoSuchMethodException e) {
             throw new ExceptionInInitializerError(e.toString());
         }
     }
 
     // Prevent a wrapped class c-tor from being invoked for the proxy by passing false to CglibProxyFactory
     private final CglibProxyFactory proxyFactory = new CglibProxyFactory(false);
 
     private final Class<U> type;
 
     MutableWrapper(Class<U> type) {
         this.type = type;
     }
 
     U createWrapper(T source) {
         if (source == null) {
             return null;
         }
 
         final Class[] typesToProxy = getTargetTypes(type);
         for (final Class<?> type : typesToProxy) {
             if (!proxyFactory.canProxy(type)) {
                 log.debug("{} may not be proxied, returning unwrapped object...", type);
                 return (U) source;
             }
         }
 
         return proxyFactory.createProxy(new BeanPropertyMethodInvoker(source), typesToProxy);
     }
 
     // Last resort of proxy detection attempt. Normally Enhancer#isEnhanced would indicate that the class is proxied with CGLIB,
     // but some frameworks like Mockito re-package CGLIB which produces proxies not detectable by Enhancer
     private static final Pattern CGLIB_FOOTPRINT = Pattern.compile("\\$\\$EnhancerBy.*CGLIB\\$\\$");
 
     private Class[] getTargetTypes(Class<U> initialType) {
 
         Class<? super U> type = initialType;
 
         while (!type.isInterface() &&
                 (Enhancer.isEnhanced(type) ||
                  proxyFactory.isProxyClass(type) ||
                  Proxy.class.isAssignableFrom(type) ||
                  CGLIB_FOOTPRINT.matcher(type.getName()).find())) {
             type = type.getSuperclass();
         }
 
         final HashSet<Class<?>> types = new HashSet<>();
         types.add(Mutable.class);
         types.add(ProxyWithBeanPropertyMethodInvoker.class);
         types.addAll(ReflectionUtils.getAllInterfaces(initialType));
         types.add(type);
 
         return types.toArray(new Class[types.size()]);
     }
 
 
     /**
      * Generic interface which allows to set the arbitrary object properties via {@link #setProperty(String, Object)}.
      * By design this interface is appended to the wrappers produced by {@link MutableWrapper}.
      *
      * @param <T> type of the managed object
      */
     public interface Mutable<T> {
         T getObject();
         void setProperty(String propertyName, Object value);
     }
 
     /**
      * Provides access to the mutable wrapper invoker.
      */
     public interface ProxyWithBeanPropertyMethodInvoker extends InvokerReference {
         @Override
         BeanPropertyMethodInvoker getInvoker();
     }
 
     /**
      * Invoker which is backing up the proxies produced by {@link MutableWrapper}. The following is provided:
      * <ul>
      * <li>Simple map based mutable state</li>
      * <li>Support for getter invocations whose return values are delegated to the wrapped object, automatically cached in the state and wrapped with {@link MutableWrapper},
      * collections and maps are copied.</li>
      * <li>Support for setter invocations which are able to change the state.</li>
      * <li>{@link Mutable} interface support - a universal setter for interfaces that are immutable by default</li>
      * <li>Basic implementations of {@link Object#toString()}, {@link Object#equals(Object)} and {@link Object#hashCode()}</li>
      * </ul>
      */
     @SuppressWarnings("rawtypes")
     public static class BeanPropertyMethodInvoker extends SimpleInvoker {
         private static final Logger log = LoggerFactory.getLogger(BeanPropertyMethodInvoker.class);
         private static final Pattern getter = compile("^(?:get|is)(.+)$");
         private static final Pattern setter = compile("^set(.+)$");
 
         private final Set<String> modifiedPropertyNames = new HashSet<>();
 
         private final Map<String, Object> propertyValueCache = new HashMap<>();
 
         BeanPropertyMethodInvoker(Object delegate) {
             super(delegate);
         }
 
         @Override
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
             if (getInvoker.equals(method)) {
                 return this;
             }
 
             if (ReflectionUtils.toString.getName().equals(method.getName()) && args.length == 0) {
                 return invokeToString();
             }
 
             if (ReflectionUtils.equals.getName().equals(method.getName()) && args.length == 1) {
                 return invokeEquals(args[0]);
             }
 
             if (ReflectionUtils.hashCode.getName().equals(method.getName()) && args.length == 0) {
                 return invokeHashCode();
             }
 
             if (method.equals(setProperty)) {
                 invokeSetter(String.valueOf(args[0]), args[1]);
                 return null;
             }
 
             if (method.equals(getObject)) {
                 return proxy;
             }
 
             final Matcher setterInvocationMatcher = setter.matcher(method.getName());
             if (setterInvocationMatcher.matches()) {
                 if (args.length < 1) {
                     log.debug("Encountered [{}] setter invocation without arguments, related type: [{}]", method.getName(), proxy.getClass().getName());
                 } else {
                     invokeSetter(StringUtils.uncapitalize(setterInvocationMatcher.group(1)), args[0]);
                 }
                 return null;
             }
 
             final Matcher getterInvocationMatcher = getter.matcher(method.getName());
             if (getterInvocationMatcher.matches()) {
                 return invokeGetter(StringUtils.uncapitalize(getterInvocationMatcher.group(1)), method);
             }
 
             final Map<String, Object> currentValues = applyFieldValues(this.propertyValueCache);
             try {
                 return super.invoke(getTarget(), method, args);
             } finally {
                 applyFieldValues(currentValues);
             }
         }
 
         private Map<String, Object> applyFieldValues(Map<String, Object> valuesToApply) {
             final Map<String, Object> oldValues = new HashMap<>();
             valuesToApply.forEach((propertyName, value) -> {
                 try {
                     final Field property = getTarget().getClass().getDeclaredField(propertyName);
                     property.setAccessible(true);
                     oldValues.put(propertyName, property.get(getTarget()));
                     property.set(getTarget(), value);
                 } catch (NoSuchFieldException | IllegalAccessException e) {
                     log.debug("Reflective setting of the property: '{}' has failed.", propertyName, e);
                 }
             });
 
             return oldValues;
         }
 
         /**
          * Provides the hashcode value based on the wrapped object's hashcode plus combined hashcode of the modified properties' values.
          */
         private int invokeHashCode() {
             int hashCode = getTarget().hashCode();
             for (final String modifiedPropertyName : modifiedPropertyNames) {
                 final Object modifiedValue = propertyValueCache.get(modifiedPropertyName);
                 hashCode += modifiedValue == null ? 0 : modifiedValue.hashCode();
             }
             return hashCode;
         }
 
         /**
          * {@link Object#toString()} implementation which prints the wrapped object plus the modified properties.
          */
         private String invokeToString() {
             final StringBuilder sb = new StringBuilder();
             sb.append("Mutable wrapper of [")
               .append(getTarget().toString())
               .append("]");
 
             if (!modifiedPropertyNames.isEmpty()) {
                 sb.append(" with modified properties: ");
                 List<String> modifiedPropertyStatements = new ArrayList<>(modifiedPropertyNames.size());
                 for (final String modifiedPropertyName : modifiedPropertyNames) {
                     modifiedPropertyStatements.add(String.format("{%s : %s}", modifiedPropertyName, propertyValueCache.get(modifiedPropertyName)));
                 }
                 sb.append(Joiner.on(", ").join(modifiedPropertyStatements));
             }
 
             return sb.toString();
         }
 
         /**
          * Provides support for equality check. The strategy is as follows:
          * - it is only possible that this proxy is equal to a proxy of the same kind
          * - source objects are equal
          * - all the values of modified properties are equal
          */
         private boolean invokeEquals(Object other) {
             if (other instanceof MutableWrapper.ProxyWithBeanPropertyMethodInvoker) {
                 final BeanPropertyMethodInvoker otherProxy = ((ProxyWithBeanPropertyMethodInvoker) other).getInvoker();
                 boolean sameTarget = otherProxy.getTarget().equals(getTarget());
                 if (sameTarget) {
                     if (otherProxy.modifiedPropertyNames.equals(modifiedPropertyNames)) {
                         for (final String modifiedPropertyName : modifiedPropertyNames) {
                             if (!Objects.equal(propertyValueCache.get(modifiedPropertyName), otherProxy.propertyValueCache.get(modifiedPropertyName))) {
                                 return false;
                             }
                         }
                         return true;
                     }
                 }
             }
             return false;
         }
 
         private void invokeSetter(String propertyName, Object value) {
             // track modified property
             modifiedPropertyNames.add(propertyName);
             // Remember the new explicit property value
             propertyValueCache.put(propertyName, value);
         }
 
         private Object invokeGetter(String propertyName, Method getterMethod) {
             if (propertyValueCache.containsKey(propertyName)) {
                 return propertyValueCache.get(propertyName);
             }
 
             final Object fallbackValue;
             try {
                 fallbackValue = getterMethod.invoke(getTarget());
             } catch (IllegalAccessException | InvocationTargetException e) {
                 log.warn("Failed to invoke a fallback {} call due to a reflection operation problem: {}, returning null", getterMethod.getName(), e.getMessage(), e);
                 return null;
             }
 
             if (fallbackValue == null) {
                 return null;
             }
 
             Object wrappedValue;
 
             if (fallbackValue instanceof Collection) {
                 wrappedValue = wrapCollection((Collection) fallbackValue);
             } else if (fallbackValue instanceof Map) {
                 wrappedValue = wrapMap((Map) fallbackValue);
             } else {
                 wrappedValue = MutableWrapper.wrap(fallbackValue);
             }
 
             propertyValueCache.put(propertyName, wrappedValue);
             return wrappedValue;
         }
 
         private Map<?, ?> wrapMap(Map<?, ?> sourceMap) {
             final Map<Object, Object> mapCopy = new LinkedHashMap<>();
             for (final Map.Entry<?, ?> entry : sourceMap.entrySet()) {
                 mapCopy.put(entry.getKey(), MutableWrapper.wrap(entry.getValue()));
             }
             return mapCopy;
         }
 
         private Collection<?> wrapCollection(Collection<?> sourceCollection) {
             final Collection<Object> collectionCopy = sourceCollection instanceof List ? new ArrayList<>() : new LinkedHashSet<>();
             for (final Object element : sourceCollection) {
                 collectionCopy.add(MutableWrapper.wrap(element));
             }
             return collectionCopy;
         }
     }
 }