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 com.lexicalscope.fluentreflection.Visibility.visibilityFromModifiers;
  import static java.lang.String.format;
  
  import java.lang.reflect.Field;
  import java.lang.reflect.Modifier;
  import java.util.ArrayList;
  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 FluentFieldImpl extends AbstractFluentAnnotated implements FluentField {
      private final ReflectedTypeFactory reflectedTypeFactory;
      private final FluentClass<?> reflectedClass;
      private final TypeLiteral<?> typeLiteral;
      private final Field field;
  
      public FluentFieldImpl(
              final ReflectedTypeFactory reflectedTypeFactory,
              final FluentClass<?> reflectedClass,
              final TypeLiteral<?> typeLiteral,
              final Field field) {
          super(reflectedTypeFactory, field);
          this.reflectedTypeFactory = reflectedTypeFactory;
          this.reflectedClass = reflectedClass;
          this.typeLiteral = typeLiteral;
          this.field = field;
  
          try { field.setAccessible(true); } catch(final SecurityException e)
          { /* ignore, if we can set the field as accessible we get much improved performance */ }
      }
  
      @Override public String name() {
          return field.getName();
      }
  
      @Override public FluentClass<?> declarer() {
          return reflectedTypeFactory.reflect(typeLiteral);
      }
  
      @Override public boolean isStatic() {
          return Modifier.isStatic(field.getModifiers());
      }
  
      @Override public boolean isFinal() {
          return Modifier.isFinal(field.getModifiers());
      }
  
      @Override public String property() {
          return field.getName();
      }
  
      @Override public Field member() {
          return field;
      }
  
      @Override public Visibility visibility() {
          return visibilityFromModifiers(field.getModifiers());
      }
  
      @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 = "";
         }
 
         return format(
                 "%s%s%s%s %s",
                 visibility,
                 staticModifier,
                 finalModifier,
                 type(),
                 field.getName());
     }
 
     @Override public boolean equals(final Object obj) {
         if (obj != null && this.getClass().equals(obj.getClass())) {
             final FluentFieldImpl that = (FluentFieldImpl) obj;
             return new EqualsBuilder()
                     .append(this.field, that.field)
                     .append(this.typeLiteral, that.typeLiteral)
                     .isEquals();
         }
         return false;
     }
 
     @Override public int hashCode() {
         return new HashCodeBuilder().append(field).append(typeLiteral).toHashCode();
     }
 
     @Override public int argCount() {
         return 1;
     }
 
     @Override public List<FluentClass<?>> args() {
         return new ArrayList<FluentClass<?>>();
     }
 
     @Override public FluentClass<?> type() {
         final TypeLiteral<?> returnType = typeLiteral.getFieldType(field);
         if (returnType == null) {
             return null;
         }
         return reflectedTypeFactory.reflect(returnType);
     }
 
     @Override public Object callRaw(final Object... args) {
         if(args == null || args.length == 0 || args[0] == null) {
             throw new ReflectionRuntimeException("reading a field requires an instance argument");
         } else if (args.length > 2) {
             throw new ReflectionRuntimeException("reading a field requires one argument, writing a field requires two arguments. Got " + args.length + " arguments");
         }
 
         try {
             final Object fieldValue = field.get(args[0]);
             if(args.length == 2)
             {
                 field.set(args[0], args[1]);
             }
             return fieldValue;
         } catch (final IllegalArgumentException e) {
             throw new IllegalArgumentRuntimeException(e, field, args[0]);
         } catch (final IllegalAccessException e) {
             throw new IllegalAccessRuntimeException(e, field);
         }
     }
 
     @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 <T> FluentCall<T> as(final Class<T> returnType) {
         return new AbstractCall<T>(reflectedTypeFactory) {
             @Override public T callRaw(final Object... args) {
                 return returnType.cast(FluentFieldImpl.this.callRaw(args));
             }
         };
     }
 }