// Copyright 2011-2013 The Apache Software Foundation
//
// Licensed 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.tapestry5.internal.plastic;

import org.apache.tapestry5.internal.plastic.asm.ClassReader;
import org.apache.tapestry5.internal.plastic.asm.ClassWriter;
import org.apache.tapestry5.internal.plastic.asm.Opcodes;
import org.apache.tapestry5.internal.plastic.asm.tree.*;
import org.apache.tapestry5.plastic.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Modifier;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * Responsible for managing a class loader that allows ASM {@link ClassNode}s
 * to be instantiated as runtime classes.
 */
@SuppressWarnings("rawtypes")
public class PlasticClassPool implements ClassLoaderDelegate, Opcodes, PlasticClassListenerHub
{
    private static final Logger LOGGER = LoggerFactory.getLogger(PlasticClassPool.class);

    final PlasticClassLoader loader;

    private final PlasticManagerDelegate delegate;

    private final Set<String> controlledPackages;

    private final Map<String, Boolean> checkedExceptionCache = new HashMap<String, Boolean>();


    // Would use Deque, but that's added in 1.6 and we're still striving for 1.5 code compatibility.

    private final Stack<String> activeInstrumentClassNames = new Stack<String>();

    /**
     * Maps class names to instantiators for that class name.
     * Synchronized on the loader.
     */
    private final Map<String, ClassInstantiator> instantiators = PlasticInternalUtils.newMap();

    private final InheritanceData emptyInheritanceData = new InheritanceData(null);

    private final StaticContext emptyStaticContext = new StaticContext();

    private final List<PlasticClassListener> listeners = new CopyOnWriteArrayList<PlasticClassListener>();

    private final Cache<String, TypeCategory> typeName2Category = new Cache<String, TypeCategory>()
    {
        @Override
        protected TypeCategory convert(String typeName)
        {
            ClassNode cn = constructClassNodeFromBytecode(typeName);

            return Modifier.isInterface(cn.access) ? TypeCategory.INTERFACE : TypeCategory.CLASS;
        }
    };

    static class BaseClassDef
    {
        final InheritanceData inheritanceData;

        final StaticContext staticContext;

        public BaseClassDef(InheritanceData inheritanceData, StaticContext staticContext)
        {
            this.inheritanceData = inheritanceData;
            this.staticContext = staticContext;
        }
    }

    /**
     * Map from FQCN to BaseClassDef. Synchronized on the loader.
     */
    private final Map<String, BaseClassDef> baseClassDefs = PlasticInternalUtils.newMap();


    private final Map<String, FieldInstrumentations> instrumentations = PlasticInternalUtils.newMap();

    private final Map<String, String> transformedClassNameToImplementationClassName = PlasticInternalUtils.newMap();


    private final FieldInstrumentations placeholder = new FieldInstrumentations(null);


    private final Set<TransformationOption> options;

    /**
     * Creates the pool with a set of controlled packages; all classes in the controlled packages are loaded by the
     * pool's class loader, and all top-level classes in the controlled packages are transformed via the delegate.
     *
     * @param parentLoader
     *         typically, the Thread's context class loader
     * @param delegate
     *         responsible for end stages of transforming top-level classes
     * @param controlledPackages
     *         set of package names (note: retained, not copied)
     * @param options
     *         used when transforming classes
     */
    public PlasticClassPool(ClassLoader parentLoader, PlasticManagerDelegate delegate, Set<String> controlledPackages,
                            Set<TransformationOption> options)
    {
        loader = new PlasticClassLoader(parentLoader, this);
        this.delegate = delegate;
        this.controlledPackages = controlledPackages;
        this.options = options;
    }

    public ClassLoader getClassLoader()
    {
        return loader;
    }

    public Class realizeTransformedClass(ClassNode classNode, InheritanceData inheritanceData,
                                         StaticContext staticContext)
    {
        synchronized (loader)
        {
            Class result = realize(PlasticInternalUtils.toClassName(classNode.name), ClassType.PRIMARY, classNode);
            baseClassDefs.put(result.getName(), new BaseClassDef(inheritanceData, staticContext));

            return result;
        }

    }

    public Class realize(String primaryClassName, ClassType classType, ClassNode classNode)
    {
        synchronized (loader)
        {
            if (!listeners.isEmpty())
            {
                fire(toEvent(primaryClassName, classType, classNode));
            }

            byte[] bytecode = toBytecode(classNode);

            String className = PlasticInternalUtils.toClassName(classNode.name);

            return loader.defineClassWithBytecode(className, bytecode);
        }
    }

    private PlasticClassEvent toEvent(final String primaryClassName, final ClassType classType,
                                      final ClassNode classNode)
    {
        return new PlasticClassEvent()
        {
            @Override
            public ClassType getType()
            {
                return classType;
            }

            @Override
            public String getPrimaryClassName()
            {
                return primaryClassName;
            }

            @Override
            public String getDissasembledBytecode()
            {
                return PlasticInternalUtils.dissasembleBytecode(classNode);
            }

            @Override
            public String getClassName()
            {
                return PlasticInternalUtils.toClassName(classNode.name);
            }
        };
    }

    private void fire(PlasticClassEvent event)
    {
        for (PlasticClassListener listener : listeners)
        {
            listener.classWillLoad(event);
        }
    }

    private byte[] toBytecode(ClassNode classNode)
    {
        ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);

        classNode.accept(writer);

        return writer.toByteArray();
    }

    public AnnotationAccess createAnnotationAccess(String className)
    {
        try
        {
            final Class<?> searchClass = loader.loadClass(className);

            return new AnnotationAccess()
            {
                @Override
                public <T extends Annotation> boolean hasAnnotation(Class<T> annotationType)
                {
                    return getAnnotation(annotationType) != null;
                }

                @Override
                public <T extends Annotation> T getAnnotation(Class<T> annotationType)
                {
                    return searchClass.getAnnotation(annotationType);
                }
            };
        } catch (Exception ex)
        {
            throw new RuntimeException(ex);
        }
    }

    public AnnotationAccess createAnnotationAccess(List<AnnotationNode> annotationNodes)
    {
        if (annotationNodes == null)
        {
            return EmptyAnnotationAccess.SINGLETON;
        }

        final Map<String, Object> cache = PlasticInternalUtils.newMap();
        final Map<String, AnnotationNode> nameToNode = PlasticInternalUtils.newMap();

        for (AnnotationNode node : annotationNodes)
        {
            nameToNode.put(PlasticInternalUtils.objectDescriptorToClassName(node.desc), node);
        }

        return new AnnotationAccess()
        {
            @Override
            public <T extends Annotation> boolean hasAnnotation(Class<T> annotationType)
            {
                return nameToNode.containsKey(annotationType.getName());
            }

            @Override
            public <T extends Annotation> T getAnnotation(Class<T> annotationType)
            {
                String className = annotationType.getName();

                Object result = cache.get(className);

                if (result == null)
                {
                    result = buildAnnotation(className);

                    if (result != null)
                        cache.put(className, result);
                }

                return annotationType.cast(result);
            }

            private Object buildAnnotation(String className)
            {
                AnnotationNode node = nameToNode.get(className);

                if (node == null)
                    return null;

                return createAnnotation(className, node);
            }
        };
    }

    Class loadClass(String className)
    {
        try
        {
            return loader.loadClass(className);
        } catch (Exception ex)
        {
            throw new RuntimeException(String.format("Unable to load class %s: %s", className,
                    PlasticInternalUtils.toMessage(ex)), ex);
        }
    }

    protected Object createAnnotation(String className, AnnotationNode node)
    {
        AnnotationBuilder builder = new AnnotationBuilder(loadClass(className), this);

        node.accept(builder);

        return builder.createAnnotation();
    }

    @Override
    public boolean shouldInterceptClassLoading(String className)
    {
        int searchFromIndex = className.length() - 1;

        while (true)
        {
            int dotx = className.lastIndexOf('.', searchFromIndex);

            if (dotx < 0)
                break;

            String packageName = className.substring(0, dotx);

            if (controlledPackages.contains(packageName))
                return true;

            searchFromIndex = dotx - 1;
        }

        return false;
    }

    // Hopefully the synchronized will not cause a deadlock

    @Override
    public synchronized Class<?> loadAndTransformClass(String className) throws ClassNotFoundException
    {
        // Inner classes are not transformed, but they are loaded by the same class loader.

        if (className.contains("$"))
        {
            return loadInnerClass(className);
        }

        // TODO: What about interfaces, enums, annotations, etc. ... they shouldn't be in the package, but
        // we should generate a reasonable error message.

        if (activeInstrumentClassNames.contains(className))
        {
            StringBuilder builder = new StringBuilder("");
            String sep = "";

            for (String name : activeInstrumentClassNames)
            {
                builder.append(sep);
                builder.append(name);

                sep = ", ";
            }

            throw new IllegalStateException(String.format("Unable to transform class %s as it is already in the process of being transformed; there is a cycle among the following classes: %s.",
                    className, builder));
        }

        activeInstrumentClassNames.push(className);

        try
        {

            InternalPlasticClassTransformation transformation = getPlasticClassTransformation(className);

            delegate.transform(transformation.getPlasticClass());

            ClassInstantiator createInstantiator = transformation.createInstantiator();
            ClassInstantiator configuredInstantiator = delegate.configureInstantiator(className, createInstantiator);

            instantiators.put(className, configuredInstantiator);

            return transformation.getTransformedClass();
        } finally
        {
            activeInstrumentClassNames.pop();
        }
    }

    private Class loadInnerClass(String className)
    {
        ClassNode classNode = constructClassNodeFromBytecode(className);

        interceptFieldAccess(classNode);

        return realize(className, ClassType.INNER, classNode);
    }

    private void interceptFieldAccess(ClassNode classNode)
    {
        for (MethodNode method : classNode.methods)
        {
            interceptFieldAccess(classNode.name, method);
        }
    }

    private void interceptFieldAccess(String classInternalName, MethodNode method)
    {
        InsnList insns = method.instructions;

        ListIterator it = insns.iterator();

        while (it.hasNext())
        {
            AbstractInsnNode node = (AbstractInsnNode) it.next();

            int opcode = node.getOpcode();

            if (opcode != GETFIELD && opcode != PUTFIELD)
            {
                continue;
            }

            FieldInsnNode fnode = (FieldInsnNode) node;

            String ownerInternalName = fnode.owner;

            if (ownerInternalName.equals(classInternalName))
            {
                continue;
            }

            FieldInstrumentation instrumentation = getFieldInstrumentation(ownerInternalName, fnode.name, opcode == GETFIELD);

            if (instrumentation == null)
            {
                continue;
            }

            // Replace the field access node with the appropriate method invocation.

            insns.insertBefore(fnode, new MethodInsnNode(INVOKEVIRTUAL, ownerInternalName, instrumentation.methodName, instrumentation.methodDescription));

            it.remove();
        }
    }


    /**
     * For a fully-qualified class name of an <em>existing</em> class, loads the bytes for the class
     * and returns a PlasticClass instance.
     *
     * @throws ClassNotFoundException
     */
    public InternalPlasticClassTransformation getPlasticClassTransformation(String className)
            throws ClassNotFoundException
    {
        assert PlasticInternalUtils.isNonBlank(className);

        ClassNode classNode = constructClassNodeFromBytecode(className);

        String baseClassName = PlasticInternalUtils.toClassName(classNode.superName);

        instrumentations.put(classNode.name, new FieldInstrumentations(classNode.superName));

        // TODO: check whether second parameter should really be null
        return createTransformation(baseClassName, classNode, null, false);
    }

    /**
     * @param baseClassName
     *         class from which the transformed class extends
     * @param classNode
     *         node for the class
     * @param implementationClassNode
     *         node for the implementation class. May be null.
     * @param proxy
     *         if true, the class is a new empty class; if false an existing class that's being transformed
     * @throws ClassNotFoundException
     */
    private InternalPlasticClassTransformation createTransformation(String baseClassName, ClassNode classNode, ClassNode implementationClassNode, boolean proxy)
            throws ClassNotFoundException
    {
        if (shouldInterceptClassLoading(baseClassName))
        {
            loader.loadClass(baseClassName);

            BaseClassDef def = baseClassDefs.get(baseClassName);

            assert def != null;

            return new PlasticClassImpl(classNode, implementationClassNode, this, def.inheritanceData, def.staticContext, proxy);
        }

        // When the base class is Object, or otherwise not in a transformed package,
        // then start with the empty
        return new PlasticClassImpl(classNode, implementationClassNode, this, emptyInheritanceData, emptyStaticContext, proxy);
    }

    /**
     * Constructs a class node by reading the raw bytecode for a class and instantiating a ClassNode
     * (via {@link ClassReader#accept(org.apache.tapestry5.internal.plastic.asm.ClassVisitor, int)}).
     *
     * @param className
     *         fully qualified class name
     * @return corresponding ClassNode
     */
    public ClassNode constructClassNodeFromBytecode(String className)
    {
        byte[] bytecode = readBytecode(className);

        if (bytecode == null)
            return null;

        return PlasticInternalUtils.convertBytecodeToClassNode(bytecode);
    }

    private byte[] readBytecode(String className)
    {
        ClassLoader parentClassLoader = loader.getParent();

        return PlasticInternalUtils.readBytecodeForClass(parentClassLoader, className, true);
    }

    public PlasticClassTransformation createTransformation(String baseClassName, String newClassName)
    {
        return createTransformation(baseClassName, newClassName, null);
    }

    public PlasticClassTransformation createTransformation(String baseClassName, String newClassName, String implementationClassName)
    {
        try
        {
            ClassNode newClassNode = new ClassNode();

            final String internalNewClassNameinternalName = PlasticInternalUtils.toInternalName(newClassName);
            final String internalBaseClassName = PlasticInternalUtils.toInternalName(baseClassName);
            newClassNode.visit(PlasticConstants.DEFAULT_VERSION_OPCODE, ACC_PUBLIC, internalNewClassNameinternalName, null, internalBaseClassName, null);

            ClassNode implementationClassNode = null;

            if (implementationClassName != null)
            {
                // When decorating or advising a service, implementationClassName is the name
                // of a proxy class already, such as "$ServiceName_[random string]",
                // which doesn't exist as a file in the classpath, just in memory.
                // So we need to keep what's the original implementation class name
                // for each proxy, even a proxy around a proxy.
                if (transformedClassNameToImplementationClassName.containsKey(implementationClassName))
                {
                    implementationClassName =
                            transformedClassNameToImplementationClassName.get(implementationClassName);
                }

                if (!implementationClassName.startsWith("com.sun.proxy"))
                {

                    try
                    {
                        implementationClassNode = readClassNode(implementationClassName);
                    } catch (IOException e)
                    {
                        LOGGER.warn(String.format("Unable to load class %s as the implementation of service %s",
                                implementationClassName, baseClassName));
                        // Go on. Probably a proxy class
                    }

                }

                transformedClassNameToImplementationClassName.put(newClassName, implementationClassName);

            }

            return createTransformation(baseClassName, newClassNode, implementationClassNode, true);
        } catch (ClassNotFoundException ex)
        {
            throw new RuntimeException(String.format("Unable to create class %s as sub-class of %s: %s", newClassName,
                    baseClassName, PlasticInternalUtils.toMessage(ex)), ex);
        }

    }

    private ClassNode readClassNode(String className) throws IOException
    {
        return readClassNode(className, getClassLoader());
    }

    static ClassNode readClassNode(String className, ClassLoader classLoader) throws IOException
    {
        ClassNode classNode = new ClassNode();
        final String location = PlasticInternalUtils.toInternalName(className) + ".class";
        InputStream inputStream = classLoader.getResourceAsStream(location);
        BufferedInputStream bis = new BufferedInputStream(inputStream);
        ClassReader classReader = new ClassReader(inputStream);
        inputStream.close();
        bis.close();
        classReader.accept(classNode, 0);
        return classNode;

    }

    public ClassInstantiator getClassInstantiator(String className)
    {
        synchronized (loader)
        {
            if (!instantiators.containsKey(className))
            {
                try
                {
                    loader.loadClass(className);
                } catch (ClassNotFoundException ex)
                {
                    throw new RuntimeException(ex);
                }
            }

            ClassInstantiator result = instantiators.get(className);

            if (result == null)
            {
                // TODO: Verify that the problem is incorrect package, and not any other failure.

                StringBuilder b = new StringBuilder();
                b.append("Class '")
                        .append(className)
                        .append("' is not a transformed class. Transformed classes should be in one of the following packages: ");

                String sep = "";

                List<String> names = new ArrayList<String>(controlledPackages);
                Collections.sort(names);

                for (String name : names)
                {
                    b.append(sep);
                    b.append(name);

                    sep = ", ";
                }

                String message = b.append('.').toString();

                throw new IllegalArgumentException(message);
            }

            return result;
        }
    }

    TypeCategory getTypeCategory(String typeName)
    {
        synchronized (loader)
        {
            // TODO: Is this the right place to cache this data?

            return typeName2Category.get(typeName);
        }
    }

    @Override
    public void addPlasticClassListener(PlasticClassListener listener)
    {
        assert listener != null;

        listeners.add(listener);
    }

    @Override
    public void removePlasticClassListener(PlasticClassListener listener)
    {
        assert listener != null;

        listeners.remove(listener);
    }

    boolean isEnabled(TransformationOption option)
    {
        return options.contains(option);
    }


    void setFieldReadInstrumentation(String classInternalName, String fieldName, FieldInstrumentation fi)
    {
        instrumentations.get(classInternalName).read.put(fieldName, fi);
    }


    private FieldInstrumentations getFieldInstrumentations(String classInternalName)
    {
        FieldInstrumentations result = instrumentations.get(classInternalName);

        if (result != null)
        {
            return result;
        }

        String className = PlasticInternalUtils.toClassName(classInternalName);

        // If it is a top-level (not inner) class in a controlled package, then we
        // will recursively load the class, to identify any field instrumentations
        // in it.
        if (!className.contains("$") && shouldInterceptClassLoading(className))
        {
            try
            {
                loadAndTransformClass(className);

                // The key is written into the instrumentations map as a side-effect
                // of loading the class.
                return instrumentations.get(classInternalName);
            } catch (Exception ex)
            {
                throw new RuntimeException(PlasticInternalUtils.toMessage(ex), ex);
            }
        }

        // Either a class outside of controlled packages, or an inner class. Use a placeholder
        // that contains empty maps.

        result = placeholder;
        instrumentations.put(classInternalName, result);

        return result;
    }

    FieldInstrumentation getFieldInstrumentation(String ownerClassInternalName, String fieldName, boolean forRead)
    {
        String currentName = ownerClassInternalName;

        while (true)
        {

            if (currentName == null)
            {
                return null;
            }

            FieldInstrumentations instrumentations = getFieldInstrumentations(currentName);

            FieldInstrumentation instrumentation = instrumentations.get(fieldName, forRead);

            if (instrumentation != null)
            {
                return instrumentation;
            }

            currentName = instrumentations.superClassInternalName;
        }
    }


    void setFieldWriteInstrumentation(String classInternalName, String fieldName, FieldInstrumentation fi)
    {
        instrumentations.get(classInternalName).write.put(fieldName, fi);
    }

    boolean isCheckedException(String exceptionName)
    {
        Boolean cached = checkedExceptionCache.get(exceptionName);

        if (cached != null)
        {
            return cached;
        }

        try
        {
            Class asClass = getClassLoader().loadClass(exceptionName);


            boolean checked = !(Error.class.isAssignableFrom(asClass) ||
                    RuntimeException.class.isAssignableFrom(asClass));

            checkedExceptionCache.put(exceptionName, checked);

            return checked;
        } catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
}