/*

  * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH

  *

  * 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 de.smartics.properties.spi.core.convert;

 import java.lang.reflect.Method;

 import java.lang.reflect.Modifier;

 import org.apache.commons.beanutils.ConversionException;

 import org.apache.commons.beanutils.Converter;

 import org.apache.commons.lang.ObjectUtils;

 import de.smartics.util.lang.Arg;

 import de.smartics.util.lang.NullArgumentException;

 /**

  * Converter for types that provide a static <code>fromString</code> or

  * <code>valueOf</code> method.

  *

  * <pre>

  * public static T fromString(String value);

  * </pre>

  *

  * <pre>

  * public static T valueOf(String value);

  * </pre>

  */

 final class FromStringTypeConverter implements Converter

 { // NOPMD

   // ********************************* Fields *********************************

   // --- constants ------------------------------------------------------------

   // --- members --------------------------------------------------------------

   /**

    * The type to convert.

    */

   private final Class<?> type;

   /**

    * The static <code>fromString</code> method of {@link #type}.

    */

   private final Method fromStringMethod;

   // ****************************** Initializer *******************************

   // ****************************** Constructors ******************************

   /**

    * Default constructor.

    *

    * @param type the type to convert.

    * @throws NullArgumentException if {@code type} is <code>null</code>.

    * @throws IllegalArgumentException if {@code type} does not provide a static

    *           <code>fromString</code> method.

    */

   FromStringTypeConverter(final Class<?> type) throws IllegalArgumentException,

     NullArgumentException

   {

     this.type = Arg.checkNotNull("type", type);

     this.fromStringMethod = calcStaticFromStringMethod(type);

   }

   // ****************************** Inner Classes *****************************

   // ********************************* Methods ********************************

   // --- init -----------------------------------------------------------------

   private static Method calcStaticFromStringMethod(final Class<?> type)

   {

     final Method method = getMethod(type);

     checkStatic(type, method);

     final Class<?> returnType = method.getReturnType();

     checkNonVoid(type, returnType);

     checkNonPrimitiveType(type, returnType);

     return method;

   }

   private static Method getMethod(final Class<?> type)

   {

     try

     {

       final Method method = type.getMethod("fromString", String.class);

       return method;

     }

     catch (final SecurityException e)

     {

       return retryWithValueOf(type, e);

     }

     catch (final NoSuchMethodException e)

     {

       return retryWithValueOf(type, e);

     }

   }

   private static Method retryWithValueOf(final Class<?> type,

       final SecurityException e)

   {

     final IllegalArgumentException previous =

         new IllegalArgumentException(String.format(

             "Method 'fromString' of type '%s' cannot be accessed.",

             type.getName()), e);

     try

     {

       final Method method = type.getMethod("valueOf", String.class);

       return method;

     }

     catch (final SecurityException e2)

     {

       throw createValueOfCannotBeAccessed(type, previous); // NOPMD

     }

     catch (final NoSuchMethodException e2)

     {

       throw createValueOfDoesNotExist(type, previous); // NOPMD

     }

   }

   private static Method retryWithValueOf(final Class<?> type,

       final NoSuchMethodException e)

   {

     final IllegalArgumentException previous =

         new IllegalArgumentException(

             String.format("Method 'fromString' of type '%s' does not exist.",

                 type.getName()), e);

     try

     {

       final Method method = type.getMethod("valueOf", String.class);

       return method;

     }

     catch (final SecurityException e2)

     {

       throw createValueOfCannotBeAccessed(type, previous); // NOPMD

     }

     catch (final NoSuchMethodException e2)

     {

       throw createValueOfDoesNotExist(type, previous); // NOPMD

     }

   }

   private static IllegalArgumentException createValueOfDoesNotExist(

       final Class<?> type, final IllegalArgumentException previous)

   {

     return new IllegalArgumentException(String.format(

         "Method 'valueOf' of type '%s' does exist.", type.getName()), previous);

   }

   private static IllegalArgumentException createValueOfCannotBeAccessed(

       final Class<?> type, final IllegalArgumentException previous)

   {

     return new IllegalArgumentException(String.format(

         "Method 'valueOf' of type '%s' cannot be accessed.", type.getName()),

         previous);

   }

   private static void checkStatic(final Class<?> type, final Method method)

   {

     if (!Modifier.isStatic(method.getModifiers()))

     {

       throw new IllegalArgumentException(String.format(

           "Method 'fromString' of type '%s' is not static.", type.getName()));

     }

   }

   private static void checkNonPrimitiveType(final Class<?> type,

       final Class<?> returnType)

   {

     if (returnType.isPrimitive())

     {

       throw new IllegalArgumentException(

           String

               .format(

                   "Method 'fromString' of type '%s' is required to return a non-primitive type.",

                   type.getName()));

     }

   }

   private static void checkNonVoid(final Class<?> type,

       final Class<?> returnType)

   {

     if (Void.TYPE.equals(returnType))

     {

       throw new IllegalArgumentException(

           String

               .format(

                   "Method 'fromString' of type '%s' is required to return a non-void type.",

                   type.getName()));

     }

   }

   // --- get&set --------------------------------------------------------------

   // --- business -------------------------------------------------------------

   @Override

   @SuppressWarnings("rawtypes")

   public Object convert(final Class toType, final Object value)

     throws ConversionException

   {

     try

     {

       return convertFromString(toType, value);

     }

     catch (final ConversionException e)

     {

       throw e;

     }

     catch (final IllegalArgumentException e)

     {

       throw new ConversionException("Cannot convert value: " + e.getMessage(),

           e);

     }

     catch (final RuntimeException e)

     {

       throw new ConversionException(

           "Can only convert to/from String, not to/from " + type.getName(), e);

     }

   }

   @SuppressWarnings("rawtypes")

   private Object convertFromString(final Class toType, final Object value)

     throws ConversionException

   {

     final Object converted;

     final String stringValue = ObjectUtils.toString(value, null);

     if (String.class == toType)

     {

       converted = stringValue;

     }

     else

     {

       converted = convertFromString(stringValue);

     }

     return converted;

   }

   private Object convertFromString(final String stringValue)

   {

     try

     {

       final Object instance = fromStringMethod.invoke(type, stringValue);

       return instance;

     }

     catch (final Exception e)

     {

       throw new ConversionException(String.format(

           "Cannot convert '%s' to an instance of type '%s'.", stringValue,

           type.getName()), e);

     }

   }

   // --- object basics --------------------------------------------------------

 }