// Class you need
package com.luna.lib.reflection;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import com.luna.lib.loggers.BasicLogger;
import com.luna.lib.loggers.enums.EnumLogType;

public class ClassEnumerator {
	/**
	 * Singleton instance
	 */
	private static volatile ClassEnumerator	instance;
	
	/**
	 * Returns the singleton instance creates one if the instance is null
	 * 
	 * @return instance
	 */
	public static ClassEnumerator getInstance() {
		if( instance == null ) {
			BasicLogger.getInstance().setDebug( true );
			instance = new ClassEnumerator();
		}
		return instance;
	}
	
	/**
	 * Parses a directory for jar files and class files
	 * 
	 * Recurses through if necessary
	 * 
	 * @param directory
	 *            directory to parse
	 * @return class array
	 */
	public List< Class< ? >> getClassesFromExternalDirectory( final File directory ) {
		final List< Class< ? >> classes = new ArrayList< Class< ? >>();
		for( final File file : directory.listFiles() ) {
			try {
				final ClassLoader classLoader = new URLClassLoader( new URL[ ] {
					file.toURI().toURL()
				}, /* this */directory.getClass().getClassLoader() );
				if( file.getName().toLowerCase().trim().endsWith( ".class" ) ) {
					BasicLogger.getInstance().log( EnumLogType.DEBUG, file.getName() );
					classes.add( classLoader.loadClass( file.getName().replace( ".class", "" )
							.replace( "/", "." ) ) );
				}
				if( file.getName().toLowerCase().trim().endsWith( ".jar" ) ) {
					classes.addAll( getClassesFromJar( file, classLoader ) );
				}
				if( file.isDirectory() ) {
					classes.addAll( getClassesFromExternalDirectory( file ) );
				}
			} catch( final MalformedURLException e ) {
				e.printStackTrace();
			} catch( final ClassNotFoundException e ) {
				e.printStackTrace();
			}
		}
		return classes;
	}
	
	/**
	 * Returns the class array of all classes within a package
	 * 
	 * @param classe
	 *            class to get code source location for
	 * 
	 * @return class array
	 */
	public Class< ? >[ ] getClassesFromPackage( final Class< ? > classe ) {
		final List< Class< ? >> classes = new ArrayList< Class< ? >>();
		URI uri = null;
		try {
			uri = classe.getProtectionDomain().getCodeSource().getLocation().toURI();
		} catch( final URISyntaxException e ) {
			e.printStackTrace();
		}
		if( uri == null ) {
			throw new RuntimeException( "No uri for "
					+ classe.getProtectionDomain().getCodeSource().getLocation() );
		}
		BasicLogger.getInstance().log( EnumLogType.DEBUG, "URI: " + uri.toString() );
		
		classes.addAll( processDirectory( new File( uri ), "" ) );
		return classes.toArray( new Class[ classes.size() ] );
	}
	
	/**
	 * Returns all class files inside a jar
	 * 
	 * @param file
	 *            jar file
	 * @param classLoader
	 *            classloader created previously using the jar file
	 * @return class list
	 */
	public List< Class< ? >> getClassesFromJar( final File file, final ClassLoader classLoader ) {
		final List< Class< ? >> classes = new ArrayList< Class< ? >>();
		try {
			final JarFile jarFile = new JarFile( file );
			final Enumeration< JarEntry > enumeration = jarFile.entries();
			while( enumeration.hasMoreElements() ) {
				final JarEntry jarEntry = enumeration.nextElement();
				if( jarEntry.isDirectory() || !jarEntry.getName().toLowerCase().trim().endsWith( ".class" ) ) {
					continue;
				}
				classes.add( classLoader.loadClass( jarEntry.getName().replace( ".class", "" )
						.replace( "/", "." ) ) );
			}
			jarFile.close();
		} catch( final IOException e ) {
			e.printStackTrace();
		} catch( final ClassNotFoundException e ) {
			e.printStackTrace();
		}
		return classes;
	}
	
	/**
	 * Processes a directory and retrieves all classes from it and its
	 * subdirectories
	 * 
	 * Recurses if necessary
	 * 
	 * @param directory
	 *            directory file to traverse
	 * @return list of classes
	 */
	private List< Class< ? >> processDirectory( final File directory, final String append ) {
		final List< Class< ? >> classes = new ArrayList< Class< ? >>();
		final String[ ] files = directory.list();
		for( final String fileName : files ) {
			String className = null;
			if( fileName.endsWith( ".class" ) ) {
				className = append + '.' + fileName.replace( ".class", "" );
			}
			if( className != null ) {
				classes.add( loadClass( className.substring( 1 ) ) );
			}
			final File subdir = new File( directory, fileName );
			if( subdir.isDirectory() ) {
				classes.addAll( processDirectory( subdir, append + "." + fileName ) );
			}
		}
		return classes;
	}
	
	/**
	 * Loads a class based upon the name
	 * 
	 * @param className
	 *            name of class (.class is pre removed)
	 * @return Class if it was loaded properly
	 */
	private Class< ? > loadClass( final String className ) {
		try {
			return Class.forName( className );
		} catch( final ClassNotFoundException e ) {
			throw new RuntimeException( "Error loading class '" + className + "'" );
		}
	}
}

// In your Module Manager class, use this to get the list of classes that are modules
	/**
	 * Parses the class code source to get modules from the retrieved classes
	 * 
	 * @param classe
	 *            class to get code source for
	 * @return module array from package
	 */
	private Module[ ] getModulesFromPackage( final Class< ? > classe ) {
		final List< Module > modules = new ArrayList<>();
		final Class< ? >[ ] classes = ClassEnumerator.getInstance().getClassesFromPackage( classe );
		for ( final Class< ? > c : classes ) {
			if ( Module.class.isAssignableFrom( c ) && !c.equals( Module.class ) ) {
				try {
					modules.add( ( Module ) c.newInstance() );
				} catch ( final InstantiationException e ) {
					e.printStackTrace();
				} catch ( final IllegalAccessException e ) {
					e.printStackTrace();
				}
			}
		}
		return modules.toArray( new Module[ modules.size() ] );
	}

// And then use the returned array to load your modules!