/*
    * $Id: DatabaseConnectorFactory.java,v 1.17 2006/01/12 19:12:48 psionides Exp $
    * 
    */
   package net.sourceforge.jdbdump.connect;
   import java.io.File;
   import java.io.IOException;
   import java.net.JarURLConnection;
   import java.net.URL;
  import java.util.ArrayList;
  import java.util.Enumeration;
  import java.util.Iterator;
  import java.util.jar.JarFile;
  import java.util.zip.ZipEntry;
  import org.apache.log4j.Logger;
  
  /***
   * A DatabaseConnectorFactory is an object that lists all the database types that can be 
   * backed up and creates connectors to the specific database types.
   * Connectors are the objects that extend the DatabaseConnector class and provide methods that enable 
   * you to create backup of a specific database.
   * This class implements two design patterns: Factory and Singleton. 
   * Factory pattern makes it easy to produce the proper databse connector. 
   * Singleton pattern checks if there is only one instance of DatabaseConnectorFactory.
   *  
   * @author tomgur
   *
   */
  
  public class DatabaseConnectorFactory {
  	/***an object providing Singleton desing pattern implementation */
  	public static DatabaseConnectorFactory singleton = null; 
  	
  	/*** A log4j logger for this class. */
  	private static Logger logger = Logger.getLogger(DatabaseConnectorFactory.class);
  	
  	
  	/***
  	 * 
  	 * Imlements Singleton desing pattern 
  	 * 
  	 */
  	public static DatabaseConnectorFactory getInstance(){
  		if (singleton == null){
  			synchronized(DatabaseConnectorFactory.class){
  				DatabaseConnectorFactory localFactory = new DatabaseConnectorFactory();
  				singleton = localFactory;
  			}
  		}
  		
  		return singleton;
  	}
  	/***
  	 * Lists all database plugins that are available.
  	 * @return a list of available classes extending DatabaseConnector
  	 */
  	public String[] listPlugins() {
  		ArrayList<String> plugins = listPlugins("net.sourceforge.jdbdump.connect.connectors",
  			"net.sourceforge.jdbdump.connect.DatabaseConnector");
  		return (String[]) plugins.toArray(new String[0]);
  	}
  	
  	/***
  	 * Lists all the classes inheriting a given
  	 * class in the currently loaded packages.
  	 * @param tosubclassname the name of the class to inherit from
  	 * @throws ClassNotFoundException
  	 */
  	public ArrayList<String> listPlugins(String tosubclassname) {
  		ArrayList<String> pluginsTmp = new ArrayList<String>();
  		ArrayList<String> plugins = new ArrayList<String>();
  		String plugin;
  		try {
  			Class tosubclass = Class.forName(tosubclassname);
  			Package [] pcks = Package.getPackages();
  			for (int i=0;i<pcks.length;i++) {
  				
  				pluginsTmp = listPlugins(pcks[i].getName(), tosubclass);
  				if(pluginsTmp != null) {
  					for(Iterator it = pluginsTmp.iterator();it.hasNext();) {
  						plugin = it.next().toString();
  						plugins.add(plugin);
  					}
  				}
  			}
  		} 
  		catch (ClassNotFoundException ex) {
  			logger.warn("listPlugins(String tosubclassname): Error while finding class: " + ex);
  		}
  		
  		return plugins;
  	}
  	
  	
  	/***
  	 * Listss all the classes inheriting a given
  	 * class in a given package.
  	 * @param pckgname the fully qualified name of the package
  	 * @param tosubclass the name of the class to inherit from
 	 * @throws ClassNotFoundException
 	 */
 	public ArrayList<String> listPlugins(String pckname, String tosubclassname) {
 		ArrayList<String> plugins = new ArrayList<String>();
 		try {
 			Class tosubclass = Class.forName(tosubclassname);
 			plugins = listPlugins(pckname,tosubclass);
 		} 
 		catch (ClassNotFoundException e) {
 			logger.error("listPlugins(String pckname, String tosubclassname): Error while finding class: " + e);
 		}
 		
 		return plugins;
 		
 	}
 	
 	
 	/***
 	 * Lists all the classes inheriting a given
 	 * class in a given package.
 	 * @param pckgname the fully qualified name of the package
 	 * @param tosubclass the Class object to inherit from
 	 * @throws ClassNotFoundException
 	 * @throws InstantiationException
 	 * @throws IllegalAccessException
 	 * @throws IOException
 	 */
 	public ArrayList<String> listPlugins(String pckgname, Class tosubclass) {
 
 		ArrayList<String> plugins = new ArrayList<String>();
 		String plugin;
 		// Translate the package name into an absolute path
 		String name = new String(pckgname);
 		if (!name.startsWith("/")) {
 			name = "/" + name;
 		}	
 		name = name.replace('.','/');
 
 		// Get a File object for the package
 		URL url = DatabaseConnectorFactory.class.getResource(name);
 		// URL url = tosubclass.getResource(name);
 		// URL url = ClassLoader.getSystemClassLoader().getResource(name);
   	
 		if (url==null) return null;
 
 		File directory = new File(url.getFile());
 
 		// directory has been found
 		if (directory.exists()) {
 			// Get the list of the files contained in the package
 			String [] files = directory.list();
 			for (int i=0;i<files.length;i++) {
 		
 				// we are only interested in .class files
 				if (files[i].endsWith(".class")) {
 					// removes the .class extension
 					String classname = files[i].substring(0,files[i].length()-6);
 					try {
 						// Try to create an instance of the object
 						Object o = Class.forName(pckgname+"."+classname).newInstance();
 						if (tosubclass.isInstance(o)) {
 							plugin = pckgname+"."+classname;
 							//adding the name of the subclass to the arraylist
 							plugins.add(plugin);
 						}
 					} 
 					catch (ClassNotFoundException e) {
 						logger.error("listPlugins(String pckgname, Class tosubclass): Error while finding class: " + e);
 					} 
 					catch (InstantiationException e) {
 						// We try to instanciate an interface
 						// or an object that does not have a 
 						// default constructor
 						logger.error("listPlugins(String pckgname, Class tosubclass): Error while instantiation: " + e);
 					} 
 					catch (IllegalAccessException e) {
 						// The class is not public
 						logger.error("listPlugins(String pckgname, Class tosubclass): Illegal Access Error: " + e);
 					}
 				}
 			}
 	
 		} 
 		else {
 			try {
 				// It does not work with the filesystem: we must
 				// be in the case of a package contained in a jar file.
 				JarURLConnection conn = (JarURLConnection)url.openConnection();
 				String starts = conn.getEntryName();
 				JarFile jfile = conn.getJarFile();
 				Enumeration e = jfile.entries();
 				while (e.hasMoreElements()) {
 					ZipEntry entry = (ZipEntry)e.nextElement();
 					String entryname = entry.getName();
 					if (entryname.startsWith(starts)
 						&&(entryname.lastIndexOf('/')<=starts.length())
 						&&entryname.endsWith(".class")) 
 					{
 						String classname = entryname.substring(0,entryname.length()-6);
 						if (classname.startsWith("/")) 
 							classname = classname.substring(1);
 						classname = classname.replace('/','.');
 			    
 						try {
 							// Try to create an instance of the object
 							Object o = Class.forName(classname).newInstance();
 							if (tosubclass.isInstance(o)) {
 								//System.out.println(classname.substring(classname.lastIndexOf('.')+1));
 								plugin = classname.substring(classname.lastIndexOf('.')+1);
 								plugins.add(plugin);
 							}
 						} 
 						catch (ClassNotFoundException ex) {
 							logger.error("listPlugins(String pckgname, Class tosubclass): Error while finding class: " + ex);
 						} 
 						catch (InstantiationException ex) {
 							// We try to instanciate an interface
 							// or an object that does not have a 
 							// default constructor
 							logger.error("listPlugins(String pckgname, Class tosubclass): Error while instantiation: " + ex);
 						} 
 						catch (IllegalAccessException iaex) {
 							// The class is not public
 							logger.error("listPlugins(String pckgname, Class tosubclass): Illegal Access Error: " + e);
 						}
 					}
 				}
 			} 
 			catch (IOException e) {
 				logger.error("listPlugins(String pckgname, Class tosubclass): IOExeption: " + e);
 			}	
 		}
    
 		return plugins;
 	}
 	/***
 	 * Creates connector to the database on the basis of provided data and implements the Factory 
 	 * design pattern
 	 * @param name - name of the database plugin
 	 * @throws ClassNotFoundException
 	 * @throws InstantiationException
 	 * @throws IllegalAccessException
 	 */
 	public DatabaseConnector createConnector(String name){
 		 
 		DatabaseConnector dbConnector = null;
 		Class connectorClass;
 		try{
 			connectorClass = Class.forName(name);
 			dbConnector = (DatabaseConnector)connectorClass.newInstance();
 		}catch(ClassNotFoundException e){
 			logger.error("createConnector(String name): Error while creating connector: " + e);
 		}catch(InstantiationException e){
 			logger.error("createConnector(String name): Error while creating connector: " + e);
 		}catch(IllegalAccessException e){
 			logger.error("createConnector(String name): Error while creating connector: " + e);
 		}
 		return dbConnector;
 	}
 
 }