/*
   Wotonomy: OpenStep design patterns for pure Java applications.
   Copyright (C) 2000 Michael Powers
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
  This library 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, see http://www.gnu.org
  */
  
  package net.wotonomy.web.xml;
  
  import java.io.IOException;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Stack;
  
  import net.wotonomy.foundation.internal.Introspector;
  import net.wotonomy.foundation.internal.ValueConverter;
  import net.wotonomy.foundation.internal.WotonomyException;
  
  import org.xml.sax.Attributes;
  import org.xml.sax.InputSource;
  import org.xml.sax.Locator;
  import org.xml.sax.SAXException;
  import org.xml.sax.SAXParseException;
  import org.xml.sax.helpers.DefaultHandler;
  
  /***
  * Used by XMLDecoder to implement the necessary interfaces
  * required by the jclark xp parser. 
  * This class is not thread safe.
  */
  class XMLRPCDecoderHelper extends DefaultHandler
  {
      protected final Object nilMarker = new Object();
      protected Stack valueStack;
      protected String methodName;
      protected int faultCode;
      protected String faultString;
      protected List parameters;
      protected StringBuffer cdataBuffer;
  
  
  
  	public XMLRPCDecoderHelper()
      {
          valueStack = new Stack();
          parameters = new LinkedList();
          cdataBuffer = new StringBuffer();
          reset();
      } 
      
      public void reset()
      {
          valueStack.clear();
          parameters.clear();
          cdataBuffer.setLength( 0 );
          methodName = null;
          faultCode = 0;
          faultString = null;
      }
      
      public boolean isRequest()
      {
          return ( methodName != null );   
      }
      
      public boolean isResponse()
      {
          return ( methodName == null );   
      }
      
      public boolean isFault()
      {
          // faults are responses
          return ( isResponse() ) && ( faultString != null );   
      }
      
      public int getFaultCode() 
      {
          return faultCode;   
      }
      
      public String getFaultString()
      {
          return faultString;   
      }
     
     public String getMethodName()
     {
         return methodName;   
     }
     
     public Object[] getParameters()
     {
         return parameters.toArray();   
     }
     
     public void endDocument() throws SAXException {
 		// TODO Auto-generated method stub
 		super.endDocument();
 	}
 
 	public void startDocument() throws SAXException {
 		// TODO Auto-generated method stub
 		super.startDocument();
 		reset();
 	}
 	
     public Object getResult() 
     {
         if ( valueStack.empty() ) return null;
         Object result = valueStack.peek();
         if ( result == nilMarker ) result = null;
         return result;
     }
 
     
 	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
 		super.startElement(uri, localName, qName, attributes);
         if ( XMLRPCEncoder.VALUE.equals( localName ) )
         {
             ValueMarker marker = new ValueMarker(); 
             String classname = attributes.getValue( uri, XMLRPCEncoder.CLASS );
             if ( classname != null )
             {
                 try
                 {
                     Class c = Class.forName( classname );
                     if ( c != null )
                     {
                         marker.setMarkerClass( c );
                     }
                 }
                 catch ( Exception exc )
                 {
                     System.out.println( "XMLRPCDecoderHelper.startElement: " +
                         "Can't find class: " + classname );
                 }
             }
             valueStack.push( marker );
         }
 	}
 	
     public void characters(char[] ch, int start, int length) throws SAXException {
 		super.characters(ch, start, length);
 		char[] someChars = new char[((start+length)<=ch.length) ? length : ch.length-start];
 		for (int i = 0; i < someChars.length; i++ ) {
 			someChars[i] = ch[start+i];
 		}
 		cdataBuffer.append(someChars);
 	}
 
 	public void endElement(String uri, String localName, String qName) throws SAXException {
 		super.endElement(uri, localName, qName);
 
         // if any cdata is buffered or if string value
         if ( ( XMLRPCEncoder.STRING.equals( localName ) ) 
         ||   ( cdataBuffer.length() > 0 ) )
         {
             // push value on the stack
             valueStack.push( cdataBuffer.toString() );
             cdataBuffer.setLength( 0 );
         }
 
         if ( XMLRPCEncoder.VALUE.equals( localName ) )  
         {	
             Object value = valueStack.pop();
             try
             {
 //                ValueMarker marker = (ValueMarker) valueStack.pop();
                 ValueMarker marker = null;
                 Object markerValue = valueStack.pop();
                 if ( markerValue instanceof ValueMarker )
                 {
                     marker = (ValueMarker) markerValue;
                 }
                 else
                 {
                     throw new WotonomyException( "Expected value marker, found" 
                         + markerValue.getClass() + " : " + markerValue );
                 }
                 
 //System.out.println( "getMarkerClass: " + marker.getMarkerClass() + " : " + value );                            
 //System.out.println( valueStack );
                 if ( marker.getMarkerClass() != null )
                 {
                     // apply introspection
                     if ( value instanceof Map )
                     {
                         Map map = (Map)value;
                         Map.Entry entry;
                         value = marker.getMarkerClass().newInstance();
                         Iterator it = map.entrySet().iterator();
                         Object entryValue;
                         while( it.hasNext() )
                         {
                             entry = (Map.Entry) it.next();
                             entryValue = entry.getValue();
                             if ( entryValue == nilMarker ) entryValue = null;
                             Introspector.set( 
                                 value, entry.getKey().toString(), entryValue );
                         }
                     }
                     if ( ! ( value.getClass().equals( marker.getMarkerClass() ) ) )
                     {
                         Object converted = 
                             ValueConverter.convertObjectToClass( 
                                 value, marker.getMarkerClass() );
                         if ( converted != null )
                         {
                             value = converted;
                         }
                     }
                 }
             }
             catch ( Exception exc )
             {
                 // fall back on unconverted value
             }
             
             valueStack.push( value );
 // System.out.println( "convertedValue: " + value + "("+ value.getClass() +")" );            
         }
         else
         if ( XMLRPCEncoder.MEMBER.equals( localName ) )  // Map.Entry
         {
             // leave key and value to be handled by struct
         }
         else
         if ( XMLRPCEncoder.STRUCT.equals( localName ) ) // write Entries to map or object
         {
             // write values to array (reverse the order)  
             Object value;      
             Map map = new HashMap();
             while ( ( ! valueStack.empty() ) 
             && ( ! ( valueStack.peek() instanceof ValueMarker ) ) )
             {
                 value = valueStack.pop();
                 map.put( valueStack.pop(), value );
             }
             // push the list on the stack
             valueStack.push( map );
         }
         else
         if ( XMLRPCEncoder.ARRAY.equals( localName ) ) 
         {
 //System.out.println( "ended ARRAY: " + valueStack.size() );
             // write values to array (reverse the order)        
             Object value;
             LinkedList list = new LinkedList();
             while ( ( ! valueStack.empty() ) 
             && ( ! ( valueStack.peek() instanceof ValueMarker ) ) )
             {
                 value = valueStack.pop();
                 if ( value == nilMarker ) value = null;                
                 list.addFirst( value );
             }
             // push the list on the stack
             valueStack.push( list );
         }
         else
         if ( XMLRPCEncoder.INT.equals( localName ) )  
         {
             Object value = valueStack.pop();
             try
             {
                 valueStack.push( 
                     new Integer( value.toString() ) );
             }
             catch ( NumberFormatException exc )
             {
                 throw new WotonomyException( 
                     "Invalid double format: " + value.toString() );
             }
         }
         else
         if ( XMLRPCEncoder.I4.equals( localName ) )  
         {
             Object value = valueStack.pop();
             try
             {
                 valueStack.push( 
                     new Integer( value.toString() ) );
             }
             catch ( NumberFormatException exc )
             {
                 throw new WotonomyException( 
                     "Invalid double format: " + value.toString() );
             }
         }
         else
         if ( XMLRPCEncoder.NIL.equals( localName ) )  
         {
             valueStack.push( nilMarker );
         }
         else
         if ( XMLRPCEncoder.DOUBLE.equals( localName ) )  
         {
             Object value = valueStack.pop();
             try
             {
                 valueStack.push( 
                     new Double( value.toString() ) );
             }
             catch ( NumberFormatException exc )
             {
                 throw new WotonomyException( 
                     "Invalid double format: " + value.toString() );
             }
         }
         else
         if ( XMLRPCEncoder.DATE.equals( localName ) )  
         {
             Object value = valueStack.pop();
             try
             {
                 valueStack.push( 
                     XMLRPCEncoder.DATEFORMAT8601.parseObject( 
                         value.toString() ) );
             }
             catch ( Exception exc )
             {
                 throw new WotonomyException( 
                     "Invalid date format: " + value );
             }
         }
         else
         if ( XMLRPCEncoder.BOOLEAN.equals( localName ) )  
         {
             Object value = valueStack.pop();
             if ( XMLRPCEncoder.TRUE.equals( value ) )
             {
                 valueStack.push( Boolean.TRUE );
             }
             else
             if ( XMLRPCEncoder.FALSE.equals( value ) )
             {
                 valueStack.push( Boolean.FALSE );
             }
             else
             {
                 throw new WotonomyException( 
                     "Invalid boolean format: " + value );
             }
         }
         else
         if ( XMLRPCEncoder.BASE64.equals( localName ) )  
         {
             throw new WotonomyException( "Not implemented yet." );
         }
         else
         if ( XMLRPCEncoder.FAULT.equals( localName ) )  
         {
             Map faultMap = (Map) valueStack.pop();
             try
             {
                 faultCode = ((Integer)
                     faultMap.get( XMLRPCEncoder.FAULTCODE )).intValue();
                 faultString = (String) faultMap.get( XMLRPCEncoder.FAULTSTRING );
             }
             catch ( Exception exc )
             {
                 throw new WotonomyException(
                     "Invalid fault format: " + faultMap );
             }
         }
         else
         if ( XMLRPCEncoder.METHODNAME.equals( localName ) )  
         {
             methodName = (String) valueStack.pop();
         }
         else
         if ( XMLRPCEncoder.PARAM.equals( localName ) )  
         {
             //NOTE: this leaves the parameter on the stack
             parameters.add( getResult() );
         }
     }
     
 
 
 	public void endPrefixMapping(String prefix) throws SAXException {
 		// TODO Auto-generated method stub
 		super.endPrefixMapping(prefix);
 	}
 
 	public void error(SAXParseException e) throws SAXException {
 		// TODO Auto-generated method stub
 		super.error(e);
 	}
 
 	public void fatalError(SAXParseException e) throws SAXException {
 		// TODO Auto-generated method stub
 		super.fatalError(e);
 	}
 
 	public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {
 		// TODO Auto-generated method stub
 		super.ignorableWhitespace(ch, start, length);
 	}
 
 	public void notationDecl(String name, String publicId, String systemId) throws SAXException {
 		// TODO Auto-generated method stub
 		super.notationDecl(name, publicId, systemId);
 	}
 
 	public void processingInstruction(String target, String data) throws SAXException {
 		// TODO Auto-generated method stub
 		super.processingInstruction(target, data);
 	}
 
 	public InputSource resolveEntity(String publicId, String systemId) throws SAXException {
 		// NOTE: Sun accepted an incompatible api difference.  The (false) should be tossed by hotspot
 		try {
 			if (false) throw new IOException("Fake exception to make it compile in both 1.4 and 1.5");
 			return super.resolveEntity(publicId, systemId);		
 		} catch (IOException e) {
 			throw new SAXException(e.getClass().getName() + " thrown while resolving entity.",e);
 		}
 	}
 
 	public void setDocumentLocator(Locator locator) {
 		// TODO Auto-generated method stub
 		super.setDocumentLocator(locator);
 	}
 
 	public void skippedEntity(String name) throws SAXException {
 		// TODO Auto-generated method stub
 		super.skippedEntity(name);
 	}
 
 
 
 	public void startPrefixMapping(String prefix, String uri) throws SAXException {
 		// TODO Auto-generated method stub
 		super.startPrefixMapping(prefix, uri);
 	}
 
 	public void unparsedEntityDecl(String name, String publicId, String systemId, String notationName) throws SAXException {
 		// TODO Auto-generated method stub
 		super.unparsedEntityDecl(name, publicId, systemId, notationName);
 	}
 
 	public void warning(SAXParseException e) throws SAXException {
 		// TODO Auto-generated method stub
 		super.warning(e);
 	}
 
     
     // marker class
     
     private class ValueMarker 
     {
         private Class theClass;
     
         public ValueMarker()
         {
             theClass = null;
         }
     
         public void setMarkerClass( Class aClass )
         {
             theClass = aClass;
         }
         
         public Class getMarkerClass()
         {
             return theClass;
         }
 
         public String toString()
         {
             return "[ValueMarker: " + theClass + "]";
         }
     }
     
 }
 
 /*
  * $Log$
  * Revision 1.1  2006/02/19 01:44:03  cgruber
  * Add xmlrpc files
  * Remove jclark and replace with dom4j and javax.xml.sax stuff
  * Re-work dependencies and imports so it all compiles.
  *
  * Revision 1.1  2006/02/16 13:22:22  cgruber
  * Check in all sources in eclipse-friendly maven-enabled packages.
  *
  * Revision 1.7  2003/08/06 23:07:53  chochos
  * general code cleanup (mostly, removing unused imports)
  *
  * Revision 1.6  2001/03/03 15:16:35  mpowers
  * Fixed bug in decoding empty strings: string handler did nothing and
  * empty cdatas were ignored, so no value was placed on the stack.
  *
  * Revision 1.5  2001/02/17 16:52:06  mpowers
  * Changes in imports to support building with jdk1.1 collections.
  *
  * Revision 1.4  2001/02/09 15:51:39  mpowers
  * Fixed a pernicious bug: I was using the character event entirely
  * incorrectly, but the problem only exhibited itself with large data
  * and even then only randomly.  Now using a string buffer.
  *
  * Revision 1.3  2001/02/07 19:24:28  mpowers
  * Moved XML classes to separate package.
  *
  * Revision 1.2  2001/02/06 14:34:23  mpowers
  * Forgot to rename the package declarations.
  *
  * Revision 1.1  2001/02/06 14:31:19  mpowers
  * Moving XML utilities from util to xml package.
  *
  * Revision 1.1.1.1  2000/12/21 15:52:39  mpowers
  * Contributing wotonomy.
  *
  * Revision 1.2  2000/12/20 16:25:48  michael
  * Added log to all files.
  *
  *
  */