package com.lexicalscope.fluentreflection;

 /*

  * Copyright 2011 Tim Wood

  *

  * 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.

  */

 import static ch.lambdaj.Lambda.*;

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

 import static java.lang.String.format;

 import static java.lang.System.arraycopy;

 import java.lang.reflect.InvocationTargetException;

 import java.lang.reflect.Method;

 import java.lang.reflect.Modifier;

 import java.lang.reflect.TypeVariable;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.List;

 import org.apache.commons.lang3.builder.EqualsBuilder;

 import org.apache.commons.lang3.builder.HashCodeBuilder;

 import com.google.inject.TypeLiteral;

 final class FluentMethodImpl extends AbstractFluentAnnotated implements FluentMethod {

     private final ReflectedTypeFactory reflectedTypeFactory;

     private final FluentClass<?> reflectedClass;

     private final TypeLiteral<?> typeLiteral;

     private final Method method;

     public FluentMethodImpl(

             final ReflectedTypeFactory reflectedTypeFactory,

             final FluentClass<?> reflectedClass,

             final TypeLiteral<?> typeLiteral,

             final Method method) {

         super(reflectedTypeFactory, method);

         this.reflectedTypeFactory = reflectedTypeFactory;

         this.reflectedClass = reflectedClass;

         this.typeLiteral = typeLiteral;

         this.method = method;

     }

     @Override public String name() {

         return method.getName();

     }

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

         final List<FluentClass<?>> result = new ArrayList<FluentClass<?>>();

         result.addAll(convert(

                 typeLiteral.getParameterTypes(method),

                 new ConvertTypeLiteralToReflectedType(reflectedTypeFactory)));

         return result;

     }

     @Override public int argCount() {

         final int parameterCount = method.getParameterTypes().length;

         if (isStatic()) {

             return parameterCount;

         }

         return parameterCount;

     }

     @Override public FluentClass<?> declarer() {

         return reflectedTypeFactory.reflect(typeLiteral);

     }

     @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 Object callRaw(final Object... args) {

         if (isStatic()) {

             return invokeMethod(null, args);

         } else {

             if (args.length < 1) {

                 throw new IllegalArgumentException("target instance must be specified as first argument when calling "

                         + method);

             }

             final Object[] remainingArguments = new Object[args.length - 1];

             arraycopy(args, 1, remainingArguments, 0, args.length - 1);

             return invokeMethod(args[0], remainingArguments);

         }

     }

     private Object invokeMethod(final Object instance, final Object[] arguments) {

         try {

             if (!method.isAccessible()) {

                 method.setAccessible(true);

             }

             return method.invoke(instance, arguments);

         } catch (final IllegalArgumentException e) {

             throw new IllegalArgumentRuntimeException(e, method, instance, arguments);

         } catch (final IllegalAccessException e) {

             throw new IllegalAccessRuntimeException(e, method);

         } catch (final InvocationTargetException e) {

             throw new InvocationTargetRuntimeException(e, method);

         }

     }

     @Override public boolean isStatic() {

         return Modifier.isStatic(method.getModifiers());

     }

     @Override public boolean isFinal() {

         return Modifier.isFinal(method.getModifiers());

     }

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

         return new AbstractCall<T>(reflectedTypeFactory) {

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

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

             }

         };

     }

     @Override public FluentClass<?> type() {

         final TypeLiteral<?> returnType = typeLiteral.getReturnType(method);

         if (returnType == null) {

             return null;

         }

         return reflectedTypeFactory.reflect(returnType);

     }

     @Override public String property() {

         final String name = name();

         if (name.length() > 2) {

             if (name.length() > 3) {

                 if (name.startsWith("get") || name.startsWith("set")) {

                     return initialLowerCase(name.substring(3));

                 }

             }

             if (name.startsWith("is")) {

                 return initialLowerCase(name.substring(2));

             }

         }

         return method.getName();

     }

     private String initialLowerCase(final String substring) {

         return substring.substring(0, 1).toLowerCase() + substring.substring(1);

     }

     @Override public Method member() {

         return method;

     }

     @Override public Visibility visibility() {

         return visibilityFromModifiers(method.getModifiers());

     }

     private List<TypeVariable<Method>> typeParameters()

     {

         return Arrays.asList(method.getTypeParameters());

     }

     @Override public String toString() {

         final String visibility;

         if (visibility().toString().isEmpty())

         {

             visibility = visibility().toString();

         }

         else

         {

             visibility = visibility().toString() + " ";

         }

         final String staticModifier;

         if (isStatic())

         {

             staticModifier = "static ";

         }

         else

         {

             staticModifier = "";

         }

         final String finalModifier;

         if (isFinal())

         {

             finalModifier = "final ";

         }

         else

         {

             finalModifier = "";

         }

         final String typeParameters;

         if (typeParameters().isEmpty())

         {

             typeParameters = "";

         }

         else

         {

             typeParameters = "<" + joinFrom(typeParameters(), ", ").toString() + "> ";

         }

         final String arguments;

         if (argCount() > 0) {

             arguments = joinFrom(args(), ", ").toString();

         } else {

             arguments = "";

         }

         return format(

                 "%s%s%s%s%s %s(%s)",

                 visibility,

                 staticModifier,

                 finalModifier,

                 typeParameters,

                 type(),

                 method.getName(),

                 arguments);

     }

     @Override public boolean equals(final Object obj) {

         if (obj != null && this.getClass().equals(obj.getClass())) {

             final FluentMethodImpl that = (FluentMethodImpl) obj;

             return new EqualsBuilder()

                     .append(this.method, that.method)

                     .append(this.typeLiteral, that.typeLiteral)

                     .isEquals();

         }

         return false;

     }

     @Override public int hashCode() {

         return new HashCodeBuilder().append(method).append(typeLiteral).toHashCode();

     }

 }