/*
    *  Copyright 2010, 2011 Chris Pheby
    *
    *  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.
   */
  package org.jadira.bindings.core.spring;
  
  import java.lang.annotation.Annotation;
  import java.util.HashSet;
  import java.util.Set;
  
  import org.jadira.bindings.core.annotation.BindingScope;
  import org.jadira.bindings.core.annotation.DefaultBinding;
  import org.jadira.bindings.core.binder.BasicBinder;
  import org.jadira.bindings.core.binder.ConverterKey;
  import org.springframework.core.convert.TypeDescriptor;
  import org.springframework.core.convert.converter.ConditionalGenericConverter;
  
  /**
   * Implementation of Spring's {@link ConditionalGenericConverter} that makes use
   * of Jadira Binding to perform conversions.
   */
  public class BindingConverter implements ConditionalGenericConverter {
  
      private static final BasicBinder BINDING = new BasicBinder();
      
      /**
       * {@inheritDoc}
       */
      /* @Override */
      public Set<ConvertiblePair> getConvertibleTypes() {
          
          Set<ConvertiblePair> result = new HashSet<ConvertiblePair>();
          
  		Iterable<ConverterKey<?,?>> entries = BINDING.getConverterEntries();
          for (ConverterKey<?,?> next : entries) {
              result.add(new ConvertiblePair(next.getInputClass(), next.getOutputClass()));
          }
          
          return result;
      }
  
      /**
       * {@inheritDoc}
       */
      /* @Override */
      public Object convert(Object object, TypeDescriptor sourceType, TypeDescriptor targetType) {
          
          final Object result;
          result = BINDING.convertTo(object.getClass(), targetType.getObjectType(), object, matchAnnotationToScope(targetType.getAnnotations()));
          return result;
      }
  
      /**
       * {@inheritDoc}
       */
      public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
  
          try {
              BINDING.findConverter(sourceType.getObjectType(), targetType.getObjectType(), matchAnnotationToScope(targetType.getAnnotations()));
              return true;
          } catch (IllegalStateException e) {
              return false;
          }    	
      }
      
      /**
       * Helper method for matching and returning a scope annotation 
       * @param annotations Annotations to inspect for a scope annotation
       * @return The matched annotation
       */
      private <T> Class<? extends Annotation> matchAnnotationToScope(Annotation[] annotations) {
  
          for (Annotation next : annotations) {
              Class<? extends Annotation> nextType = next.annotationType();
              if (nextType.getAnnotation(BindingScope.class) != null) {
                  return nextType;
              }
          }
          return DefaultBinding.class;
      }
  }