/**
 * Copyright (C) 2007 Aelitis, All Rights Reserved.
 *
 * This program 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
 * of the License, or (at your option) any later version.
 * This program 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-1307, USA.
 *
 * AELITIS, SAS au capital de 63.529,40 euros
 * 8 Allee Lenotre, La Grille Royale, 78600 Le Mesnil le Roi, France.
 *
 */
package com.aelitis.azureus.launcher;

import java.lang.reflect.Method;
import java.net.URL;

import com.aelitis.azureus.launcher.classloading.*;

/**
 * This will (hopefully) become a unified launching pathway covering everything
 * from the bare core over UIs to Launchable Plugins in the future
 * 
 * @author Aaron Grunthal
 * @create 28.12.2007
 */
public class Launcher {
	
	private final static boolean LOADER_ENABLED = false; 
	
	/**
	 * Bootstraps a new {@link PrimaryClassloader} from the system class loader,
	 * creates a new thread, instantiates MainClass and invokes its main method
	 * with the provided arguments.
	 * 
	 * 
	 * @param MainClass
	 *            class implementing the main() method which will be invoked
	 * @param args
	 *            arguments to the main method
	 */
	public static void launch(Class MainClass,String[] args)
	{
		ClassLoader primaryloader = PrimaryClassloader.getBootstrappedLoader();
		try
		{
			Method mainWrapper = primaryloader.loadClass(MainExecutor.class.getName()).getDeclaredMethod("load", new Class[] {ClassLoader.class,String.class,String[].class});
			mainWrapper.setAccessible(true);
			mainWrapper.invoke(null, new Object[] {primaryloader,MainClass.getName(),args});
		} catch (Exception e)
		{
			System.err.println("Bootstrapping failed");
			e.printStackTrace();
			System.exit(1);
		}
	}
	
	/**
	 * Checks if the current classloader is not part of the {@link PeeringClassloader} hierarchy and performs {@link #launch(Class, String[])} if so<br>
	 * <br>
	 * 
	 * This example shows how to implement a main class that ensures that it is
	 * called through the primary class loader: <code><pre>
	 * MyClass {
	 * 	public static void main(String[] args) {
	 * 		if(Launcher.checkAndLaunch(MyClass.class,args))
	 * 			return;
	 * 		... // normal main code
	 * 	}
	 * }
	 * </pre></code>
	 * 
	 * 
	 * @param MainClass
	 * @param args
	 * @return true if bootstrapping was necessary and the main method was
	 *         called through a new classloader, false otherwise
	 */
	public static boolean checkAndLaunch(Class MainClass,String[] args)
	{
		if(isBootStrapped())
			return false;
		launch(MainClass, args);
		return true;
	}
	
	/**
	 * 
	 * @return true if the current classloader is part of the {@link PeeringClassloader} hierarchy
	 */
	public static boolean isBootStrapped()
	{
		if(!LOADER_ENABLED || ClassLoaderWitness.class.getClassLoader() instanceof PeeringClassloader)
			return true;
		return false;
	}
	
	public static SecondaryClassLoader getComponentLoader(URL[] urls)
	{
		if(!isBootStrapped())
			throw new IllegalStateException("Current Classloader is not part of the peering hierarchy!");
		ClassLoader primary = ClassLoaderWitness.class.getClassLoader();
		while(!(primary instanceof PrimaryClassloader))
			primary = primary.getParent();
		return new SecondaryClassLoader(urls,(PrimaryClassloader)primary);
	}
	
	public static void main(String[] args) {
		// TODO unify commandline processing and GUI selection code here
	}
	
}
