package com.lexicalscope.fluentreflection;

 import static ch.lambdaj.Lambda.convert;

 import static com.lexicalscope.fluentreflection.Visibility.visibilityFromModifiers;

 import java.lang.reflect.Constructor;

 import java.lang.reflect.InvocationTargetException;

 import java.util.List;

 import com.google.inject.TypeLiteral;

 final class FluentConstructorImpl<T> extends AbstractFluentAnnotated implements FluentConstructor<T> {

     private final ReflectedTypeFactory reflectedTypeFactory;

     private final TypeLiteral<T> typeLiteral;

     private final Constructor<T> constructor;

     public FluentConstructorImpl(

             final ReflectedTypeFactory reflectedTypeFactory,

             final TypeLiteral<T> typeLiteral,

             final Constructor<T> constructor) {

         super(reflectedTypeFactory, constructor);

         this.reflectedTypeFactory = reflectedTypeFactory;

         this.typeLiteral = typeLiteral;

         this.constructor = constructor;

     }

     @Override public int argCount() {

         return constructor.getParameterTypes().length;

     }

     @Override public List<FluentClass<?>> args() {

         return convert(

                 typeLiteral.getParameterTypes(constructor),

                 new ConvertTypeLiteralToReflectedType(reflectedTypeFactory));

     }

     @Override public Constructor<T> member() {

         return constructor;

     }

     @Override public T callRaw(final Object... args) {

         try {

             return constructor.newInstance(args);

         } catch (final InstantiationException e) {

             throw new InstantiationRuntimeException(e, constructor);

         } catch (final IllegalAccessException e) {

             throw new IllegalAccessRuntimeException(e, constructor);

         } catch (final InvocationTargetException e) {

             throw new InvocationTargetRuntimeException(e, constructor);

         }

     }

     @SuppressWarnings({ "unchecked", "rawtypes" }) @Override public FluentObject<?> call(final Object... args) {

         final Object object = callRaw(args);

         if(object == null) {

             return null;

         }

         return reflectedTypeFactory.reflect((Class) object.getClass(), object);

     }

     @Override public FluentClass<?> declarer() {

         return reflectedTypeFactory.reflect(typeLiteral);

     }

     @Override public String name() {

         return constructor.getName();

     }

     @Override public String property() {

         return "<init>";

     }

     @Override public FluentClass<?> type() {

         return declarer();

     }

     @Override public Visibility visibility() {

         return visibilityFromModifiers(constructor.getModifiers());

     }

     @Override public <S> FluentCall<S> as(final Class<S> returnType) {

         return new AbstractCall<S>(reflectedTypeFactory) {

             @Override public S callRaw(final Object... args) {

                 return returnType.cast(FluentConstructorImpl.this.callRaw(args));

             }

         };

     }

     @Override public boolean isStatic() {

         return true;

     }

     @Override public boolean isFinal() {

         return false;

     }

 }