using System;
using iNTERFACEWARE.Chameleon;
using iNTERFACEWARE.Iguana.Plugin;

namespace IguanaPlugin
{
   /// <summary>
   /// The DestinationPluginEngine is an example of an Iguana destination plugin.
   /// </summary>
   class DestinationPluginExample : Log
   {
      DestinationPluginExample()
      {
         // Connect handlers to receive plugin events.
         destination.MessageReceived += new Destination.MessageReceivedEvent(OnMessageReceived);
         destination.ResubmissionPreviewMessageReceived += new Destination.ResubmissionPreviewMessageReceivedEvent(OnResubmissionPreviewMessageReceived);
         destination.Disconnected += new Destination.DisconnectedEvent(OnDisconnected);

         // 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.

         engine.AddLog(this);
         System.Console.WriteLine("Loading plugin_receive_test.vmd...");
         engine.Load("plugin_receive_test.vmd");
         engine.CurrentConfigIndex = 0;
         System.Console.WriteLine("plugin_receive_test.vmd loaded");
      }

      /// <summary>
      /// Log interface implementation.
      /// </summary>
      public void Println(string line)
      {
         System.Console.WriteLine(line);
         logString += line;
         logString += "\n";
      }

      /// <summary>
      /// Message processing invoked by OnMessageReceived and 
      /// OnResubmissionPreviewMessageReceived event handlers.
      /// </summary>
      public void ProcessMessage
      (
         DestinationMessageReceivedEventInputs inputs,
         DestinationMessageReceivedEventOutputs outputs,
         bool resubmissionPreview
      )
      {
         try
         {
            // The resubmissionPreview flag indicates whether or not we're processing a resubmission 
            // preview message.  When processing a resubmission preview message, the plugin should 
            // simulate the processing that would happen for a regular message, but without causing 
            // external side effects.  For example, no database commits should be made for resubmission
            // preview messages.  In this example, regular message processing has no external side 
            // effects, so we simply ignore the resubmissionPreview flag.

            System.Console.WriteLine("");
            System.Console.WriteLine("*** Message Received ***");
            System.Console.WriteLine(inputs.Message.Replace('\r', '\n'));

            // Notice that we 'manually' invoke the parseMessage method on the engine 
            // object. This will fire one of the generated onMessage events which are 
            /// defined in the DestinationPluginEngine class.
            // 
            // The plugin classes are not tightly coupled to the HL7Engine object. 
            // You can use any kind of transport you like with  Chameleon, including 
            // your own transports or third party components.
            // 
            // In this application we do not block on events - this is because the
            // plugin components are asynchronous. You can write synchronous 
            // applications using Chameleon but you would need to use another 
            // transport mechanism other than the plugin components supplied here.

            logString = "";
            engine.ParseMessage(inputs.Message, null);

            // Tell Iguana that the message has been successfully processed.
            outputs.MessageProcessedFlag = true;
         }
         catch (Exception e)
         {
            System.Console.WriteLine(e.ToString());

            // Tell Iguana that the message was not successfully processed.
            outputs.MessageProcessedFlag = false;

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

            // You can use ResendMessageFlag and ResendMessageDelay to request that Iguana
            // resend the same message again after a delay period.  This is useful in situations
            // where the message processing failure was due to a time sensitive cause, and
            // message processing might succeed at a later time.
            //
            // outputs.ResendMessageFlag = true;
            // outputs.ResendMessageDelay = 1000; // Resend after 1 second
            //
            // You can 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.StopChannelFlag = true;
            // outputs.StopChannelErrorFlag = true;
            // outputs.StopChannelReason = "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 (logString.Length > 0)
         {
            outputs.AddInfoLogMessage(logString);
         }
      }
      
      /// <summary>
      /// This event is received when a message is received from Iguana.
      /// </summary>
      public void OnMessageReceived
      (
         object sender, 
         System.EventArgs args, 
         DestinationMessageReceivedEventInputs inputs,
         DestinationMessageReceivedEventOutputs outputs
      )
      {
         // Note that exceptions can never be thrown outside the handler.
         try
         {
            ProcessMessage(inputs, outputs, false);
         } 
         catch (Exception e) 
         {
            System.Console.WriteLine(e.ToString());
         }
      }

      /// <summary>
      /// This event is received when a resubmission preview message is received from Iguana.
      /// </summary>
      public void OnResubmissionPreviewMessageReceived
      (
         object sender,
         System.EventArgs args,
         DestinationMessageReceivedEventInputs inputs,
         DestinationMessageReceivedEventOutputs outputs
      )
      {
         // Note that exceptions can never be thrown outside the handler.
         try
         {
            // This handler should simulate the processing that would be performed by the
            // OnMessageReceived event handler without causing external side effects.
            // For example, database changes should not be made for resubmission preview messages.

            ProcessMessage(inputs, outputs, true);
         }
         catch (Exception e)
         {
            System.Console.WriteLine(e.ToString());
         }
      }

      /// <summary>
      /// This event is triggered when the plugin disconnects from Iguana.
      /// </summary>
      public void OnDisconnected(object sender, System.EventArgs Args)
      {
         // Note that exceptions can never be thrown outside the handler.
         try 
         {
            System.Console.WriteLine("Source disconnected.");
         }
         catch (Exception e) 
         {
            System.Console.WriteLine(e.ToString());
         }
      }

      public Destination destination = new Destination();
      private DestinationPluginEngine engine = new DestinationPluginEngine();
      private string logString = "";

      /// <summary>
      /// The main entry point for the application.
      /// </summary>
      [STAThread]
      static void Main(string[] args)
      {
         try 
         {
            if (args.Length < 3) 
            {
               throw new Exception("Invalid command line arguments.");
            }

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

            DestinationPluginExample DestinationPluginExample = new DestinationPluginExample();
            DestinationPluginExample.destination.Connect(hostname, port, channel);

            // Wait for the plugin to disconnect.
            // Could also use waitForDisconnectWithTimeout() here.
            DestinationPluginExample.destination.WaitForDisconnect();

            // Print the reason for disconnection.
            DisconnectReason disconnectReason = DestinationPluginExample.destination.DisconnectReason;
            System.Console.WriteLine(disconnectReason.Description);
         } 
         catch (Exception e) 
         {
            System.Console.WriteLine(e.ToString());
            System.Console.WriteLine();
            System.Console.WriteLine("This is an Iguana destination plugin.  It runs as a command line application");
            System.Console.WriteLine("which connects via TCP/IP to the plugin communication server within Iguana.");
            System.Console.WriteLine("It will be necessary to run a channel in Iguana and set up a channel with");
            System.Console.WriteLine("a To Plugin component for this to connect to.  See:");
            System.Console.WriteLine();
            System.Console.WriteLine("   http://www.interfaceware.com/manual/plugin_setup_csharp.html");
            System.Console.WriteLine();
            System.Console.WriteLine("Once the channel is set up and running you can connect to it with this usage:");
            System.Console.WriteLine();
            System.Console.WriteLine("  DestinationPluginExample <iguana hostname> <plugin communication port> <channel name>");
            System.Console.WriteLine();
            System.Console.WriteLine("The plugin communication port is the port that Iguana listens on for plugin");
            System.Console.WriteLine("communication.");
         }
      }
   }
}