/*

  * 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.nabla.forward.analysis;

 import java.io.IOException;

 import java.io.InputStream;

 import java.lang.reflect.Field;

 import java.util.Set;

 import org.apache.commons.math3.analysis.UnivariateFunction;

 import org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction;

 import org.apache.commons.nabla.DifferentiationException;

 import org.apache.commons.nabla.NablaMessages;

 import org.objectweb.asm.ClassReader;

 import org.objectweb.asm.Label;

 import org.objectweb.asm.Opcodes;

 import org.objectweb.asm.Type;

 import org.objectweb.asm.tree.ClassNode;

 import org.objectweb.asm.tree.FieldNode;

 import org.objectweb.asm.tree.MethodNode;

 /**

  * Differentiator for classes using forward mode.

  * <p>

  * This differentiator transforms classes implementing the

  * {@link UnivariateFunction UnivariateFunction} interface and convert

  * them to classes implementing the {@link UnivariateDifferentiableFunction

  * UnivariateDifferentiableFunction} interface.

  * </p>

  * <p>

  * The differentiator creates a new class in the same package as the primitive class and

  * which only preserve a private reference to the primitive instance. They access the

  * current value of all necessary primitive instance fields thanks to reflection and

  * bypassing access restrictions.

  * </p>

  * <p>

  * The original class bytecode is not changed at all.

  * </p>

  * @version $Id$

  */

 public class ClassDifferentiator {

     /** Name for the primitive instance field. */

     private static final String PRIMITIVE_FIELD = "primitive";

     /** Name fo the constructor methods. */

     private static final String INIT = "<init>";

     /** Math implementation classes. */

     private final Set<String> mathClasses;

     /** Class to differentiate. */

     private final Class<? extends UnivariateFunction> primitiveClass;

     /** Node of the class to differentiate. */

     private final ClassNode primitiveNode;

     /** Class to differentiate. */

     private final ClassNode classNode;

     /**

      * Simple constructor.

      * @param primitiveClass primitive class

      * @param mathClasses math implementation classes

      * @exception DifferentiationException if class cannot be differentiated

      * @throws IOException if class cannot be read

      */

     public ClassDifferentiator(final Class<? extends UnivariateFunction> primitiveClass,

                                final Set<String> mathClasses)

         throws DifferentiationException, IOException {

         // get the original class

         this.primitiveClass = primitiveClass;

         final String classResourceName = "/" + primitiveClass.getName().replace('.', '/') + ".class";

         final InputStream stream = primitiveClass.getResourceAsStream(classResourceName);

         final ClassReader reader = new ClassReader(stream);

         primitiveNode = new ClassNode(Opcodes.ASM4);

         reader.accept(primitiveNode, ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);

         this.mathClasses = mathClasses;

         classNode = new ClassNode(Opcodes.ASM4);

         // check the UnivariateFunction interface is implemented

         final Class<UnivariateFunction> uFuncClass = UnivariateFunction.class;

         boolean isDifferentiable = false;

         for (String interf : primitiveNode.interfaces) {

             final String interfName = interf.replace('/', '.');

             Class<?> interfClass = null;

             try {

                 interfClass = Class.forName(interfName);

             } catch (ClassNotFoundException cnfe) {

                 // this should never occur since class has already been loaded

                 // and an instance already exists ...

                 throw new DifferentiationException(NablaMessages.INTERFACE_NOT_FOUND_WHILE_DIFFERENTIATING,

                                                    interfName, primitiveNode.name);

             }

             if (interfClass != null) {

                 isDifferentiable = isDifferentiable || uFuncClass.isAssignableFrom(interfClass);

             }

         }

         if (!isDifferentiable) {

             throw new DifferentiationException(NablaMessages.CLASS_DOES_NOT_IMPLEMENT_INTERFACE,

                                                primitiveNode.name, uFuncClass.getName());

         }

         // change the class properties for the derived class

         classNode.visit(primitiveNode.version, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC,

                         primitiveNode.name + "_NablaForwardModeUnivariateDerivative",

                         null, Type.getType(Object.class).getInternalName(),

                         new String[] {

                             UnivariateDifferentiableFunction.class.getName().replace('.', '/')

                         });

         // add boilerplate code

         addPrimitiveField();

         addConstructor();

         addGetPrimitiveFieldMethod();

     }

     /**

      * Differentiate a method.

      * @param name of the method

      * @param primitiveDesc descriptor of the method in the primitive class

      * @param derivativeDesc descriptor of the method in the derivative class

      * @exception DifferentiationException if method cannot be differentiated

      */

     public void differentiateMethod(final String name, final String primitiveDesc,

                                     final String derivativeDesc)

         throws DifferentiationException {

         for (final MethodNode method : primitiveNode.methods) {

             if (method.name.equals(name) && method.desc.equals(primitiveDesc)) {

                 final MethodDifferentiator differentiator =

                         new MethodDifferentiator(mathClasses, classNode.name);

                 differentiator.differentiate(primitiveNode.name, method);

                 classNode.methods.add(method);

             }

         }

     }

     /**

      * Get the derived class.

      * @return derived class

      */

     public ClassNode getDerivedClass() {

         return classNode;

     }

     /** Add the primitive field.

      */

     private void addPrimitiveField() {

         final FieldNode primitiveField =

             new FieldNode(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC,

                           PRIMITIVE_FIELD, Type.getDescriptor(primitiveClass), null, null);

         classNode.fields.add(primitiveField);

     }

     /** Add the class constructor.

      */

     private void addConstructor() {

         final MethodNode constructor =

             new MethodNode(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, INIT,

                            Type.getMethodDescriptor(Type.VOID_TYPE, Type.getType(primitiveClass)),

                            null, null);

         constructor.visitVarInsn(Opcodes.ALOAD, 0);

         constructor.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getType(Object.class).getInternalName(),

                                     INIT, "()V");

         constructor.visitVarInsn(Opcodes.ALOAD, 0);

         constructor.visitVarInsn(Opcodes.ALOAD, 1);

         constructor.visitFieldInsn(Opcodes.PUTFIELD, classNode.name, PRIMITIVE_FIELD,

                                    Type.getDescriptor(primitiveClass));

         constructor.visitInsn(Opcodes.RETURN);

         constructor.visitMaxs(0, 0);

         classNode.methods.add(constructor);

     }

     /** Add the getPrimitiveField method.

      */

     private void addGetPrimitiveFieldMethod() {

         final MethodNode method =

             new MethodNode(Opcodes.ACC_PRIVATE | Opcodes.ACC_SYNTHETIC, "getPrimitiveField",

                            Type.getMethodDescriptor(Type.getType(Object.class), Type.getType(String.class)),

                            null, null);

         final Label start     = new Label();

         final Label end       = new Label();

         method.visitTryCatchBlock(start, end, end, Type.getInternalName(IllegalAccessException.class));

         method.visitTryCatchBlock(start, end, end, Type.getInternalName(NoSuchFieldException.class));

         method.visitLabel(start);

         method.visitLdcInsn(Type.getType(primitiveClass));

         method.visitVarInsn(Opcodes.ALOAD, 1);

         method.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(Class.class),

                                "getDeclaredField",

                                Type.getMethodDescriptor(Type.getType(Field.class), Type.getType(String.class)));

         method.visitVarInsn(Opcodes.ASTORE, 2);

         method.visitVarInsn(Opcodes.ALOAD, 2);

         method.visitInsn(Opcodes.ICONST_1);

         method.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(Field.class),

                                "setAccessible",

                                Type.getMethodDescriptor(Type.VOID_TYPE, Type.BOOLEAN_TYPE));

         method.visitVarInsn(Opcodes.ALOAD, 2);

         method.visitVarInsn(Opcodes.ALOAD, 0);

         method.visitFieldInsn(Opcodes.GETFIELD, classNode.name, PRIMITIVE_FIELD,

                               Type.getDescriptor(primitiveClass));

         method.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(Field.class),

                                "get",

                                Type.getMethodDescriptor(Type.getType(Object.class), Type.getType(Object.class)));

         method.visitInsn(Opcodes.ARETURN);

         method.visitLabel(end);

         method.visitVarInsn(Opcodes.ASTORE, 2);

         method.visitTypeInsn(Opcodes.NEW, Type.getInternalName(RuntimeException.class));

         method.visitInsn(Opcodes.DUP);

         method.visitVarInsn(Opcodes.ALOAD, 2);

         method.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(RuntimeException.class),

                                INIT, Type.getMethodDescriptor(Type.VOID_TYPE, Type.getType(Throwable.class)));

         method.visitInsn(Opcodes.ATHROW);

         classNode.methods.add(method);

     }

 }