/*
 * Copyright 2008 Google Inc.
 * 
 * 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 com.google.gwt.junit.rebind;

import com.google.gwt.core.ext.Generator;
import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.NotFoundException;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
import com.google.gwt.user.rebind.SourceWriter;

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * This class generates a stub class for classes that derive from GWTTestCase.
 * This stub class provides the necessary bridge between our Hosted or Hybrid
 * mode classes and the JUnit system.
 */
public class JUnitTestCaseStubGenerator extends Generator {

  /**
   * An interface for filtering out methods.
   */
  protected interface MethodFilter {
    boolean accept(JMethod method);
  }

  /**
   * Like JClassType.getMethod(String name) except:
   * 
   * <li>it accepts a filter</li>
   * <li>it searches the inheritance hierarchy (includes superclasses)</li>
   * 
   * For methods which are overridden, only the most derived implementations are
   * included.
   * 
   * @param type the type to search (non-null)
   * @return the set of matching methods (non-null)
   */
  protected static Map<String, List<JMethod>> getAllMethods(JClassType type,
      MethodFilter filter) {
    Map<String, List<JMethod>> methods = new HashMap<String, List<JMethod>>();
    JClassType cls = type;

    while (cls != null) {
      JMethod[] clsDeclMethods = cls.getMethods();

      // For every method, include it iff our filter accepts it
      // and we don't already have a matching method
      for (int i = 0, n = clsDeclMethods.length; i < n; ++i) {

        JMethod declMethod = clsDeclMethods[i];

        if (!filter.accept(declMethod)) {
          continue;
        }

        List<JMethod> list = methods.get(declMethod.getName());

        if (list == null) {
          list = new ArrayList<JMethod>();
          methods.put(declMethod.getName(), list);
          list.add(declMethod);
          continue;
        }

        JParameter[] declParams = declMethod.getParameters();

        for (int j = 0; j < list.size(); ++j) {
          JMethod method = list.get(j);
          JParameter[] parameters = method.getParameters();
          if (!equals(declParams, parameters)) {
            list.add(declMethod);
          }
        }
      }
      cls = cls.getSuperclass();
    }

    return methods;
  }

  /**
   * Returns true if the method is considered to be a valid JUnit test method.
   * The criteria are that the method's name begin with "test" and have public
   * access. The method may be static. You must choose to include or exclude
   * methods which have arguments.
   */
  protected static boolean isJUnitTestMethod(JMethod method, boolean acceptArgs) {
    if (!method.getName().startsWith("test")) {
      return false;
    }

    if (!method.isPublic()) {
      return false;
    }

    return acceptArgs || method.getParameters().length == 0 && !acceptArgs;
  }

  /**
   * Returns true IFF the two sets of parameters are of the same lengths and
   * types.
   * 
   * @param params1 must not be null
   * @param params2 must not be null
   */
  private static boolean equals(JParameter[] params1, JParameter[] params2) {
    if (params1.length != params2.length) {
      return false;
    }
    for (int i = 0; i < params1.length; ++i) {
      if (params1[i].getType() != params2[i].getType()) {
        return false;
      }
    }
    return true;
  }

  /**
   * Returns the method names for the set of methods that are strictly JUnit
   * test methods (have no arguments).
   * 
   * @param requestedClass
   */
  private static String[] getTestMethodNames(JClassType requestedClass) {
    return getAllMethods(requestedClass, new MethodFilter() {
      public boolean accept(JMethod method) {
        return isJUnitTestMethod(method, false);
      }
    }).keySet().toArray(new String[] {});
  }

  protected TreeLogger logger;
  private String packageName;
  private String qualifiedStubClassName;
  private JClassType requestedClass;
  private String simpleStubClassName;
  private SourceWriter sourceWriter;
  private TypeOracle typeOracle;

  /**
   * Create a new type that satisfies the rebind request.
   */
  @Override
  public String generate(TreeLogger logger, GeneratorContext context,
      String typeName) throws UnableToCompleteException {

    if (!init(logger, context, typeName)) {
      return qualifiedStubClassName;
    }

    writeSource();
    sourceWriter.commit(logger);

    return qualifiedStubClassName;
  }

  protected JClassType getRequestedClass() {
    return requestedClass;
  }

  protected SourceWriter getSourceWriter() {
    return sourceWriter;
  }

  protected TypeOracle getTypeOracle() {
    return typeOracle;
  }

  @SuppressWarnings("unused")
  protected void writeSource() throws UnableToCompleteException {
    String[] testMethods = getTestMethodNames(requestedClass);
    writeDoRunTestMethod(testMethods, sourceWriter);
  }

  /**
   * Gets the name of the native stub class.
   */
  private String getSimpleStubClassName(JClassType baseClass) {
    return "__" + baseClass.getSimpleSourceName() + "_unitTestImpl";
  }

  private SourceWriter getSourceWriter(TreeLogger logger, GeneratorContext ctx,
      String packageName, String className, String superclassName) {

    PrintWriter printWriter = ctx.tryCreate(logger, packageName, className);
    if (printWriter == null) {
      return null;
    }

    ClassSourceFileComposerFactory composerFactory = new ClassSourceFileComposerFactory(
        packageName, className);

    composerFactory.setSuperclass(superclassName);

    return composerFactory.createSourceWriter(ctx, printWriter);
  }

  private boolean init(TreeLogger logger, GeneratorContext context,
      String typeName) throws UnableToCompleteException {
    this.logger = logger;
    typeOracle = context.getTypeOracle();
    assert typeOracle != null;

    try {
      requestedClass = typeOracle.getType(typeName);
    } catch (NotFoundException e) {
      logger.log(
          TreeLogger.ERROR,
          "Could not find type '"
              + typeName
              + "'; please see the log, as this usually indicates a previous error ",
          e);
      throw new UnableToCompleteException();
    }

    // Get the stub class name, and see if its source file exists.
    //
    simpleStubClassName = getSimpleStubClassName(requestedClass);
    packageName = requestedClass.getPackage().getName();
    qualifiedStubClassName = packageName + "." + simpleStubClassName;

    sourceWriter = getSourceWriter(logger, context, packageName,
        simpleStubClassName, requestedClass.getQualifiedSourceName());

    return sourceWriter != null;
  }

  private void writeDoRunTestMethod(String[] testMethodNames, SourceWriter sw) {
    sw.println();
    sw.println("protected final void doRunTest(String name) throws Throwable {");
    sw.indent();
    for (int i = 0, n = testMethodNames.length; i < n; ++i) {
      String methodName = testMethodNames[i];

      if (i > 0) {
        sw.print("else ");
      }

      sw.println("if (name.equals(\"" + methodName + "\")) {");
      sw.indentln(methodName + "();");
      sw.println("}");
    }
    sw.outdent();
    sw.println("}"); // finish doRunTest();
  }

}