/*
 * $Id: ReceivingServlet.java
 */

package JAXMInvoicing.customer;

import javax.xml.messaging.*;
import javax.xml.soap.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

import javax.xml.transform.*;
import javax.xml.transform.stream.*;
import javax.xml.parsers.*;
import javax.xml.transform.dom.*;
import org.w3c.dom.*;

import javax.naming.*;
import javax.activation.DataHandler;
import java.util.*;
import java.net.*;



public class ReceivingServlet 
    extends JAXMServlet 
    implements ReqRespListener
{


    private final String attachmentRef = "href";
    static MessageFactory fac = null;
    
    static {
        try {
            fac = MessageFactory.newInstance();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    };
        
    
    public void init(ServletConfig servletConfig) throws ServletException {
        super.init(servletConfig);
    }

	
    /**
      Searches and returns the first node if finds in the inputted DOM tree
      for an element with an attribute called href. It performs depth first search
      @param root the inputted DOM representation of the SOAPMessage body
      @return returns null if no element with a href attribute is found otherwise it returns a reference to the first matching element found
     **/
     public org.w3c.dom.Node findAttachmentNode(org.w3c.dom.Node root){


	//This is the entirenode
	org.w3c.dom.Node attachmentNode = null;

	//If the element has attributes check if it has a href attribute
	//if it does then return root as the node which has the href attribute
        if(root.hasAttributes()){
		NamedNodeMap elementAttrs = root.getAttributes();
		org.w3c.dom.Node attributeNode = 
			elementAttrs.getNamedItem(attachmentRef);

		if(attributeNode != null){
			System.out.println("href found for element"+root.getNodeName());
			return root;
		}
	}

	//Check if root has any children if not return null;
	if(!(root.hasChildNodes()))
		return null;

        //If root has children, and no href is found continue searching root's children
	NodeList childNodes = root.getChildNodes();
	int noChildren = childNodes.getLength();
	for (int i = 0; i<noChildren; i++){
		
        	if(attachmentNode == null){
			org.w3c.dom.Node child = childNodes.item(i);
	        	attachmentNode = 
				findAttachmentNode(child);
	        }else break;
	}

        return attachmentNode;
     }
 

	
    /**
     This method will be called when an attachment should be in the message package.
     Given a href value which is assumed to be an absolute URI, it will look for an
     attachment part with a content-location MIME header equal to hrefValue.

     @param message	The message package which should have attachment parts

     @param hrefValue	A string in URI form. This is the hrefValue.

     @return	Either a matching attachmentPart is return otherwise an exception will be thrown
     @exception Two exceptions can be thrown. If no matching attachments are found, an error is thrown. Or if there is a matching attachment
		but it is the wrong content-type.
     **/
    public AttachmentPart findXMLAttachment(SOAPMessage message,
						 String hrefValue)
					             throws Exception{
        Iterator allAttachments = message.getAttachments();
	AttachmentPart ap1 = null;
        while(allAttachments.hasNext()){
		ap1 = (AttachmentPart)allAttachments.next();
		String contentLocation = ap1.getContentLocation();
	        if(contentLocation == null)
		    continue;	
		
                if(contentLocation.equals(hrefValue)){
			if(ap1.getContentType().equals("text/xml"))
					return ap1;
                        else throw new Exception("not correct type");
                 }
        }
       
        throw new Exception("There is no accompanying attachment with "+
				"a content-location value of "+hrefValue);
    }

 
    /**
     Check that the node is of DOCUMENT_NODE type

     @param root The input node
     @return True if root is of DOCUMENT_NODE type otherwise false
     **/
     public boolean isDOCUMENT_NODEType(org.w3c.dom.Node root){
	return((root.getNodeType()) == org.w3c.dom.Node.DOCUMENT_NODE);
     } 

    /**
    Retrieve the value of the href attribute
    @param attachmentNode The element node which has an attribute value equal to href
    @return The value of the href value as a string
    **/	
    public String getHrefValue(org.w3c.dom.Node attachmentNode){
	 NamedNodeMap attributes = attachmentNode.getAttributes();
         org.w3c.dom.Node hrefNode = attributes.getNamedItem(attachmentRef);
	 return(hrefNode.getNodeValue());
    }


   /**
   Retrieve an emptyDocument element. Synchronization control is required
   for thread-safety purposes
   @return A empty document
   @exception Throws a ParserConfigurationException if there is a problem with the underlying DOM parser
    **/ 
    public Document getNewEmptyDocument() throws ParserConfigurationException{
	DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
	synchronized(dbf){
		DocumentBuilder db = dbf.newDocumentBuilder();
		return(db.newDocument());
	}
     }


    /**
   Will return a DOMResult of some xml input. It will transform source into a DOM Result
   @param source A javax.xml.transform.Source which acts as a handler on an xml source
   @return  A DOMResult object which is the transformed source
   @exception A ParserConfigurationException, TransformerConfigurationException, TransformerException can be thrown if the underlying DOM and
	      XSLT processors have problems.
    **/
    public DOMResult getDOMResult(Source source)
                throws ParserConfigurationException, 
		       TransformerConfigurationException, 
		       TransformerException{
	
	DOMResult domResult = null;
	TransformerFactory tf = TransformerFactory.newInstance();
	Transformer transformer = tf.newTransformer();
	transformer.transform(source, 
			(domResult = new DOMResult(getNewEmptyDocument())));
	return domResult;			
    }


     /**
     Outputs the DOM representation given as root to a file called outputFile
     @param root The DOM representation to be outputted
     @param outputFile The name of the file.
    **/
    public void printOutDocument(org.w3c.dom.Node root, String outputFile)
			throws TransformerException,
			       TransformerConfigurationException,
			       FileNotFoundException{
	TransformerFactory tf = TransformerFactory.newInstance();
	Transformer transformer = tf.newTransformer();
	transformer.transform(new DOMSource(root), 
			new StreamResult(new FileOutputStream(outputFile)));
    }


    /**
     The central method which takes a SOAPMessage and an accompanying xml attachment and creates a single DOM representation
     @param message The SOAPMessage
    **/
    public void createSOAPDOM(SOAPMessage message){
	try{
		SOAPPart sp = message.getSOAPPart();
		
		//Retrieve SOAPMessage part
		Source source = sp.getContent();

	        //Create a DOMRepresentation of SOAPMessage
                DOMResult domSOAPMessage = getDOMResult(source);
	

		//Need fully-qualified name of Node to avoid ambiguity
		//Retrieve the root of the SOAPMessage
		org.w3c.dom.Node domSOAPMessageRoot = domSOAPMessage.getNode();
                

		//Check that root is of DOCUMENT_NODE type if not throw error
		if(!(isDOCUMENT_NODEType(domSOAPMessageRoot)))
	         throw new Exception("SOAPMessage is not a DOCUMENT_NODE type");

		//The SOAPMessage can be parsed into a DOM, so continue
                 Element domSOAPMessageRootEl=
			(((Document)domSOAPMessageRoot).getDocumentElement());

                //loop around a while loop to place all XML attachments into their
		//DOM representation, and placed in the correct place of the SOAP message DOM.

		org.w3c.dom.Node attachmentNode = null;
                
		//Find an attachment node by looking for elements with attribute name equal to href.
		while((attachmentNode = findAttachmentNode(domSOAPMessageRootEl)) != null){

		
		//Retrieve href reference value
		String attachmentName = getHrefValue(attachmentNode);

		//Retrieve the attachment with matching values
                AttachmentPart xmlAttachment = findXMLAttachment(message,attachmentName);

         
	        //Convert the attachment part into its DOM Representation	
		DataHandler attachmentContent = xmlAttachment.getDataHandler();
		StreamSource attachmentStream = 
			new StreamSource(attachmentContent.getInputStream());
		DOMResult domAttachment = getDOMResult(attachmentStream);
	      
                org.w3c.dom.Node domAttachmentNode = domAttachment.getNode(); 

		//If the attachment is a proper xml document then continue else throw exception
	        if(!(isDOCUMENT_NODEType(domAttachmentNode)))
	         throw new Exception("Attachment is not of DOCUMENT_NODE type");

                 Document domAttachmentDocument = (Document)domAttachmentNode;


	         //Add the DOM representation of attachment into the DOM
		 //representation of the SOAPMessage at the correct place
	
		 //Create a documentFragment of DOM representation of attachment 
		 DocumentFragment docFrag = 
				domAttachmentDocument.createDocumentFragment();
	
                Element el = domAttachmentDocument.getDocumentElement(); 

		 //Add the DOM attachment as a child of docFrag
		 docFrag.appendChild(el); 

		 /**
                 Want to replace the attachmentNode in SOAPMessage (i.e. the
		 node with href attribute) with the contents of attachment.
		 Need to retrieve the parent node of the attachmentNode to 
		 replace the attachmentNode with the docFragment that contains
		 the contents of the attachment as a DOM Node
		 **/
		org.w3c.dom.Node attachmentparent = 
				attachmentNode.getParentNode();
                org.w3c.dom.Node result = 
	         ((Document)domSOAPMessageRoot).importNode(docFrag, true);  

		attachmentparent.replaceChild(result, attachmentNode);
	       }

	   //Print out the entire DOM Object.
           //When this application is run on TOMCAT, DOMAttachment.xml will be found in the TOMCAT_HOME directory

           printOutDocument(domSOAPMessageRoot, "DOMAttachment.xml");

         }catch(ParserConfigurationException pe){
		System.out.println("Problem with setting up DOM");
		System.out.println("ERROR"+pe.getMessage());
		pe.printStackTrace();
	 }catch(TransformerConfigurationException te){
		System.out.println("Problem setting up transformer");
		te.printStackTrace();
	 }catch(TransformerException tre){
		System.out.println("Problem doing a transformation");
		tre.printStackTrace();
         }catch(Exception e){
		System.out.println("Exception in createSOAPDOM "+
							e.getMessage());
	 }
    } 			

		

		
    
    // This is the application code for handling the message.. Once the
    // message is received the application can retrieve the soap part, the
    // attachment part if there are any, or any other information from the
    // message.

    public SOAPMessage onMessage(SOAPMessage message) {
        try {
            message.writeTo(System.out);
            createSOAPDOM(message);
            return message;
        } catch(Exception e) {
	    System.out.println("ERROR: "+ e.getMessage());
            return null;
        }
    }
}