/**
 * The contents of this file are subject to the Mozilla Public License Version 1.1
 * (the "License"); you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at http://www.mozilla.org/MPL/
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the
 * specific language governing rights and limitations under the License.
 *
 * The Original Code is "Responder.java".  Description:
 * "Performs the responding role in a message exchange according to HL7's original mode
 * processing rules."
 *
 * The Initial Developer of the Original Code is University Health Network. Copyright (C)
 * 2002.  All Rights Reserved.
 *
 * Contributor(s): ______________________________________.
 *
 * Alternatively, the contents of this file may be used under the terms of the
 * GNU General Public License (the  �GPL�), in which case the provisions of the GPL are
 * applicable instead of those above.  If you wish to allow use of your version of this
 * file only under the terms of the GPL and not to allow others to use your version
 * of this file under the MPL, indicate your decision by deleting  the provisions above
 * and replace  them with the notice and other provisions required by the GPL License.
 * If you do not delete the provisions above, a recipient may use your version of
 * this file under either the MPL or the GPL.
 *
 */

package ca.uhn.hl7v2.app;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.Reader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import ca.uhn.hl7v2.HL7Exception;
import ca.uhn.hl7v2.llp.HL7Reader;
import ca.uhn.hl7v2.llp.HL7Writer;
import ca.uhn.hl7v2.llp.LLPException;
import ca.uhn.hl7v2.model.Message;
import ca.uhn.hl7v2.model.Segment;
import ca.uhn.hl7v2.parser.Parser;
import ca.uhn.hl7v2.parser.PipeParser;
import ca.uhn.hl7v2.util.MessageIDGenerator;
import ca.uhn.hl7v2.util.Terser;
import ca.uhn.log.HapiLog;
import ca.uhn.log.HapiLogFactory;
//import ca.uhn.hl7v2.model.v24.datatype.ValidNM;

/**
 * <p>Performs the responding role in a message exchange (i.e receiver of the first message,
 * sender of the response; analagous to the server in a client-server interaction), according
 * to HL7's original mode processing rules.</p>
 * <p>At the time of writing, enhanced mode, two-phase reply, continuation messages, and
 * batch processing are unsupported. </p>
 * @author  Bryan Tripp
 */
public class Responder {
    
    private static final HapiLog log = HapiLogFactory.getHapiLog(Responder.class);
    
    //private LowerLayerProtocol llp;
    private Parser parser;
    private ArrayList apps;
    private HL7Reader in;
    private HL7Writer out;
    private BufferedWriter checkWriter = null;
    
    /**
     * Creates a new instance of Responder that optionally validates parsing of incoming
     * messages using a system property.  If the system property
     * <code>ca.uhn.hl7v2.app.checkparse</code> equals "true", parse integrity is checked,
     * i.e. each message is re-encoded and differences between the received message text
     * and the re-encoded text are written to the file <hapi.home>/parse_check.txt.
     */
    public Responder(Parser parser) throws LLPException {
        String checkParse = System.getProperty("ca.uhn.hl7v2.app.checkparse");
        if (checkParse != null && checkParse.equals("true")) {
            init(parser, true);
        }
        else {
            init(parser, false);
        }
    }
    
    /**
     * Creates a new instance of Responder that optionally validates parsing of incoming messages.
     * @param validate if true, encodes each incoming message after parsing it, compares
     *      the result to the original message string, and prints differences to the file
     *      "<hapi.home>/parse_check.txt" in the working directory.  This process is slow and should
     *      only be used during testing.
     */
    public Responder(Parser parser, boolean checkParse) {
        init(parser, checkParse);
    }
    
    /**
     * Performs common constructor tasks.
     */
    private void init(Parser parser, boolean checkParse) {
        this.parser = parser;
        apps = new ArrayList(10);
        try {
            if (checkParse)
                checkWriter = new BufferedWriter(
                    new FileWriter(
                    ca.uhn.hl7v2.util.Home.getHomeDirectory().getAbsolutePath() + "/parse_check.txt", true));
        }
        catch (IOException e) {
            log.error( "Unable to open file to write parse check results.  Parse integrity checks will not proceed", e );
        }
    }
    
    /**
     * Processes an incoming message string and returns the response message string.
     * Message processing consists of parsing the message, finding an appropriate
     * Application and processing the message with it, and encoding the response.
     * Applications are chosen from among those registered using
     * <code>registerApplication</code>.  The Parser is obtained from the Connection
     * associated with this Responder.
     */
    protected String processMessage(String incomingMessageString) throws HL7Exception {
        HapiLog rawOutbound = HapiLogFactory.getHapiLog("ca.uhn.hl7v2.raw.outbound");
        HapiLog rawInbound = HapiLogFactory.getHapiLog("ca.uhn.hl7v2.raw.inbound");
        
        log.info( "Responder got message: " + incomingMessageString );
        rawInbound.info(incomingMessageString);
        
        Message incomingMessageObject = null;
        String outgoingMessageString = null;
        try {
            incomingMessageObject = parser.parse(incomingMessageString);
        }
        catch (HL7Exception e) {
        	boolean processed = false;
        	for (Object app : apps) {
				if (!processed) {
					if (app instanceof ApplicationExceptionHandler) {
						ApplicationExceptionHandler aeh = (ApplicationExceptionHandler) app;
						outgoingMessageString = aeh.processException(incomingMessageString, e);
						processed = true;
					}
					if (app instanceof MessageTypeRouter) {
						HashMap routerApps = ((MessageTypeRouter) app).apps;
						Set<Map.Entry<Object, Application>> entrySet = routerApps.entrySet();
						for (Map.Entry<Object, Application> entry : entrySet) {
							app = entry.getValue();
							if (app instanceof ApplicationExceptionHandler) {
								ApplicationExceptionHandler aeh = (ApplicationExceptionHandler) app;
								outgoingMessageString = aeh.processException(incomingMessageString, e);
								processed = true;
							}
						}
					}
				}
			}
        	if (!processed) {
        		outgoingMessageString = logAndMakeErrorMessage(e, parser.getCriticalResponseData(incomingMessageString), parser, parser.getEncoding(incomingMessageString));
        	}
        }
        
        if (outgoingMessageString == null) {
            try {
                //optionally check integrity of parse
                try {
                    if (checkWriter != null)
                        checkParse(incomingMessageString, incomingMessageObject, parser);
                }
                catch (IOException e) {
                    log.error( "Unable to write parse check results to file", e );
                }
                
                //message validation (in terms of optionality, cardinality) would go here ***
                
                Application app = findApplication(incomingMessageObject);
                Message response = app.processMessage(incomingMessageObject);
                
                //Here we explicitly use the same encoding as that of the inbound message - this is important with GenericParser, which might use a different encoding by default
                outgoingMessageString = parser.encode(response, parser.getEncoding(incomingMessageString));
            }
            catch (Exception e) {
                outgoingMessageString = logAndMakeErrorMessage(e, (Segment) incomingMessageObject.get("MSH"), parser, parser.getEncoding(incomingMessageString));
            }
        }
        
        log.info( "Responder sending message: " + outgoingMessageString );
        rawOutbound.info(outgoingMessageString);
        
        return outgoingMessageString;
    }
    
    /**
     * Returns the first Application that has been registered, which can process the given
     * Message (according to its canProcess() method).
     */
    private Application findApplication(Message message) {
        int c = 0;
        Application app = null;
        while (app == null && c < this.apps.size()) {
            Application a = (Application) this.apps.get(c++);
            if (a.canProcess(message))
                app = a;
        }
        
        //have to send back an application reject of no apps available to process
        if (app == null)
            app = new DefaultApplication();
        return app;
    }
    
    /**
     * Encodes the given message and compares it to the given string.  Any differences
     * are noted in the file [hapi.home]/parse_check.txt.  Ignores extra field delimiters.
     */
    private void checkParse(String originalMessageText, Message parsedMessage, Parser parser)
    throws HL7Exception, IOException {
        log.info("ca.uhn.hl7v2.app.Responder is checking parse integrity (turn this off if you are not testing)");
        String newMessageText = parser.encode(parsedMessage);
        
        checkWriter.write("******************* Comparing Messages ****************\r\n");
        checkWriter.write("Original:           " + originalMessageText + "\r\n");
        checkWriter.write("Parsed and Encoded: " + newMessageText + "\r\n");
        
        if (!originalMessageText.equals(newMessageText)) {
            //check each segment
            StringTokenizer tok = new StringTokenizer(originalMessageText, "\r");
            ArrayList one = new ArrayList();
            while (tok.hasMoreTokens()) {
                String seg = tok.nextToken();
                if (seg.length() > 4)
                    one.add(seg);
            }
            tok = new StringTokenizer(newMessageText, "\r");
            ArrayList two = new ArrayList();
            while (tok.hasMoreTokens()) {
                String seg = tok.nextToken();
                if (seg.length() > 4)
                    two.add(stripExtraDelimiters(seg, seg.charAt(3)));
            }
            
            if (one.size() != two.size()) {
                checkWriter.write("Warning: inbound and parsed messages have different numbers of segments: \r\n");
                checkWriter.write("Original: " + originalMessageText + "\r\n");
                checkWriter.write("Parsed:   " + newMessageText + "\r\n");
            }
            else {
                //check each segment
                for (int i = 0; i < one.size(); i++) {
                    String origSeg = (String) one.get(i);
                    String newSeg = (String) two.get(i);
                    if (!origSeg.equals(newSeg)) {
                        checkWriter.write("Warning: inbound and parsed message segment differs: \r\n");
                        checkWriter.write("Original: " + origSeg + "\r\n");
                        checkWriter.write("Parsed: " + newSeg + "\r\n");
                    }
                }
            }
        }
        else {
            checkWriter.write("No differences found\r\n");
        }
        
        checkWriter.write("********************  End Comparison  ******************\r\n");
        checkWriter.flush();
        
    }
    
    /**
     * Removes unecessary delimiters from the end of a field or segment.
     * This is cut-and-pasted from PipeParser (just making it public in
     * PipeParser would kind of cloud the purpose of PipeParser).
     */
    private static String stripExtraDelimiters(String in, char delim) {
        char[] chars = in.toCharArray();
        
        //search from back end for first occurance of non-delimiter ...
        int c = chars.length - 1;
        boolean found = false;
        while (c >= 0 && !found) {
            if (chars[c--] != delim)
                found = true;
        }
        
        String ret = "";
        if (found)
            ret = String.valueOf(chars, 0, c + 2);
        return ret;
    }
    
    /**
     * Logs the given exception and creates an error message to send to the
     * remote system.
     * 
     * @param encoding The encoding for the error message. If <code>null</code>, uses default encoding 
     */
    public static String logAndMakeErrorMessage(Exception e, Segment inHeader, Parser p, String encoding) throws HL7Exception {
        
        log.error( "Attempting to send error message to remote system.", e);
        
        // create error message ...
        String errorMessage = null;
        try {
            Message out = DefaultApplication.makeACK(inHeader);
            Terser t = new Terser(out);
            
            //copy required data from incoming message ...
            try {
                t.set("/MSH-10", MessageIDGenerator.getInstance().getNewID());
            }
            catch (IOException ioe) {
                throw new HL7Exception("Problem creating error message ID: " + ioe.getMessage());
            }
            
            //populate MSA ...
            t.set("/MSA-1", "AE"); //should this come from HL7Exception constructor?
            t.set("/MSA-2", Terser.get(inHeader, 10, 0, 1, 1));
            String excepMessage = e.getMessage();
            if (excepMessage != null)
                t.set("/MSA-3", excepMessage.substring(0, Math.min(80, excepMessage.length())));
            
            /* Some earlier ACKs don't have ERRs, but I think we'll change this within HAPI
               so that there is a single ACK for each version (with an ERR). */
            //see if it's an HL7Exception (so we can get specific information) ...
            if (e.getClass().equals(HL7Exception.class)) {
                Segment err = (Segment) out.get("ERR");
                // ((HL7Exception) e).populate(err); // FIXME: this is broken, it relies on the database in a place where it's not available
            }
            else {
                t.set("/ERR-1-4-1", "207");
                t.set("/ERR-1-4-2", "Application Internal Error");
                t.set("/ERR-1-4-3", "HL70357");
            }
            
            if (encoding != null) {
                errorMessage = p.encode(out, encoding);
            } else {
                errorMessage = p.encode(out);                
            }
            
        }
        catch (IOException ioe) {
            throw new HL7Exception(
            "IOException creating error response message: " + ioe.getMessage(),
            HL7Exception.APPLICATION_INTERNAL_ERROR);
        }
        return errorMessage;
    }
    
    /**
     * Registers a message parser/encoder with this responder.  If multiple parsers
     * are registered, each message is inspected by each parser in the order in which
     * they are registered, until one parser recognizes the format and parses the
     * message.
     */
    /*public void registerParser(Parser p) {
        this.parsers.add(p);
    }*/
    
    /**
     * Registers an Application with this Responder.  The "Application", in this
     * context, is the software that uses the information in the message.  If multiple
     * applications are registered, incoming Message objects will be passed to
     * each one in turn (calling <code>canProcess()</code>) until one of them accepts
     * responsibility for the message.  If none of the registered applications can
     * process the message, a DefaultApplication is used, which simply returns an
     * Application Reject message.
     */
    public void registerApplication(Application a) {
        this.apps.add(a);
    }
    
    /**
     * Test code.
     */
    public static void main(String args[]) {
        if (args.length != 1) {
            System.err.println("Usage: DefaultApplication message_file");
            System.exit(1);
        }
        
        //read test message file ...
        try {
            File messageFile = new File(args[0]);
            Reader in = new BufferedReader(new FileReader(messageFile));
            int fileLength = (int) messageFile.length();
            char[] cbuf = new char[fileLength];
            in.read(cbuf, 0, fileLength);
            String messageString = new String(cbuf);
            
            //parse inbound message ...
            final Parser parser = new PipeParser();
            Message inMessage = null;
            try {
                inMessage = parser.parse(messageString);
            }
            catch (HL7Exception e) {
                e.printStackTrace();
            }
            
            //process with responder ...
            PipedInputStream initInbound = new PipedInputStream();
            PipedOutputStream initOutbound = new PipedOutputStream();
            PipedInputStream respInbound = new PipedInputStream(initOutbound);
            PipedOutputStream respOutbound = new PipedOutputStream(initInbound);
            
            /*  This code won't work with new changes:
            final Initiator init = new Initiator(parser, new MinLowerLayerProtocol(), initInbound, initOutbound);
            Responder resp = new Responder(respInbound, respOutbound);
             
            //run the initiator in a separate thread ...
            final Message inMessCopy = inMessage;
            Thread initThd = new Thread(new Runnable() {
                public void run() {
                    try {
                        Message response = init.sendAndReceive(inMessCopy);
                        System.out.println("This is initiator writing response ...");
                        System.out.println(parser.encode(response));
                    } catch (Exception ie) {
                        if (HL7Exception.class.isAssignableFrom(ie.getClass())) {
                            System.out.println("Error in segment " + ((HL7Exception)ie).getSegmentName() + " field " + ((HL7Exception)ie).getFieldPosition());
                        }
                        ie.printStackTrace();
                    }
                }
            });
            initThd.start();
             
            //process the message we expect from the initiator thread ...
            System.out.println("Responder is going to respond now ...");
            resp.processOneMessage();
             */
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        
    }
    
}