/*
    * 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 --------------------------------------------------------
 
 }