package com.lexicalscope.fluentreflection;

 import static ch.lambdaj.Lambda.*;

 import static com.lexicalscope.fluentreflection.ReflectionMatcher.allOf;

 import static com.lexicalscope.fluentreflection.ReflectionMatchers.*;

 import java.lang.annotation.Annotation;

 import java.lang.reflect.Type;

 import java.util.List;

 import org.hamcrest.Matcher;

 /*

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

  */

 final class FluentObjectImpl<T> implements FluentObject<T> {

     private final FluentClass<T> reflect;

     private final T instance;

     private final ReflectedTypeFactory reflectedTypeFactory;

     public FluentObjectImpl(

             final ReflectedTypeFactory reflectedTypeFactory,

             final FluentClass<T> reflect,

             final T instance) {

         this.reflectedTypeFactory = reflectedTypeFactory;

         this.reflect = reflect;

         this.instance = instance;

     }

     @Override public Class<T> classUnderReflection() {

         return reflect.classUnderReflection();

     }

     @Override public FluentClass<T> reflectedClass() {

         return reflect;

     }

     @Override public FluentMethod method(final Matcher<? super FluentMethod> methodMatcher) {

         final FluentMethod method = selectFirst(boundMethods(), methodMatcher);

         if(method == null) {

             throw new MethodNotFoundException(reflect.classUnderReflection(), methodMatcher);

         }

         return method;

     }

     @Override public FluentMethod method(final String name) {

         return method(hasName(name));

     }

     @Override public List<FluentMethod> methods() {

         return boundMethods();

     }

     @Override public List<FluentMethod> declaredMethods() {

         return boundDeclaredMethods();

     }

     @Override public List<FluentMethod> methods(final Matcher<? super FluentMethod> methodMatcher) {

         return select(boundMethods(), methodMatcher);

     }

     private List<FluentMethod> boundMethods() {

         return bind(reflect.methods());

     }

     private List<FluentMethod> bind(final List<FluentMethod> methods) {

         return convert(

                 select(methods, isNotStatic()),

                 new ConvertReflectedMethodToBoundReflectedMethod(reflectedTypeFactory, instance));

     }

     private List<FluentMethod> boundDeclaredMethods() {

         return bind(reflect.declaredMethods());

     }

     @Override public FluentObject<?> call(final String name, final Object ... args) {

         final ReflectionMatcher<FluentMember> methodMatcher = hasName(name);

         return call(methodMatcher, args);

     }

     @Override public FluentObject<?> call(final Matcher<? super FluentMethod> methodMatcher, final Object... args) {

         return method(allOf(methodMatcher, canBeCalledWithArguments(args))).call(args);

     }

     @Override public List<FluentField> fields(final ReflectionMatcher<? super FluentField> fieldMatcher) {

         return select(boundFields(), fieldMatcher);

     }

     @Override public List<FluentField> declaredFields() {

         return boundDeclaredFields();

     }

     private List<FluentField> boundFields() {

         return bindFields(reflect.fields());

     }

     private List<FluentField> boundDeclaredFields() {

         return bindFields(reflect.declaredFields());

     }

     private List<FluentField> bindFields(final List<FluentField> fields) {

         return convert(

                 select(fields, isNotStatic()),

                 new ConvertReflectedFieldToBoundReflectedField(reflectedTypeFactory, instance));

     }

     @Override public List<FluentField> fields() {

         return boundFields();

     }

     @Override public FluentField field(final ReflectionMatcher<FluentMember> fieldMatcher) {

         final FluentField selectedField = selectFirst(fields(), fieldMatcher);

         if (selectedField == null) {

             throw new FieldNotFoundException(instance.getClass(), fieldMatcher);

         }

         return selectedField;

     }

     @Override public boolean canBeBoxed(final Class<?> from) {

         return reflect.canBeBoxed(from);

     }

     @Override public boolean canBeUnboxed(final Class<?> from) {

         return reflect.canBeUnboxed(from);

     }

     @Override public FluentClass<?> annotation(final Matcher<? super FluentClass<?>> annotationMatcher) {

         return reflect.annotation(annotationMatcher);

     }

     @Override public <A extends Annotation> A annotation(final Class<A> annotationClass) {

         return reflect.annotation(annotationClass);

     }

     @Override public boolean annotatedWith(final Class<? extends Annotation> annotationClass) {

         return reflect.annotatedWith(annotationClass);

     }

     @Override public boolean annotatedWith(final Matcher<? super FluentClass<?>> annotationMatcher) {

         return reflect.annotatedWith(annotationMatcher);

     }

     @Override public boolean isPrimitive() {

         return reflect.isPrimitive();

     }

     @Override public boolean isUnboxable() {

         return reflect.isUnboxable();

     }

     @Override public FluentClass<T> boxedType() {

         return reflect.boxedType();

     }

     @Override public FluentClass<T> unboxedType() {

         return reflect.unboxedType();

     }

     @Override public boolean assignableFromObject(final Object value) {

         return reflect.assignableFromObject(value);

     }

     @Override public boolean assignableTo(final Class<?> klass) {

         return reflect.assignableTo(klass);

     }

     @Override public FluentClass<?> typeArgument(final int typeParameter) {

         return reflect.typeArgument(typeParameter);

     }

     @Override public String name() {

         return reflect.name();

     }

     @Override public String simpleName() {

         return reflect.simpleName();

     }

     @Override public Type type() {

         return reflect.type();

     }

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

         return reflect.interfaces();

     }

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

         return reflect.superclasses();

     }

     @Override public boolean isType(final ReflectionMatcher<FluentClass<?>> typeMatcher) {

         return reflect.isType(typeMatcher);

     }

     @Override public T value() {

         return instance;

     }

     @Override public <V> V as(final Class<V> asType) {

         return asType.cast(value());

     }

 }