import com.interfaceware.chameleon.*;
import com.interfaceware.iguana.plugin.*;
import HL7.*;
import java.util.Date;
import java.util.Random;

/**
 * Class: SourcePluginExample
 * 
 * Description:
 * 
 * The SourcePluginExample is an example of an Iguana source plugin.
 */
class SourcePluginExample {

    class SourcePluginLog implements Log {
         /*
         * A real HL7 interface should have some type of system of logging into log
         * files.  Iguana, for instance, has a very nice logging system that allows 
         * administrators to drill into and browse processed messages and errors.  
         * How you implement this logging is up to your requirements for run time 
         * management of your HL7 interface.
         * 
         * For this example, we will log to the Java console, and we'll collect
         * log messages to send back to Iguana to be logged in Iguana's logging system.
         * See addInfoLogMessage below.
         */
        public void println(String Line) {
            System.out.println(Line);
            logString += Line;
            logString += "\n";
        }

        String logString;
    }

    class MySourceListener implements SourceListener {

        Random random = new Random();

        public String generateRandomMessage() throws Exception {
            switch (random.nextInt(1)) {
            case 0:
                return generatePersonUpdate();
            default:
                return generatePersonUpdate();
            }
        }

        /* This event is triggered when Iguana requests a message.
         */
        public void messageRequested
        (
            SourceMessageRequestedEventInputs inputs,
            SourceMessageRequestedEventOutputs outputs
        ) 
        {
            // Note that exceptions can never be thrown outside the handler.
            try {
                try {
                    println("");
                    println("*** Message Requested ***");

                    /* To simulate the behavior of a real-world plugin, we throttle the rate
                     * at which we generate messages to at most once per second.
                     *
                     * Real world plugins need no such throttling mechanism.  Real-world plugins
                     * should respond to message requests immediately with either the next available 
                     * message, or an empty response if no messages are presently available.
                     *
                     * When a plugin responds to a message request with an empty response (signifying
                     * that no messages are presently available), Iguana will delay for the period 
                     * specified by the channel's From Plugin component Polling Time setting before 
                     * sending another message request.
                     */
                    Date now = new Date();
                    boolean generateMessage = (now.getTime() - lastMessageRequestTime.getTime()) > 1000;
                    lastMessageRequestTime = now;

                    if (generateMessage) {
                        // Set OutboundMessage to next available message.
                        log.logString = "";
                        String outboundMessage = generateRandomMessage();
                        outputs.setOutboundMessage(outboundMessage);
                        
                        // Set PluginMessageId to a unique identifier for the message, which will
                        // be sent back to the plugin in the next messageRequestCompleted event.
                        String pluginMessageId = lastMessageRequestTime.toString();
                        outputs.setPluginMessageId(pluginMessageId);

                        println("Message Generated (plugin message id: " + pluginMessageId + ")");
                        println(outboundMessage.replace('\r','\n'));
                    } else {
                        println("Responding with an empty message - no messages presently available.");
                    }
                } catch (Exception e) {
                    println("Message Generation Error:");
                    e.printStackTrace();

                    // Add an error-level log message to Iguana's logs describing the failure.
                    outputs.addErrorLogMessage(e.toString());

                    /*
                     * You could also use StopChannelFlag, StopChannelErrorFlag, and StopChannelReason 
                     * to stop the Iguana channel with or without an error flag, and provide a 
                     * reason for the stop request.
                     *
                     * outputs.setStopChannel(true);
                     * outputs.setStopChannelErrorFlag(true);
                     * outputs.setStopChannelReason("An error occurred.");
                     */
                } 

                /* You can send additional error/warning/info/debug log messages to Iguana.
                 * In this case we simply send an info-level log message containing the 
                 * Chameleon engine's log output.
                 */
                if (log.logString.length() != 0) {
                    outputs.addInfoLogMessage(log.logString);
                }
            } catch (Exception e) {
                e.printStackTrace(); 
            }
        }

        /*
         * This event is received when Iguana has received the message sent via the previous 
         * messageRequested event.
         */
        public void messageRequestCompleted
        (
            SourceMessageRequestCompletedEventInputs inputs,
            SourceMessageRequestCompletedEventOutputs outputs
        )
        {
            // Note that exceptions can never be thrown outside the handler.
            try {
                /* 
                 * pluginMessageId will contain the unique identifier provided by the plugin in the
                 * previous call to messageRequested.
                 *
                 * If messageProcessed is false, Iguana was unable to enqueue the message, and it
                 * should be sent again.
                 */
                println("");
                println("*** Message Request Completed (plugin message id: " + inputs.getPluginMessageId() + ") ***");

            } catch (Exception e) {
               e.printStackTrace();
            }
        }

        /* 
         * This event is received when the plugin disconnects from Iguana.
         * See also the use of waitForDisconnect() below.
         */
        public void disconnected() {
            // Note that exceptions can never be thrown outside the handler.
            try {
                println("Source disconnected.");
            } catch (Exception e) {
               e.printStackTrace();
            }
        }
    }

    Source source;
    HL7Engine sourceEngine;
    SourcePluginLog log;
    Date lastMessageRequestTime;
    
    /**
     * Main entry point.
     */
    static public void main(String[] args) throws Exception {
         try {
            if (args.length < 3) {
                throw new Exception("Invalid command line arguments.");
            }

            String hostname  = args[0];
            int    port      = Integer.parseInt(args[1]);
            String channel   = args[2];

            SourcePluginExample sourcePluginExample = new SourcePluginExample();
            sourcePluginExample.source.connect(hostname, port, channel);

            // Wait for the plugin to disconnect.
            // Could also use waitForDisconnectWithTimeout() here.
            sourcePluginExample.source.waitForDisconnect();

            // Print the reason for disconnection.
            DisconnectReason disconnectReason = sourcePluginExample.source.getDisconnectReason();
            System.out.println(disconnectReason.getDescription());

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println();
            System.out.println("This is an Iguana source plugin.  It runs as a command line application");
            System.out.println("which connects via TCP/IP to the plugin communication server within Iguana.");
            System.out.println("It will be necessary to run a channel in Iguana and set up a channel with");
            System.out.println("a From Plugin component for this to connect to.  See:");
            System.out.println();
            System.out.println("   http://www.interfaceware.com/manual/plugin_setup_java.html");
            System.out.println();
            System.out.println("Once the channel is set up and running you can connect to it with this usage:");
            System.out.println();
            System.out.println("  SourcePluginExample <iguana hostname> <plugin communication port> <channel name>");
            System.out.println();
            System.out.println("The plugin communication port is the port that Iguana listens on for plugin");
            System.out.println("communication.");
        }
    }

    /**
     * Constructor.
     */
    public SourcePluginExample() throws Exception {
        println("Source plugin started");

        source = new Source();
        source.addListener(new MySourceListener());

        lastMessageRequestTime = new Date(0);

        initializeEngine();
    }

    public void println(String Line) {
        System.out.println(Line);
    }

    public void initializeEngine() throws ChameleonException {
        /*
         * The first step in making the generated HL7Engine object useable 
         * is to load the message definition or 'vmd' file. This file contains
         * the information about the structure of the messages, tables, and 
         * data mappings that were defined in the Chameleon GUI. 
         *  
         * HL7Engine is a generated engine which means that it has an interface
         * based on the Messages and Tables you define in your vmd file. The 
         * use of stub code is helpful since it means that the compiler can 
         * catch typos or spelling mistakes of fields at compile rather than 
         * run time. However, it is not the only way you can use Chameleon. It
         * is possible to use a non-stubcode interface for the Chameleon
         * engine which we call the 'dynamic interface'. Please review the 
         * manual documentation for more details if you need this functionality
         * - most customers find that the stub code interface works well for 
         * their applications.
         */
        log = new SourcePluginLog();
        sourceEngine = new HL7Engine();
        sourceEngine.addLog(log);
        println("Loading vmd files...");
        sourceEngine.load("plugin_receive_test.vmd");
        sourceEngine.setCurrentConfigIndex(0);
        println("plugin_receive_test.vmd loaded");
    }

    /*
     * These generated methods are examples of how an HL7 message can be 
     * created using Chameleon's generated stubcode objects. We are populating
     * these objects with dummy data. In a real application, you would need to
     * obtain this data from somewhere (e.g. a database).
     * 
     * It should be noted that each Message object corresponds to the message 
     * defined in the vmd file loaded into the sourceEngine. These objects have
     * tables and sub tables with properties that you can populate the message
     * with.
     * It must be emphasized that this will be a mirror of the 'table grammar' 
     * for each message - i.e. the user defined definitions of each table and 
     * the fields in those tables as defined in the Chameleon GUI.
     *
     * Also keep in mind that this is using the static stubcode interface of 
     * Chameleon. For advanced applications, it is possible to use a dynamic 
     * interface to populate messages.  See the manual for more details.
     */
    public String generatePersonUpdate() throws Exception {
        PersonUpdateMessage Message = new PersonUpdateMessage(sourceEngine);
        return Message.generateMessage();
    }



}