// Copyright 2006, 2007, 2008 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.transform;

import org.apache.tapestry5.MarkupWriter;
import org.apache.tapestry5.internal.util.MethodInvocationBuilder;
import org.apache.tapestry5.ioc.internal.util.InternalUtils;
import org.apache.tapestry5.ioc.util.BodyBuilder;
import org.apache.tapestry5.model.MutableComponentModel;
import org.apache.tapestry5.services.ClassTransformation;
import org.apache.tapestry5.services.ComponentClassTransformWorker;
import org.apache.tapestry5.services.MethodFilter;
import org.apache.tapestry5.services.TransformMethodSignature;

import java.lang.annotation.Annotation;
import java.util.Iterator;
import java.util.List;

/**
 * Converts one of the methods of {@link org.apache.tapestry5.runtime.Component} into a chain of command that, itself,
 * invokes certain methods (render phase methods) marked with an annotation, or named in a specific way.
 */
public class RenderPhaseMethodWorker implements ComponentClassTransformWorker
{
    private static final String CHECK_ABORT_FLAG = "if ($2.isAborted()) return;";

    private final Class<? extends Annotation> methodAnnotation;

    private final TransformMethodSignature lifecycleMethodSignature;

    private final String lifecycleMethodName;

    private final boolean reverse;

    private final MethodInvocationBuilder invocationBuilder = new MethodInvocationBuilder();

    /**
     * Normal method invocation: parent class, then methods in ascending alphabetical order. Reverse order: method in
     * descending alphabetical order, then parent class.
     *
     * @param lifecycleMethodSignature the signature of the method to be implemented in the component class
     * @param methodAnnotation         the class of the corresponding annotation
     * @param reverse                  if true, the normal method invocation order is reversed
     */
    public RenderPhaseMethodWorker(TransformMethodSignature lifecycleMethodSignature,
                                   Class<? extends Annotation> methodAnnotation, boolean reverse)
    {
        this.lifecycleMethodSignature = lifecycleMethodSignature;
        this.methodAnnotation = methodAnnotation;
        this.reverse = reverse;
        lifecycleMethodName = lifecycleMethodSignature.getMethodName();

        // If we ever add more parameters to the methods, then we can add more to the invocation
        // builder.
        // *Never* expose the Event parameter ($2), it is for internal use only.

        invocationBuilder.addParameter(MarkupWriter.class.getName(), "$1");
    }

    @Override
    public String toString()
    {
        return String.format("RenderPhaseMethodWorker[%s]", methodAnnotation.getName());
    }

    public void transform(final ClassTransformation transformation, MutableComponentModel model)
    {
        MethodFilter filter = new MethodFilter()
        {
            public boolean accept(TransformMethodSignature signature)
            {
                // These methods get added to base classes and otherwise fall into this filter. If
                // we don't include this filter, then we get endless loops.

                if (signature.equals(lifecycleMethodSignature)) return false;

                // A degenerate case would be a method, say beginRender(), with an conflicting
                // annotation, say @AfterRender. In that case, this code is broken, as the method
                // will be invoked for both phases!

                return (correctName(signature) || correctAnnotation(signature)) &&
                        !transformation.isMethodOverride(signature);
            }

            private boolean correctAnnotation(TransformMethodSignature signature)
            {
                return transformation.getMethodAnnotation(signature, methodAnnotation) != null;
            }

            private boolean correctName(TransformMethodSignature signature)
            {
                return signature.getMethodName().equals(lifecycleMethodName);
            }
        };

        List<TransformMethodSignature> methods = transformation.findMethods(filter);

        // Except in the root class, don't bother to add a new method unless there's something to
        // call (beside super).

        if (methods.isEmpty()) return;

        model.addRenderPhase(methodAnnotation);

        BodyBuilder builder = new BodyBuilder();
        builder.begin();

        // If in a subclass, and in normal order mode, invoke the super class version first.

        if (!(reverse || model.isRootClass()))
        {
            builder.addln("super.%s($$);", lifecycleMethodName);
            builder.addln(CHECK_ABORT_FLAG);
        }

        Iterator<TransformMethodSignature> i = reverse ? InternalUtils.reverseIterator(methods) : methods
                .iterator();

        builder.addln("try");
        builder.begin();

        while (i.hasNext())
            addMethodCallToBody(builder, i.next(), transformation);

        // In reverse order in a a subclass, invoke the super method last.

        if (reverse && !model.isRootClass()) builder.addln("super.%s($$);", lifecycleMethodName);


        builder.end(); // try

        // Let runtime exceptions work up (they'll be caught at a higher level.
        // Wrap checked exceptions for later reporting.

        builder.addln("catch (RuntimeException ex) { throw ex; }");
        builder.addln("catch (Exception ex) { throw new RuntimeException(ex); }");

        builder.end();

        // Let's see if this works; for base classes, we are adding an empty method the adding a
        // non-empty
        // method "on top of it".

        transformation.addMethod(lifecycleMethodSignature, builder.toString());
    }


    private void addMethodCallToBody(BodyBuilder builder, TransformMethodSignature sig,
                                     ClassTransformation transformation)
    {
        boolean isVoid = sig.getReturnType().equals("void");

        builder.addln("$2.setMethodDescription(\"%s\");", transformation.getMethodIdentifier(sig));

        if (!isVoid)
        {
            // If we're not going to invoke storeResult(), then there's no reason to invoke
            // setMethodDescription().

            builder.add("if ($2.storeResult(($w) ");
        }

        // This is the best part; the method can even be private and this still works. It's a lot
        // like how javac enables access to private members for inner classes (by introducing
        // synthetic, static methods).

        builder.add(invocationBuilder.buildMethodInvocation(sig, transformation));

        // Now, if non void ...

        if (!isVoid)
        {
            // Complete the call to storeResult(). If storeResult() returns true, then
            // the event is aborted and no further processing is required.

            builder.addln(")) return;");
        }
        else
            builder.addln(";");
    }
}