/*
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.
 *
 *
 */