/**
 * Copyright (C) 2010 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.inject.assistedinject;

import static com.google.inject.name.Names.named;

import com.google.inject.AbstractModule;
import com.google.inject.Binding;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.Stage;
import com.google.inject.internal.util.ImmutableList;
import com.google.inject.internal.util.ImmutableSet;
import com.google.inject.internal.util.Iterables;
import com.google.inject.internal.util.Lists;
import com.google.inject.name.Named;
import com.google.inject.spi.DefaultBindingTargetVisitor;
import com.google.inject.spi.Dependency;
import com.google.inject.spi.Element;
import com.google.inject.spi.Elements;

import junit.framework.AssertionFailedError;
import junit.framework.TestCase;

import java.util.List;
import java.util.Set;
import java.util.logging.Logger;

/**
 * Tests for AssistedInject Spi.
 *
 * @author ramakrishna@google.com (Ramakrishna Rajanna)
 */
public class ExtensionSpiTest extends TestCase {

  public final void testSpiOnElements() throws Exception {
    AssistedInjectSpiVisitor visitor = new AssistedInjectSpiVisitor();
    Integer count = 0;
    for(Element element : Elements.getElements(new Module())) {
      if(element instanceof Binding) {
        assertEquals(count++, ((Binding<?>)element).acceptTargetVisitor(visitor));
      }
    }
    validateVisitor(visitor);
  }

  public void testSpiOnVisitor() throws Exception {
    AssistedInjectSpiVisitor visitor = new AssistedInjectSpiVisitor();
    Integer count = 0;
    Injector injector = Guice.createInjector(new Module());
    for(Binding<?> binding : injector.getBindings().values()) {
      assertEquals(count++, binding.acceptTargetVisitor(visitor));
    }
    validateVisitor(visitor);
  }

  private void validateVisitor(AssistedInjectSpiVisitor visitor) throws Exception {
    assertEquals(1, visitor.assistedBindingCount);
    List<AssistedMethod> assistedMethods =
        Lists.newArrayList(Iterables.getOnlyElement(
            visitor.assistedInjectBindings).getAssistedMethods());
    assertEquals(7, assistedMethods.size());
    assertEquals(1, visitor.assistedBindingCount);
    assertEquals(1, visitor.assistedInjectBindings.size());

    // Validate for each of the methods in AnimalFactory
    validateCreateAStrangeCatAsAnimal(assistedMethods.get(0));
    validatecreateStrangeCatWithConstructorForOwner(assistedMethods.get(1));
    validatecreateStrangeCatWithConstructorForAge(assistedMethods.get(2));
    validateCreateCatWithANonAssistedDependency(assistedMethods.get(3));
    validateCreateCat(assistedMethods.get(4));
    validateCreateASimpleCatAsAnimal(assistedMethods.get(5));
    validateCreateCatWithNonAssistedDependencies(assistedMethods.get(6));

  }

  private void validateCreateAStrangeCatAsAnimal(AssistedMethod assistedMethod) {
    validateAssistedMethod(assistedMethod, "createAStrangeCatAsAnimal",
      StrangeCat.class, ImmutableList.<Key<?>>of());
  }

  private void validatecreateStrangeCatWithConstructorForOwner(AssistedMethod assistedMethod) {
    validateAssistedMethod(assistedMethod, "createStrangeCatWithConstructorForOwner",
      StrangeCat.class, ImmutableList.<Key<?>>of());
  }

  private void validatecreateStrangeCatWithConstructorForAge(AssistedMethod assistedMethod) {
    validateAssistedMethod(assistedMethod, "createStrangeCatWithConstructorForAge",
      StrangeCat.class, ImmutableList.<Key<?>>of());
  }

  private void validateCreateCatWithANonAssistedDependency(AssistedMethod assistedMethod)
      throws Exception {
    validateAssistedMethod(assistedMethod, "createCatWithANonAssistedDependency",
        CatWithAName.class, ImmutableList.<Key<?>>of(Key.get(String.class, named("catName2"))));
  }

  private void validateCreateCat(AssistedMethod assistedMethod) throws Exception {
    validateAssistedMethod(assistedMethod, "createCat", Cat.class, ImmutableList.<Key<?>>of());
  }

  private void validateCreateASimpleCatAsAnimal(AssistedMethod assistedMethod) {
    validateAssistedMethod(assistedMethod, "createASimpleCatAsAnimal", SimpleCat.class,
        ImmutableList.<Key<?>>of());
  }

  private void validateCreateCatWithNonAssistedDependencies(AssistedMethod assistedMethod) {
    List<Key<?>> dependencyKeys = ImmutableList.<Key<?>>of(
        Key.get(String.class, named("catName1")),
        Key.get(String.class, named("petName")),        
        Key.get(Integer.class, named("age")));
    validateAssistedMethod(assistedMethod, "createCatWithNonAssistedDependencies",
      ExplodingCat.class, dependencyKeys);
  }

  private void validateAssistedMethod(AssistedMethod assistedMethod, String factoryMethodName,
                                      Class clazz, List<Key<?>> dependencyKeys){
    assertEquals(factoryMethodName, assistedMethod.getFactoryMethod().getName());
    assertEquals(clazz, assistedMethod.getImplementationConstructor().getDeclaringClass());
    assertEquals(dependencyKeys.size(), assistedMethod.getDependencies().size());
    for (Dependency<?> dependency : assistedMethod.getDependencies()) {
      assertTrue(dependencyKeys.contains(dependency.getKey()));
    }
    assertEquals(clazz, assistedMethod.getImplementationType().getType());
  }


  interface AnimalFactory {
    Cat createCat(String owner);
    CatWithAName createCatWithANonAssistedDependency(String owner);
    @Named("SimpleCat") Animal createASimpleCatAsAnimal(String owner);
    Animal createAStrangeCatAsAnimal(String owner);
    StrangeCat createStrangeCatWithConstructorForOwner(String owner);
    StrangeCat createStrangeCatWithConstructorForAge(Integer age);
    ExplodingCat createCatWithNonAssistedDependencies(String owner);
  }

  interface Animal {}

  private static class Cat implements Animal {
    @Inject Cat(@Assisted String owner) {}
  }

  private static class SimpleCat implements Animal {
    @Inject SimpleCat(@Assisted String owner) {
    }
  }

  private static class StrangeCat implements Animal {
    @AssistedInject StrangeCat(@Assisted String owner) {}
    @AssistedInject StrangeCat(@Assisted Integer age) {}
  }

  private static class ExplodingCat implements Animal {
    @Inject public ExplodingCat(@Named("catName1") String name, @Assisted String owner,
                                @Named("age") Integer age, @Named("petName") String petName) {}
  }

  private static class CatWithAName extends Cat {
    @Inject CatWithAName(@Assisted String owner, @Named("catName2") String name) {
      super(owner);
    }
  }

  public class Module extends AbstractModule{
    @Override
    protected void configure() {
      bind(String.class).annotatedWith(named("catName1")).toInstance("kitty1");
      bind(String.class).annotatedWith(named("catName2")).toInstance("kitty2");
      bind(String.class).annotatedWith(named("petName")).toInstance("pussy");
      bind(Integer.class).annotatedWith(named("age")).toInstance(12);
      install(new FactoryModuleBuilder()
        .implement(Animal.class, StrangeCat.class)
        .implement(Animal.class, named("SimpleCat"), SimpleCat.class)
        .build(AnimalFactory.class));
    }
  }

  public class AssistedInjectSpiVisitor extends DefaultBindingTargetVisitor<Object, Integer>
      implements AssistedInjectTargetVisitor<Object, Integer>  {

    private final Set<Class> allowedClasses = 
      ImmutableSet.<Class> of(
        Injector.class, Stage.class, Logger.class,
        String.class, Integer.class);
    
    private int assistedBindingCount = 0;
    private int currentCount = 0;
    private List<AssistedInjectBinding<?>> assistedInjectBindings = Lists.newArrayList();

    public Integer visit(AssistedInjectBinding assistedInjectBinding) {
      assistedInjectBindings.add(assistedInjectBinding);
      assistedBindingCount++;
      return currentCount++;
    }

    @Override
    protected Integer visitOther(Binding<? extends Object> binding) {
      if(!allowedClasses.contains(binding.getKey().getTypeLiteral().getRawType())) {
        throw new AssertionFailedError("invalid other binding: " + binding);
      }
      return currentCount++;
    }
  }
}