/*
    * Copyright 2001,2004 The Apache Software Foundation.
    * 
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * 
    *      http://www.apache.org/licenses/LICENSE-2.0
    * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.commons.jjar;
  
  import java.lang.Package;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.Collection;
  import java.util.Map;
  import java.util.List;
  import java.util.StringTokenizer;
  import java.util.Enumeration;
  
  import java.util.jar.JarFile;
  import java.util.jar.Manifest;
  import java.util.jar.Attributes;
  import java.util.jar.JarInputStream;
  import java.util.jar.JarOutputStream;
  import java.util.jar.JarEntry;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.InputStream;
  import java.io.ByteArrayOutputStream;
  
  import java.net.JarURLConnection;
  import java.net.URLConnection;
  import java.net.URL;
  
  
  /**
   *  classpath support for JJAR.  This is currently a jumble - will
   *  clean up.
   *
   *  @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
   *  @version $Id: ClasspathUtil.java 155454 2005-02-26 13:23:34Z dirkv $ 
   */
  public class ClasspathUtil
  {
      /**
       *  current default repository
       */
  
      public static String getDefaultRepository()
      {
          return "http://jakarta.apache.org/jjar/";
      }
  
      /**
       *  lists the jars currently in the classpath
       */
      public static void listJars( String path )
      {
         List jars = getJarList( path );
  
         Iterator i = jars.iterator();
         
         while( i.hasNext() )
         {
             String jar =  (String) i.next();
             System.out.println(" inspecting :  " + jar );
         }
  
         return;
      }
      
      /**
       *  checks to see if the classpath <code>path</code> contains
       *  the package / version
       */
      public static boolean containsVersionedJar( String path, String pkg, String version)
      {
          List jars = getJarList( path );
  
         /*
          *  now, with this set of jars, see if we can find those that match
          *  the package name
          */
  
          Iterator i = jars.iterator();
   
          while( i.hasNext() )
         {
             String jar =  (String) i.next();
 
             try
             {
                 URL url = new URL("jar:file:" + jar + "!/");
                 JarURLConnection conn  = (JarURLConnection) url.openConnection(); 
 
                 if (packageMatch( conn, pkg, version ) )
                 {
                     // System.out.println( jar + " : pkg = " + pkg + " ver = " + version );
 
                     return true;
                 }
             }
             catch( Exception e )
             {
                 //System.out.println("Exception (continuing) : " + e );
             }
         }
         
         return false;
     }
 
     /**
      *  returns a JJARPackage( info ) for a given jar
      */
     public static JJARPackage getPackage( String jarname )
         throws Exception
     {
         URL url = new URL("jar:file:" + jarname + "!/");
         JarURLConnection conn  = (JarURLConnection) url.openConnection(); 
         
         return getPackage( conn );
     }
 
     public static JJARPackage getPackage( JarURLConnection jarConn )
         throws Exception
     {
         if (jarConn == null)
             return null;
 
         Manifest mfst = jarConn.getManifest();
         
         if (mfst == null)
         {
             return null;
         }
         
         /*
          * get the attributes we care about
          */
 
         Attributes att = mfst.getMainAttributes();
 
         String jarpkg = att.getValue( Attributes.Name.IMPLEMENTATION_TITLE );
         String jarver = att.getValue( Attributes.Name.IMPLEMENTATION_VERSION );
 
         if (jarpkg == null || jarver == null)
         {
             /*
              * unusable
              */
             
             return null;
         }
         
         return new JJARPackage( jarpkg, jarver );
     }
        
     /**
      *  determines if two packages are equal
      */
     public static boolean packageMatch( JarURLConnection jarConn, String pkg, String version )
         throws Exception
     {
         JJARPackage jjarp = getPackage( jarConn );
 
         if ( jjarp == null)
             return false;
 
         /*
          *  compare
          */
         
         return jjarp.equals( pkg, version );
     } 
 
 
     /**
      *  returns a list of jars in the specified claspath.
      *  will check the system classpath by default
      */
     public static List getJarList( String path )
     {
         if (path == null)
         {
             path = "java.class.path";
         }
 
         String classpath = System.getProperty( path );
         String pathSep = System.getProperty("path.separator");
 
         /*
          *  take the classpath, and look for jars
          */
 
         StringTokenizer st = new StringTokenizer( classpath, pathSep );
 
         ArrayList jars = new ArrayList();
 
         while( st.hasMoreTokens() )
         {
             String foo = st.nextToken();
             
             if ( foo.indexOf("jar") != -1 )
                 jars.add(foo);
         }
 
         return jars;
     }    
 
     public static void main( String args[] )
     {
         /*
          *  see if the default classpath has the jar we need
          */
         if ( ClasspathUtil.containsVersionedJar( null, "commons-beanutils", "0.1") )
             System.out.println("Found commons-beanutils v0.1");
         else
         {
             /*
              * didn't find it...
              */
 
             try
             {
                 /*
                  *  so go to the repository
                  */
 
                 URL url = new URL("jar:file:/home/gmj/jakarta/jakarta-commons/beanutils/dist/commons-beanutils.jar!/");
                 JarURLConnection conn  = (JarURLConnection) url.openConnection(); 
 
                 /*
                  * ensure that it's right
                  */
 
                 if (!packageMatch( conn, "commons-beanutils", "0.1" ))
                 {
                     System.out.println("repository doesn't have it");
                     return;
                 }
 
                 System.out.println("jar in repository correct. Fetching");
 
                 String jar = "commons-beanutils-0.1.jar";
 
                 url = new URL("file:/home/gmj/jakarta/jakarta-commons/beanutils/dist/commons-beanutils.jar");
                 URLConnection uconn  = (URLConnection) url.openConnection(); 
 
                 Transport.fetchJar( uconn, jar );
 
                 /*
                  *  add to classpath and verify
                  */
                 
                 String classpath = System.getProperty( "java.class.path" );
                 String pathSep = System.getProperty("path.separator");
 
                 classpath = classpath + pathSep + jar;
 
                 System.setProperty("java.class.path", classpath);
 
                 if ( ClasspathUtil.containsVersionedJar( null, "commons-beanutils", "0.1") )
                     System.out.println("Found commons-beanutils v0.1");
                 
             }
             catch( Exception e )
             {
                 System.out.println("exception " + e );
             }
         }
         
     }
 
     /**
      *  doesn't work.  don't use
      */
     public static boolean markJar( String jarname, String packagename, String version )
         throws Exception
     {
         JarFile jf = new JarFile( jarname );
 
         Manifest mfst = jf.getManifest();
         
         if (mfst == null)
         {
             return false;
         }
         
         /*
          * set the attributes we care about
          */
 
         Attributes att = mfst.getMainAttributes();
 
         Object a = att.put( Attributes.Name.IMPLEMENTATION_TITLE, packagename );
         Object b = att.put( Attributes.Name.IMPLEMENTATION_VERSION, version );
 
         System.out.println(" Object a " + a );
         System.out.println(" Object b " + b );
 
         JarOutputStream jos = new JarOutputStream( new FileOutputStream( new File( jarname + "-jjar")));
         byte[] buffer = new byte[1024]; 
         int bytesRead; 
 
         for( Enumeration e = jf.entries(); e.hasMoreElements(); )
         {
             JarEntry entry = (JarEntry) e.nextElement(); 
 
             if( entry.getName().equals("META-INF/MANIFEST.MF"))
             {
                 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 
                 mfst.write( baos );
 
                 JarEntry ee = new JarEntry( entry );
 
                 ee.setSize(baos.size() );
 
                 jos.putNextEntry(ee );
                 mfst.write( jos );
                 continue;
             }
 
             System.out.println(" Name : " + entry.getName() );
 
             InputStream entryStream = jf.getInputStream( entry); 
 
             jos.putNextEntry(entry );
 
             while ((bytesRead = entryStream.read(buffer)) != -1) 
             { 
                 jos.write(buffer, 0, bytesRead);
             }
         }
 
         jos.close();
         jf.close();
 
         return true;
     }   
 }