using System;
using System.IO;
using System.Text;
using System.Collections;
using System.Collections.Specialized;
using iNTERFACEWARE.Iguana.Plugin;

// 1) Get the all the log messages for the specified period and use the
//    ReferenceLogId to build the trees of related log messages
// 2) For every HL7 message (MessageType="Message"):
//      - locate its tree of related log messages and
//      - if an Error (MessageType="Error") appears anywhere in that tree,
//        flag that HL7 message as having encountered an error.
//    There are many ways to do this.  The approach taken here is
//      - For each MessageType="Error" mark the root of its tree
//      - For each MessageType="Message" check if the root of its tree is marked
// As an optimization (to avoid using up lots of memory), the query period
// is subdivided into 15 minutes subinterval.

class ReconciliationReport
{
   static public string findRoot(StringDictionary Forest, String Node)
   {
      string Root = Node;
      for (Node=Forest[Node] ; Node!=null && Node!="" ; Node=Forest[Node])
      {
         Root = Node;
      }
      return Root;
   }

   [STAThread]
   static public void Main(string[] Args)
   {
      try
      {
         String UrlPrefix     = "http://localhost:6543/log_browse?refid=";
         DateTime StartPeriod = DateTime.Parse("2009/12/15 00:00:00");
         DateTime EndPeriod   = DateTime.Parse("2009/12/15 23:59:59");
         LogQuery Query = new LogQuery();
         Query.Host = "localhost";
         Query.Port = 6543;
         Query.Username = "admin";
         Query.Password = "password";
	 Query.Encrypt = false;
         Query.IncludeDeleted = true;
         Query.IncludeNonDeleted = true;
         Query.IncludeSourceLogs = true;

         // List of Ids having Type=Error
         StringCollection ErrorList     = new StringCollection();
         // List of Ids having Type=Message
         StringCollection MessageList   = new StringCollection();
         // List of root nodes that have errors under them
         StringCollection RootErrorList = new StringCollection();
         // List of Ids having Type=Message and flagged as having related error
         StringCollection FlaggedList   = new StringCollection();
         // Mapping of LogMessageId to LogMessageId of its parent
         StringDictionary ParentMapping = new StringDictionary();

         while (StartPeriod <= EndPeriod)
         {
            Query.After = StartPeriod;
            StartPeriod = StartPeriod.AddMinutes(15);
            Query.Before = (StartPeriod>EndPeriod) ? EndPeriod : StartPeriod;
            LogQueryResult ResultSet = Query.Execute();
            if (!ResultSet.Success)
            {
               throw new Exception(ResultSet.ErrorDescription);
            }
            LogQueryResult.MessageCollection MessageArray = ResultSet.Message;
            for (int MessageIndex=0, MessageCount=MessageArray.Count ;
                 MessageIndex<MessageCount ; MessageIndex++)
            {
               LogMessage Message = MessageArray[MessageIndex];
               string MessageType = Message.MessageType;
               string MessageId   = Message.MessageLogId;
               string ParentId    = Message.ReferenceLogId;
               if (MessageId==null) { MessageId = ""; }
               if (ParentId ==null) { ParentId  = ""; }
               // Eliminate duplicates (since time intervals do overlap)
               if (ParentMapping[MessageId] != null) { continue; }
               if      (MessageType=="Error"  ) { ErrorList  .Add(MessageId); }
               else if (MessageType=="Message") { MessageList.Add(MessageId); }
               ParentMapping.Add(MessageId, ParentId);
            }
            System.Console.Write(".");
         }

         // Mark all the root nodes that have a related error
         foreach (string MessageId in ErrorList)
         {
            string Root = findRoot(ParentMapping, MessageId);
            if (!RootErrorList.Contains(Root))
            {
               RootErrorList.Add(Root);
            }
         }

         // Flag all HL7 messages that have a root node that contains an error
         foreach (string MessageId in MessageList)
         {
            if (RootErrorList.Contains(findRoot(ParentMapping, MessageId)))
            {
               FlaggedList.Add(MessageId);
            }
         }

         int TotalCount     = MessageList.Count;
         int FailedCount    = FlaggedList.Count;
         int SucceededCount = TotalCount - FailedCount;
         System.Console.WriteLine(" Total="+TotalCount+
			          " Succeeded="+SucceededCount+
				  " Failed="+FailedCount+" : ");
         foreach (String MessageId in FlaggedList)
         {
            System.Console.WriteLine("   "+UrlPrefix+MessageId);
         }
      }
      catch (Exception e)
      {
         System.Console.WriteLine(e.Message);
         System.Environment.Exit(1);
      }
   }