/*
    *  XNap - A P2P framework and client.
    *
    *  See the file AUTHORS for copyright information.
    *
    *  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.
    *
   *  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
   */
  
  package org.xnap.loader;
  
  // this class is only allowed to access XNap classes in its own package
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.lang.reflect.Method;
  import java.net.URL;
  import java.net.URLDecoder;
  import java.util.*;
  
  /***
   * Checks if a version of XNap is available in the users preferences
   * directory and launches the newest version found.
   */
  public class XNapLoader {
  
      //--- Constant(s) ---
  
      /***
       * Current version of the core distribution. This version needs to
       * be in sync with the version of the xnap-core package in the
       * control file.
  	 *
       * <p><pre>
       * Format: '$MAJOR.$MINOR[-$EXTRA(1-9)]'
       * $EXTRA can be 'alpha', 'beta' or 'pre'
       *
       * Examples: 1.3-alpha1, 2.1-pre1, 2.4
       * </pre>
       *
       * <p>Security fix related releases should append 'r(1-9)' to the version,
       * like this 2.4r1 .
       */
      public static final String VERSION = "3.0-pre1";
  
  	public static final String LOADER_FILENAME
  		= XNapClassLoader.getHomeDir() + "loader";
  
      //--- Data field(s) ---
  
      //--- Method(s) ---
  
      /***
       *
       */
      public static void main(String[] argv) 
      {
  		if (!invoke(LOADER_FILENAME, true, argv)) {
  
  			err("Using default class path");
  			if (!invoke("default_loader", false, argv)) {
  
  				err("Could not find suitable loader file, giving up");
  				System.exit(1);
  			}
  		}	
      }
  
      /***
       * Prints <code>o.toString()</code> to stderr.
       */
      public static void err(Object o)
      {
  		System.err.println(o);
      }
  
  	public static URL[] getStartupClassPath
  		(InputStream inStream, File parent, boolean requireVersion)
  		throws IOException
  	{
  		boolean versionFound = false;
  		LinkedList list = new LinkedList();
  
  		BufferedReader in 
  			= new BufferedReader(new InputStreamReader(inStream));
 		try {
 			String s;
 			while ((s = in.readLine()) != null) {
 				if (s.startsWith("#")) {
 					continue;
 				}
 				else if (s.startsWith("Loader-Version: ")) {
 					StringTokenizer t = new StringTokenizer(s, ":");
 					t.nextToken();
 					if (t.hasMoreTokens()) {
 						versionFound = true;
 						String loaderVersion = t.nextToken().trim();
 						if (!VERSION.equals(loaderVersion)) {
 							throw new IOException
 								("Mismatch of loader versions");
 						}
 					}
 					continue;
 				}
 				
 				list.add(new File(parent, s).toURL());
 			}
 		}
 		finally {
 			try {
 				in.close();
 			}
 			catch (IOException e) {
 			}
 		}
 
 		if (requireVersion && !versionFound) {
 			throw new IOException("Loader version information is missing");
 		}
 
 		return (URL[])list.toArray(new URL[0]);
 	}
 
     /***
      * Returns the jar that contains the XNapLoader class.
      *
      * @return null, if path can not be determined; the jar, otherwise
      */
     public static File getJar()
     {
 		URL url = ClassLoader.getSystemClassLoader().getResource
 			("org/xnap/loader/XNapLoader.class");
 		if (url != null) {
 			String path = url.getFile();
 			if (path != null) {
 				int index = path.lastIndexOf("!/");
 				if (index > 0) {
 					// remove URL stuff
 					path = "//" + URLDecoder.decode(path.substring(5, index));
 					return new File(path);
 				}
 			}
 		}
 
 		return null;
     }
 
     /***
      * Returns path of the jar that contains the XNapLoader class.
      *
      * @return null, if path can not be determined; the path, otherwise
      * @see #getJar()
      */
     public static File getJarPath()
     {
 		File f = getJar();
 		return (f != null) ? f.getParentFile() : null;
     }
 
 	public static boolean invoke
 		(String filename, 
 		 boolean requireVersion,
 		 String[] argv) 
 	{
 		URL[] urls;
 		try {
 			File parent = getJarPath();
 			InputStream in 
 				= XNapClassLoader.getInstance().getResourceAsStream(filename);
 			if (in == null) {
 				in = new FileInputStream(filename);
 				parent = null;
 			}
 			urls = getStartupClassPath(in, parent, requireVersion);
 		}
 		catch (IOException e) {
 			err("Could not read startup classpath from " + filename
 				+ " (" + e.getLocalizedMessage() + ")");
 			return false;
 		}
 
 		try {
 			// add jar files to loader
 			for (int i = 0; i < urls.length; i++) {
 				XNapClassLoader.getInstance().add(urls[i]);
 			}
 
 			// load main class
 			Class c = XNapClassLoader.getInstance().loadClass("org.xnap.XNap");
 			Object app = c.newInstance();
 			Method m = c.getMethod("main", new Class[] { String[].class });
 			m.invoke(app, new Object[] { argv });
 			return true;
 		}
 		catch (Throwable e) {
 			err("Could not load XNap");
 			e.printStackTrace(System.err);
 			return false;
 		}
 	}
 
 }