/*
Wotonomy: OpenStep design patterns for pure Java applications.
Copyright (C) 2000 Intersect Software Corporation

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.OutputStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Array;
import java.text.Format;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import net.wotonomy.foundation.internal.Introspector;
import net.wotonomy.foundation.internal.WotonomyException;
import net.wotonomy.foundation.xml.XMLEncoder;

import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
import org.dom4j.util.NonLazyElement;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;

/**
* An implementation of XMLEncoder that serializes objects  
* into XMLRPC format, which is found at http://xmlrpc.com/spec.
* We extend that standard only in that we add a "class" 
* attribute to the "value" tag, so that a java-based decoder
* can more closely reconstruct the original java data structure.
* The class attribute can be safely ignored by clients.
* This implementation is not thread-safe, so a new instances
* should be created to accomodate multiple threads.
*/
public class XMLRPCEncoder implements XMLEncoder
{
    public static final String METHODCALL = "methodCall";
    public static final String METHODNAME = "methodName";
    public static final String METHODRESPONSE = "methodResponse";
    public static final String PARAMS = "params";
    public static final String PARAM = "param";
    public static final String FAULT = "fault";
    public static final String FAULTCODE = "faultCode";
    public static final String FAULTSTRING = "faultString";

    public static final String VALUE = "value";
    public static final String CLASS = "class";
    
    public static final String STRUCT = "struct";
    public static final String MEMBER = "member";
    public static final String NAME = "name";

    public static final String ARRAY = "array";
    public static final String DATA = "data";
    
    public static final String NIL = "nil";
    public static final String INT = "int";
    public static final String I4 = "i4";
    public static final String BOOLEAN = "boolean";
    public static final String STRING = "string";
    public static final String DOUBLE = "double";
    public static final String DATE = "dateTime.iso8601";
    public static final String BASE64 = "base64";
    
    public static final String TRUE = "1";
    public static final String FALSE = "0";
    
    public static final Format DATEFORMAT8601 = 
        new SimpleDateFormat( "yyyyMMdd'T'HHmmss" );

    /**
    * Encodes an object to the specified output stream as XML.
    * @param anObject The object to be serialized to XML format.
    * @param anOutputStream The output stream to which the object
    * will be written.  
    */ 
    public void encode( Object anObject, OutputStream anOutputStream )
    {
        try
        {
        
            //XMLWriter writer = new UTF8XMLWriter( anOutputStream );
            RPCXMLWriter writer = new RPCXMLWriter(anOutputStream,OutputFormat.createCompactFormat());
        	writeValueToXMLWriter( anObject, writer );
            writer.flush();
        }
        catch ( Exception exc )
        {
            throw new WotonomyException( exc );
        }
    }
    
    /**
    * Encodes a method request in XML-RPC format in a "methodCall" tag,
    * and writes the XML to the specified output stream.
    * This method only writes XML: the caller is responsible for 
    * generating the appropriate header, if any, which should set
    * the content type as "text/xml" and the content length as appropriate.
    * The caller is also responsible for writing the xml version tag.
    * @param aMethodName The method name to appear in the "methodName" tag.
    * @param aParameterArray An array of objects, each of which will be
    * encoded as values enclosed in a "param" tag, all of which will be
    * enclosed in a "params" tag.
    * @param anOutputStream The stream to which the XML will be written.
    */
    public void encodeRequest( 
        String aMethodName, Object[] aParameterArray, 
        OutputStream anOutputStream )
    {
        try
        {
            RPCXMLWriter writer = new RPCXMLWriter( anOutputStream, OutputFormat.createCompactFormat());
            writer.processingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" );
            writer.startElement( METHODCALL );
            writer.startElement( METHODNAME );
            writer.write( aMethodName );
            writer.endElement( METHODNAME );
            writer.startElement( PARAMS );
            for ( int i = 0; i < aParameterArray.length; i++ )
            {
                writer.startElement( PARAM );
                writeValueToXMLWriter( aParameterArray[i], writer );
                writer.endElement( PARAM );
            }
            writer.endElement( PARAMS );
            writer.endElement( METHODCALL );
            writer.flush();
        }
        catch ( Exception exc )
        {
            throw new WotonomyException( exc );
        }
        
        //TODO: should this return the content-length?
    }
    
    /**
    * Encodes a method response in XML-RPC format in a "methodResponse" tag,
    * and writes the XML to the specified output stream.
    * This method only writes XML: the caller is responsible for 
    * generating the appropriate header, if any, which should set
    * the content type as "text/xml" and the content length as appropriate.
    * The caller is also responsible for writing the xml version tag.
    * @param aResult A object which will be
    * encoded as values enclosed in a "param" tag, all of which will be
    * enclosed in a "params" tag.  
    * @param anOutputStream The stream to which the XML will be written.
    */
    public void encodeResponse( 
        Object aResult, OutputStream anOutputStream )
    {
        try
        {
            RPCXMLWriter writer = new RPCXMLWriter( anOutputStream, OutputFormat.createCompactFormat() );
            writer.processingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" );
            writer.startElement( METHODRESPONSE );
            writer.startElement( PARAMS );
            writer.startElement( PARAM );
            writeValueToXMLWriter( aResult, writer );                
            writer.endElement( PARAM );
            writer.endElement( PARAMS );
            writer.endElement( METHODRESPONSE );
            writer.flush();
        }
        catch ( Exception exc )
        {
            throw new WotonomyException( exc );
        }
        
        //TODO: should this return the content-length?
    }
    
    /**
    * Encodes a fault response in XML-RPC format in a "methodResponse" tag,
    * and writes the XML to the specified output stream.
    * This method only writes XML: the caller is responsible for first
    * generating the appropriate header, if any, which should set
    * the content type as "text/xml" and the content length as appropriate.
    * The caller is also responsible for writing the xml version tag.
    * @param aFaultCode An application-defined error code.
    * @param aFaultString A human-readable error description.
    * @param anOutputStream The stream to which the XML will be written.
    */
    public void encodeFault( 
        int aFaultCode, String aFaultString, OutputStream anOutputStream )
    {
        try
        {
            RPCXMLWriter writer = new RPCXMLWriter( anOutputStream, OutputFormat.createCompactFormat() );
            writer.processingInstruction( "xml", "version=\"1.0\"" );
            writer.startElement( METHODRESPONSE );
            writer.startElement( FAULT );
            writer.startElement( VALUE );
            writer.startElement( STRUCT );

            writer.startElement( MEMBER );
            writer.startElement( NAME );
            writer.write( FAULTCODE );
            writer.endElement( NAME );
            writer.startElement( VALUE );
            writer.startElement( INT );
            writer.write( new Integer( aFaultCode ).toString() );
            writer.endElement( INT );
            writer.endElement( VALUE );
            writer.endElement( MEMBER );

            writer.startElement( MEMBER );
            writer.startElement( NAME );
            writer.write( FAULTSTRING );
            writer.endElement( NAME );
            writer.startElement( VALUE );
            writer.startElement( STRING );
            writer.write( aFaultString );
            writer.endElement( STRING );
            writer.endElement( VALUE );
            writer.endElement( MEMBER );

            writer.endElement( STRUCT );
            writer.endElement( VALUE );
            writer.endElement( FAULT );
            writer.endElement( METHODRESPONSE );
            writer.flush();
        }
        catch ( Exception exc )
        {
            throw new WotonomyException( exc );
        }
        
        //TODO: should this return the content-length?
    }
    
    /**
    * Performs the actual writing of the file to XML.
    */
    private void writeValueToXMLWriter( 
        Object anObject, RPCXMLWriter writer )
    {
        try
        {

        
        if ( anObject == null )
        {
        	writer.startElement( VALUE );
        	// write nil for null
        	Element nill = new NonLazyElement(NIL);
        	writer.write(nill);
        }
        else
        if ( anObject instanceof Collection )
        {
            // write class so we can restore if possible
        	AttributesImpl a = new AttributesImpl();
            a.addAttribute(null, CLASS, null, null, anObject.getClass().getName() );
            
            writer.startElement( VALUE, a );

            // write items in the order we get them from the iterator
            
            writer.startElement( ARRAY );
            writer.startElement( DATA );
            Iterator it = ((Collection)anObject).iterator();
            while ( it.hasNext() )
            {
                writeValueToXMLWriter( it.next(), writer );
            }
            writer.endElement( DATA );
            writer.endElement( ARRAY );
        
        }
        else
        if ( anObject instanceof Map )
        {
        	AttributesImpl a = new AttributesImpl();
            a.addAttribute(null, CLASS, null, null, anObject.getClass().getName() );
            
            writer.startElement( VALUE, a );

            // write items in the order we get them from the iterator
            //FIXME: The method-based properties are being ignored!
            
            Map.Entry entry;
            writer.startElement( STRUCT );
            writer.startElement( MEMBER );
            Iterator it = ((Map)anObject).entrySet().iterator();
            while ( it.hasNext() )
            {
                entry = (Map.Entry) it.next();
                writer.startElement( NAME );
                writeValueToXMLWriter( entry.getKey(), writer );
                writer.endElement( NAME );
                writeValueToXMLWriter( entry.getValue(), writer );
            }
            writer.endElement( MEMBER );
            writer.endElement( STRUCT );
        }
        else // not a collection 
        {
            // check for primitive types
            if ( anObject instanceof String )
            {                
                writer.startElement( VALUE );
                
                writer.startElement( STRING );
                writer.write( anObject.toString() );
                writer.endElement( STRING );
            }
            else
            if ( anObject instanceof StringBuffer )
            {
                // write class so we can restore if possible
            	AttributesImpl a = new AttributesImpl();
                a.addAttribute(null, CLASS, null, null, anObject.getClass().getName() );
                
                writer.startElement( VALUE, a );

                writer.startElement( STRING );
                writer.write( anObject.toString() );
                writer.endElement( STRING );
            }
            else
            if ( anObject instanceof Number )
            {
                // write class so we can restore if possible
            	AttributesImpl a = new AttributesImpl();
                a.addAttribute(null, CLASS, null, null, anObject.getClass().getName() );
                
                writer.startElement( VALUE, a );

                if ( ( anObject instanceof Double ) 
                || ( anObject instanceof Float ) )
                {
                    writer.startElement( DOUBLE );
                    writer.write( anObject.toString() );
                    writer.endElement( DOUBLE );
                }
                else
                {
                    writer.startElement( INT );
                    writer.write( anObject.toString() );
                    writer.endElement( INT );
                }
            }
            else
            if ( anObject instanceof Date )
            {
                // write class so we can restore if possible
            	AttributesImpl a = new AttributesImpl();
                a.addAttribute(null, CLASS, null, null, anObject.getClass().getName() );
                
                writer.startElement( VALUE, a );

                writer.startElement( DATE );
                writer.write( DATEFORMAT8601.format( anObject ) );
                writer.endElement( DATE );
            }
            else
            if ( anObject instanceof Boolean )
            {
                writer.startElement( BOOLEAN );
                if ( ((Boolean)anObject).booleanValue() )
                {
                    writer.write( "1" );
                }
                else
                {
                    writer.write( "0" );
                }
                writer.endElement( BOOLEAN );
            }
            else
            if ( anObject.getClass().isArray() )
            {
                // write class so we can restore if possible
            	AttributesImpl a = new AttributesImpl();
                a.addAttribute(null, CLASS, null, null, anObject.getClass().getName() );
                
                writer.startElement( VALUE, a );
    
                writer.startElement( ARRAY );
                writer.startElement( DATA );
    
                int length = Array.getLength( anObject );
                for ( int i = 0; i < length; i++ )
                {
                    writeValueToXMLWriter( Array.get( anObject, i ), writer );  
                }
    
                writer.endElement( DATA );
                writer.endElement( ARRAY );
            }
            else // not primitive or collection, treat as struct
            {
                // write class so we can restore if possible
            	AttributesImpl a = new AttributesImpl();
                a.addAttribute(null, CLASS, null, null, anObject.getClass().getName() );
                
                writer.startElement( VALUE, a );

                List readProperties = new ArrayList();
                String[] read = Introspector.getReadPropertiesForObject( anObject );
                for ( int i = 0; i < read.length; i++ )
                {
                    readProperties.add( read[i] );
                }
        
                List properties = new ArrayList();
                String[] write = Introspector.getWritePropertiesForObject( anObject );
                for ( int i = 0; i < write.length; i++ )
                {
                    properties.add( write[i] );
                }
                
                // only use readable properties
                properties.retainAll( readProperties );
                
//                if ( properties.size() > 0 )
//                {
                    String key;
                    Object value;
                    Iterator it = properties.iterator();
                    writer.startElement( STRUCT );
                    while ( it.hasNext() )
                    {
                        key = (String) it.next();
                        value = Introspector.get( anObject, key );
                    
                        writer.startElement( MEMBER );
                            writer.startElement( NAME );
                                writer.write( key ); 
                            writer.endElement( NAME );
                                writeValueToXMLWriter( value, writer );
                        writer.endElement( MEMBER );
                    }
                    writer.endElement( STRUCT );
/*                    
                }
                else // no properties - write a converted string
                {
                    writer.startElement( STRING );
                    Object converted =
                        ValueConverter.convertObjectToClass( anObject, String.class );
                    if ( converted != null )
                    {
                        writer.write( converted.toString() );
                    }
                    else
                    {
                        writer.write( anObject.toString() );
                    }
                    writer.endElement( STRING );
                }
*/                
            }
        }
        
        writer.endElement( VALUE );
        } 
        catch ( Exception exc )
        {
            System.err.println( "XMLFileSoup.writeValueToXMLWriter: " + exc );
            exc.printStackTrace();
        }
        
    }
/*    
    public static void main( String[] argv )
    {
        System.out.println( "<test>" );
        XMLRPCEncoder encoder = new XMLRPCEncoder();
        encoder.encodeRequest( "systemObject.test", new Object[] { 
            new net.wotonomy.test.TestObject(), 
            new net.wotonomy.test.TestObject(), 
            new net.wotonomy.test.TestObject() }, System.out );
        System.out.println();
        System.out.println();
        encoder.encodeResponse( new net.wotonomy.test.TestObject(), System.out );
        System.out.println();
        System.out.println();
        encoder.encodeFault( -1, "This is a fault.", System.out );
        System.out.println();
        System.out.println();
        System.out.println( "</test>" );
    }
*/        
    
    private class RPCXMLWriter extends XMLWriter {

		public RPCXMLWriter(OutputStream arg0, OutputFormat arg1) throws UnsupportedEncodingException {
			super(arg0, arg1);
		}

		public void endElement(String localname) throws SAXException {	
			super.endElement(null, localname, null);
		}

		public void startElement(String localname) throws SAXException {
			this.startElement(localname, null);
		}
		public void startElement(String localname, Attributes attributes) throws SAXException {
			this.startElement(null, localname, null, attributes);
		}

    }
    
}