/*
 * 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.dev.javac.typemodel;

import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.HasAnnotations;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.NotFoundException;
import com.google.gwt.dev.javac.typemodel.test.AnnotatedClass;
import com.google.gwt.dev.javac.typemodel.test.ClassAnnotatedWithBinaryOnlyAnnotation;
import com.google.gwt.dev.javac.typemodel.test.ClassLiteralReferenceAnnotation;
import com.google.gwt.dev.javac.typemodel.test.PrimitiveValuesAnnotation;
import com.google.gwt.dev.javac.typemodel.test.PrimitivesAnnotatedClass;
import com.google.gwt.dev.javac.typemodel.test.SourceRetentionAnnotation;
import com.google.gwt.dev.javac.typemodel.test.TestAnnotation;
import com.google.gwt.dev.util.log.PrintWriterTreeLogger;

import junit.framework.TestCase;

import java.io.File;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * Test cases for the {@link TypeOracle}'s {@link Annotation} support.
 * 
 * Array annotations Enum annotations String from field annotations
 */
public class TypeOracleAnnotationSupportTest extends TestCase {

  private static void validateAnnotation(HasAnnotations annotatedElement,
      String testAnnotationValue, String nestedAnnotationValue,
      TestAnnotation realAnnotation) {
    assertNotNull(annotatedElement);

    assertNull(annotatedElement.getAnnotation(SourceRetentionAnnotation.class));

    TestAnnotation testAnnotation = annotatedElement.getAnnotation(TestAnnotation.class);
    assertNotNull(testAnnotation);

    // Check our proxy objects against the real thing.
    assertEquals(realAnnotation, testAnnotation);
    assertEquals(realAnnotation.hashCode(), testAnnotation.hashCode());

    // tobyr doesn't like this.
    // assertEquals(realAnnotation.toString(), testAnnotation.toString());

    // checks default value
    assertEquals(testAnnotationValue, testAnnotation.value());
    assertEquals(nestedAnnotationValue,
        testAnnotation.nestedAnnotation().value());

    // Tests default values using conditional statements.
    assertEquals(realAnnotation.longValue(), testAnnotation.longValue());

    // Tests default value of array type.
    assertEquals(realAnnotation.intArrayValue().length,
        testAnnotation.intArrayValue().length);

    // Tests default value which is a field reference.
    assertEquals(realAnnotation.stringValue(), testAnnotation.stringValue());

    // Tests default value that is a class literal.
    assertEquals(realAnnotation.classLiteral(), testAnnotation.classLiteral());

    // Tests implicit array initializers
    Class<?>[] expectedArrayValue = realAnnotation.arrayWithImplicitArrayInitializer();
    Class<?>[] actualArrayValue = testAnnotation.arrayWithImplicitArrayInitializer();
    assertTrue(expectedArrayValue.length > 0);
    assertEquals(expectedArrayValue.length, actualArrayValue.length);
    assertEquals(expectedArrayValue[0], actualArrayValue[0]);

    // Tests that empty array initializers are also handled correctly.
    assertEquals(realAnnotation.emptyArray().length,
        testAnnotation.emptyArray().length);
  }

  private final boolean logToConsole = false;
  private final ModuleContext moduleContext = new ModuleContext(logToConsole
      ? new PrintWriterTreeLogger() : TreeLogger.NULL,
      "com.google.gwt.dev.javac.typemodel.TypeOracleTest");

  private final TypeOracle typeOracle = moduleContext.getOracle();

  public TypeOracleAnnotationSupportTest() throws UnableToCompleteException {
  }

  /**
   * Test that a class can be annotated.
   */
  public void testAnnotatedClass() throws NotFoundException {
    JClassType annotatedClass = typeOracle.getType(AnnotatedClass.class.getName());

    TestAnnotation realAnnotation = AnnotatedClass.class.getAnnotation(TestAnnotation.class);
    validateAnnotation(annotatedClass, "Class", "Foo", realAnnotation);

    ClassLiteralReferenceAnnotation classReferenceAnnotation = annotatedClass.getAnnotation(ClassLiteralReferenceAnnotation.class);
    assertEquals(ClassLiteralReferenceAnnotation.Foo.class,
        classReferenceAnnotation.value());

    assertEquals(2, annotatedClass.getAnnotations().length);
  }

  /**
   * Test that a constructor can be annotated.
   */
  public void testAnnotatedConstructor() throws NotFoundException,
      SecurityException, NoSuchMethodException {
    JClassType annotatedClass = typeOracle.getType(AnnotatedClass.class.getName());
    JConstructor ctor = annotatedClass.getConstructor(TypeOracle.NO_JTYPES);

    Constructor<AnnotatedClass> constructor = AnnotatedClass.class.getConstructor();
    TestAnnotation realAnnotation = constructor.getAnnotation(TestAnnotation.class);

    validateAnnotation(ctor, "Constructor", "Not assigned", realAnnotation);
  }

  /**
   * Test that a field can be annotated.
   */
  public void testAnnotatedField() throws NotFoundException, SecurityException,
      NoSuchFieldException {
    JClassType annotatedClass = typeOracle.getType(AnnotatedClass.class.getName());
    JField annotatedField = annotatedClass.getField("annotatedField");

    Field field = AnnotatedClass.class.getDeclaredField("annotatedField");
    TestAnnotation realAnnotation = field.getAnnotation(TestAnnotation.class);

    validateAnnotation(annotatedField, "Field", "Not assigned", realAnnotation);
  }

  /**
   * Tests that methods can be annotated.
   */
  public void testAnnotatedMethod() throws NotFoundException,
      SecurityException, NoSuchMethodException {
    JClassType annotatedClass = typeOracle.getType(AnnotatedClass.class.getName());
    JMethod annotatedMethod = annotatedClass.getMethod("annotatedMethod",
        TypeOracle.NO_JTYPES);

    Method method = AnnotatedClass.class.getDeclaredMethod("annotatedMethod");
    TestAnnotation realAnnotation = method.getAnnotation(TestAnnotation.class);

    validateAnnotation(annotatedMethod, "Method", "Not assigned",
        realAnnotation);
  }

  /**
   * Tests that packages can be annotated. This necessitates the existence of a
   * package-info.java file in the package that you wish to annotate.
   */
  public void testAnnotatedPackage() throws NotFoundException,
      ClassNotFoundException {
    JPackage annotatedPackage = typeOracle.getPackage("com.google.gwt.dev.javac.typemodel.test");
    assertNotNull(annotatedPackage);

    TestAnnotation realAnnotation = Class.forName(
        "com.google.gwt.dev.javac.typemodel.test.package-info", false,
        TypeOracleAnnotationSupportTest.class.getClassLoader()).getAnnotation(
        TestAnnotation.class);

    validateAnnotation(annotatedPackage, "Package", "Not assigned",
        realAnnotation);
  }

  /**
   * Tests that parameters can be annotated.
   */
  public void testAnnotatedParameter() throws NotFoundException,
      SecurityException, NoSuchMethodException {
    JClassType annotatedClass = typeOracle.getType(AnnotatedClass.class.getName());
    JMethod jmethod = annotatedClass.getMethod("methodWithAnnotatedParameter",
        new JType[]{JPrimitiveType.INT});
    JParameter parameter = jmethod.getParameters()[0];

    Method method = AnnotatedClass.class.getDeclaredMethod(
        "methodWithAnnotatedParameter", int.class);
    Annotation[][] paramAnnotations = method.getParameterAnnotations();
    TestAnnotation realAnnotation = (TestAnnotation) paramAnnotations[0][0];

    validateAnnotation(parameter, "Parameter", "Not assigned", realAnnotation);
  }

  public void testAnnotatedWithArrayOfClasses() throws NotFoundException,
      SecurityException, NoSuchMethodException {
    JClassType annotatedClass = typeOracle.getType(AnnotatedClass.class.getName());
    JMethod annotatedMethod = annotatedClass.getMethod(
        "annotatedWithArrayOfClasses", TypeOracle.NO_JTYPES);

    Method method = AnnotatedClass.class.getDeclaredMethod("annotatedWithArrayOfClasses");
    TestAnnotation realAnnotation = method.getAnnotation(TestAnnotation.class);

    validateAnnotation(annotatedMethod, "Method", "Not assigned",
        realAnnotation);
  }

  /**
   * Tests translatable classes that are annotated with annotations for which we
   * have no source.
   */
  public void testBinaryOnlyAnnotation() throws NotFoundException {
    // It is an error if we fail to get the type.
    JClassType classType = typeOracle.getType(ClassAnnotatedWithBinaryOnlyAnnotation.class.getCanonicalName());

    BinaryOnlyAnnotation annotation = classType.getAnnotation(BinaryOnlyAnnotation.class);
    assertNotNull(annotation);
    assertEquals(File.class, annotation.jreClassLiteralReference());
  }

  /**
   * Ensures that we properly handle primitive value attributes on annotations.
   * (Special-cased, because of how JDT handles char/numeric literals)
   */
  public void testPrimitiveValuesAnnotations() throws NotFoundException {
    JClassType primitivesAnnotatedClass = typeOracle.getType(PrimitivesAnnotatedClass.class.getName());
    PrimitiveValuesAnnotation annotation = primitivesAnnotatedClass.getAnnotation(PrimitiveValuesAnnotation.class);

    boolean bool = annotation.bool();
    assertTrue(bool);

    byte b = annotation.b();
    assertTrue(b > 0);

    char c = annotation.c();
    assertTrue(c > 0);

    double d = annotation.d();
    assertTrue(d > 0);

    float f = annotation.f();
    assertTrue(f > 0);

    int i = annotation.i();
    assertTrue(i > 0);

    long l = annotation.l();
    assertTrue(l > 0);

    short s = annotation.s();
    assertTrue(s > 0);

    int[] ia = annotation.ia();
    assertEquals(3, ia.length);
    for (int it = 0; it < 3; ++it) {
      assertEquals(it, ia[it]);
    }
  }
}