/*
 * 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;

import com.google.gwt.dev.javac.BinaryTypeReferenceRestrictionsChecker.BinaryTypeReferenceSite;

import junit.framework.TestCase;

import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.SingleMemberAnnotation;
import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.env.IBinaryAnnotation;
import org.eclipse.jdt.internal.compiler.env.IBinaryField;
import org.eclipse.jdt.internal.compiler.env.IBinaryMethod;
import org.eclipse.jdt.internal.compiler.env.IBinaryNestedType;
import org.eclipse.jdt.internal.compiler.env.IBinaryType;
import org.eclipse.jdt.internal.compiler.env.IBinaryTypeAnnotation;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
import org.eclipse.jdt.internal.compiler.lookup.MethodScope;

import java.io.File;
import java.util.List;

/**
 *
 */
public class BinaryTypeReferenceRestrictionsCheckerTest extends TestCase {
  /**
   * Mocks a binary type
   */
  static class MockBinaryType implements IBinaryType {
    private final String qualifiedTypeName;

    MockBinaryType(String typeName) {
      this.qualifiedTypeName = typeName;
    }

    @Override
    public IBinaryAnnotation[] getAnnotations() {
      return null;
    }

    @Override public IBinaryTypeAnnotation[] getTypeAnnotations() {
      return new IBinaryTypeAnnotation[0];
    }

    @Override
    public char[] getEnclosingMethod() {
      return null;
    }

    @Override
    public char[] getEnclosingTypeName() {
      return null;
    }

    @Override
    public IBinaryField[] getFields() {
      return null;
    }

    @Override
    public char[] getFileName() {
      return (qualifiedTypeName.replace('.', File.separatorChar) + ".java").toCharArray();
    }

    @Override
    public char[] getGenericSignature() {
      return qualifiedTypeName.toCharArray();
    }

    @Override
    public char[][] getInterfaceNames() {
      return null;
    }

    @Override
    public IBinaryNestedType[] getMemberTypes() {
      return null;
    }

    @Override
    public IBinaryMethod[] getMethods() {
      return null;
    }

    @Override
    public char[][][] getMissingTypeNames() {
      return null;
    }

    @Override
    public int getModifiers() {
      return 0;
    }

    @Override
    public char[] getName() {
      return qualifiedTypeName.toCharArray();
    }

    @Override
    public char[] getSourceName() {
      return null;
    }

    @Override
    public char[] getSuperclassName() {
      return null;
    }

    @Override
    public long getTagBits() {
      return 0;
    }

    @Override
    public boolean isAnonymous() {
      return false;
    }

    @Override
    public boolean isBinaryType() {
      return true;
    }

    @Override
    public boolean isLocal() {
      return false;
    }

    @Override
    public boolean isMember() {
      return false;
    }

    @Override
    public char[] sourceFileName() {
      return null;
    }
  }

  private static final String BINARY_TYPE_NAME = "BinaryType";

  private static TypeReference createMockBinaryTypeReference(
      BinaryTypeBinding binaryTypeBinding) {
    SingleTypeReference singleTypeReference = new SingleTypeReference(null, 0);
    singleTypeReference.resolvedType = binaryTypeBinding;
    return singleTypeReference;
  }

  private static LookupEnvironment createMockLookupEnvironment() {
    LookupEnvironment lookupEnvironment = new LookupEnvironment(null, new CompilerOptions(),
        null, null);
    return lookupEnvironment;
  }

  public void testCheck() {
    // fail("Not yet implemented");
  }

  /**
   * Creates a mock {@link CompilationUnitDeclaration} that has binary type
   * references in a superclass reference, in a method return type, in an
   * annotation and in a local variable declaration. It then checks that the we
   * find all of these locations except for the one used in an annotation.
   */
  public void testFindAllBinaryTypeReferenceSites() {
    CompilationResult compilationResult = new CompilationResult(
        "TestCompilationUnit.java".toCharArray(), 0, 0, 0);
    CompilationUnitDeclaration cud = new CompilationUnitDeclaration(null,
        compilationResult, 1);
    LookupEnvironment lookupEnvironment = createMockLookupEnvironment();
    cud.scope = new CompilationUnitScope(cud, lookupEnvironment);

    TypeDeclaration typeDeclaration = new TypeDeclaration(compilationResult);
    typeDeclaration.scope = new ClassScope(cud.scope, null);
    typeDeclaration.staticInitializerScope = new MethodScope(
        typeDeclaration.scope, null, false);
    cud.types = new TypeDeclaration[] {typeDeclaration};

    BinaryTypeBinding binaryTypeBinding = new BinaryTypeBinding(null,
        new MockBinaryType(BINARY_TYPE_NAME), lookupEnvironment);
    typeDeclaration.superclass = createMockBinaryTypeReference(binaryTypeBinding);

    MethodDeclaration methodDeclaration = new MethodDeclaration(
        compilationResult);
    methodDeclaration.scope = new MethodScope(typeDeclaration.scope, null,
        false);
    methodDeclaration.returnType = createMockBinaryTypeReference(binaryTypeBinding);

    LocalDeclaration localDeclaration = new LocalDeclaration(null, 0, 0);
    localDeclaration.type = createMockBinaryTypeReference(binaryTypeBinding);
    methodDeclaration.statements = new Statement[] {localDeclaration};

    SingleMemberAnnotation annotation = new SingleMemberAnnotation(
        createMockBinaryTypeReference(binaryTypeBinding), 0);
    annotation.memberValue = annotation.type;
    typeDeclaration.annotations = new Annotation[] {annotation};

    typeDeclaration.methods = new AbstractMethodDeclaration[] {methodDeclaration};

    /*
     * Check that we find binary type references in the following expected
     * locations.
     */
    Expression[] expectedExpressions = new Expression[] {
        typeDeclaration.superclass, methodDeclaration.returnType,
        localDeclaration.type};

    List<BinaryTypeReferenceSite> binaryTypeReferenceSites = BinaryTypeReferenceRestrictionsChecker.findAllBinaryTypeReferenceSites(cud);
    assertEquals(expectedExpressions.length, binaryTypeReferenceSites.size());
    for (int i = 0; i < binaryTypeReferenceSites.size(); ++i) {
      BinaryTypeReferenceSite binaryTypeReferenceSite = binaryTypeReferenceSites.get(i);
      assertSame(binaryTypeBinding,
          binaryTypeReferenceSite.getBinaryTypeBinding());
      assertSame(expectedExpressions[i],
          binaryTypeReferenceSite.getExpression());
    }
  }

  public void testFormatBinaryTypeRefErrorMessage() {
    String expectedMessage = "No source code is available for type MyClass; did you forget to inherit a required module?";
    String actualMessage = BinaryTypeReferenceRestrictionsChecker.formatBinaryTypeRefErrorMessage("MyClass");
    assertEquals(expectedMessage, actualMessage);
  }
}