/*
    * 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 );
 		}
 				
 	}
 
 }