//
// SwitchRMI  Framework
// Copyright (c) 2000-2002 by Michael J. Henderson & Associates.
//
// Michael Henderson
// http://switchrmi.sf.net
// mailto:mikehenderson@dunelm.org.uk
//
// This library is free software.
//
// You may redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License as published by the Free Software Foundation.
//
// Version 2.1 of the license should be included with this distribution in
// the file LICENSE, as well as License.html. If the license is not
// included with this distribution, you may find a copy at the FSF web
// site at 'www.gnu.org' or 'www.fsf.org', or you may write to the
// Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139 USA.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied waranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// $Id: XmlRpcProtocol.java,v 1.1 2002/11/11 22:19:48 mikehenderson Exp $
package com.mjh.switchrmi.protocol.xmlrpc;

import com.mjh.dom.*;
import com.mjh.switchrmi.*;

import java.io.*;

import java.lang.reflect.Method;

import java.text.*;

import java.util.*;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.apache.log4j.Logger;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;

/*
    Support Xml rpc spec only.
    
    struct params are a Map (not hashtable)
    array params are a List; (not Vector)
    

*/
public class XmlRpcProtocol implements RmiProtocol
{
    private static final Logger log = 
            Logger.getLogger(XmlRpcProtocol.class.getName());
    private static final String XMLRPC_REQUEST_TEMPLATE_FILE = 
            "XmlRpcRequestTemplate.xml";
    private static final String XMLRPC_RESPONSE_TEMPLATE_FILE = 
            "XmlRpcResponseTemplate.xml";
    private static final String XMLRPC_FAULTRESPONSE_TEMPLATE_FILE = 
            "XmlRpcFaultResponseTemplate.xml";
    private static Document requestTemplate;
    private static Document responseTemplate;
    private static Document faultResponseTemplate;

    static
    {
        try
        {
            DocumentBuilderFactory factory = 
                    DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();

            requestTemplate = parse(XMLRPC_REQUEST_TEMPLATE_FILE, builder);
            responseTemplate = parse(XMLRPC_RESPONSE_TEMPLATE_FILE, builder);
            faultResponseTemplate = parse(XMLRPC_FAULTRESPONSE_TEMPLATE_FILE, 
                                          builder);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }

    private RmiRequest request;
    private RmiTransport transport;
    private SimpleDateFormat dateFormatter = 
            new SimpleDateFormat("yyyyMMdd kk:mm:ss");

    public XmlRpcProtocol()
    {
    }

    private static Document parse(String resourceName, DocumentBuilder builder)
                           throws Exception
    {
        InputStream in = XmlRpcProtocol.class.getResourceAsStream(resourceName);
        Document doc = (Document) builder.parse(in);

        in.close();

        return doc;
    }

    public String getName()
    {
        return RmiProtocol.XMLRPC;
    }

    public String getMimeType()
    {
        return RmiProtocol.XMLRPC_CONTENT_TYPE;
    }

    public RmiRequest createRequest(Method method, Object[] args, 
                                    RmiContext context)
    {
        return new RmiRequestImpl(method, args);
    }

    public RmiResponse createResponse(RmiRequest request, Object result, 
                                      RmiContext context)
    {
        return new RmiResponseImpl(request, result);
    }

    public void writeRequest(RmiRequest req, RmiContext context)
                      throws Exception
    {
        boolean debug = log.isDebugEnabled();

        log.debug("writeRequest");

        try
        {
            request = req;

            Document doc = (Document) requestTemplate.cloneNode(true);
            NodeList nodes = doc.getElementsByTagName("methodName");
            Node node = nodes.item(0);
            Text text = (Text) node.getFirstChild();
            String signature = req.getEncodedMethodSignature();
            String methodName = 
                    XmlRpcMethodSignatures.getExternalNameForEncodedSignature(
                            signature);

            if (debug)
            {
                log.debug("methodName = " + methodName);
            }

            if (methodName == null)
            {
                methodName = signature;
            }

            text.setData(methodName);

            Object[] arguments = request.getArguments();
            String[] argumentTypes = request.getStringArgumentTypes();

            nodes = doc.getElementsByTagName("param");
            node = nodes.item(0);

            Node params = node.getParentNode();

            params.removeChild(node);

            if (argumentTypes != null)
            {
                for (int i = 0; i < argumentTypes.length; i++)
                {
                    String xmlRmiType = 
                            convertObjectTypeToXmlRpcType(argumentTypes[i]);
                    Node xmlRmiValue = 
                            convertObjectToXmlRpcValue(arguments[i], xmlRmiType, 
                                                       doc);
                    Node param = doc.createElement("param");

                    param.appendChild(xmlRmiValue);

                    params.appendChild(param);
                }
            }

            TransformerFactory transFactory = TransformerFactory.newInstance();
            Transformer transformer = transFactory.newTransformer();
            DOMSource source = new DOMSource(doc);
            OutputStream out = context.getTransport().getOutputStream(context);

            if (debug)
            {
                log.debug("doc = " + doc);
                log.debug("source = " + source);
                log.debug("context.getTransport() = " + context.getTransport());
                log.debug("out = " + out);
            }

            StreamResult result = new StreamResult(out);

            transformer.transform(source, result);
            out.flush();

            if (debug)
            {
                log.debug("doc = " + doc.getDocumentElement());

                ByteArrayOutputStream bo = new ByteArrayOutputStream();

                result = new StreamResult(bo);
                transformer.transform(source, result);
                log.debug("request = " + bo.toString());
            }
        }
        catch (Exception ex)
        {
            if (debug)
            {
                log.debug("Exception: " + ex);
                ex.printStackTrace();
            }
        }
    }

    public RmiRequest readRequest(RmiContext context)
                           throws Exception
    {
        boolean debug = log.isDebugEnabled();

        if (debug)
        {
            log.debug("readRequest()");
        }

        try
        {
            DocumentBuilderFactory factory = 
                    DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            InputStream in = context.getTransport().getInputStream(context);
            Document doc = (Document) builder.parse(in);

            if (debug)
            {
                log.debug("doc = " + doc.getDocumentElement());
            }

            request = new RmiRequestImpl();

            Text text = (Text) doc.getElementsByTagName("methodName").item(0)
                                  .getFirstChild();
            String externalName = text.getData();
            String methodName = 
                    XmlRpcMethodSignatures.getEncodedSignatureForExternalName(
                            context.getTarget().getClass(), externalName);

            if (debug)
            {
                log.debug("text = " + text);
                log.debug("externalName = " + externalName);
                log.debug("context = " + context);
                log.debug("context.getTarget = " + context.getTarget());
                log.debug("methodName = " + methodName);
            }

            if (methodName == null)
            {
                methodName = text.getData();
            }

            request.setEncodedMethodSignature(methodName);

            NodeList nodes = doc.getElementsByTagName("param");

            if (debug)
            {
                log.debug("nodes = " + nodes);
                log.debug("nodes.getLength() = " + nodes.getLength());
            }

            if (nodes.getLength() > 0)
            {
                List values = extractValueNodesFromParams(nodes);
                Object[] argValues = extractArgumentValuesFromParams(values);

                if (debug)
                {
                    log.debug("argValues.length = " + argValues.length);
                }

                request.setArguments(argValues);
            }
        }
        catch (Exception ex)
        {
            if (debug)
            {
                log.debug("Exception: " + ex);
                ex.printStackTrace();
            }
        }

        return request;
    }

    public void writeResponse(RmiResponse response, RmiContext context)
                       throws Exception
    {
        Object object = response.getObject();
        Document document = null;

        if (object instanceof Exception)
        {
            document = writeFaultResponse((Exception) object);
        }
        else
        {
		log.debug("object = " + object);
            document = writeResultResponse(object);
        }

        TransformerFactory transFactory = TransformerFactory.newInstance();
        Transformer transformer = transFactory.newTransformer();
        OutputStream out = context.getTransport().getOutputStream(context);

        transformer.transform(new DOMSource(document), new StreamResult(out));
        out.flush();

        if (log.isDebugEnabled())
        {
            log.debug("document = " + document.getDocumentElement());
        }
    }

    private Document writeResultResponse(Object object)
        throws Exception
    {
        Document doc = null;

        try
        {
            doc = (Document) responseTemplate.cloneNode(true);

            String xmlRmiType = 
                    convertObjectTypeToXmlRpcType(object.getClass().getName());
            Node xmlRmiValue = 
                    convertObjectToXmlRpcValue(object, xmlRmiType, doc);
            NodeList list = doc.getElementsByTagName("param");
            Node param = list.item(0);

            param.appendChild(xmlRmiValue);
        }
        catch (Exception ex)
        {
            if (log.isDebugEnabled())
            {
                ex.printStackTrace();
            }

            throw new XmlRpcUnsupportedTypeException(
                    "Unsupported Type in response: "
                    + object.getClass().getName());
        }

        return doc;
    }

    private Document writeFaultResponse(Exception exception)
        throws Exception
    {
        Document doc = null;

        try
        {
            String faultString = exception.getMessage();

            if (faultString == null)
            {
                faultString = exception.toString();
            }

            HashMap map = new HashMap();

            map.put("faultCode", new Integer(100));
            map.put("faultString", faultString);
            doc = (Document) faultResponseTemplate.cloneNode(true);

            NodeList list = doc.getElementsByTagName("fault");
            Node fault = list.item(0);
            Node xmlRmiValue = convertObjectToXmlRpcValue(map, "struct", doc);

            fault.appendChild(xmlRmiValue);
        }
        catch (Exception ex)
        {
            if (log.isDebugEnabled())
            {
                ex.printStackTrace();
            }
        }

        return doc;
    }

    public RmiResponse readResponse(RmiContext context)
                             throws Exception
    {
        return (context.getTransport().getType().equals(RmiTransport.SYNCHRONOUS))
               ? (RmiResponse) readSynchronousResponse(context)
               : new RmiResponseImpl(null);
    }

    public RmiResponse readSynchronousResponse(RmiContext context)
        throws Exception
    {
        boolean debug = log.isDebugEnabled();

        if (debug)
        {
            log.debug("readResponse()");
        }

        Object result = null;

        try
        {
            if (debug)
            {
                log.debug("transport = " + transport);
            }

            InputStream in = context.getTransport().getInputStream(context);

            if (debug)
            {
                log.debug("in = " + in);
            }

            DocumentBuilderFactory factory = 
                    DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document doc = (Document) builder.parse(in);

            if (debug)
            {
                TransformerFactory transFactory = 
                        TransformerFactory.newInstance();
                Transformer transformer = transFactory.newTransformer();
                OutputStream out = new java.io.ByteArrayOutputStream();

                transformer.transform(new DOMSource(doc), new StreamResult(out));
                log.debug("response = " + out.toString());
                out.flush();
                out.close();
                log.debug("doc = " + doc.getDocumentElement());
            }

            NodeList list = doc.getElementsByTagName("fault");

            if (list.getLength() > 0)
            {
                result = readFault(doc);
            }
            else
            {
                Node param = doc.getElementsByTagName("param").item(0);
                Node value = DomUtil.getChildElements(param).item(0);

                result = convertXmlRpcValueToObject(value);

                if (log.isDebugEnabled())
                {
                    log.debug("result = " + result);
                }
            }
        }
        catch (Exception ex)
        {
            result = ex;
        }

        RmiResponse response = new RmiResponseImpl(result);

        return response;
    }

    private Object readFault(Document doc)
                      throws Exception
    {
        boolean debug = log.isDebugEnabled();
        NodeList list = doc.getElementsByTagName("fault");
        Node node = list.item(0);

        if (debug)
        {
            log.debug("node = [" + node.toString() + "]");
        }

        node = DomUtil.getFirstChildElement(node);

        if (debug)
        {
            log.debug("node = [" + node.toString() + "]");
        }

        Map map = (Map) convertXmlRpcValueToObject(node);
        String faultString = (String) map.get("faultString");

        return new RmiRemoteException(faultString);
    }

    private String convertObjectTypeToXmlRpcType(String javaType)
        throws XmlRpcUnsupportedTypeException
    {
        String result = XmlRpcTypes.getXmlRpcTypeForJavaType(javaType);

        if (result == null)
        {
            throw new XmlRpcUnsupportedTypeException(
                    "Unsupported Type in Method Arguments: " + javaType);
        }

        return result;
    }

    private Node convertObjectToXmlRpcValue(Object object, String type, 
                                            Document doc)
        throws XmlRpcUnsupportedTypeException
    {
        Node result = doc.createElement("value");
        Node value = null;

        if (type.equals(XmlRpcTypes.STRUCT_TYPE))
        {
            value = convertObjectToStruct((Map) object, doc);
        }
        else if (type.equals(XmlRpcTypes.ARRAY_TYPE))
        {
            value = convertObjectToArray((List) object, doc);
        }
        else if (type.equals(XmlRpcTypes.DATETIME_TYPE))
        {
            value = convertObjectToDateTimeValue((Date) object, doc);
        }
        else if (type.equals(XmlRpcTypes.BASE64_TYPE))
        {
            value = convertObjectToBase64Value((byte[]) object, doc);
        }
        else if (type.equals(XmlRpcTypes.BOOLEAN_TYPE))
        {
            value = doc.createElement(type);

            Boolean bool = (Boolean) object;
            String boolString = (bool.booleanValue()) ? "1" : "0";

            value.appendChild(doc.createTextNode(boolString));
        }
        else
        {
            value = doc.createElement(type);
            value.appendChild(doc.createTextNode(object.toString()));
        }

        result.appendChild(value);

        return result;
    }

    private Object convertXmlRpcValueToObject(Node node)
        throws XmlRpcException
    {
        boolean debug = log.isDebugEnabled();
        Object object = null;
        NodeList list = DomUtil.getChildElements(node);

        if (list.getLength() > 0)
        {
            Element element = (Element) list.item(0);
            String xmlrpcType = element.getTagName();

            if (element == null)
            {
                throw new XmlRpcFormatException(
                        "Missing Value For Request Parameter");
            }

            if (debug)
            {
                log.debug("xmlrpcType = " + xmlrpcType);
                log.debug("element = " + element);
            }

            if (xmlrpcType.equals(XmlRpcTypes.STRUCT_TYPE))
            {
                object = convertStructToObject(element);
            }
            else if (xmlrpcType.equals(XmlRpcTypes.ARRAY_TYPE))
            {
                object = convertArrayToObject(element);
            }
            else if (xmlrpcType.equals(XmlRpcTypes.DATETIME_TYPE))
            {
                object = convertDateTimeToObject(element);
            }
            else if (xmlrpcType.equals(XmlRpcTypes.BASE64_TYPE))
            {
                object = convertBase64ToObject(element);
            }
            else
            {
                object = convertSimpleToObject(element);
            }
        }
        else
        {
            Text text = (Text) node.getFirstChild();

            object = text.getData();
        }

        return object;
    }

    private Object convertSimpleToObject(Element element)
        throws XmlRpcException
    {
        boolean debug = log.isDebugEnabled();
        Object object = null;

        if (debug)
        {
            log.debug("element = " + element);
        }

        try
        {
            if (element instanceof Text)
            {
                object = ((Text) element).getData();
            }
            else
            {
                String xmlRmiType = element.getTagName();
                Text text = (Text) element.getFirstChild();

                if (debug)
                {
                    log.debug("text = " + text);
                }

                if (text != null)
                {
                    String value = text.getData();

                    if (debug)
                    {
                        log.debug("value = " + value);
                    }

                    if (xmlRmiType.equals(XmlRpcTypes.INT_TYPE)
                        || xmlRmiType.equals(XmlRpcTypes.I4_TYPE))
                    {
                        object = new Integer(value);
                    }
                    else if (xmlRmiType.equals(XmlRpcTypes.BOOLEAN_TYPE))
                    {
                        object = new Boolean(!value.equals("0"));
                    }
                    else if (xmlRmiType.equals(XmlRpcTypes.DOUBLE_TYPE))
                    {
                        object = new Double(value);
                    }
                    else
                    {
                        object = value;
                    }
                }
            }
        }
        catch (Exception ex)
        {
            throw new XmlRpcFormatException("Malformed parameters for  request");
        }

        return object;
    }

    private Node convertObjectToArray(List list, Document doc)
        throws XmlRpcUnsupportedTypeException
    {
        Element data = doc.createElement("data");

        Iterator elements = list.iterator();

        while (elements.hasNext())
        {
            Object object = elements.next();
            String type = convertObjectTypeToXmlRpcType(
                                  object.getClass().getName());
            Node node = convertObjectToXmlRpcValue(object, type, doc);

            data.appendChild(node);
        }

        Element array = doc.createElement(XmlRpcTypes.ARRAY_TYPE);

        array.appendChild(data);

        return array;
    }

    private List convertArrayToObject(Node node)
        throws XmlRpcException
    {
        ArrayList list = null;
        boolean debug = log.isDebugEnabled();

        try
        {
            node = DomUtil.getChildElementsByTagName(node, "data").item(0);

            NodeList values = DomUtil.getChildElements(node);
            int numValues = values.getLength();

            if (debug)
            {
                log.debug("numValues = " + numValues);
            }

            list = new ArrayList(numValues);

            for (int i = 0; i < numValues; i++)
            {
                String xmlrpcType = "string";
                Node value = values.item(i);

                /*
                Node typeNode = DomUtil.getChildElements(value).item(0);// <int>, <string>, <struct> etc
                if (typeNode instanceof Element) {
                xmlrpcType = ((Element)typeNode).getTagName();
                }
                */
                if (debug)
                {
                    log.debug("value = " + value);
                }

                Object object = convertXmlRpcValueToObject(value);

                if (debug)
                {
                    log.debug("object = " + object);
                }

                list.add(object);
            }
        }
        catch (XmlRpcException ex)
        {
            throw ex;
        }
        catch (Exception ex)
        {
            throw new XmlRpcFormatException(
                    "Failed Converting XML-RPC <array> to List");
        }

        return list;
    }

    private Node convertObjectToStruct(Map map, Document doc)
        throws XmlRpcUnsupportedTypeException
    {
        Element struct = doc.createElement(XmlRpcTypes.STRUCT_TYPE);
        Set entrySet = map.entrySet();
        Iterator entries = entrySet.iterator();

        while (entries.hasNext())
        {
            Map.Entry entry = (Map.Entry) entries.next();
            String memberName;
            Object key = entry.getKey();

            if (key instanceof String)
            {
                memberName = (String) key;
            }
            else
            {
                throw new XmlRpcUnsupportedTypeException(
                        "Unsupported Type For Map Key: "
                        + key.getClass().getName());
            }

            Object object = entry.getValue();
            Element member = doc.createElement("member");
            Element name = doc.createElement("name");
            Text text = doc.createTextNode(memberName);

            name.appendChild(text);
            member.appendChild(name);

            String type = convertObjectTypeToXmlRpcType(
                                  object.getClass().getName());
            Node value = convertObjectToXmlRpcValue(object, type, doc);

            member.appendChild(value);

            struct.appendChild(member);
        }

        return struct;
    }

    private Map convertStructToObject(Node node)
        throws XmlRpcException
    {
        HashMap map = null;

        try
        {
            NodeList members = DomUtil.getChildElements(node);
            int memberCount = members.getLength();

            map = new HashMap(memberCount);

            for (int i = 0; i < memberCount; i++)
            {
                Node member = members.item(i);
                NodeList nodes = DomUtil.getChildElements(member);

                node = nodes.item(0);

                Text text = (Text) node.getFirstChild();
                String key = text.getData();

                node = nodes.item(1);

                Object object = convertXmlRpcValueToObject(node);

                map.put(key, object);
            }
        }
        catch (XmlRpcException ex)
        {
            throw ex;
        }
        catch (Exception ex)
        {
            throw new XmlRpcFormatException("Failed reading <struct> members");
        }

        return map;
    }

    private Node convertObjectToDateTimeValue(Date date, Document doc)
    {
        Node datetime = doc.createElement(XmlRpcTypes.DATETIME_TYPE);
        String string = dateFormatter.format(date);

        string = string.replace(' ', 'T');

        Text text = doc.createTextNode(string);

        datetime.appendChild(text);

        return datetime;
    }

    private Date convertDateTimeToObject(Node node)
        throws XmlRpcException
    {
        Date date = null;
        boolean debug = log.isDebugEnabled();

        try
        {
            if (debug)
            {
                log.debug("node = " + node);
            }

            Text text = (Text) node.getFirstChild();

            if (debug)
            {
                log.debug("text = " + text);
            }

            String string = text.getData();

            string = string.replace('T', ' ');

            if (debug)
            {
                log.debug("string = " + string);
            }

            date = dateFormatter.parse(string);

            if (debug)
            {
                log.debug("date = " + date);
            }
        }
        catch (Exception ex)
        {
            if (debug)
            {
                log.debug("ex = " + ex);
            }

            throw new XmlRpcFormatException(
                    "Failed while parsing a Date from XML-RPC request");
        }

        return date;
    }

    private Node convertObjectToBase64Value(byte[] bytes, Document doc)
    {
        Node node = doc.createElement(XmlRpcTypes.BASE64_TYPE);
        String string = new String(bytes);
        Text text = doc.createTextNode(string);

        node.appendChild(text);

        return node;
    }

    private byte[] convertBase64ToObject(Node node)
        throws XmlRpcException
    {
        byte[] bytes = null;
        boolean debug = log.isDebugEnabled();

        try
        {
            if (debug)
            {
                log.debug("node = " + node);
            }

            Text text = (Text) node.getFirstChild();

            if (debug)
            {
                log.debug("text = " + text);
            }

            String string = text.getData();

            bytes = string.getBytes();
        }
        catch (Exception ex)
        {
            if (debug)
            {
                log.debug("ex = " + ex);
            }

            throw new XmlRpcFormatException(
                    "Failed while parsing a Base 64 value from XML-RPC request");
        }

        return bytes;
    }

    private List extractValueNodesFromParams(NodeList nodes)
    {
        int listLength = nodes.getLength();
        ArrayList list = new ArrayList(listLength);

        for (int i = 0; i < listLength; i++)
        {
            Node node = nodes.item(i); // <param>

            if (log.isDebugEnabled())
            {
                log.debug("node = " + node);
            }

            node = DomUtil.getChildElements(node).item(0); // <value>
            list.add(node);
        }

        return list;
    }

    private String[] extractArgumentTypesFromParams(List values)
    {
        int listLength = values.size();
        String[] strings = new String[listLength];
        Iterator nodes = values.iterator();
        int i = 0;

        while (nodes.hasNext())
        {
            String xmlrpcType = "string";
            Node node = (Node) nodes.next();

            node = node.getFirstChild();

            if (node instanceof Element)
            {
                xmlrpcType = ((Element) node).getTagName();
            }


            //String javaType = (String)xmlrpcTypes.get(xmlrpcType);
            strings[i++] = xmlrpcType;
        }

        return strings;
    }

    private Object[] extractArgumentValuesFromParams(List values)
        throws XmlRpcException
    {
        boolean debug = log.isDebugEnabled();
        int listLength = values.size();
        Object[] objects = new Object[listLength];

        if (debug)
        {
            log.debug("listLength = " + listLength);
        }

        for (int i = 0; i < listLength; i++)
        {
            Node node = (Node) values.get(i);

            if (debug)
            {
                log.debug("node = " + node);
            }

            Object object = convertXmlRpcValueToObject(node);

            if (debug)
            {
                log.debug("object = " + object);
            }

            objects[i] = object;
        }

        return objects;
    }
}