/**
    * This file Copyright (c) 2019 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.i18nsystem.bytebudddy;
  
  import static info.magnolia.i18nsystem.bytebudddy.AnyTypeInGenericSignatureMatcher.annotationIsPresentInGenericSignature;
  import static info.magnolia.i18nsystem.bytebudddy.MethodOrSuperMethodMatcher.annotationIsPresentInHierarchy;
  import static java.util.stream.Collectors.*;
  import static net.bytebuddy.dynamic.loading.ClassLoadingStrategy.Default.WRAPPER;
  import static net.bytebuddy.implementation.MethodDelegation.to;
  import static net.bytebuddy.matcher.ElementMatchers.*;
  
  import info.magnolia.context.Context;
  import info.magnolia.dynamic.MagnoliaProxy;
  import info.magnolia.i18nsystem.ContextLocaleProvider;
  import info.magnolia.i18nsystem.I18nKeyGenerator;
  import info.magnolia.i18nsystem.I18nKeyGeneratorFactory;
  import info.magnolia.i18nsystem.I18nParentable;
  import info.magnolia.i18nsystem.I18nText;
  import info.magnolia.i18nsystem.I18nable;
  import info.magnolia.i18nsystem.I18nizer;
  import info.magnolia.i18nsystem.TranslationService;
  
  import java.lang.reflect.Field;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.lang.reflect.Type;
  import java.lang.reflect.TypeVariable;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Optional;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.function.BiFunction;
  import java.util.stream.Stream;
  
  import javax.inject.Inject;
  import javax.inject.Provider;
  import javax.inject.Singleton;
  
  import org.objenesis.Objenesis;
  import org.objenesis.ObjenesisStd;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.collect.Collections2;
  
  import net.bytebuddy.ByteBuddy;
  import net.bytebuddy.TypeCache;
  import net.bytebuddy.description.type.TypeDescription;
  import net.bytebuddy.dynamic.DynamicType;
  import net.bytebuddy.implementation.FieldAccessor;
  import net.bytebuddy.implementation.bind.annotation.AllArguments;
  import net.bytebuddy.implementation.bind.annotation.Origin;
  import net.bytebuddy.implementation.bind.annotation.RuntimeType;
  import net.bytebuddy.implementation.bind.annotation.This;
  import net.sf.cglib.proxy.Enhancer;
  
  /**
   * I18nizer implementation based on ByteBuddy framework.
   */
  @Singleton
  public class ByteBuddyI18nizer implements I18nizer {
  
      private static final Logger log = LoggerFactory.getLogger(ByteBuddyI18nizer.class);
  
      private static final String I18N_SOURCE = "_I18N_SOURCE";
     private static final String I18N_PARENT = "_I18N_PARENT";
 
     private final Objenesis objenesis = new ObjenesisStd(true);
 
     private final TypeCache<Class> typeCache = new TypeCache.WithInlineExpunction<>(TypeCache.Sort.SOFT);
     private final Map<Method, String> i18nTextFallbackCache = new ConcurrentHashMap<>();
 
     private final TranslationService translationService;
     private final Provider<Context> contextProvider;
 
     @Inject
     public ByteBuddyI18nizer(TranslationService translationService, Provider<Context> contextProvider) {
         this.translationService = translationService;
         this.contextProvider = contextProvider;
     }
 
     @Override
     public <C> C decorate(C obj) {
         if (obj == null) {
             return null;
         }
         // Check if this has already been decorated to avoid redundancy in client code
         if (isProxied(obj.getClass()) && obj instanceof I18nParentable) {
             throw new IllegalStateException(obj + " has already been enhanced by " + getClass().getSimpleName());
         }
 
         return decorateInstance(obj, null);
     }
 
     @SuppressWarnings("unchecked")
     private <C> C decorateInstance(C instance, Object parent) {
         if (instance == null) {
             return null;
         }
 
         Class<C> clazz = getOriginalType(instance);
         Class<C> proxyType = (Class<C>) typeCache.findOrInsert(getClass().getClassLoader(), clazz, () -> generateByteBuddyDecorator(clazz));
 
         final C proxy = objenesis.newInstance(proxyType);
         setFieldValue(proxy, I18N_SOURCE, instance);
         setFieldValue(proxy, I18N_PARENT, parent);
 
         return proxy;
     }
 
     private <C> Class generateByteBuddyDecorator(Class<C> type) {
         TypeVariable<Class<C>>[] typeParameters = type.getTypeParameters();
         DynamicType.Builder<C> subclass;
 
         if (typeParameters.length == 0) {
             subclass = new ByteBuddy().subclass(type);
         } else {
             Type[] stubParameterTypes = Arrays.stream(typeParameters).map(param -> {
                 Type[] bounds = param.getBounds();
                 return bounds.length == 0 ? Object.class : bounds[0];
             }).toArray(Type[]::new);
 
             subclass = (DynamicType.Builder<C>) new ByteBuddy().subclass(TypeDescription.Generic.Builder.parameterizedType(type, stubParameterTypes).build());
         }
 
         return subclass
                 .defineField(I18N_SOURCE, type)
                 .defineField(I18N_PARENT, Object.class)
                 .implement(MagnoliaProxy.class)
                 .implement(DelegateResolver.class)
                 .implement(I18nParentable.class)
                 .method(not(isDeclaredBy(Object.class)).and(isPublic()))
                 .intercept(to(new DefaultInterceptor<C>()))
                 .method(isGetter().and(annotationIsPresentInHierarchy(I18nText.class)))
                 .intercept(to((new I18NTextAnnotatedGetterInterceptor<>(translationService, I18nKeyGeneratorFactory.newKeyGeneratorFor(type)))))
                 .method(isGetter().and(returnsGeneric(annotationIsPresentInGenericSignature(I18nable.class))))
                 .intercept(to(new I18NableGetterInterceptor<>(this::decorateInstance)))
                 .method(isDeclaredBy(DelegateResolver.class))
                 .intercept(FieldAccessor.ofField(I18N_SOURCE))
                 .method(isDeclaredBy(I18nParentable.class))
                 .intercept(FieldAccessor.ofField(I18N_PARENT))
                 .make()
                 .load(getClass().getClassLoader(), WRAPPER).getLoaded();
     }
 
     private boolean isProxied(Class<?> clazz) {
         return MagnoliaProxy.class.isAssignableFrom(clazz);
     }
 
     private Object getUndecoratedValue(Method method, Object target) {
         try {
             return method.invoke(target);
         } catch (IllegalAccessException | InvocationTargetException e) {
             log.warn("Undecorated value couldn't be retrieved {}", e.getMessage());
             return null;
         }
     }
 
     @SuppressWarnings("unchecked")
     private <C> Class<C> getOriginalType(C instance) {
         Class<C> clazz = (Class<C>) instance.getClass();
         if (instance instanceof MagnoliaProxy || Enhancer.isEnhanced(clazz)) {
             clazz = (Class<C>) clazz.getSuperclass();
         }
 
         return clazz;
     }
 
     private <C> void setFieldValue(C target, String propertyName, Object value) {
         try {
             final Field delegateField = target.getClass().getDeclaredField(propertyName);
             delegateField.setAccessible(true);
             delegateField.set(target, value);
         } catch (IllegalAccessException | NoSuchFieldException e) {
             log.error("Failed to set property [{}], i18n enhancement process failed", propertyName, e);
         }
     }
 
     /**
      * Mixin interface which makes it easier for the i18n proxy to expose
      * the object that it wraps.
      *
      * @param <T>
      *     type of the wrapped object
      */
     public interface DelegateResolver<T> {
         T getProxyDelegate();
     }
 
     /**
      * Catch-all interceptor which merely dispatches all the calls to the wrapped object.
      * Note that the annotated getters will be handled by other intercepters accordingly.
      *
      * @param <T>
      *     type of the wrapped object
      */
     public class DefaultInterceptor<T> {
 
         @RuntimeType
         public Object intercept(@This DelegateResolver<T> that, @Origin Method method, @AllArguments Object[] args) {
             try {
                 return method.invoke(that.getProxyDelegate(), args);
             } catch (IllegalAccessException | InvocationTargetException e) {
                 log.error("Failed to intercept method [{}]", method.getName(), e);
                 return null;
             }
         }
     }
 
     /**
      * Handles the getters which return i18n-annotated types.
      * Automatically recursively i18n-izes them.
      *
      * @param <T>
      *     type of the getter owner
      */
     public class I18NableGetterInterceptor<T> {
 
         private final BiFunction<Object, T, Object> decorator;
 
         public I18NableGetterInterceptor(BiFunction<Object, T, Object> decorator) {
             this.decorator = decorator;
         }
 
         @SuppressWarnings("unchecked")
         @RuntimeType
         public Object decorate(@Origin Method method, @This DelegateResolver<T> delegateResolver, @This T parent) {
             Object value = getUndecoratedValue(method, delegateResolver.getProxyDelegate());
             if (value instanceof Map) {
                 value = ((Map<?, ?>) value).entrySet().stream()
                         .collect(toMap(Map.Entry::getKey,
                                 el -> decorator.apply(el.getValue(), parent),
                                 (u, v) -> {
                                     throw new IllegalStateException(String.format("Duplicate key %s", u));
                                 },
                                 LinkedHashMap::new)
                         );
             } else if (value instanceof Collection) {
                 // We can't use Collections2.transform() or Lists.transform() as these create new immutable collections
                 if (value instanceof List) {
                     //this is wrapped in newArrayList() to make it modifiable since info.magnolia.ui.contentapp.movedialog.MoveDialogPresenterImpl#prepareWorkbenchDefinition relies on it (just for compatibility although it should be fixed there)
                     value = ((List<?>) value).stream().map(el -> decorator.apply(el, parent)).collect(toList());
                 } else {
                     value = Collections2.transform((Collection) value, el -> decorator.apply(el, parent));
                 }
             } else {
                 value = decorator.apply(value, parent);
             }
             return value;
         }
     }
 
     /**
      * Handles the getters annotated with {@link I18nText}.
      * Delegates the calls to the translation service.
      *
      * @param <T>
      *     type of the getter owner
      */
     public class I18NTextAnnotatedGetterInterceptor<T> {
 
         private final TranslationService translationService;
         private final I18nKeyGenerator<T> keyGenerator;
 
         public I18NTextAnnotatedGetterInterceptor(TranslationService translationService, I18nKeyGenerator<T> keyGenerator) {
             this.translationService = translationService;
             this.keyGenerator = keyGenerator;
         }
 
         @RuntimeType
         public String i18nTextMethod(@Origin Method method, @This DelegateResolver<T> delegateResolver, @This T that) {
             String undecoratedValue = (String) getUndecoratedValue(method, delegateResolver.getProxyDelegate());
             String[] keys;
             String fallback;
             if (undecoratedValue != null) {
                 keys = new String[]{undecoratedValue};
                 fallback = undecoratedValue;
             } else {
                 keys = keyGenerator.keysFor(null, that, method);
                 fallback = getFallback(method);
             }
             final ContextLocaleProvider#ContextLocaleProvider">ContextLocaleProvider localeProvider = new ContextLocaleProvider(contextProvider.get());
             return translationService.translate(localeProvider, keys, fallback);
         }
 
         private String getFallback(@Origin Method method) {
             String fallback = i18nTextFallbackCache.get(method);
             if (fallback == null) {
                 fallback = Optional.ofNullable(method.getAnnotation(I18nText.class)).map(I18nText::fallback).orElseGet(() ->
                         Stream.concat(
                                 Arrays.stream(method.getDeclaringClass().getInterfaces()).flatMap(aClass -> Arrays.stream(aClass.getMethods())),
                                 Arrays.stream(Optional.ofNullable(method.getDeclaringClass().getSuperclass()).map(Class::getMethods).orElse(new Method[]{})))
                                 .filter(interfaceMethod -> interfaceMethod.getName().equals(method.getName()))
                                 .findFirst()
                                 .map(this::getFallback)
                                 .orElse(I18nText.NO_FALLBACK)
                 );
                 i18nTextFallbackCache.put(method, fallback);
             }
             return fallback;
         }
     }
 }