package ca.uhn.hl7v2.util;

 import java.util.regex.Pattern;

 import org.w3c.dom.Document;

 import org.w3c.dom.Element;

 import org.w3c.dom.NamedNodeMap;

 import org.w3c.dom.Node;

 import org.w3c.dom.NodeList;

 import org.xml.sax.SAXException;

 import ca.uhn.hl7v2.HL7Exception;

 import ca.uhn.hl7v2.model.Message;

 import ca.uhn.hl7v2.parser.GenericParser;

 /**

  * Tools for testing message strings for semantic equivalence without assuming the correctness

  * of parsers.  

  * @author Bryan Tripp

  */

 public class EncodedMessageComparator {

     static final GenericParser parser = new GenericParser();  

     /**

      * Returns a "standardized" equivalent of the given message string.  For delimited

      * messages, the returned value is the shortest string that has an equivalent

      * meaning in HL7.  For XML-encoded messages, the returned value is equivalent XML output

      * using a standard pretty-print format.  An automatic determination is made about whether 

      * the given string is XML or ER7 (i.e. traditionally) encoded.

      * @param message an XML-encoded or ER7-encoded message string

      */

     public static String standardize(String message) throws SAXException {

         String result = null;

         String encoding = parser.getEncoding(message);

         if (encoding.equals("XML")) {

             result = standardizeXML(message);

         } else {

             result = standardizeER7(message);

         }

         return result;

     }

     /**

      * Returns the shortest string that is semantically equivalent to a given ER7-encoded 

      * message string.

      */

     public static String standardizeER7(String message) {

         //make delimiter sequences (must quote with \ if not alphanumeric; can't otherwise because of regexp rules)

         char fieldDelimChar = message.charAt(3);

         String fieldDelim = String.valueOf(fieldDelimChar);

         if (!Character.isLetterOrDigit(fieldDelimChar)) fieldDelim = "\\" + fieldDelimChar;

         char compSepChar = message.charAt(4);

         String compSep = String.valueOf(compSepChar);

         if (!Character.isLetterOrDigit(compSepChar)) compSep = "\\" + compSepChar;

         char repSepChar = message.charAt(5);

         String repSep = String.valueOf(repSepChar);

         if (!Character.isLetterOrDigit(repSepChar)) repSep = "\\" + repSepChar;

         char subSepChar = message.charAt(7);

         String subSep = String.valueOf(subSepChar);

         if (!Character.isLetterOrDigit(subSepChar)) subSep = "\\" + subSepChar;

         //char space = ' ';

         /* Things to strip (cumulative):

          *  - all delimiters and repetition separators before end line (i.e. end segment)

          *  - repetition separators, comp and subcomp delims before new field

          *  - subcomponent delimiters before new component

          */

         Pattern endSegment = Pattern.compile("[" + fieldDelim + compSep + repSep + subSep + "]*[\n\r]+");

         message = endSegment.matcher(message).replaceAll("\r");

         Pattern endField = Pattern.compile("[" + repSep + compSep + subSep + "]*" + fieldDelim);

         message = endField.matcher(message).replaceAll(String.valueOf(fieldDelim));

         Pattern endComp = Pattern.compile("[" + subSep + "]*" + compSep);

         message = endComp.matcher(message).replaceAll(String.valueOf(compSep));

         //Pattern endSub = Pattern.compile("[ ]*" + subSep);

         //message = endSub.matcher(message).replaceAll(String.valueOf(subSep));

         //handle special case of subcomp delim in encoding characters

         message = message.substring(0, 7) + subSepChar + message.substring(7);

         return message;

     }

     /**

      * Returns a semantic equivalent of a given XML-encoded message in a default format.

      * Attributes, comments, and processing instructions are not considered to change the 

      * HL7 meaning of the message, and are removed in the standardized representation.    

      */

     public static String standardizeXML(String message) throws SAXException {

         try {

                 Document doc = XMLUtils.parse(message);

             clean(doc.getDocumentElement());

             return XMLUtils.serialize(doc, true);

         } catch (Exception e) {

             throw new RuntimeException("Exception while standardizing XML ", e);

         }

     }

     /** Removes attributes, comments, and processing instructions. */

     private static void clean(Element elem) {

         NodeList children = elem.getChildNodes();        

         for (int i = 0; i < children.getLength(); i++) {

             Node child = children.item(i);

             if (child.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE 

                 || child.getNodeType() == Node.COMMENT_NODE)

             {

                                 elem.removeChild(child);

             } else if (child.getNodeType() == Node.ELEMENT_NODE) {

                 clean((Element) child);

             }

         }

         NamedNodeMap attributes = elem.getAttributes();

         //get names

         String[] names = new String[attributes.getLength()];

         for (int i = 0; i < names.length; i++) {

             names[i] = attributes.item(i).getNodeName();

         }

         //remove by name

         for (int i = 0; i < names.length; i++) {

             attributes.removeNamedItem(names[i]);

         }

     }

     /**

      * <p>Compares two HL7 messages to see if they are equivalent (in terms of their  

      * HL7 meaning).  Semantically irrelevant differences (e.g. spaces in an XML tag; 

      * extra field delimiters at the end of a segment; XML vs. ER7 encoding; XML attributes)

      * are ignored. This check is performed without assuming the correctness of the HAPI parsers, 

      * and can therefore be used to test them.  This is done by parsing a message, encoding it

      * again, and comparing the result with this original.  </p>

      * <p>If one message is in XML and the other in ER7, the former is converted to ER7 to 

      * perform the comparison.  This process relies on the HAPI parsers.  However, the 

      * parsed message is first encoded as XML and compared to the original, so that the 

      * integrity of the parser can be verified.  An exception is thrown if this comparison 

      * is unsuccessful.  </p>

      * @return true if given messages are semantically equivalent 

      */

     public static boolean equivalent(String message1, String message2) throws HL7Exception {

             Pair<String> messages = standardize(message1, message2);

         return messages.getValue1().equals(messages.getValue2());

     }

     static Pair<String> standardize(String message1, String message2) throws HL7Exception {

         String encoding1 = parser.getEncoding(message1);

         String encoding2 = parser.getEncoding(message2);

         if (!encoding1.equals(encoding2)) {

             if (encoding1.equals("XML")) {

                 message1 = safeER7Conversion(message1);

             } else {

                 message2 = safeER7Conversion(message2);

             }

         }

         String std1, std2;

         try {

             std1 = standardize(message1);

             std2 = standardize(message2);

         } catch (SAXException e) {

             throw new HL7Exception("Equivalence check failed due to SAXException: " + e.getMessage());

         }

         return new Pair<String>(std1, std2);

         }

         /** 

      * Converts XML message to ER7, first checking integrity of parse and throwing 

      * an exception if parse not correct

      */

     static String safeER7Conversion(String xmlMessage) throws HL7Exception {

         Message m = parser.parse(xmlMessage);

         String check = parser.encode(m, "XML");

         if (!equivalent(xmlMessage, check)) {

             throw new HL7Exception("Parsed and encoded message not equivalent to original (possibilities: invalid message, bug in parser)");

         }

         return parser.encode(m, "VB");        

     }

 }