/*
    *  Licensed to the Apache Software Foundation (ASF) under one
    *  or more contributor license agreements.  See the NOTICE file
    *  distributed with this work for additional information
    *  regarding copyright ownership.  The ASF licenses this file
    *  to you 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.apache.mina.integration.beans;
  
  import java.beans.PropertyEditor;
  import java.util.Collection;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  import java.util.Set;
  
  /**
   * A factory that creates a new {@link PropertyEditor} which is appropriate for
   * the specified object or class. 
   * 
   * @author <a href="http://mina.apache.org">Apache MINA Project</a>
   */
  public final class PropertyEditorFactory {
      private PropertyEditorFactory() {
      }
  
      /**
       * Creates a new instance of editor, depending on the given object's type
       * 
       * @param object The object we need an editor to be created for
       * @return The created editor
       */
      @SuppressWarnings("unchecked")
      public static PropertyEditor getInstance(Object object) {
          if (object == null) {
              return new NullEditor();
          }
  
          if (object instanceof Collection<?>) {
              Class<?> elementType = null;
              
              for (Object e : (Collection<Object>) object) {
                  if (e != null) {
                      elementType = e.getClass();
                      
                      break;
                  }
              }
  
              if (elementType != null) {
                  if (object instanceof Set) {
                      return new SetEditor(elementType);
                  }
  
                  if (object instanceof List) {
                      return new ListEditor(elementType);
                  }
  
                  return new CollectionEditor(elementType);
              }
          }
  
          if (object instanceof Map) {
              Class<?> keyType = null;
              Class<?> valueType = null;
              
              for (Object entry : ((Map<?,?>) object).entrySet()) {
                  Map.Entry<?,?> e = (Map.Entry<?,?>) entry;
                  
                  if ((e.getKey() != null) && (e.getValue() != null)) {
                      keyType = e.getKey().getClass();
                      valueType = e.getValue().getClass();
                      
                      break;
                  }
              }
  
              if ((keyType != null) && (valueType != null)) {
                  return new MapEditor(keyType, valueType);
              }
          }
  
          return getInstance(object.getClass());
      }
  
      /**
       * Creates a new instance of editor, depending on the given type
      * 
      * @param type The type of editor to create
      * @return The created editor
      */
     public static PropertyEditor getInstance(Class<?> type) {
         if (type == null) {
             throw new IllegalArgumentException("type");
         }
 
         if (type.isEnum()) {
             return new EnumEditor(type);
         }
 
         if (type.isArray()) {
             return new ArrayEditor(type.getComponentType());
         }
 
         if (Collection.class.isAssignableFrom(type)) {
             if (Set.class.isAssignableFrom(type)) {
                 return new SetEditor(String.class);
             }
 
             if (List.class.isAssignableFrom(type)) {
                 return new ListEditor(String.class);
             }
 
             return new CollectionEditor(String.class);
         }
 
         if (Map.class.isAssignableFrom(type)) {
             return new MapEditor(String.class, String.class);
         }
 
         if (Properties.class.isAssignableFrom(type)) {
             return new PropertiesEditor();
         }
 
         try {
             return (PropertyEditor) PropertyEditorFactory.class
                     .getClassLoader()
                     .loadClass(
                             PropertyEditorFactory.class.getPackage().getName() + '.' + 
                             filterPrimitiveType(type).getSimpleName() + "Editor")
                     .newInstance();
         } catch (Exception e) {
             return null;
         }
     }
 
     private static Class<?> filterPrimitiveType(Class<?> type) {
         if (type.isPrimitive()) {
             if (type == boolean.class) {
                 return Boolean.class;
             }
             
             if (type == byte.class) {
                 return Byte.class;
             }
             
             if (type == char.class) {
                 return Character.class;
             }
             
             if (type == double.class) {
                 return Double.class;
             }
             
             if (type == float.class) {
                 return Float.class;
             }
             
             if (type == int.class) {
                 return Integer.class;
             }
             
             if (type == long.class) {
                 return Long.class;
             }
             
             if (type == short.class) {
                 return Short.class;
             }
         }
         
         return type;
     }
 }