/FileExtraction/Java_unseen/dlitz_resin/modules/kernel/src/com/caucho/config/gen/BeanGenerator.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.config.gen;

import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.enterprise.inject.spi.AnnotatedMethod;
import javax.enterprise.inject.spi.AnnotatedType;
import javax.interceptor.InterceptorBinding;
import javax.interceptor.Interceptors;

import com.caucho.config.reflect.AnnotatedMethodImpl;
import com.caucho.inject.Module;
import com.caucho.java.JavaWriter;
import com.caucho.java.gen.DependencyComponent;
import com.caucho.java.gen.GenClass;
import com.caucho.make.ClassDependency;
import com.caucho.make.VersionDependency;
import com.caucho.vfs.PersistentDependency;

/**
 * Generates the skeleton for a bean.
 */
@Module
abstract public class BeanGenerator<X> extends GenClass
{
  private final AnnotatedType<X> _beanType;
  
  private DependencyComponent _dependency = new DependencyComponent();

  protected BeanGenerator(String fullClassName,
                          AnnotatedType<X> beanType)
  {
    super(fullClassName);
    
    _beanType = beanType;

    addDependency(new VersionDependency());
    addDependency(beanType.getJavaClass());
  }

  public AnnotatedType<X> getBeanType()
  {
    return _beanType;
  }

  protected void addDependency(PersistentDependency depend)
  {
    _dependency.addDependency(depend);
  }

  protected void addDependency(Class<?> cl)
  {
    _dependency.addDependency(new ClassDependency(cl));
  }

  public String getBeanClassName()
  {
    return getBeanType().getJavaClass().getName();
  }

  public String getViewClassName()
  {
    throw new UnsupportedOperationException(getClass().getName());
  }

  public boolean isRemote()
  {
    return false;
  }
  
  public boolean isProxy()
  {
    return false;
  }

  /**
   * Returns the introspected methods
   */
  public ArrayList<AspectGenerator<X>> getMethods()
  {
    throw new UnsupportedOperationException(getClass().getName());
  }
  
  protected abstract AspectBeanFactory<X> getAspectBeanFactory();
  
  protected AspectBeanFactory<X> getLifecycleAspectFactory()
  {
    return getAspectBeanFactory();
  }

  public void introspect()
  {
    
  }
  
  //
  // Java generation
  //
  
  public void generateClassStaticFields(JavaWriter out)
    throws IOException
  {
    out.println("private static final java.util.logging.Logger __caucho_log");
    out.println("  = java.util.logging.Logger.getLogger(\"" + getFullClassName() + "\");");
    out.println("private static RuntimeException __caucho_exception;");
    
    out.println();
    out.println("public static RuntimeException __caucho_getException()");
    out.println("{");
    out.println("  return __caucho_exception;");
    out.println("}");
  }
  
  /**
   * Generates the view contents
   */
  /*
  @Override
  abstract public void generate(JavaWriter out)
    throws IOException;
    */

  /**
   * Generates the view contents
   */
  public void generateDestroyViews(JavaWriter out)
    throws IOException
  {
    // view.generateDestroy(out);
  }

  /**
   * Generates context object's constructor
   */
  public void generateContextObjectConstructor(JavaWriter out)
    throws IOException
  {
  }

  /**
   * Generates timer code
   */
  public void generateTimer(JavaWriter out)
    throws IOException
  {
  }

  /**
   * Frees a bean instance.
   */
  public void generateFreeInstance(JavaWriter out, String name)
    throws IOException
  {
    throw new UnsupportedOperationException(getClass().getName());
  }

  /**
   * Generates any global destroy
   */
  public void generateDestroy(JavaWriter out, HashMap<String,Object> map)
    throws IOException
  {
    generatePreDestroy(out, map);
    
    out.println();
    out.println("public void __caucho_destroy(com.caucho.config.inject.CreationalContextImpl env)");
    out.println("{");
    out.pushDepth();
    
    out.println("__caucho_preDestroy();");

    generateDestroyImpl(out);

    out.popDepth();
    out.println("}");
  }
  
  protected void generateDestroyImpl(JavaWriter out)
    throws IOException
  {
    HashMap<String,Object> map = new HashMap<String,Object>();
    for (AspectGenerator<X> method : getMethods()) {
      method.generateDestroy(out, map);
    }
  }

  /**
   * Generates constructor additions
   */
  public void generateProxyConstructor(JavaWriter out)
    throws IOException
  {
    HashMap<String,Object> map = new HashMap<String,Object>();
    generateProxyConstructor(out, map);
  }

  /**
   * Generates constructor additions
   */
  public void generateProxyConstructor(JavaWriter out, 
                                       HashMap<String,Object> map)
    throws IOException
  {
    for (AspectGenerator<X> method : getMethods()) {
      method.generateProxyConstructor(out, map);
    }
  }

  /**
   * Generates constructor additions
   */
  public void generateBeanConstructor(JavaWriter out)
    throws IOException
  {
    HashMap<String,Object> map = new HashMap<String,Object>();
    generateBeanConstructor(out, map);
  }

  /**
   * Generates constructor additions
   */
  public void generateBeanConstructor(JavaWriter out, 
                                      HashMap<String,Object> map)
    throws IOException
  {
    for (AspectGenerator<X> method : getMethods()) {
      method.generateBeanConstructor(out, map);
    }
  }

  /**
   * Generates prologue additions
   */
  public void generateBeanPrologue(JavaWriter out, 
                                   HashMap<String,Object> map)
    throws IOException
  {
    for (AspectGenerator<X> method : getMethods()) {
      method.generateBeanPrologue(out, map);
    }
  }

  protected void generateInject(JavaWriter out,
                                HashMap<String,Object> map)
    throws IOException
  {
    out.println();
    out.println("public Object []__caucho_inject(Object []delegates"
                + ", Object []interceptors"
                + ", com.caucho.config.inject.CreationalContextImpl<?> parentEnv)");
    out.println("{");
    out.pushDepth();

    generateInjectContent(out, map);

    out.println("return interceptors;");
    
    out.popDepth();
    out.println("}");
  }

  protected void generateInjectContent(JavaWriter out,
                                       HashMap<String,Object> map)
    throws IOException
  {
    for (AspectGenerator<X> method : getMethods()) {
      method.generateInject(out, map);
    }

    getAspectBeanFactory().generateInject(out, map);
  }

  protected void generateDelegate(JavaWriter out,
                                HashMap<String,Object> map)
    throws IOException
  {
    out.println();
    out.println("public Object __caucho_getDelegate()");
    out.println("{");
    out.print("  return ");
    out.print(getAspectBeanFactory().getBeanInstance());
    out.println(";");
    out.println("}");
  }

  protected void generatePostConstruct(JavaWriter out, 
                                       HashMap<String,Object> map)
     throws IOException
  {
    generatePostConstructImpl(out, map);
  }
  
  protected void generatePostConstructImpl(JavaWriter out, 
                                           HashMap<String,Object> map)
       throws IOException
  {
    ArrayList<Method> postConstructMethods 
      = getLifecycleAspects(PostConstruct.class);
    
    if (postConstructMethods.size() == 0
        && getBeanType().isAnnotationPresent(Interceptors.class)) {
      generateDummyPostConstruct(postConstructMethods, out, map);
    }
    
    // postConstructMethods = getLifecycleAspects(PostConstruct.class);
    
    out.println();
    out.println("public void __caucho_postConstruct()");
    out.println("  throws Exception");
    out.println("{");
    out.pushDepth();

    // postConstructMethods = getLifecycleMethods(PostConstruct.class);
    
    /*
    for (AspectGenerator<?> method : getLifecycleAspects(PostConstruct.class)) {
      // method.generatePostConstruct(out, map);
      
    }
    */

    Method postConstructMethod = null;
    int methodsSize = postConstructMethods.size();
    for (int i = 0; i < methodsSize && postConstructMethod == null; i++) {
      Method method = postConstructMethods.get(i);
      
      if (Modifier.isPrivate(method.getModifiers())
          && i + 1 < methodsSize) {
        // ejb/1064, ejb/1063
        continue;
      }
                             
      postConstructMethod = method;
    }

    // ejb/1060 - TCK
    boolean isLifecycle = false;
    for (int i = 0; i < methodsSize; i++) {
      Method method = postConstructMethods.get(i);

      if (postConstructMethod != method) {
        generateLifecycleMethod(out, i, method, "postConstruct");
      }
      else if (! isLifecycle) {
        isLifecycle = true;
        
        String declName = method.getDeclaringClass().getSimpleName();
        String methodName = method.getName();

        out.println("__caucho_lifecycle_" + declName + "_" + methodName + "();");
      }
    }
    
    /*
    // ejb/4018, ejb/1060 - TCK
    for (int i = 0; i < methodsSize; i++) {
      Method method = postConstructMethods.get(i);
      
      String declName = method.getDeclaringClass().getSimpleName();
      String methodName = method.getName();

      out.println("__caucho_lifecycle_" + declName + "_" + methodName + "();");
    }
    */
      
    // getAspectBeanFactory().generatePostConstruct(out, map);

    out.popDepth();
    out.println("}");
    
    generateLifecycleMethodReflection(out, postConstructMethods, "postConstruct");
    
    out.println();
    out.println("private void __caucho_postConstructImpl()");
    out.println("{");
    out.pushDepth();
    
    generateLifecycleMethods(out, postConstructMethods, "postConstruct");
    
    out.popDepth();
    out.println("}");
  }
  
  private void generateDummyPostConstruct(ArrayList<Method> postConstructMethods,
                                          JavaWriter out,
                                          HashMap<String,Object> map)
    throws IOException
  {
    if (postConstructMethods.size() > 0)
      throw new IllegalStateException();
    
    Method method = CandiUtil.getDummyPostConstruct();
    
    AnnotatedMethodImpl annMethod;
    annMethod = new AnnotatedMethodImpl(getBeanType(), null, method);
    annMethod.addAnnotation(new PostConstructLiteral());
    
    AspectGenerator<X> methodGen
      = getLifecycleAspectFactory().create(annMethod);
   
    if (methodGen != null) {
      methodGen.generate(out, map);
      
      out.println("public static void __caucho_CandiUtil_dummyPostConstruct_POST_CONSTRUCT() {}");
      
      postConstructMethods.add(method);
    }
  }

  private void generatePreDestroy(JavaWriter out, 
                                  HashMap<String,Object> map)
     throws IOException
  {
    ArrayList<Method> preDestroyMethods = getLifecycleAspects(PreDestroy.class);
    
    if (preDestroyMethods.size() == 0
        && isInterceptorPresent(getBeanType())) {
      generateDummyPreDestroy(preDestroyMethods, out, map);
    }
    
    out.println();
    out.println("public void __caucho_preDestroy()");
    out.println("{");
    out.pushDepth();

    for (Method method : preDestroyMethods) {
      String declName = method.getDeclaringClass().getSimpleName();
      String methodName = method.getName();
      
      out.println("__caucho_lifecycle_" + declName + "_" + methodName + "();");
    }
 
      
    // getAspectBeanFactory().generatePostConstruct(out, map);

    /*
    for (AspectGenerator<X> method : getMethods()) {
      method.generatePreDestroy(out, map);
    }
     
    getAspectBeanFactory().generatePreDestroy(out, map);
    */

    out.popDepth();
    out.println("}");
    
    generateLifecycleMethodReflection(out, preDestroyMethods, "preDestroy");
    
    out.println();
    out.println("private void __caucho_preDestroyImpl()");
    out.println("  throws Exception");
    out.println("{");
    out.pushDepth();
    
    generateLifecycleMethods(out, preDestroyMethods, "preDestroy");
    
    out.popDepth();
    out.println("}");
  }
  
  private boolean isInterceptorPresent(AnnotatedType<?> beanType)
  {
    for (Annotation ann : beanType.getAnnotations()) {
      Class<?> annType = ann.annotationType();
      
      if (Interceptors.class.equals(annType))
        return true;
      else if (annType.isAnnotationPresent(InterceptorBinding.class))
        return true;
    }
    
    return false;
  }
  
  private void generateDummyPreDestroy(ArrayList<Method> preDestroyMethods,
                                       JavaWriter out,
                                       HashMap<String,Object> map)
    throws IOException
  {
    if (preDestroyMethods.size() > 0)
      throw new IllegalStateException();
    
    Method method = CandiUtil.getDummyPreDestroy();
    
    AnnotatedMethodImpl annMethod;
    annMethod = new AnnotatedMethodImpl(getBeanType(), null, method);
    annMethod.addAnnotation(new PreDestroyLiteral());
    
    AspectGenerator<X> methodGen
      = getLifecycleAspectFactory().create(annMethod);
   
    if (methodGen != null) {
      methodGen.generate(out, map);
      
      out.println("public static void __caucho_CandiUtil_dummyPreDestroy_PRE_DESTROY() {}");
      
      preDestroyMethods.add(method);
    }
  }
  
  protected void generateLifecycleMethodReflection(JavaWriter out,
                                                   ArrayList<Method> methods,
                                                   String lifecycleType)
    throws IOException
  {
    for (int i = 0; i < methods.size(); i++) {
      Method method = methods.get(i);
      
      String methodName = "__caucho_" + lifecycleType + "_" + i;

      out.println();
      out.println("static final java.lang.reflect.Method " + methodName);
      
      out.print("  = ");
      
      out.printClass(CandiUtil.class);
      out.print(".findAccessibleMethod(");
      out.printClass(method.getDeclaringClass());
      out.print(".class, \"");
      out.print(method.getName());
      out.println("\");");
    }
  }
  
  protected void generateLifecycleMethods(JavaWriter out,
                                          ArrayList<Method> methods,
                                          String lifecycleType)
    throws IOException
  {
    for (int i = 0; i < methods.size(); i++) {
      generateLifecycleMethod(out, i, methods.get(i), lifecycleType);
    }
  }
  
  protected void generateLifecycleMethod(JavaWriter out,
                                         int i,
                                         Method method,
                                         String lifecycleType)
    throws IOException
  {
    out.println("try {");
    out.pushDepth();

    out.println("if (" + getLifecycleInstance() + " != null) {");
    out.pushDepth();
      
    out.print("__caucho_" + lifecycleType + "_" + i + ".invoke(");
    out.print(getLifecycleInstance());
    out.println(");");
      
    out.popDepth();
    out.println("}");
      
    out.popDepth();
    out.println("} catch (RuntimeException ex) {");
    out.println("  throw ex;");
    out.println("} catch (java.lang.reflect.InvocationTargetException ex) {");
    out.println("  if (ex.getCause() instanceof RuntimeException)");
    out.println("    throw (RuntimeException) ex.getCause();");
    out.println("  else");
    out.println("    throw new RuntimeException(ex);");
    out.println("} catch (Exception ex) {");
    out.println("  throw new RuntimeException(ex);");
    out.println("}");
  }
  
  protected String getLifecycleInstance()
  {
    return getAspectBeanFactory().getBeanInstance();
  }

  
  protected ArrayList<Method>
  getLifecycleMethods(Class<? extends Annotation> annType)
  {
    ArrayList<Method> methods = new ArrayList<Method>();
    
    for (AnnotatedMethod<? super X> method : getBeanType().getMethods()) {
      if (! method.isAnnotationPresent(annType))
        continue;
      
      if (method.getParameters().size() != 0)
        continue;
      
      methods.add(method.getJavaMember());
    }
    
    Collections.sort(methods, new PostConstructComparator());
    
    return methods;
  }
  
  protected ArrayList<Method> 
  getLifecycleAspects(Class<? extends Annotation> annType)
  {
    ArrayList<Method> aspects = new ArrayList<Method>();
    
    for (AspectGenerator<?> gen : getMethods()) {
      AnnotatedMethod<?> method = gen.getMethod();
      
      if (! method.isAnnotationPresent(annType))
        continue;
      
      if (method.getParameters().size() != 0)
        continue;
      
      aspects.add(method.getJavaMember());
    }
    
    
    Collections.sort(aspects, new PostConstructComparator());
    
    return aspects;
  }

  protected void generateEpilogue(JavaWriter out, HashMap<String,Object> map)
     throws IOException
  {
    getAspectBeanFactory().generateEpilogue(out, map);
  }

  /**
   * Generates view's business methods
   */
  public void generateBusinessMethods(JavaWriter out,
                                      HashMap<String,Object> map)
    throws IOException
  {
    for (AspectGenerator<X> method : getMethods()) {
      method.generate(out, map);
    }
  }

  protected void generateDependency(JavaWriter out)
    throws IOException
  {
    _dependency.generate(out);
  }

  @Override
  public String toString()
  {
    return (getClass().getSimpleName()
            + "[" + _beanType.getJavaClass().getSimpleName() + "]");
  }
  
  static class PostConstructComparator implements Comparator<Method> {
    @Override
    public int compare(Method a, Method b)
    {
      Class<?> classA = a.getDeclaringClass();
      Class<?> classB = b.getDeclaringClass();
      
      if (classA == classB)
        return a.getName().compareTo(b.getName());
      else if (classA.isAssignableFrom(classB))
        return -1;
      else if (classB.isAssignableFrom(classA))
        return 1;
      else
        return a.getName().compareTo(b.getName());
    }
  }
  
  static class PostConstructAspectComparator 
    implements Comparator<AspectGenerator<?>> {
    @Override
    public int compare(AspectGenerator<?> genA, AspectGenerator<?> genB)
    {
      Method a = genA.getMethod().getJavaMember();
      Method b = genB.getMethod().getJavaMember();
      
      Class<?> classA = a.getDeclaringClass();
      Class<?> classB = b.getDeclaringClass();
      
      if (classA == classB)
        return a.getName().compareTo(b.getName());
      else if (classA.isAssignableFrom(classB))
        return -1;
      else if (classB.isAssignableFrom(classA))
        return 1;
      else
        return a.getName().compareTo(b.getName());
    }
  }
}
