/*

  * Created on 3-May-2004

  */

 package ca.uhn.hl7v2.protocol.impl;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import ca.uhn.hl7v2.HL7Exception;

 import ca.uhn.hl7v2.model.Message;

 import ca.uhn.hl7v2.parser.GenericParser;

 import ca.uhn.hl7v2.parser.Parser;

 import ca.uhn.hl7v2.protocol.Initiator;

 import ca.uhn.hl7v2.protocol.Processor;

 import ca.uhn.hl7v2.protocol.Transportable;

 import ca.uhn.hl7v2.util.Terser;

 /**

  * Default implementation of <code>Initiator</code>. 

  * 

  * @author <a href="mailto:bryan.tripp@uhn.on.ca">Bryan Tripp</a>

  * @version $Revision: 1.1 $ updated on $Date: 2007-02-19 02:24:26 $ by $Author: jamesagnew $

  */

 public class InitiatorImpl implements Initiator {

     private final List<String> myMetadataFields;

     private final Parser myParser;

     private final Processor myProcessor;

     private int myMaxRetries;

     private long myRetryInterval;

     private long myReceiveTimeout;

     /**

      * Creates an instance that uses a <code>GenericParser</code>

      * @param theProcessor the <code>Processor</code> used to communicate 

      *  with the remote system

      */

     public InitiatorImpl(Processor theProcessor) {

         myMetadataFields = new ArrayList<String>(20);

         myMetadataFields.add("MSH-18"); //add character set by default

         myParser = new GenericParser();

         myProcessor = theProcessor;

         init();

     }

     /**

      * Creates an instance that uses the given <code>Parser</code>

      * @param theParser parser to use for parsing and encoding messages

      * @param theProcessor the <code>Processor</code> used to communicate 

      *  with the remote system

      */

     public InitiatorImpl(Parser theParser, Processor theProcessor) {

         myMetadataFields = new ArrayList<String>(20);

         myParser = theParser;

         myProcessor = theProcessor;

         init();

     }

     private void init() {

         myMaxRetries = 3;

         myRetryInterval = 3000;

         myReceiveTimeout = 10000;

     }

     /**

      * @param theMaxRetries max number of retries for initial message delivery 

      */

     public void setMaxRetries(int theMaxRetries) {

         myMaxRetries = theMaxRetries;

     }

     public int getMaxRetries() {

         return myMaxRetries;

     }

     /**

      * @param theRetryIntervalMillis milliseconds between retries of message delivery 

      */

     public void setRetryInterval(long theRetryIntervalMillis) {

         myRetryInterval = theRetryIntervalMillis;

     }

     public long getRetryInterval() {

         return myRetryInterval;

     }

     /**

      * @param theReceiveTimeout the length of time we wait for responses (defaults 

      *      to 10 seconds)

      */

     public void setReceiveTimeout(long theReceiveTimeout) {

         myReceiveTimeout = theReceiveTimeout;

     }

     public long getReceiveTimeout() {

         return myReceiveTimeout;

     }

     /**

      * @see ca.uhn.hl7v2.protocol.Initiator#sendAndReceive(ca.uhn.hl7v2.model.Message)

      */

     public Message sendAndReceive(Message theMessage) throws HL7Exception {

         Terser t = new Terser(theMessage);

         String appAckNeeded = t.get("/MSH-16");

         String msgId = t.get("/MSH-10");

         String messageText = getParser().encode(theMessage);

         Map<String, Object> metadata = getMetadata(theMessage);

         Transportable out = new TransportableImpl(messageText, metadata);

         if (needAck(appAckNeeded)) {

             myProcessor.reserve(msgId, getReceiveTimeout());

         }

         myProcessor.send(out, getMaxRetries(), getRetryInterval());

         Message in = null;

         if (needAck(appAckNeeded)) { 

             Transportable received = myProcessor.receive(msgId, getReceiveTimeout());

             if (received != null && received.getMessage() != null) {

                 in = getParser().parse(received.getMessage());

             }

         }

         return in;

     }

     /**

      * @param theAckCode from MSH-16

      * @return true if the code indicates that we should wait for an ACK and try 

      *      to return it to the caller 

      */

     private boolean needAck(String theAckCode) {

         boolean need = false;

         if (theAckCode == null 

             || theAckCode.equals("") 

             || theAckCode.equals(Processor.AL) 

             || theAckCode.equals(Processor.ER)) 

         {

             need = true; 

         }        

         return need;

     }

     private Map<String, Object> getMetadata(Message theMessage) throws HL7Exception {

         Map<String, Object> md = new HashMap<String, Object>();

         Terser t = new Terser(theMessage);

         //snapshot so concurrent changes won't break our iteration

         String[] fields = getMetadataFields().toArray(new String[0]);

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

             String field = fields[i].toString();

             String val = t.get(field); 

             md.put(field, val);

         }

         return md;

     }

     /** 

      * @see ca.uhn.hl7v2.protocol.Initiator#getParser()

      */

     public Parser getParser() {

         return myParser;

     }

     /** 

      * @see ca.uhn.hl7v2.protocol.Initiator#getUnderlyingProcessor()

      */

     public Processor getUnderlyingProcessor() {

         return myProcessor;

     }

     /**

      * @see ca.uhn.hl7v2.protocol.Initiator#getMetadataFields()

      */

     public List<String> getMetadataFields() {

         return myMetadataFields;

     }

 }