/*

  * 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.config.proxy;

 import java.io.Serializable;

 import java.lang.reflect.Method;

 import de.smartics.properties.api.config.domain.SerializableConfigurationProperties;

 import de.smartics.properties.api.config.domain.UnknownPropertyException;

 import de.smartics.properties.api.core.annotations.PropertyMetaDataMethod;

 import de.smartics.properties.api.core.domain.PropertiesContext;

 import de.smartics.properties.api.core.domain.PropertyDescriptor;

 import de.smartics.properties.api.core.domain.PropertyKey;

 import de.smartics.properties.api.core.domain.PropertyValidationException;

 import de.smartics.properties.spi.core.metadata.PropertyMetaDataParser;

 import de.smartics.util.lang.Arg;

 /**

  * The invocation handler receives every method invocation on the proxy that is

  * wrapped over the properties interface. It analyzes the intent of this method

  * call and provides (calculates) the return value. The main task is to detect

  * whether a value, a property key or a property description has to be returned.

  * After this decision making the task to calculate the return value is

  * delegated to a specialized class.

  */

 public final class PropertiesProxyInvocationHandler implements

     java.lang.reflect.InvocationHandler, Serializable

 {

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

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

   /**

    * The class version identifier.

    */

   private static final long serialVersionUID = 1L;

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

   /**

    * To access the properties.

    *

    * @serial

    */

   private final SerializableConfigurationProperties configurationProperties;

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

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

   /**

    * Default constructor.

    *

    * @param configurationProperties the configuration properties on that the

    *          method calls are delegated.

    * @throws NullPointerException if {@code configurationProperties} is

    *           <code>null</code>.

    */

   public PropertiesProxyInvocationHandler(

       final SerializableConfigurationProperties configurationProperties)

     throws NullPointerException

   {

     this.configurationProperties =

         Arg.checkNotNull("configurationProperties", configurationProperties);

   }

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

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

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

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

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

   /**

    * {@inheritDoc}

    *

    * @throws InvalidArgumentsException when arguments are passed. Only no arg

    *           methods are supported.

    * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object,

    *      java.lang.reflect.Method, java.lang.Object[])

    */

   public Object invoke(final Object proxy, final Method method,

       final Object[] args) throws InvalidArgumentsException

   {

     if (proxy == null)

     {

       return null;

     }

     final String methodName = method.getName();

     if ("equals".equals(methodName))

     {

       return handleMethodEquals(proxy, args);

     }

     checkNoArgs(args);

     if ("toString".equals(methodName))

     {

       return handleMethodToString(proxy);

     }

     else if ("hashCode".equals(methodName))

     {

       return handleMethodHashCode(proxy);

     }

     return handlePropertyMethod(method);

   }

   private Object handlePropertyMethod(final Method method)

     throws UnknownPropertyException, PropertyValidationException,

     InvalidArgumentsException

   {

     final Class<?> declaringClass = method.getDeclaringClass();

     final PropertiesContext context =

         configurationProperties.getContext(declaringClass);

     final PropertyMetaDataParser parser =

         PropertyMetaDataParser.create(context);

     if (isPropertyKeyMethod(method))

     {

       final Method propertyMethod =

           PropertyMethodNameUtilities.fetchPropertyMethod(method);

       return parser.readKey(propertyMethod);

     }

     else if (isPropertyDescriptorMethod(method))

     {

       final Method propertyMethod =

           PropertyMethodNameUtilities.fetchPropertyMethod(method);

       return parser.readDescriptor(propertyMethod);

     }

     else if (isPropertyMethod(method))

     {

       final PropertyKey key = parser.readKey(method);

         final Object propertyValue =

             configurationProperties.getPropertyValue(key);

         return propertyValue;

     }

     else

     {

       throw new InvalidArgumentsException(

           "The method '" + method.getName() + "' of interface '"

               + method.getDeclaringClass().getCanonicalName()

               + "' is not a property method, not a property key method and "

               + "not a property descriptor method.");

     }

   }

   Object handleMethodEquals(final Object proxy, final Object[] args)

   {

     checkOneArg(args);

     return proxy == args[0];

   }

   private Object handleMethodHashCode(final Object proxy)

     throws SecurityException

   {

     final Method[] methods = proxy.getClass().getMethods();

     int hash = proxy.getClass().getCanonicalName().hashCode();

     for (int i = 0; i < methods.length; i++)

     {

       hash = hash * 37 + methods[i].getName().hashCode();

     }

     return hash;

   }

   private Object handleMethodToString(final Object proxy)

     throws SecurityException

   {

     final StringBuilder toStringBuilder =

         new StringBuilder("Proxy for: ").append(proxy.getClass().getName());

     final Method[] methods = proxy.getClass().getMethods();

     for (int i = 0; i < methods.length; i++)

     {

       toStringBuilder.append("::").append(methods[i].getName());

     }

     return toStringBuilder.toString();

   }

   private boolean isPropertyKeyMethod(final Method m)

   {

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

     return PropertyKey.class.equals(returnType);

   }

   private boolean isPropertyDescriptorMethod(final Method m)

   {

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

     return PropertyDescriptor.class.equals(returnType);

   }

   private boolean isPropertyMethod(final Method m)

   {

     return !PropertyMethodNameUtilities.isMethodAnnotatedWithAnnotation(

         PropertyMetaDataMethod.class, m);

   }

   /**

    * Check that the method called has exactly one arg.

    *

    * @param args the method args.

    */

   private void checkOneArg(final Object[] args)

   {

     if (args == null || args.length != 1)

     {

       throw new InvalidArgumentsException("Equals need one parameter.");

     }

   }

   /**

    * Check that the method called has no args, as only noarg methods are

    * supported for property methods right now.

    *

    * @param args the method args.

    */

   private void checkNoArgs(final Object[] args)

   {

     if (args != null && args.length > 0)

     {

       throw new InvalidArgumentsException(

           "Only methods without arguments are supported for property methods.");

     }

   }

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

 }