package org.andromda.maven.plugin.andromdapp.script;

import java.io.File;
import java.net.URL;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtField;
import javassist.CtMethod;
import javassist.LoaderClassPath;
import javassist.Modifier;
import javassist.NotFoundException;
import org.andromda.core.common.ExceptionUtils;
import org.apache.commons.lang.StringUtils;

/**
 * This class instruments a given class file in order for it be scripted.  A class modified
 * by this script generator can have its methods edited and the logic available without having
 * to redeploy or compile the class.
 *
 * @author Chad Brandon
 */
public final class ScriptClassGenerator
{
    /**
     * The shared instance of this class.
     */
    private static ScriptClassGenerator instance;

    /**
     * The name of the script wrapper to use.
     */
    private String scriptWrapperName;

    /**
     * Retrieves an instance of this class and uses the given script wrapper with
     * the given <code>scriptWrapperName</code>.
     *
     * @param scriptWrapperName the fully qualified name of the script wrapper class to use.
     * @return the instance of this class.
     */
    public static final ScriptClassGenerator getInstance(final String scriptWrapperName)
    {
        ExceptionUtils.checkEmpty(
            "scriptWrapperName",
            scriptWrapperName);
        instance = new ScriptClassGenerator();
        instance.scriptWrapperName = scriptWrapperName;
        return instance;
    }

    private ScriptClassGenerator()
    {
        // - do not allow instantiation
    }

    /**
     * Modifies the <code>existingClass</code> (basically inserts the script wrapper class into
     * the class).
     * @param scriptDirectory the directory in which to find the script.
     * @param existingClass the class to modify.
     */
    public void modifyClass(
        final String scriptDirectory,
        final Class existingClass)
    {
        try
        {
            final String className = existingClass.getName();

            final ClassPool pool = ClassPool.getDefault();
            final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
            if (contextClassLoader != null)
            {
                pool.insertClassPath(new LoaderClassPath(contextClassLoader));
            }
            final CtClass ctClass = pool.get(className);

            // - make sure the class isn't frozen
            ctClass.defrost();

            final String scriptWrapperFieldName = "scriptWrapper";
            try
            {
                ctClass.getField(scriptWrapperFieldName);
            }
            catch (Exception exception)
            {
                final CtField scriptWrapper =
                    new CtField(
                        convert(
                            pool,
                            this.scriptWrapperName),
                        scriptWrapperFieldName,
                        ctClass);
                scriptWrapper.setModifiers(Modifier.PRIVATE + Modifier.FINAL);
                ctClass.addField(
                    scriptWrapper,
                    getScriptWrapperInitialization(
                        scriptDirectory,
                        className));
            }

            final CtMethod[] existingMethods = ctClass.getDeclaredMethods();
            for (int ctr = 0; ctr < existingMethods.length; ctr++)
            {
                final CtMethod method = existingMethods[ctr];
                if (!Modifier.isStatic(method.getModifiers()))
                {
                    final CtClass returnType = method.getReturnType();
                    String methodBody;
                    if (returnType.equals(CtClass.voidType))
                    {
                        methodBody =
                                '{' + constructArgumentString(method) + "scriptWrapper.invoke(\"" + method.getName() +
                            "\", arguments);}";
                    }
                    else
                    {
                        if (returnType.isPrimitive())
                        {
                            methodBody =
                                    '{' + constructArgumentString(method) + " return ((" + getWrapperTypeName(returnType) +
                                ")scriptWrapper.invoke(\"" + method.getName() + "\", arguments))." +
                                returnType.getName() + "Value();}";
                        }
                        else
                        {
                            methodBody =
                                    '{' + constructArgumentString(method) + " return (" + method.getReturnType().getName() +
                                ")scriptWrapper.invoke(\"" + method.getName() + "\", arguments);}";
                        }
                    }
                    method.setBody(methodBody);
                }
            }

            final File directory = getClassOutputDirectory(existingClass);
            ctClass.writeFile(directory.getAbsolutePath());
        }
        catch (final Throwable throwable)
        {
            throwable.printStackTrace();
            throw new ScriptClassGeneratorException(throwable);
        }
    }

    /**
     * Retrieves the output directory which the adapted class will be written to.
     *
     * @return the output directory
     */
    private File getClassOutputDirectory(final Class existingClass)
    {
        final String className = existingClass.getName();
        final String classResourcePath = '/' + className.replace(
            '.',
            '/') + ".class";
        final URL classResource = existingClass.getResource(classResourcePath);
        if (classResource == null)
        {
            throw new ScriptClassGeneratorException("Could not find the class resource '" + classResourcePath + '\'');
        }
        final String file = classResource.getFile().replaceAll(".*(\\\\|//)", "/");
        return new File(StringUtils.replace(file, classResourcePath, ""));
    }

    private String constructArgumentString(final CtMethod method)
        throws NotFoundException
    {
        CtClass[] argumentTypes = method.getParameterTypes();
        final int argumentNumber = argumentTypes.length;
        final StringBuilder arguments =
            new StringBuilder("final Object[] arguments = new Object[" + argumentNumber + "];");
        for (int ctr = 1; ctr <= argumentNumber; ctr++)
        {
            final CtClass argumentType = argumentTypes[ctr - 1];
            arguments.append("arguments[").append(ctr - 1).append("] = ");
            if (argumentType.isPrimitive())
            {
                arguments.append("new java.lang.").append(getWrapperTypeName(argumentType)).append("($").append(ctr).append(");");
            }
            else
            {
                arguments.append('$').append(ctr).append(';');
            }
        }
        return arguments.toString();
    }

    private String getWrapperTypeName(CtClass ctClass)
    {
        final String typeName = ctClass.getName();
        StringBuilder name = new StringBuilder(typeName);
        if ("int".equalsIgnoreCase(typeName))
        {
            name.append("eger");
        }
        return StringUtils.capitalize(name.toString());
    }

    private String getScriptWrapperInitialization(
        final String directory,
        final String className)
    {
        return "new " + this.scriptWrapperName + "(this, \"" +
        new File(
            directory,
            className.replace(
                '.',
                '/')).getAbsolutePath().replace(
            '\\',
            '/') + ".java" + "\");";
    }

    /**
     * Converts the given <code>clazz</code> to a CtClass instances.
     *
     * @param pool the pool from which to retrieve the CtClass instance.
     * @param clazz the class to convert.
     * @return the CtClass instances.
     * @throws NotFoundException
     */
    private CtClass convert(
        final ClassPool pool,
        final String className)
        throws NotFoundException
    {
        CtClass ctClass = null;
        if (className != null)
        {
            ctClass = pool.get(className);
        }
        return ctClass;
    }
}