using System;
using System.Text;
using System.Text.RegularExpressions;
using Softek.Cls.Impl.Kaiser.Util;
using Softek.Nigiri;
using Softek.Nigiri.Clinical.Processing.Model;

namespace Softek.Cls.Impl.Kaiser.Processors.RadiologyExam.ModelTransforms
{
   public class ExtractRadAndDatesFromReport : IModelTransform
   {
      private static readonly Regex radRegex = new Regex(@"<br>\s*(?<name>.(?:(?<!(?:   |: |\<br\>)).)+?)\u0020*(?:M\.?D\.?|D\.?O\.?)\<br\>(?:&nbsp;)?\<br\>DD:\s*(?<DictatedDate>\d{1,2}/\d{1,2}/\d{4})?\s*DT:\s*(?<Month>\d{1,2})/(?<Day>\d{1,2})/(?<Year>\d{4})",
                                                RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Compiled);

      private static readonly Regex newRadRegex = new Regex(@"Electronically Signed by:\s*(?<name>[A-Za-z]*\s*[A-Za-z]*\s*(?:(\(?(?:M\.?D\.?|D\.?O\.?)\)?))\s*[A-Za-z]*)\s*on\s*(?<Month>\d{1,2})/(?<Day>\d{1,2})/(?<Year>\d{2,4})(<br>)*\s*(?<Hour>\d{1,2}):(?<Minute>\d{1,2})[\\n\\r<br> ]*(?<TimePeriod>(AM|PM))",
                                                RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Compiled);

      private static readonly Regex addendumRegex = new Regex(@"<!--\s*IDXRADR:ADDEND:END\s*-->",
                                                      RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Compiled);

      public void Transform(IDocument model)
      {
         string report = model["report_text"];

         if (string.IsNullOrEmpty(report))
            return;

         SigningInfo si = GetSigningInfo(report);
         if (si != null)
         {
            string currentStatus = model["status"];

            if (currentStatus == "Dictated" || currentStatus == "Transcribed")
            {
              SetDictatedBy(model, si);
              model["dictateddate"] = si.Date.ToZuluString();
              model["transcribeddate"] = si.Date.ToZuluString();
            }

            if (currentStatus == "Finalized")
            {
               if (model["addendumstatus"] == "addended")
               {
                  string originalReport = GetOriginalReport(report);
                  if (originalReport != null)
                  {
                     SigningInfo originalSigning = GetSigningInfo(originalReport);
                     if (originalSigning != null)
                     {
                        SetDictatedBy(model, originalSigning);
                        SetFinalizedBy(model, originalSigning);

                        model["dictateddate"] = originalSigning.Date.ToZuluString();
                        model["transcribeddate"] = originalSigning.Date.ToZuluString();
                        model["finalizeddate"] = originalSigning.Date.ToZuluString();

                     }
                  }
                  SetLastAddendedBy(model, si);
                  model["addendeddate"] = si.Date.ToZuluString();
               }
               else
               {
                  SetDictatedBy(model, si);
                  SetFinalizedBy(model, si);

                  model["dictateddate"] = si.Date.ToZuluString();
                  model["transcribeddate"] = si.Date.ToZuluString();
                  model["finalizeddate"] = si.Date.ToZuluString();
               }

            }

         }
      }

      private void SetDictatedBy(IDocument model, SigningInfo rad)
      {
         model["dictatedbyproviderid"] = rad.Id;
         model["dictatedby"] = rad.LastName.ToUpper() + ", " + rad.FirstName.ToUpper();
         model["dictatedbyfirstname"] = rad.FirstName.ToUpper();
         model["dictatedbylastname"] = rad.LastName.ToUpper();
      }

      private void SetFinalizedBy(IDocument model, SigningInfo rad)
      {
         model["finalizedbyproviderid"] = rad.Id;
         model["finalizedby"] = rad.LastName.ToUpper() + ", " + rad.FirstName.ToUpper();
         model["finalizedbyfirstname"] = rad.FirstName.ToUpper();
         model["finalizedbylastname"] = rad.LastName.ToUpper();
      }

      private void SetLastAddendedBy(IDocument model, SigningInfo rad)
      {
         model["lastaddendedbyid"] = rad.Id;
         model["lastaddendedby"] = rad.LastName.ToUpper() + ", " + rad.FirstName.ToUpper();
      }

      private SigningInfo GetSigningInfo(string text)
      {
         SigningInfo retVal = null;

         Match match = radRegex.Match(text);

         if (match.Success)
         {
            retVal = GetSigningInfo(retVal, match);
            var month = match.Groups["Month"].Value.Trim();
            var day = match.Groups["Day"].Value.Trim();
            var year = match.Groups["Year"].Value.Trim();
            retVal.Date = new DateTimeOffset(
                                             new DateTime(int.Parse(year), int.Parse(month), int.Parse(day),
                                             0, 0, 0, DateTimeKind.Local));
         }
         var newMatch = newRadRegex.Match(text);
         if (newMatch.Success)
         {
            retVal = GetSigningInfo(retVal, match);
            retVal.Date = new DateTimeOffset(DateTime.Parse(BuildDateTimeString(newMatch)));
         }
         return retVal;
      }

      private static string BuildDateTimeString(Match match)
      {
         var builder = new StringBuilder();
         builder.Append(match.Groups["Month"].Value.Trim());
         builder.Append("/");
         builder.Append(match.Groups["Day"].Value.Trim());
         builder.Append("/");
         builder.Append(match.Groups["Year"].Value.Trim());
         builder.Append(" ");
         builder.Append(match.Groups["Hour"].Value.Trim());
         builder.Append(":");
         builder.Append(match.Groups["Minute"].Value.Trim());
         builder.Append(" ");
         builder.Append(match.Groups["TimePeriod"].Value.Trim());
         return builder.ToString();
      }

      private static SigningInfo GetSigningInfo(SigningInfo retVal, Match match)
      {
         retVal = new SigningInfo();
         string rad = match.Groups["name"].Value.Trim();

         string ln = string.Empty;
         string fn = string.Empty;
         int index = rad.IndexOf(',');
         if (index > -1)
         {
            ln = rad.Substring(0, index);
            fn = rad.Substring(index + 1);
         }

         if (index < 0)
         {
            index = rad.LastIndexOf(" ");
            if (index < 0)
            {
               ln = rad;
               fn = "Unknown";
            }
            else
            {
               fn = rad.Substring(0, index);
               ln = rad.Substring(index + 1);
            }
         }

         char[] trimmedChars = {',', ' '};
         retVal.FirstName = fn.Trim(trimmedChars);
         retVal.LastName = ln.Trim(trimmedChars);

         // Find DT date

         return retVal;
      }


      private string GetOriginalReport(string text)
      {
         Match match = addendumRegex.Match(text);

         int index = -1;
         while (match.Success)
         {
            index = match.Index + match.Value.Length;
            match = match.NextMatch();
         }

         if (index < 0)
            return null;

         return text.Substring(index);
      }

      private class SigningInfo
      {
         public string Id
         {
            get{ return (uint.MaxValue + (LastName + "|" + FirstName).GetHashCode()).ToString(); }
         }
         public string FirstName { get; set; }
         public string LastName { get; set; }
         public DateTimeOffset? Date { get; set; }
      }
   }
}