/*
      Copyright 2008 Ramon Servadei
   
      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 fulmine.model.field;
  
  import static fulmine.util.Utils.DOT;
  import static fulmine.util.Utils.safeToString;
  
  /**
   * Provides utility methods for working with {@link IField} instances
   * 
   * @author Ramon Servadei
   */
  public abstract class FieldUtils
  {
  
      /**
       * The name of a field that is created from a native type.
       * 
       * @see #createFromNative(Object)
       */
      public static final String CREATE_FROM_NATIVE = "createFromNative";
  
      /**
       * Create an instance of an {@link IField} using the parameters passed in.
       * The (String, String) constructor for the field class is located and
       * invoked.
       * 
       * @param <T>
       * @param field
       *            the field {@link Class}
       * @param fieldName
       *            the field name
       * @param fieldValue
       *            the field value
       * @return the field instance
       */
      @SuppressWarnings("unchecked")
      public static <T extends IField> T createFromString(
          Class<? extends IField> field, String fieldName, String fieldValue)
      {
          try
          {
              return (T) field.getConstructor(String.class, String.class).newInstance(
                  fieldName, fieldValue);
          }
          catch (Exception e)
          {
              throw new IllegalArgumentException(
                  "Could not construct an instance of " + field + " with name="
                      + fieldName + ", value=" + fieldValue, e);
          }
      }
  
      /**
       * Create an instance of an {@link IField} using the simple class name and
       * the name for the field
       * 
       * @param <T>
       * @param simpleClassName
       *            the simple class name, e.g. StringField
       * @param fieldName
       *            the name for the field
       * @return the field
       */
      @SuppressWarnings("unchecked")
      public static <T extends IField> T createFromString(String simpleClassName,
          String fieldName)
      {
          try
          {
              String packageName =
                  AbstractField.class.getPackage().getName() + DOT;
              final Class<?> fieldClass =
                  Class.forName(packageName + simpleClassName);
              return (T) fieldClass.getConstructor(String.class).newInstance(
                  fieldName);
          }
          catch (Exception e)
          {
              throw new IllegalArgumentException(
                  "Could not construct an instance of " + simpleClassName
                      + " with name=" + fieldName, e);
          }
      }
  
      /**
      * Create an instance of an {@link IField} using the simple class name and
      * the name for the field
      * 
      * @param <T>
      * @param simpleClassName
      *            the simple class name, e.g. StringField
      * @param fieldName
      *            the name for the field
      * @param application
      *            the application code for the field
      * @param permission
      *            the permission code for the field
      * @return the field
      */
     @SuppressWarnings({ "unchecked", "boxing" })
     public static <T extends IField> T createFromString(String simpleClassName,
         String fieldName, byte application, short permission)
     {
         try
         {
             String packageName =
                 AbstractField.class.getPackage().getName() + DOT;
             final Class<?> fieldClass =
                 Class.forName(packageName + simpleClassName);
             return (T) fieldClass.getConstructor(String.class, Byte.TYPE,
                 Short.TYPE).newInstance(fieldName, application, permission);
         }
         catch (Exception e)
         {
             throw new IllegalArgumentException(
                 "Could not construct an instance of " + simpleClassName
                     + " with name=" + fieldName, e);
         }
     }
 
     /**
      * Convert an object from its native object to a framework object
      * 
      * @param nativeObject
      *            the object to convert
      * @return a framework object
      * @throws IllegalArgumentException
      *             if the native object is not supported
      */
     @SuppressWarnings("boxing")
     public static IField createFromNative(Object nativeObject)
     {
         if (nativeObject == null)
         {
             return null;
         }
         if (nativeObject instanceof String)
         {
             return new StringField(CREATE_FROM_NATIVE, (String) nativeObject);
         }
         if (nativeObject instanceof Boolean)
         {
             return new BooleanField(CREATE_FROM_NATIVE, (Boolean) nativeObject);
         }
         if (nativeObject instanceof Integer)
         {
             return new IntegerField(CREATE_FROM_NATIVE, (Integer) nativeObject);
         }
         if (nativeObject instanceof Double)
         {
             return new DoubleField(CREATE_FROM_NATIVE, (Double) nativeObject);
         }
         if (nativeObject instanceof Long)
         {
             return new LongField(CREATE_FROM_NATIVE, (Long) nativeObject);
         }
         if (nativeObject instanceof Float)
         {
             return new FloatField(CREATE_FROM_NATIVE, (Float) nativeObject);
         }
         throw new IllegalArgumentException("Unhandled type "
             + safeToString(nativeObject.getClass()) + " value="
             + safeToString(nativeObject));
     }
 
     /**
      * Convert the native class to the framework class
      * 
      * @param nativeType
      *            the native class type
      * @return the framework class
      * @throws IllegalArgumentException
      *             if the native class is not compatible with the framework
      */
     public static Class<? extends IField> getFrameworkClass(Class<?> nativeType)
     {
         if (nativeType == null)
         {
             return null;
         }
         if (String.class.equals(nativeType))
         {
             return StringField.class;
         }
         if (Boolean.class.equals(nativeType) || Boolean.TYPE.equals(nativeType))
         {
             return BooleanField.class;
         }
         if (Integer.class.equals(nativeType) || Integer.TYPE.equals(nativeType))
         {
             return IntegerField.class;
         }
         if (Double.class.equals(nativeType) || Double.TYPE.equals(nativeType))
         {
             return DoubleField.class;
         }
         if (Long.class.equals(nativeType) || Long.TYPE.equals(nativeType))
         {
             return LongField.class;
         }
         if (Float.class.equals(nativeType) || Float.TYPE.equals(nativeType))
         {
             return FloatField.class;
         }
         throw new IllegalArgumentException("Unhandled type "
             + safeToString(nativeType));
     }
 }