/*

  * 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.util.Properties;

 import java.util.StringTokenizer;

 import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Stack;

 import java.util.Map;

 import java.util.HashMap;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.io.InputStream;

 import java.io.InputStreamReader;

 import java.io.BufferedInputStream;

 import java.io.IOException;

 import java.net.URL;

 import java.net.URLConnection;

 import org.xml.sax.*;

 import uk.co.wilson.xml.MinML2;

 /**

  *  Repository implementation that supports XML repository

  *  definitions.  Uses a great small little lightweight SAX

  *  parser - but it's not clear what it doesn't support, so

  *  be careful

  *

  *  @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>

  *  @version $Id: RepositoryXML.java 155454 2005-02-26 13:23:34Z dirkv $

  */

 public class RepositoryXML extends MinML2 implements Repository

 {

         /** list of packages */

     private HashMap packageMap = new HashMap();

         int packageCount = 0;

         /** handles package dependency generation */

         private static DependencyEngine de = new DependencyEngine();

         /** root of our document tree */

     private Node root = null;

         /** stack used for SAX parsing */

     private Stack  stack = new Stack();

         /** user for SAX parsing to avoid character events */

     private StringWriter saxWriter = null;

     /** string constants for use in data structure */

         private static String PACKAGENAME = "packagename";

         private static String DEFAULTVERSION = "defaultversion";

         private static String NODE = "node";

         private static String DESCRIPTION = "description";

         private static String HREF = "href";

         private static String VERSION = "version";  

     private static String VERSION_INFO = "version_info";

     private static String VERSION_JAR = "version_jar";

     private static String DEP_PACKAGE = "dep_package";

     private static String DEP_VERSION = "dep_version";

     private static String VERSION_DEPS = "version_deps";

     private static String VERSION_ARRAY = "version_array";

         /**

          *  loads the object with the XML data from the

          *  passed in URL.  Invokes the SAX parser.

          *

          *  @param url location of the repository.xml

          */

     public void load( URL url )

     {

         load( url, packageMap );

     }

     public void load( URL url, Map pkgMap )

     {

         try 

         {

             URLConnection conn = url.openConnection();

             InputStream is = conn.getInputStream();

             parse(new InputStreamReader(new BufferedInputStream( is)));

             process( pkgMap );

         }

         catch ( IOException e) 

         {

             System.out.println("IOException: " + e);

             e.printStackTrace();

         }

         catch ( SAXException e) 

         {

             System.out.println("SAXException: " + e);

             e.printStackTrace();

         }

         catch ( Throwable e) 

         {

             System.out.println("Other Exception: " + e);

             e.printStackTrace();

         }

     }

         /**

          *  returns a list of dependencies for

          *  a given package.  The list contains

          *  Maps, with 'package' and 'version'

          *  as the keys for the necessary info.

          *

          *  @param pkg package to get dep list for

          *  @return List of Maps

          */

         public List getDependencyList( String pkg, String version )

     {

         if( isPackage( pkg ))

             return de.getDependencies( pkg + ":" + version );

         return new ArrayList();

     }

     /**

      *  returns an iterator over the

      *   list of package names

      */ 

     public Iterator getPackageListIter()

     {

         return  packageMap.keySet().iterator();

     }

     /**

      *  returns the number of packages known to

      *  the repository

      */

     public int getPackageCount()

     {

         return packageMap.size();

     }

     /**

      *  returns the default version of the package to the caller

      */

     public String getPackageDefaultVersion( String pkg )

     {

         if (isPackage( pkg ) )

         {

             HashMap hpack = (HashMap) packageMap.get( pkg );

             return (String) hpack.get( DEFAULTVERSION);

         }

         return null;

     }

     /**

      *  returns the info/desc string to the caller

      */

     public String getPackageDescription( String pkg )

     {

         if (isPackage( pkg ) )

         {

             HashMap hpack = (HashMap) packageMap.get( pkg );

             return (String) hpack.get( DESCRIPTION);

         }

         return "";

     }

     /**

      *  returns the 'fetch' target (jarname) for the 

      *  given package : version

      */

     public String getFetchTarget( String pkg, String version )

     {

         /*

          *  first see if we know about this package.

          */

         if (!isPackage( pkg ))

             return null;

         /*

          * next, get the package info and see if we have this version

          */

         Map hp = (HashMap) packageMap.get( pkg );

         Iterator i =((ArrayList) hp.get( VERSION_ARRAY )).iterator();        

         while( i.hasNext() )

         {

             HashMap vi = (HashMap) i.next();

             String ver = (String) vi.get( VERSION );

             if (ver != null)

             {

                 if (version.equals( ver ) )

                 {

                     String out = (String) vi.get(VERSION_JAR);

                     return out;

                 }

             }

         }

         return null;

     }

     /**

      *  determines if something is a known package

      */

     public boolean isPackage( String pkg )

     {

                 Object o = packageMap.get( pkg );

                 if( o != null)

                         return true;

                 return false;

     }

     /**

      *  returns a given property 

      *  not implemented

      */

     public String getProp( String s )

     {

         return s;

     }

     /**

      *  returns a list of the know versions available

      *  for this package

      */

     public List getPackageVersionList( String pkg )

     {

         if(!isPackage( pkg ))

            return null;

         Map hp = (HashMap) packageMap.get( pkg );

         ArrayList verlist = new ArrayList();

         Iterator i =((ArrayList) hp.get( VERSION_ARRAY )).iterator();

         while( i.hasNext() )

         {

             verlist.add( ( (HashMap)i.next() ).get( VERSION ) );

         }

         return verlist;

     }

     private List makeList( String thing )

     {

         StringTokenizer st = new StringTokenizer( thing, ", ");

         List list = new ArrayList();

         while(st.hasMoreTokens() )

         {

             list.add( st.nextToken().trim() );

         }

         return list;

     }

         /**

          *  takes the intermediary form of input data, and loads the

          *  internal data structures for use later.  This needs to be

          *  called right after parsing, and before use.

          */

     private void process( Map pkgMap )

     {

         /*

          *  need to build a package list.  Get the package groups.

          */

                 List packagegroup = getDocNodeList( root, "packagegroup");

         if (packagegroup == null)

             System.out.println("Packagegroup == null");

         //System.out.println("packagegroup has " + packagegroup.size() + "elements");

         Iterator i = packagegroup.iterator();

         while( i.hasNext() )

         {

             Node pkggrp = (Node) i.next();

             //System.out.println("Processing packagegroup : " + pkggrp.getAttribute("name") );

                         List packages = getDocNodeList( pkggrp, "package");

                         /*

                          * for each package...

                          */

                         Iterator ii = packages.iterator();

                         while( ii.hasNext() )

                         {

                                 processPackageNode( (Node) ii.next(), pkgMap );

                         }

         }

     }

         private void processPackageNode( Node pkg, Map pkgMap )

         {

                 HashMap pkginfo = new HashMap();

                 /*

                  *  start with the basics

                  */

                 pkginfo.put( PACKAGENAME, pkg.getAttribute("name") );

                 pkginfo.put( DEFAULTVERSION, pkg.getAttribute("default"));

                 pkginfo.put( NODE, pkg );

         /*

          *  does this have a definition here or remote?

          */

         Node def = getDocNode( pkg, "definition");

         if (def != null)

         {

             /*

              * now get the information node

              */

             Node info = getDocNode( def, "info/desc");

             if( info != null)

                 pkginfo.put( DESCRIPTION, info.getValue());

             info = getDocNode( def, "info/href");

             if( info != null)

                 pkginfo.put( HREF, info.getValue());

             /*

              *  process version info

              */

             List  versionlist = getDocNodeList( def, "versionset/version");

             ArrayList versionArray = new ArrayList();

             Iterator v = versionlist.iterator();

             while( v.hasNext() )

             {

                 Node n = (Node) v.next();

                 HashMap vi = new HashMap();

                 vi.put( VERSION, n.getAttribute("version") );

                 Node nn = getDocNode( n, "note");

                 vi.put( VERSION_INFO, nn.getValue() );

                 nn = getDocNode( n, "jar");

                 vi.put( VERSION_JAR, nn.getValue() );

                 /*  the dependencies */

                 ArrayList deplist = new ArrayList();

                 List deps = getDocNodeList( n, "dependencies/dep");

                 if (deps != null)

                 {

                     Iterator ii = deps.iterator();

                     while( ii.hasNext() )

                     {

                         HashMap h = new HashMap();

                         Node ndep = (Node) ii.next();

                         h.put( DEP_PACKAGE, ndep.getAttribute("package") );

                         h.put( DEP_VERSION, ndep.getAttribute("version") );

                         deplist.add( h );

                     }

                     vi.put( VERSION_DEPS, deplist );

                 }

                 versionArray.add( vi );

                 /*

                  *  add the package:version to the dependency engine

                  */

                 String token = pkginfo.get( PACKAGENAME ) + ":" +  (String) vi.get( VERSION );

                 // System.out.println("Adding " + token + " to dependency engine.");

                 ArrayList depar = new ArrayList();

                 Iterator depiter = deplist.iterator();

                 while( depiter.hasNext() )

                 {

                     HashMap h = (HashMap) depiter.next();

                     String deptoken = (String) h.get(DEP_PACKAGE) + ":" +  (String) h.get(DEP_VERSION);

                     depar.add( deptoken );

                 }

                 try

                 {

                     de.addProject( token, depar, token );

                 }

                 catch( Exception e )

                     {}

             }

             pkginfo.put( VERSION_ARRAY, versionArray );

             /*

              *  add the info to the packageMap

              */

             pkgMap.put( pkginfo.get( PACKAGENAME ), pkginfo );

             //                dumpPackageInfo( pkginfo );

         }

         else

         {

             /*

              * is this a remote repository? 

              */

             Node remote = getDocNode( pkg, "remotedefinition");

             if (remote != null)

             {

                 System.out.println( "Note package '" + ( (String) pkginfo.get( PACKAGENAME ) ) 

                                     + "' defining repository is remote, coming from " + remote.getValue() );

                 /*

                  *  now recursively get the info

                  */

                 try

                 {

                     RepositoryXML rep = new RepositoryXML();

                     rep.load( new URL( remote.getValue() ), pkgMap );

                 }

                 catch( Exception ee )

                     {}

             }

             else

             {

                 System.out.println("Malformed repository : neither <definition> or <remotedefinition>");

             }

         }

         }

     /**

      *  simple dumper for debugging

      */

     private void dumpPackageInfo( Map h )

         {

                 System.out.println("Package : " + h.get( PACKAGENAME ) );

                 System.out.println("  default version : " + h.get(DEFAULTVERSION ));

                 System.out.println("     description  : " + h.get(DESCRIPTION ));

                 System.out.println("             href : " + h.get(HREF ));

         System.out.println("      version info -> " );

         ArrayList vl = (ArrayList) h.get( VERSION_ARRAY );

         Iterator i = vl.iterator();

         while( i.hasNext() )

         {

             HashMap vi = (HashMap) i.next();

             System.out.println("      ver : " + vi.get( VERSION ) );

             System.out.println("     info : " + vi.get( VERSION_INFO ) );

             System.out.println("      jar : " + vi.get( VERSION_JAR ) );

         }

         }

     /**

      *  Returns a given node from the document tree.

      *  if a multivalued node, will return the first

      *

      *  @param root  node to start seaching on

      *  @param path node path, a la "foo/bar/woogie"

      *  @return node or null

      */

         private Node getDocNode( Node root, String path )

         {

                 List ar = getDocNodeList(root, path );

                 if (ar == null || ar.size() == 0)

                         return null;

                 return (Node) ar.get(0);

         }

     /**

      *  returns the node list for a given path relative to the

      *  passed in node

      *

      *  @param root node to start from

      *  @param path note path

      *  @return List of nodes that match

      */

         private List getDocNodeList( Node root, String path)

         {

                 StringTokenizer st = new StringTokenizer( path, "/");

                 Node n = root;

                 ArrayList ar = null;

                 while( st.hasMoreTokens() )

                 {

                         String token = st.nextToken();

                         ar = n.getChildren(token);

                         if (ar == null || ar.size() == 0)

                                 return null;

                         n = (Node) ar.get(0);

                 }

                 return ar;

         }

     /**

      *  start element event handler for SAX.  

      */

     public Writer startElement( String namespaceURI, String localName, String qName, Attributes atts,  Writer writer)

         throws SAXException

     {

         /*

          *  get the top element on the list

          */

                 Node parent = null;

                 Node element = new Node( qName );

         if( root == null)

                 {

             root = element;

         }

         else

         {

             /*

              * get parent node

              */

             try

             {

                 parent = (Node) stack.peek();

             }

             catch(Exception e)

                 {}

         }

         /*

          *  everything is a list

          */

         if (parent != null)

         {    

                         parent.addChildNode( element);

         }

         /*

          *  now add our attributes

          */

         for (int i = 0; i < atts.getLength(); i++)

         {

             element.setAttribute( atts.getQName(i), atts.getValue(i) );

         }

         /*

          *  now put this element on the stack for later

          */

         stack.push(element);

         saxWriter = new StringWriter();

         return saxWriter;

     }

     /**

      *  end element event handler for SAX parsing

      */

     public void endElement( String namespaceURI, String localName, String qName)

         throws SAXException

     {

         try

         {

             Node element = (Node) stack.pop();

             String s = saxWriter.toString();

             if ( s.length() > 0)

                 element.setValue( s );

         }

         catch( Exception e )

         {

             System.out.println("endElement : " + e );

         }

     }

     public void fatalError (SAXParseException e) 

       throws SAXException 

     {

         System.out.println("RepositoryXML.fatalError(): " + e);

         throw e;

     }

     /**

      *  used for debugging

      */

     public static void main ( String[] args) 

     {

       RepositoryXML rep = new RepositoryXML();

       try

       {

           rep.load( new URL("file://" + args[0] ));

       }

       catch( Exception e )

           { System.out.println(e );}

       List al = rep.getDependencyList( "ant", "1.3");

       Iterator i = al.iterator();

       System.out.println("dep for ant 1.3 ");

       while( i.hasNext() )

       {

           System.out.println("  " + (String) i.next() );

       }

   }

     /**

      *  meethod for debugging parsing

      */

     private static  void show( String indent,  Map map )

     {

         System.out.println("");

         Iterator i = map.keySet().iterator();

         while(i.hasNext() )

         {

             String s = (String) i.next();

             Object o = map.get( s );

             System.out.print( indent + "<" + s + ">");

             if ( o instanceof Map )

             {

                 show( indent + "  ", (Map) o);

             }

             else if ( o instanceof List )

             {

                 Iterator j = ((List) o).iterator();

                 while( j.hasNext() )

                 {

                     Object oo = j.next();

                     if (oo instanceof Map)

                         show( indent + "  ", (Map) oo);

                     else

                         System.out.println("woo!" + oo.getClass());

                 }

             }

             else

             {

                 System.out.println( map.get( s ));

             }

       }

     }

         /**

          *  small class to hold our node information for

          *  XML processing

          */

         class Node 

         {

                 String name = null;

                 String value = "";

                 HashMap attributes = new HashMap();

                 HashMap children = new HashMap();

                 Node( String name )

                 {

                         this.name = name;

                 }

                 void setValue( String val )

                 {

                         value = val;

                 }

                 String getValue()

                 {

                         return value;

                 }

                 void setAttribute( String key, String val )

                 {

                         attributes.put( key, val );

                 }

                 String getAttribute( String key )

                 {

                         return (String) attributes.get( key );

                 }

                 void addChildNode( Node node )

                 {

                         ArrayList ar = (ArrayList) children.get( node.name );

                         if (ar == null)

                                 ar = new ArrayList();

                         ar.add( node );

                         children.put( node.name, ar );

                 }

                 ArrayList getChildren( String name )

                 {

                         return (ArrayList) children.get( name );

                 }

         }

 }