/* ========================================================================
 * JCommon : a free general purpose class library for the Java(tm) platform
 * ========================================================================
 *
 * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
 * 
 * Project Info:  http://www.jfree.org/jcommon/index.html
 *
 * This library is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by 
 * the Free Software Foundation; either version 2.1 of the License, or 
 * (at your option) any later version.
 *
 * This library 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 Lesser General Public 
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 
 * USA.  
 *
 * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 
 * in the United States and other countries.]
 * 
 * ------------------------
 * JavaSourceCollector.java
 * ------------------------
 * (C)opyright 2003, 2004, by Thomas Morgner and Contributors.
 *
 * Original Author:  Thomas Morgner;
 * Contributor(s):   David Gilbert (for Object Refinery Limited);
 *
 * $Id: JavaSourceCollector.java,v 1.3 2005/10/18 13:32:20 mungady Exp $
 *
 * Changes
 * -------------------------
 * 21.06.2003 : Initial version
 *
 */

package org.jfree.xml.generator;

import java.io.File;
import java.io.FileFilter;
import java.lang.reflect.Modifier;
import java.util.ArrayList;

import org.jfree.ui.ExtensionFileFilter;
import org.jfree.util.Log;
import org.jfree.util.ObjectUtilities;

/**
 * The class collects all class-files and loads the class objects named
 * by these files.
 */
public class JavaSourceCollector implements SourceCollector {

    /**
     * A file filter.
     */
    private static class CollectorFileFilter extends ExtensionFileFilter implements FileFilter {
        /**
         * Creates a new instance.
         * 
         * @param description  the file description.
         * @param extension  the file extension.
         */
        public CollectorFileFilter(final String description, final String extension) {
            super(description, extension);
        }
    }

    /** A file filter. */
    private CollectorFileFilter eff;
    
    /** The file list. */
    private ArrayList fileList;
    
    /** A list of ignored packages. */
    private ArrayList ignoredPackages;

    /** A list of ignored base classes. */
    private ArrayList ignoredBaseClasses;
    
    /** The start directory. */
    private File startDirectory;
    
    /** The initial package name. */
    private String initialPackageName;

    /**
     * Creates a new source collector.
     * 
     * @param startDirectory  the start directory.
     */
    public JavaSourceCollector(final File startDirectory) {
        this(startDirectory, "");
    }

    /**
     * Creates a new source collector.
     * 
     * @param startDirectory  the base directory.
     * @param packageName  the base package name.
     */
    public JavaSourceCollector(final File startDirectory, final String packageName) {
        this.eff = new CollectorFileFilter("<ignore>", ".java");
        this.fileList = new ArrayList();
        this.startDirectory = startDirectory;
        this.initialPackageName = packageName;
        this.ignoredPackages = new ArrayList();
        this.ignoredBaseClasses = new ArrayList();
    }

    /**
     * Adds a package that should be ignored.
     * 
     * @param pkg  the package name.
     */
    public void addIgnoredPackage(final String pkg) {
        Log.debug (new Log.SimpleMessage("Added IgnPackage: " , pkg));
        this.ignoredPackages.add(pkg);
    }

    /**
     * Adds a base class that should be ignored.
     * 
     * @param baseClass  the base class name.
     */
    public void addIgnoredBaseClass(final String baseClass) {
        final Class loadedClass = loadClass(baseClass);
        if (loadedClass != null) {
            Log.debug (new Log.SimpleMessage("Added IgnClass: " , baseClass));
            this.ignoredBaseClasses.add(loadedClass);
        }
    }

    /**
     * Adds a class to the list of ignored base classes.
     * 
     * @param baseClass  the class.
     */
    public void addIgnoredBaseClass(final Class baseClass) {
        this.ignoredBaseClasses.add(baseClass);
    }

    /**
     * Returns <code>true</code> if the named class is being ignored (because of the package that 
     * it belongs to), and <code>false</code> otherwise.
     * 
     * @param classname  the name of the class to test.
     * 
     * @return A boolean.
     */
    protected boolean isIgnoredPackage(final String classname) {
        for (int i = 0; i < this.ignoredPackages.size(); i++) {
            final String ignoredPackage = (String) this.ignoredPackages.get(i);
            if (classname.startsWith(ignoredPackage)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Returns <code>true</code> if the named class is being ignored (because it is a descendant
     * of an ignored base class), and <code>false</code> otherwise.
     * 
     * @param c  the class name.
     * 
     * @return A boolean.
     */
    protected boolean isIgnoredBaseClass(final Class c) {
        for (int i = 0; i < this.ignoredBaseClasses.size(); i++) {
            final Class ignoredClass = (Class) this.ignoredBaseClasses.get(i);
            if (ignoredClass.isAssignableFrom(c)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Collects the files/classes.
     */
    public void collectFiles() {
        collectFiles(this.startDirectory, this.initialPackageName);
    }

    /**
     * Collects the files/classes.
     * 
     * @param directory  the starting directory.
     * @param packageName  the initial package name.
     */
    protected void collectFiles(final File directory, final String packageName) {
        final File[] files = directory.listFiles(this.eff);
        for (int i = 0; i < files.length; i++) {
            if (files[i].isDirectory()) {
                collectFiles(files[i], buildJavaName(packageName, files[i].getName()));
            }
            else {
                final String fname = files[i].getName();
                final String className = fname.substring(0, fname.length() - 5);
                final String fullName = buildJavaName(packageName, className);
                if (isIgnoredPackage(fullName)) {
                    Log.debug (new Log.SimpleMessage("Do not process: Ignored: ", className));
                    continue;
                }
                final Class jclass = loadClass(fullName);
                if (jclass == null || isIgnoredBaseClass(jclass)) {
                    continue;
                }
                if (jclass.isInterface() || Modifier.isAbstract(jclass.getModifiers())) {
                    Log.debug (new Log.SimpleMessage("Do not process: Abstract: ", className));
                    continue;
                }
                if (!Modifier.isPublic(jclass.getModifiers())) {
                    Log.debug (new Log.SimpleMessage("Do not process: Not public: ", className));
                    continue;
                }
                this.fileList.add(jclass);
            }
        }
    }

    /**
     * Loads a class by its fully qualified name.
     * 
     * @param name  the class name.
     * 
     * @return The class (or <code>null</code> if there was a problem loading the class).
     */
    protected Class loadClass(final String name) {
        try {
            return ObjectUtilities.getClassLoader(JavaSourceCollector.class).loadClass(name);
        }
        catch (Exception e) {
            Log.warn (new Log.SimpleMessage("Do not process: Failed to load class:", name));
            return null;
        }
    }

    /**
     * Creates a fully qualified Java class or package name.
     * 
     * @param packageName  the base package name.
     * @param newPackage  the class/package name.
     * 
     * @return The fully qualified package/class name.
     */
    protected String buildJavaName(final String packageName, final String newPackage) {
        if (packageName.length() == 0) {
            return newPackage;
        }
        else {
            return packageName + "." + newPackage;
        }
    }

    /**
     * Returns the list of classes as an array.
     * 
     * @return The list of classes.
     */
    public Class[] getClasses() {
        return (Class[]) this.fileList.toArray(new Class[0]);
    }
    
}