/*
    * Grapht, an open source dependency injector.
    * Copyright 2014-2015 various contributors (see CONTRIBUTORS.txt)
    * Copyright 2010-2014 Regents of the University of Minnesota
    *
    * This program is free software; you can redistribute it and/or modify
    * it under the terms of the GNU Lesser General Public License as
    * published by the Free Software Foundation; either version 2.1 of the
    * License, or (at your option) any later version.
   *
   * This program 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. See the GNU General Public License for more
   * details.
   *
   * You should have received a copy of the GNU General Public License along with
   * this program; if not, write to the Free Software Foundation, Inc., 51
   * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
   */
  package org.grouplens.grapht.reflect;
  
  import org.grouplens.grapht.util.Types;
  
  import javax.annotation.Nonnull;
  import javax.annotation.Nullable;
  import java.lang.annotation.Annotation;
  import java.lang.reflect.Member;
  import java.lang.reflect.Type;
  import java.util.Collection;
  import java.util.Collections;
  
  /**
   * MockInjectionPoint is a simple injection point that wraps a type, qualifier, and a
   * transient state. It has no actual injectable point but can be used when
   * constructing ReflectionDesires on the fly for tests.
   * 
   * @author <a href="http://grouplens.org">GroupLens Research</a>
   */
  public class MockInjectionPoint implements InjectionPoint {
      private static final long serialVersionUID = 1L;
  
      private final Class<?> type;
      private final boolean nullable;
      private final Annotation qualifier;
      
      public MockInjectionPoint(Class<?> type, boolean nullable) {
          this(type, null, nullable);
      }
      
      public MockInjectionPoint(Class<?> type, Annotation qualifier, boolean nullable) {
          this.type = Types.box(type);
          this.qualifier = qualifier;
          this.nullable = nullable;
      }
      
      @Override
      public Member getMember() {
          return new Member() {
              @Override
              public Class<?> getDeclaringClass() {
                  return Void.class;
              }
  
              @Override
              public String getName() {
                  return "synthetic";
              }
  
              @Override
              public int getModifiers() {
                  return 0;
              }
  
              @Override
              public boolean isSynthetic() {
                  return true;
              }
          };
      }
      
      @Override
      public Type getType() {
          return type;
      }
      
      @Override
      public Class<?> getErasedType() {
          return type;
      }
  
      @Nullable
      @Override
      public Annotation getQualifier() {
          return qualifier;
      }
  
      @Nullable
      @Override
      public <A extends Annotation> A getAttribute(Class<A> atype) {
         return null;
     }
 
     @Nonnull
     @Override
     public Collection<Annotation> getAttributes() {
         return Collections.emptySet();
     }
 
     @Override
     public boolean isNullable() {
         return nullable;
     }
 
     @Override
     public boolean equals(Object o) {
         if (!(o instanceof MockInjectionPoint)) {
             return false;
         }
         MockInjectionPoint m = (MockInjectionPoint) o;
         return m.type.equals(type) && 
                m.nullable == nullable && 
                (m.qualifier == qualifier || (qualifier != null && qualifier.equals(m.qualifier)));
     }
     
     @Override
     public int hashCode() {
         return type.hashCode() ^ (qualifier == null ? 0 : qualifier.hashCode()) ^ (nullable ? 2 : 4);
     }
 }