/*
    * Copyright (C) 2005 by Arno Schumacher
    *
    * This file is part of net.sourceforge.servletspy
    *
    * net.sourceforge.servletspy is free software; you can redistribute
    * it and/or modify it under the terms of the GNU General Public 
    * License as published by the Free Software Foundation; either 
   * version 2, or (at your option) any later version.
   *
   * net.sourceforge.servletspy is distributed in the hope that it will
   * be useful, but WITHOUT ANY WARRANTY; without even the implied 
   * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
   * See the GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA 
   */
  
  package net.sourceforge.servletspy.handler.base;
  
  import java.beans.BeanInfo;
  import java.beans.Introspector;
  import java.beans.PropertyDescriptor;
  import java.lang.reflect.Method;
  import java.lang.reflect.Modifier;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.StringTokenizer;
  
  import net.sourceforge.servletspy.IContext;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /***
   * @author arno schumacher
   */
  public abstract class AbstractInterfaceTransformer extends AbstractHandler {
  
      /*** The logger. */
      private static final Log LOGGER = LogFactory
              .getLog(AbstractInterfaceTransformer.class);
  
      /***
       * Returns an array of <code>java.lang.Class</code> objects using
       * the provided space separated string of class names as input.
       *
       * @param clazzes The class names, space separated.
       * @return An array of <code>java.lang.Class</code> objects.
       */
      protected static Class[] fromString(final String clazzes) {
          final List interfaceList = new ArrayList();
          final StringTokenizer st = new StringTokenizer(clazzes);
          while (st.hasMoreTokens()) {
              Class clazz = loadInterface(st.nextToken().trim());
              if (clazz != null) {
                  interfaceList.add(clazz);
              }
          }
          return (Class[]) interfaceList.toArray(new Class[0]);
      }
  
      /***
       * Loads a <code>java.lang.Class</code>.
       *
       * @param s The name of the class.
       * @return The class object or <code>null</code> in case of an error.
       */
      private static Class loadInterface(final String s) {
          Class clazz = null;
          try {
              clazz =
                  Thread.currentThread().getContextClassLoader().loadClass(s);
              if (!clazz.isInterface()) {
                  clazz = null;
              }
          } catch (Exception e) {
              LOGGER.warn("Could not load class '" + s + "'");
          }
          return clazz;
      }
  
      private Class[] classes = new Class[0];
  
      /***
       * Constructor.
       */
      protected AbstractInterfaceTransformer() {
      }
  
      /***
       * Constructor.
       *
       * @param clazz an array of class specifying the interfaces for which
       *    the transformer is applicable.
       */
     protected AbstractInterfaceTransformer(final Class[] clazz) {
         if (clazz != null) {
             this.classes = clazz;
         }
     }
 
     /***
      * Constructor.
      *
      * @param s space separated string of class names specifying the
      *    interfaces for which the transformer is applicable.
      */
     protected AbstractInterfaceTransformer(final String s) {
         this(fromString(s));
     }
 
     /* (non-Javadoc)
      * @see net.sourceforge.servletspy.IContextHandler#handle(net.sourceforge.servletspy.IContext)
      */
     public final void handle(final IContext context) throws Exception {
         final Object subject = context.getSubject();
         for (int i = 0; i < classes.length; i++) {
             if (classes[i] == null) {
                 continue;
             }
             if (classes[i].isAssignableFrom(subject.getClass())) {
                 handleClass(context, classes[i]);
                 return;
             }
         }
         context.proceed();
     }
 
     private void handleClass(final IContext context, final Class clazz) throws Exception {
         final BeanInfo beanInfo = Introspector.getBeanInfo(clazz, clazz
                 .isInterface() ? null : Object.class);
         final PropertyDescriptor[] apd = beanInfo.getPropertyDescriptors();
         for (int i = 0; i < apd.length; i++) {
             final PropertyDescriptor pd = apd[i];
             final Method m = pd.getReadMethod();
             final Class clazzType = pd.getPropertyType();
             if (m == null) {
                 continue;
             }
             // Readers with parameter, i.e. indexed properties.
             if (m.getParameterTypes().length > 0) {
                 continue;
             }
             // Exclude null types, just in case there exists an
             // 'invalid' user defined property descriptor.
             if (clazzType == null) {
                 continue;
             }
             if (!Modifier.isPublic(m.getModifiers())
                     || Modifier.isStatic(m.getModifiers())) {
                 continue;
             }
             // Guess the name of the property ...
             final String mName = m.getName();
             String key = null;
             if (mName.startsWith("get") && mName.length() > 3) {
                 key = Introspector.decapitalize(mName.substring(3));
             }
             if (mName.startsWith("is") && mName.length() > 2) {
                 key = Introspector.decapitalize(mName.substring(2));
             }
             final Object prop = m.invoke(context.getSubject(), new Object[0]);
             context.add(key, prop);
         }
     }
 }