/*
    * Copyright 2002-2004 The Apache Software Foundation
    *
    * 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 org.apache.commons.clazz;
  
  import java.lang.ref.WeakReference;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.clazz.common.ClazzElementSupport;
  import org.apache.commons.clazz.common.ExtendedClazzLoaderFactory;
  import org.apache.commons.clazz.common.StandardClazzLoaderFactory;
  
  /**
   * 
   * 
   * @author <a href="mailto:scolebourne@apache.org">Stephen Colebourne</a>
   * @author <a href="mailto:dmitri@apache.org">Dmitri Plotnikov</a>
   * @version $Id: Clazz.java 155436 2005-02-26 13:17:48Z dirkv $
   */
  public abstract class Clazz extends ClazzElementSupport
          implements ClazzElement
  {
      private ClazzLoader loader;
      private String name;
      private List listeners;
  
      /**
       * The name of the standard clazz model. The value of the constant is
       * "Standard".
       */
      public static final String STANDARD_CLAZZ_MODEL =
          StandardClazzLoaderFactory.MODEL;
  
      /**
       * The name of the extended clazz model. The value of the constant is
       * "Extended".
       */
      public static final String EXTENDED_CLAZZ_MODEL =
          ExtendedClazzLoaderFactory.MODEL;
          
      private static String defaultClazzModel = EXTENDED_CLAZZ_MODEL;
      private static ClazzLoader defaultClazzLoader;
      private static Map clazzLoaderFactories = new HashMap();
      
      static {
          addClazzLoaderFactory(StandardClazzLoaderFactory.FACTORY);
          addClazzLoaderFactory(ExtendedClazzLoaderFactory.FACTORY);
      }
          
      /**
       * Register a clazz loader factory, which manages ClazzLoaders, which manage
       * Clazzes.
       * 
       * @param clazzLoaderFactory
       */
      public static void addClazzLoaderFactory(ClazzLoaderFactory factory) {
          clazzLoaderFactories.put(factory.getClazzModel(), factory);
      }
      
      /**
       * Returns a ClazzLoaderFactory registered for the supplied model. We can
       * have multiple clazz loader factories implementing different models (e.g.
       * Standard JavaBeans, Extended JavaBeans etc).
       * 
       * @param model is the type of the model we need
       * @return ClazzLoaderFactory
       */
      public static ClazzLoaderFactory getClazzLoaderFactory(String model) {
          return (ClazzLoaderFactory) clazzLoaderFactories.get(model);
      }
      
      /**
       * Select the default clazz model.
       * 
       * @param defaultClazzModel
       */
      public static void setDefaultClazzModel(String defaultClazzModel) {
          Clazz.defaultClazzModel = defaultClazzModel;
      }
  
      /**
       * Returns the name of the default clazz model.
       */
     public static String getDefaultClazzModel() {
         return defaultClazzModel;
     }
 
     /**
      * Returns a clazz loader for the specified model.  The provided ClassLoader
      * can be used by the ClazzLoader for reflection.
      * 
      * @param model
      * @param classLoader
      * @return ClazzLoader
      */
     public static ClazzLoader getClazzLoader(
         String model,
         ClassLoader classLoader) 
     {
         if (classLoader == null) {
             classLoader = Clazz.class.getClassLoader();
         }
         return getClazzLoaderFactory(model).getClazzLoader(classLoader);
     }
 
     /**
      * Returns the ClazzLoader for the default clazz model.
      */    
     public static ClazzLoader getDefaultClazzLoader(ClassLoader classLoader) {
         return getClazzLoader(getDefaultClazzModel(), classLoader);
     }
     
     /**
      * Uses the clazz loader for the specified model to obtain the Clazz for the
      * supplied object.
      */
     public static Clazz getClazz(Object instance, String model) {
         if (instance == null) {
             throw new NullPointerException();
         }
 
         ClassLoader classLoader = instance.getClass().getClassLoader();
         Clazz clazz = getClazzLoader(model, classLoader).getClazz(instance);
         if (clazz == null) {
             throw new ClazzNotFoundException(instance.getClass().getName());
         }
         return clazz;
     }
     
     /**
      * Uses the default clazz loader to obtain the Clazz for the supplied
      * object.
      */
     public static Clazz getClazz(Object instance) {
         return getClazz(instance, getDefaultClazzModel());
     }    
         
     /**
      * Keep the constructor protected or private, we want Clazzes to 
      * be created by the ClazzLoaders only.
      *  
      * @param loader is the owning model clazz loader
      * @param name must be unique within the model
      */
     protected Clazz(ClazzLoader modelClazzLoader, String name) {
         this.loader = modelClazzLoader;
         this.name = name;
     }
     
     /**
      * Every Clazz belongs to one and only one ClazzLoader. Its name is unique
      * within that loader.
      */
     public ClazzLoader getClazzLoader() {
         return loader;
     }
     
     /**
      * Returns the name of the Clazz. It is ok for the same name to be present
      * in different ClazzLoaders, except CachingClazzLoaders.
      */
     public String getName() {
         return name;
     }
     
     /**
      * Gets the package name.
      * 
      * @return the package name
      */
     public String getPackageName() {
         if (name == null) {
             return null;
         }
         int index = name.lastIndexOf('.');
         if (index == -1) {
             return "";
         }
         
         return name.substring(0, index);
     }
 
     /**
      * Gets the class name (without the package).
      * 
      * @return the class name (without the package)
      */
     public String getShortClassName() {
         if (name == null) {
             return null;
         }
         int index = name.lastIndexOf('.');
         if (index == -1) {
             return name;
         }
         
         return name.substring(index + 1);
     }
 
     /**
      * Returns the class of instances created by the <code>newInstance()</code>
      * method.
      */    
     public abstract Class getInstanceClass();
     
     /**
      * Returns the superclazz for this Clazz, or null if there is none.
      */
     public abstract Clazz getSuperclazz();
     
     /**
      * Returns true if the supplied clazz is either the same or a subclazz of
      * this clazz.
      */
     public boolean isAssignableFrom(Clazz clazz) {
         if (clazz == this) {
             return true;
         }
         Clazz superclazz = clazz.getSuperclazz();
         if (superclazz != null) {
             return isAssignableFrom(superclazz);
         }
         return false;
     }
     
     /**
      * Returns properties declared by this Clazz, not its superclazzes
      */
     public abstract List getDeclaredProperties();
 
     /**
      * Returns all properties for this clazz, including those declared
      * by superclazzes.
      */
     public abstract List getProperties();
 
     /**
      * Returns the properties that match the Predicate.
      */
 //    public abstract List getProperties(Predicate predicate);
 
     /**
      * Returns a ClazzProperty for the given name
      */
     public abstract ClazzProperty getProperty(String name);
 
     /**
      * Returns all Operations for this clazz.
      */
     public abstract List getOperations();
 
     /**
      * Returns all Operations declared by this clazz, not its superclazzes.
      */
     public abstract List getDeclaredOperations();
 
     /**
      * Returns the Operations that match the Predicate.
      */
 //    public abstract List getOperations(Predicate predicate);
 
     /**
      * Returns the Operation for the given signature. The signature should be
      * formatted as follows: <code>"name(paramClazzName1,...)"</code>
      */
     public abstract ClazzOperation getOperation(String signature);
 
     /**
      * Returns all InstanceFactories for this clazz.
      */
     public abstract List getInstanceFactories();
 
     /**
      * Returns the InstanceFactories that match the Predicate.
      */
 //    public abstract List getInstanceFactories(Predicate predicate);
 
     /**
      * Returns ClazzInstanceFactory for the given signature. The signature
      * should be formatted as follows: <code>"(paramClazzName1,...)"</code>. You
      * can pass <code>null</code> in place of <code>"()"</code>. 
      */
     public abstract ClazzInstanceFactory getInstanceFactory(String signature);
     
     /**
      * Creates a new instance of this Clazz using the InstanceFactory that takes
      * no parameters.
      */
     public Object newInstance() {
         ClazzInstanceFactory factory = getInstanceFactory("()");
         if (factory == null) {
             // @todo: define exception
             throw new RuntimeException(
                 "No such instance factory " + getName() + " ()");
         }
         return factory.newInstance(null);
     }
 
     /**
      * Creates a new instance of this Clazz using the InstanceFactory
      * with the specified signature.
      */
     public Object newInstance(String signature, Object[] parameters) {
         ClazzInstanceFactory factory = getInstanceFactory(signature);
         if (factory == null) {
             // @todo: define exception
             throw new RuntimeException(
                 "No such instance factory "
                     + getName()
                     + (signature == null ? "" : " " + signature));
         }
         return factory.newInstance(parameters);
     }
     
     
     //--- Notification mechanism - verbose, but what are you gonna do?
     
     public void addClazzChangeListener(ClazzChangeListener listener) {
         if (listeners == null) {
             listeners = new ArrayList();
         }
         
         // We don't want to prevent the subclasses from being garbage
         // collection just because they are listening to their superclasses. 
         WeakReference reference = new WeakReference(listener);
         listeners.add(reference);
     }
     
     public void removeClazzChangeListener(ClazzChangeListener listener) {
         if (listeners == null) {
             return;
         }
         for (Iterator iter = listeners.iterator(); iter.hasNext();) {
             WeakReference reference = (WeakReference) iter.next();
             if (reference.get() == listener) {
                 iter.remove();
                 break;
             }
         }
     }
         
     private static final WeakReference[] CLAZZ_CHANGE_LISTENER_ARRAY =
             new WeakReference[0];
 
     private abstract static class Notifier {
         void fire(Clazz clazz, Object parameter) {
             if (clazz.listeners != null && clazz.listeners.size() != 0) {
                 WeakReference listenerArray[] =
                     (WeakReference[]) clazz.listeners.toArray(
                         CLAZZ_CHANGE_LISTENER_ARRAY);
                 for (int i = 0; i < listenerArray.length; i++) {
                     fire(
                         clazz,
                         (ClazzChangeListener) listenerArray[i].get(),
                         parameter);
                 }
             }
         }
         
         abstract void fire(
             Clazz clazz, ClazzChangeListener listener, Object parameter);
     }
     
     private static final Notifier PROPERTY_ADDED_NOTIFIER = new Notifier() {
         void fire(Clazz clazz, ClazzChangeListener listener, Object parameter) {
             listener.propertyAdded(clazz, (ClazzProperty) parameter);
         }
     };
                     
     protected void firePropertyAdded(ClazzProperty property) {
         PROPERTY_ADDED_NOTIFIER.fire(this, property);
     }
 
     private static final Notifier PROPERTY_REMOVED_NOTIFIER = new Notifier() {
         void fire(Clazz clazz, ClazzChangeListener listener, Object parameter) {
             listener.propertyRemoved(clazz, (ClazzProperty) parameter);
         }
     };
 
     protected void firePropertyRemoved(ClazzProperty property) {
         PROPERTY_REMOVED_NOTIFIER.fire(this, property);
     }
 
     private static final Notifier OPERATION_ADDED_NOTIFIER = new Notifier() {
         void fire(Clazz clazz, ClazzChangeListener listener, Object parameter) {
             listener.operationAdded(clazz, (ClazzOperation) parameter);
         }
     };
 
     protected void fireOperationAdded(ClazzOperation operation) {
         OPERATION_ADDED_NOTIFIER.fire(this, operation);
     }
 
     private static final Notifier OPERATION_REMOVED_NOTIFIER = new Notifier() {
         void fire(Clazz clazz, ClazzChangeListener listener, Object parameter) {
             listener.operationRemoved(clazz, (ClazzOperation) parameter);
         }
     };
 
     protected void fireOperationRemoved(ClazzOperation operation) {
         OPERATION_REMOVED_NOTIFIER.fire(this, operation);
     }
 
 
     private static final Notifier FACTORY_ADDED_NOTIFIER = new Notifier() {
         void fire(Clazz clazz, ClazzChangeListener listener, Object parameter) {
             listener.instanceFactoryAdded(
                 clazz,
                 (ClazzInstanceFactory) parameter);
         }
     };
 
     protected void fireInstanceFactoryAdded(ClazzInstanceFactory factory) {
         FACTORY_ADDED_NOTIFIER.fire(this, factory);
     }
 
     private static final Notifier FACTORY_REMOVED_NOTIFIER = new Notifier() {
         void fire(Clazz clazz, ClazzChangeListener listener, Object parameter) {
             listener.instanceFactoryRemoved(
                 clazz,
                 (ClazzInstanceFactory) parameter);
         }
     };
 
     protected void fireInstanceFactoryRemoved(ClazzInstanceFactory factory) {
         FACTORY_REMOVED_NOTIFIER.fire(this, factory);
     }
 
     //--- End notification mechanism
     
     
     /**
      * Creates a signature string out of an operation or instance factory name
      * and parameter types.
      */
     public static String constructSignature(String name, Class[] arguments) {
         StringBuffer buffer = new StringBuffer();
         if (name != null) {
             buffer.append(name);
         }
         buffer.append('(');
         if (arguments != null) {
             for (int i = 0; i < arguments.length; i++) {
                 if (i != 0) {
                     buffer.append(',');
                 }
                 buffer.append(getCanonicalClassName(arguments[i]));
             }
         }
         buffer.append(')');
         return buffer.toString();
     }
 
     /**
      * Creates a signature string out of an operation or instance factory name
      * and parameter types.
      */
     public static String constructSignature(String name, Clazz[] arguments) {
         StringBuffer buffer = new StringBuffer();
         if (name != null) {
             buffer.append(name);
         }
         buffer.append('(');
         if (arguments != null) {
             for (int i = 0; i < arguments.length; i++) {
                 if (i != 0) {
                     buffer.append(',');
                 }
                 buffer.append(arguments[i].getName());
             }
         }
         buffer.append(')');
         return buffer.toString();
     }
     
     /**
      * Produces a nice type name for a classes representing an array, e.g. "[I"
      * is shown as "int[]". For non-array types returns the regular type name.
      */
     public static String getCanonicalClassName(Class javaClass) {
         /*
          * This is basically a remake of java.lang.reflect.Field.getTypeName
          * (Class), which cannot be used directly as it is declared with the
          * default scope.
          */
         if (javaClass.isArray()) {
             return getCanonicalClassName(javaClass.getComponentType()) + "[]";
         }
         return javaClass.getName();
     }
 }