using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.IO;
using System.Windows.Forms;
using iTextSharp.text.pdf;
using iTextSharp.text;
using VEPROMS.CSLA.Library;
using Volian.Base.Library;
using VlnStatus;


namespace Volian.Print.Library
{
	class CompleteROReport
	{
		private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
        readonly Headers Hdrs; // Header stack object.
		RODataFile RO_df = null;
		int curheaderlen;
        readonly string RODataFileName;
        readonly iTextSharp.text.Document _pdfReportDoc;
		PdfPTable datatable = null;

        public iTextSharp.text.Font F14 { get; set; }

        public iTextSharp.text.Font F10 { get; set; }

        public iTextSharp.text.Font F12 { get; set; }

        public iTextSharp.text.Font F10Bold { get; set; }

        public iTextSharp.text.Font F12Bold { get; set; }

        public bool ConvertCaretToDelta { get; set; } = true;

        public bool IncludeEmptyROFields { get; set; } = false;

        public int ROFstID { get; set; }
        private readonly string ReportTitle = "Complete Referenced Objects Report";
		private readonly PdfWriter _MyPDFWriter;

		public CompleteROReport(PdfWriter mypdfwriter, iTextSharp.text.Document document, string dataFileName, bool convertCaretToDelta, bool includeEmptyROFields)
		{
			Hdrs = new Headers();
			_pdfReportDoc = document;
			RODataFileName = dataFileName;
			ConvertCaretToDelta = convertCaretToDelta;
			_MyPDFWriter = mypdfwriter;
			IncludeEmptyROFields = includeEmptyROFields;
		}
		public void StartNewDataTable()
		{
            datatable = new PdfPTable(1)
            {
                TotalWidth = _pdfReportDoc.PageSize.Width - _pdfReportDoc.LeftMargin - _pdfReportDoc.RightMargin,
                LockedWidth = true
            };
            PdfPCell cell = new PdfPCell(new Phrase(ReportTitle, F14))
            {
                HorizontalAlignment = Element.ALIGN_CENTER,
                BackgroundColor = Color.WHITE,
                BorderColor = Color.WHITE
            };
            datatable.AddCell(cell);
			datatable.HeaderRows = 3;
			datatable.DefaultCell.HorizontalAlignment = Element.ALIGN_LEFT;
		}
		public void Run()
		{
			StartNewDataTable();
			RO_df = new RODataFile(RODataFileName);
			PrintReport();
			RO_df.close();
		}

        internal Dictionary<int, DocOutline> MyDocOutline { get; set; } = new Dictionary<int, DocOutline>();
        public class DocOutline
		{
            public PdfOutline MyOutline { get; set; }

            public string MyHeader { get; set; }
            public DocOutline(PdfOutline outline, string header) 
			{
				MyHeader = header;
				MyOutline = outline;
			}
		}
		private string ReplaceLineDrawCharsWithUnicode(string text)
		{
			text = text.Replace("\xc4", "\x2500");  // Horizontal
			text = text.Replace("\xb3", "\x2502");	// Vertical
			text = text.Replace("\xc0", "\x2514");	// Bottom Left Corner
			text = text.Replace("\xd9", "\x2518");	// Bottom Right Corner
			text = text.Replace("\xc1", "\x2534");	// Bottom Tee
			text = text.Replace("\xda", "\x250c");	// Upper Left Corner
			text = text.Replace("\xc3", "\x251c");	// Left Tee
			text = text.Replace("\xbf", "\x2510");  // Upper Right Corner
			text = text.Replace("\xc2", "\x252c");  // Top Tee
			text = text.Replace("\xb4", "\x2524");  // Right Tee
			text = text.Replace("\xc5", "\x253c");	// Plus
			return text;
		}
		public Phrase ConvertDOSSuperAndSubScripts(string instr, Font fnt)
		{
			int idx = 0;
			Chunk chk;
			Phrase p = new Phrase();
			bool underlineChunk = false;
			instr = instr.Replace("`", "\u00B0"); //degree
			instr = instr.Replace("[RHO]", "\u03C1"); // C2016-018 rho symbol - is being read in as a line draw character, so users need to put "[RHO]" in their text for the rho symbol to print
			if (ConvertCaretToDelta)
			{
				instr = instr.Replace("^", "\u0394"); // delta
			}
			//instr = instr.Replace("\x94", "\u0394"); // delta  - the delta symbol is being read in as character x94
			instr = ReplaceLineDrawCharsWithUnicode(instr);
			// Handle super/sub scripts
			MatchCollection mc = Regex.Matches(instr, "[#~](.*?)[#~]");
			foreach (Match m in mc)
			{
				if (idx < m.Index)
				{
					int strlen = m.Index - idx;
					int uidx = 0;
					string strChk = instr.Substring(idx, strlen);
					MatchCollection mc1 = Regex.Matches(strChk, "[_](.*?)"); // look ofr Underline on/off
					foreach (Match m1 in mc1)
					{
						if (uidx < m1.Index)
						{
							string tstr = (instr.Substring(idx+uidx, m1.Index - uidx));
							if (tstr.EndsWith(" "))
								tstr = $"{tstr.Substring(0, tstr.Length - 1)}\xA0";
							chk = new Chunk(tstr, fnt);
							if (underlineChunk)
								chk.SetUnderline(Color.BLACK, 0, 0.05F, 0, -.131F, PdfContentByte.LINE_CAP_ROUND);
							chk.SetTextRise(0);
							p.Add(chk);
							uidx += (tstr.Length + 1);
							idx += (tstr.Length + 1);
							strlen -= (tstr.Length + 1);
							underlineChunk = !underlineChunk;
						}
						else if (uidx == m1.Index)
						{
							uidx++;
							underlineChunk = !underlineChunk;
						}
					}
					chk = new Chunk(instr.Substring(idx, strlen), fnt);
					if (underlineChunk)
						chk.SetUnderline(Color.BLACK, 0, 0.05F, 0, -.131F, PdfContentByte.LINE_CAP_ROUND);
					chk.SetTextRise(0);
					p.Add(chk);
				}
				switch (m.Value[0])
				{
					case '#':
						chk = new Chunk(m.Value.Substring(1, m.Length-2), fnt);
						if (underlineChunk)
							chk.SetUnderline(Color.BLACK, 0, 0.05F, 0, -.131F, PdfContentByte.LINE_CAP_ROUND);
						chk.SetTextRise(.25F * chk.Font.Size);
						p.Add(chk);
						idx = m.Index + m.Length;
						break;
					case '~':
						chk = new Chunk(m.Value.Substring(1, m.Length-2), fnt);
						if (underlineChunk)
							chk.SetUnderline(Color.BLACK, 0, 0.05F, 0, -.131F, PdfContentByte.LINE_CAP_ROUND);
						chk.SetTextRise(-.25F * chk.Font.Size);
						p.Add(chk);
						idx = m.Index + m.Length;
						break;
				}
			}
			if (idx <= instr.Length - 1)
			{
				int uidx = 0;
				string strChk = (instr.Substring(idx));
				if (!_LastWasName) //B2016-251 Don't change underscore to underline to Name value
				{
					MatchCollection mc1 = Regex.Matches(strChk, "[_](.*?)"); // look for underline on/off
					foreach (Match m1 in mc1)
					{
						if (uidx < m1.Index)
						{
							string tstr = (strChk.Substring(uidx, m1.Index - uidx));
							if (tstr.EndsWith(" "))
								tstr = $"{tstr.Substring(0, tstr.Length - 1)}\xA0";
							chk = new Chunk(tstr, fnt);
							if (underlineChunk)
								chk.SetUnderline(Color.BLACK, 0, 0.05F, 0, -.131F, PdfContentByte.LINE_CAP_ROUND);
							chk.SetTextRise(0);
							p.Add(chk);
							uidx += (tstr.Length + 1);
							underlineChunk = !underlineChunk;
						}
						else if (uidx == m1.Index)
						{
							uidx++;
							underlineChunk = !underlineChunk;
						}
					}
				}
				if (uidx <= strChk.Length - 1)
				{
					string tstr = strChk.Substring(uidx);
					if (tstr.EndsWith(" "))
						tstr = $"{tstr.Substring(0, tstr.Length - 1)}\xA0";
					chk = new Chunk(tstr, fnt);
					if (underlineChunk)
						chk.SetUnderline(Color.BLACK, 0, 0.05F, 0, -.131F, PdfContentByte.LINE_CAP_ROUND);
					chk.SetTextRise(0);
					p.Add(chk);
				}
			}

			return p;
		}

        public void AddText(string txt, Font fnt) => AddText(txt, fnt, Color.BLACK);

        public void AddText(string txt, Font fnt, Color txtcolor)
		{
			// break the text up on double returns (paragraphs) and put each in their own cell
			// this will allow for page breaks between paragraphs0
			string[] delim = { "\r\n\r\n","\r\n \r\n" };
			string[] strlst = txt.Split(delim,StringSplitOptions.None);
			foreach (string str in strlst)
			{
                Font f = new Font(fnt)
                {
                    Color = txtcolor
                };
                PdfPCell cell = new PdfPCell(ConvertDOSSuperAndSubScripts(str, f))
                {
                    BorderColor = Color.WHITE
                };
                if (strlst.Length > 1)
					cell.PaddingBottom = 6;
				datatable.AddCell(cell);
			}
		}

		public void AddImage(string filename)
		{
			ROImageInfo roImage = ROImageInfo.GetByROFstID_FileName(ROFstID, filename) ?? ROFstInfo.Get(ROFstID).GetROImageByFilename(filename, null);
            PdfPCell spaceCell = new PdfPCell
            {
                BorderColor = Color.WHITE
            };
            datatable.AddCell(spaceCell);
			if (roImage != null)
			{
				ROImageConfig rc = new ROImageConfig(roImage);
				int size = Convert.ToInt32(rc.Image_Size);
				byte[] cnt = roImage.Content;
				byte[] dcnt = ROImageInfo.Decompress(cnt, size);
				iTextSharp.text.Image it_image;
				try
				{
					it_image = iTextSharp.text.Image.GetInstance(dcnt);
					//iTextSharp.text.Image it_image = iTextSharp.text.Image.GetInstance(ROImageInfo.Decompress(roImage.Content, size));
				}
				catch (Exception)
                {
					try
					{
						MemoryStream ms = new MemoryStream(dcnt);
						System.Drawing.Bitmap bm = new System.Drawing.Bitmap(ms);
						using (MemoryStream ms2 = new MemoryStream())
						{
							bm.Save(ms2, System.Drawing.Imaging.ImageFormat.Png);
							ms2.Seek(0, SeekOrigin.Begin);
							byte[] newdcnt = new byte[ms2.Length];
							ms2.Read(newdcnt, 0, (int)ms2.Length);
							it_image = iTextSharp.text.Image.GetInstance(newdcnt);
						}
					}
					catch (Exception ex2)
					{
						AddText(string.Format("Bad Image File: {0}", filename), F12, Color.RED);
						GenerateErrorMessage(ex2, "Bad Image File. ", string.Format("Image File: {0}", filename));
						roImage.Dispose();
						return;
					}
				}
				it_image.ScaleToFit(_MyPDFWriter.DirectContent.PdfDocument.PageSize.Width - 144, _MyPDFWriter.DirectContent.PdfDocument.PageSize.Height - 216);
                PdfPCell cell = new PdfPCell(it_image)
                {
                    BorderColor = Color.WHITE
                };
                datatable.AddCell(cell);
				roImage.Dispose();
			}
			else
			{
				AddText(string.Format("Image File {0} is missing.", filename), F12, Color.RED);
				GenerateErrorMessage(null, "Image File Missing. ", string.Format("Image File: {0}", filename));
				Application.DoEvents();
			}
		}

		public void AddXYPlot(string plotlang)
		{
			string pngFile = VlnSettings.TemporaryFolder + @"\XYPlot1.png";
			string rawPlotLang = plotlang;
			plotlang = plotlang.Replace("`", "\xB0"); //degree
			plotlang = plotlang.Replace("\xF8", "\xB0"); //degree
			if (ConvertCaretToDelta)
				plotlang = plotlang.Replace("^", "\x394"); // delta
			plotlang = plotlang.Replace("\x7F", "\x394"); //delta
            PdfPCell spaceCell = new PdfPCell
            {
                BorderColor = Color.WHITE
            };
            datatable.AddCell(spaceCell);
			try
			{
				System.Drawing.RectangleF plotRect = MSWordToPDF.CreatePlot(pngFile, plotlang, 600F, MSWordToPDF.FormForPlotGraphics);
				iTextSharp.text.Image it_image = iTextSharp.text.Image.GetInstance(pngFile);
				it_image.ScaleToFit(_MyPDFWriter.DirectContent.PdfDocument.PageSize.Width - 144, _MyPDFWriter.DirectContent.PdfDocument.PageSize.Height - 216);
                PdfPCell cell = new PdfPCell(it_image)
                {
                    BorderColor = Color.WHITE
                };
                datatable.AddCell(cell);
			}
			catch (Exception e)
			{
				AddText("-- Error Processing X/Y Plot Language --",F12,Color.RED);
				datatable.AddCell(spaceCell);
				AddText(rawPlotLang, F10);
				GenerateErrorMessage(null, "Error Processing X/Y Plot Lanuage. ", e.Message);
			}
		}

		private string processingRO = "";

        public string MyROID { get; set; } = null;

        public void PrintReport()
		{
			bool StopPrinting = false;
            VlnStatusBar showStatBar = new VlnStatusBar("Complete RO Report");
            try
			{
				if (RO_df.GetFileLength() > 0)
				{
					showStatBar.BarMax = (int)RO_df.GetFileLength();
					showStatBar.StatMsg = "Creating Report";
                    short iRecType;
                    // Loop until either printing is aborted or end of file.
                    while (!StopPrinting && (iRecType = RO_df.ReadInteger16()) != -1)
                    {
                        //Console.WriteLine("Record Type: {0}.{0:X}", iRecType);
                        switch (iRecType)
                        {
                            case 1:         // Set Header
                                SetHeader();
                                break;
                            case 2:         // Push Header
                                PushHeader();
                                break;
                            case 3:         // Pop Header
                                PopHeader();
                                break;
                            case 4:         // RRO Begin
                                RROBegin();
                                break;
                            case 5:         // RRO End
                                RROEnd();
                                processingRO = "";
                                break;
                            case 6:         // Msg
                                Msg();
                                break;
                            case 7:
                                processingRO = KeyField();
                                break;
                            case 8:
                                MyROID = ROIDField();
                                break;
                            case 100:       // Text Field - sometimes also XY Plot
                                Text();
                                Application.DoEvents();
                                break;
                            case 101:   // Plot Field
                                XYPlot();
                                Application.DoEvents();
                                break;
                            case 102:       // Image Field
                                ImageFile();
                                Application.DoEvents();
                                break;
                            case 103:       // Multi Begin - Display data for setpoints
                                Multiple();
                                break;
                            case 104:       // Multi End
                                break;
                            case 0:         // nothing was entered in that field
                                if (IncludeEmptyROFields)
                                    NoInformatEntered();
                                break;
                            case 255:
                                _pdfReportDoc.Add(datatable);
                                _pdfReportDoc.NewPage();
                                StartNewDataTable();
                                showStatBar.BarValue = (int)RO_df.GetFilePointerPosition();
                                //Console.WriteLine("Record Type: {0} No Operation", iRecType);
                                //Console.WriteLine("----------------------------------------------");
                                break;
                            default:                // Problem
                                StopPrinting = true;
                                MessageBox.Show(string.Format("Unrecognized record type [{0}]", iRecType), "Error Creating Complete RO Report", MessageBoxButtons.OK, MessageBoxIcon.Error);
                                break;
                        }
                        ;
                    }
                }
				else
				{
					StartNewDataTable();
					datatable.HeaderRows = 1;
					AddText("Selected Referenced Object has no data.", F12);
				}
			//Console.WriteLine("Record Type: {0}\n** Done **", iRecType);
			_pdfReportDoc.Add(datatable);
			showStatBar.Dispose();

			}
			catch (Exception e)
			{
				Console.WriteLine("Exception : {0}", e.Message);
				RO_df.close();
				_pdfReportDoc.Add(datatable);
				showStatBar.Dispose();
				GenerateErrorMessage(e, "Error Processing Complete RO Report. ", null);
			}
			AddErrorBookmarks();
			return;
		}

		private void GenerateErrorMessage( Exception e, string erMsg, string erMsg2)
		{
			// if there is lenght then we are in the mist of processing an RO
			string headers = erMsg;
			for (int iLoop = 0; iLoop < Hdrs.HdrCnt; iLoop++)
				headers += $"{Hdrs.strHdrs[iLoop]}\n ";
			if (processingRO.Length > 0) 
				headers += processingRO;
			if (erMsg2 != null && erMsg2.Length > 0)
				headers += "\n" + erMsg2;
			if (e != null)
				_MyLog.Error(headers, e);
			else
				_MyLog.Error(headers);
#pragma warning disable IDE0059 // Unnecessary assignment of a value - for debugging
            PdfOutline outl = new PdfOutline(MyErrorOutline, MyPdfDestPage, processingRO.Length > 0 ? processingRO : "Problem Reading Header");
#pragma warning restore IDE0059 // Unnecessary assignment of a value
                               //DestSample(outl);
        }

		//For Debugging/Testing
		//private void DestSample(PdfOutline outl)
		//{
		//    new PdfOutline(outl, new PdfDestination(PdfDestination.FIT), "FIT");
		//    new PdfOutline(outl, new PdfDestination(PdfDestination.FITV, 700), "FITV,700");
		//    new PdfOutline(outl, new PdfDestination(PdfDestination.FITH, 700), "FITH,700");
		//    new PdfOutline(outl, new PdfDestination(PdfDestination.XYZ, 72, 720, 5), "XYZ,72,720,5");
		//    new PdfOutline(outl, new PdfDestination(PdfDestination.FITR, 72, 650, 144, 722), "FITR,72, 650, 144, 722");
		//    new PdfOutline(outl, new PdfDestination(PdfDestination.XYZ, 72, 720, 10), "XYZ,72,720,10");
		//    new PdfOutline(outl, new PdfDestination(PdfDestination.FITR, 0, 500, _pdfReportDoc.PageSize.Width, 720), "FITR,0, 500,_pdfReportDoc.PageSize.Width , 720");
		//    new PdfOutline(outl, new PdfDestination(PdfDestination.XYZ, 0, 792, 1), "XYZ,72,720,10");
		//}

		public void AddErrorBookmarks()
		{
			if (_MyErrorOutline == null) return;
			string emsg = "A Bookmark grouping named \"Errors\" was added to the PDF.\n\n Click on the RO in this grouping to jump to the report page which will contain an error message.\n\nThe error were also recorded in the PROMS error log.";
			MessageBox.Show(emsg, "Errors Found Creating Report", MessageBoxButtons.OK, MessageBoxIcon.Information);

		}
		public void Multiple()
		{
            short typ, i, j;
			string str, sep;
			string buff = "";
			int[] width;
			LastHeader();
			sep = "";
            // nw - number of fields
            short nw = RO_df.ReadInteger16();
            // allocate space for widths
            width = new int[nw];
			// loop through and load field widths and names
			for (i = 0; i < nw; i++)
			{
				// load width
				width[i] = RO_df.ReadInteger16();
				// load name
				str = RO_df.ReadText();
				// how wide is the header
				int wtxt = str.Length;
				buff += sep; 
				buff += str; 
				// if the width is wider than the header output spaces to pad
				// to specified width
				if (width[i] > wtxt)
				{
					int extra = width[i] - wtxt;
					while (extra > 0)
					{
						buff += " ";
						extra--;
					}
					// otherwise set the width to the width of the header
				}
				else
				{
					width[i] = wtxt;
				}
				// place a vertical bar between fields
				sep = "|";
			}
			sep = "\n";
			buff += "\n"; 
			// place horizonal bars between the header and the values
			for (i = 0; i < nw; i++)
			{
				for (j = 0; j < width[i]; j++)
				{
					buff += "-"; 
				}
				if (i < nw - 1)
					buff += "|"; 
			}
			i = 0;
			// While not the end of multi
			while ((typ = RO_df.ReadInteger16()) != 104)
			{
				if (typ == 0)
				{// Next row
					sep = "\n"; // set the separator (between rows) to a newline
					i = 0;
				}
				else
				{// more for this row
					// get the data
					str = RO_df.ReadText();
					// if first time output a newline otherwise output a vertical
					// bar between values
					buff += sep;
					// output value
					if (str != null)
						buff += str;
					// set the separator to a vertical bar
					sep = "|";
					if (width[i] > 0)
					{
						int jj;
						jj = width[i] - str.Length;
						// pad the value to the specified width
						while (jj > 0)
						{
							buff += " ";
							jj--;
						}
					}
					i++;

				}
			}
			// output the table
			PutHeaderAndText(buff);
			//Console.WriteLine("Multiple: {0} ", buff);
			//Console.WriteLine("----------------------------------------------");
		}

		public void SetHeader()
		{
			string pTmp;

			//Console.WriteLine("Set Header");

			// Get the number of header records
			short iNewCnt = RO_df.ReadInteger16();

			//Console.WriteLine("Num Header Records: {0}", iNewCnt);
			
			// Clear the existing headers
			Hdrs.strHdrs.Clear();
			// Loop through the headers
			int iLoop = 0;
			for (; iLoop < iNewCnt; iLoop++)
			{
				int hdrRptCnt = (int)RO_df.ReadInteger16();
				if (Hdrs.repeatCount.Count - 1 < iLoop)
					Hdrs.repeatCount.Add((int)hdrRptCnt);
				else
					Hdrs.repeatCount[iLoop] =hdrRptCnt;
				pTmp = RO_df.ReadText();
				//Console.WriteLine("SH[{0}]", pTmp);
				if (Hdrs.strHdrs.Count - 1 < iLoop)
					Hdrs.strHdrs.Add(pTmp);
				else
					Hdrs.strHdrs[iLoop] = pTmp;
				//Console.WriteLine("Value: {0}", Hdrs.repeatCount[iLoop]);
				//Console.WriteLine("Value Text: {0}", Hdrs.strHdrs[iLoop]);
				//Console.WriteLine("----------------------------------------------");
			}
			// Set the new header count
			Hdrs.HdrCnt = iNewCnt;
		}
		bool _LastWasName = false;//B2016-251 Don't change underscore to underline to Name value
		public void PushHeader()
		{
			string pTmp = RO_df.ReadText();
			//Console.WriteLine("PH[{0}]", pTmp);
			curheaderlen = pTmp.Length;
			_LastWasName = (pTmp == "Name");//B2016-251 Don't change underscore to underline to Name value
			Hdrs.strHdrs.Add(pTmp);
			Hdrs.repeatCount.Add(2);
			Hdrs.HdrCnt++;
			Hdrs.printedLastHeader = false;

			//m_pPrinterOut->PushedHeader(Hdrs.strHdrs[Hdrs.HdrCnt-1]);

			//Console.WriteLine("Push Header");
			//Console.WriteLine("Header Text: {0}", pTmp);
			//Console.WriteLine("----------------------------------------------");
		}

		public void PopHeader()
		{
			if (Hdrs.repeatCount[Hdrs.HdrCnt-1] == 2)
			{
				// if the last header was pushed on header list
				// print eject the page if the page ran out, and
				// print the header with "none".
				LastHeader();
				//m_pPrinterOut->PutLine(0, "none");
				//m_pPrinterOut->NewLine(1);
			}
			// Remove the header
			Hdrs.HdrCnt--;
			Hdrs.strHdrs.RemoveAt(Hdrs.HdrCnt);
			Hdrs.repeatCount.RemoveAt(Hdrs.HdrCnt);

			//Console.WriteLine("Pop Header");
			//Console.WriteLine("----------------------------------------------");
		}

		public void RROBegin()
		{
			//Console.WriteLine("RRO Begin");
			//Console.WriteLine("----------------------------------------------");
			// Start of a new RO, print out the headers
			for (int iLoop = 0; iLoop < Hdrs.HdrCnt; iLoop++)
			{
				if (!MyDocOutline.ContainsKey(iLoop) || MyDocOutline[iLoop].MyHeader != Hdrs.strHdrs[iLoop])
				{
                    PdfOutline parentOutline;
                    if (iLoop == 0)
						parentOutline = MyRootOutline;//_MyPDFWriter.DirectContent.RootOutline;
					else
						parentOutline = MyDocOutline[iLoop - 1].MyOutline;
					AddOutlineLevel(parentOutline, iLoop, Hdrs.strHdrs[iLoop], MyPdfDestPage);
				}
				// Change double underscore to spaces in header text
					AddText(Hdrs.strHdrs[iLoop].Replace("__"," "), F12Bold); // should be bold and first header is centered
			}
		}
		public PdfDestination MyPdfDestTop
		{
			get
			{
				// FITH was acting strange and shifting towards bottom of the page as the number of pages increased
				//Console.WriteLine("Top = {0}, {1}", _Top, _MyPDFWriter.DirectContent.PdfDocument.PageSize.Height);
				return new PdfDestination(PdfDestination.XYZ, 0, _MyPDFWriter.DirectContent.PdfDocument.PageSize.Height, 1.5f);
			}
		}

        public PdfDestination MyPdfDestPage => new PdfDestination(PdfDestination.FITV, 0);

        private PdfOutline _MyErrorOutline = null;

		public PdfOutline MyErrorOutline
		{
			get 
			{
				if (_MyErrorOutline == null)
				{
					_MyErrorOutline = new PdfOutline(_MyPDFWriter.DirectContent.RootOutline, MyPdfDestPage, "Errors");
				}
				return _MyErrorOutline; 
			}
		}
		private PdfOutline _MyRootOutline = null;

		public PdfOutline MyRootOutline
		{
			get
			{
				if (_MyRootOutline == null)
				{
					_MyRootOutline = new PdfOutline(_MyPDFWriter.DirectContent.RootOutline, MyPdfDestTop, "Referenced Objects");
				}
				return _MyRootOutline;
			}
		}
		private void AddOutlineLevel(PdfOutline parentOutline, int iLoop, string hdr, PdfDestination pdfDest)
		{
			if (MyDocOutline.ContainsKey(iLoop))
				MyDocOutline[iLoop] = new DocOutline(new PdfOutline(parentOutline, pdfDest, hdr), hdr);
			else
				MyDocOutline.Add(iLoop,new DocOutline(new PdfOutline(parentOutline, pdfDest, hdr), hdr));
		}

		public void RROEnd()
		{
			// Remove any headers that are left over
			//Console.WriteLine("{0} headers cleaned up.", Hdrs.HdrCnt);
			//Console.WriteLine("RRO End");
			//Console.WriteLine("----------------------------------------------");
		}

		public void Msg()
		{

			// Set a message to the printer on its own
			string szStr = RO_df.ReadText();
			PutHeaderAndText(szStr);
			//m_pPrinterOut->NewLine(1);
			//m_pPrinterOut->PutChr(szStr);
			//m_pPrinterOut->NewLine(1);

			//Console.WriteLine("Message");
			//Console.WriteLine("Message Text: {0}", szStr);
			//Console.WriteLine("----------------------------------------------");
		}

		public void NoInformatEntered()
		{
			PutHeaderAndText("-- No information entered --");
		}

		public void PutHeaderAndText(string txt)
		{
			if (!Hdrs.printedLastHeader)
			{
				Chunk chk = LastHeader(); 
				Phrase p = new Phrase();
				PdfPCell cell = new PdfPCell();
				p.Add(chk); // add the header chunk
				cell.BackgroundColor = Color.WHITE;
				cell.BorderColor = Color.WHITE;
				cell.AddElement(p);
				datatable.AddCell(cell);
			}
			PutText(txt);
		}
		public void Text()
		{
			// Get the lenght of the text string and read it in
			short iValue = RO_df.ReadInteger16();
			string szStr = "";
			// B2016-247 If size is zero it is an empty string.
			if (iValue > 0)
				szStr = RO_df.ReadText(iValue);
			//Console.WriteLine("[{0}.{0:X}]='{1}'",iValue,szStr);
			string temp = szStr;
			Chunk chk = LastHeader();
			Phrase p = new Phrase();
			PdfPCell cell = new PdfPCell();
			if (MyROID != null)
			{
				chk.SetLocalDestination(string.Format("ROID={0}", MyROID.ToUpper())); // Destination
				//Console.WriteLine("\"ROID\"\t\"{0}\"", MyROID.ToUpper());
				MyROID = null;
			}
			p.Add(chk); // add the header chunk
			cell.BackgroundColor = Color.WHITE;
			cell.BorderColor = Color.WHITE;

			bool isXYPlot = szStr.StartsWith("<<G");

			if (isXYPlot || (iValue + curheaderlen) > 72 || (szStr.IndexOf('\r') != -1))
			{
				// If the length of the string plus the field title is greater
				// than 72 characters or has a carriage return character in it
				// then output the text on multiple lines

				// the header goes on its own line
				cell.AddElement(p);
				datatable.AddCell(cell);
				// text goes below the header

				if (isXYPlot)
					AddXYPlot(szStr); // xy plot - sometimes plots were put in text fields
				else
					PutText(temp); // it's just text
			}
			else
			{
				// Otherwise output the header and text on a single line
				p.Add(ConvertDOSSuperAndSubScripts(szStr,F10));
				cell.AddElement(p);
				datatable.AddCell(cell);
				//m_pPrinterOut->SetNumberOfNewLines(0);
				//m_pPrinterOut->putline(0, temp);
			}
			//Console.WriteLine("Text");
			//Console.WriteLine("Value: {0}", iValue);
			//Console.WriteLine("Text: {0}", szStr);
			//Console.WriteLine("----------------------------------------------");
		}

		public string KeyField()
		{
			// use the key field as the PDF bookbark
			string szStr = RO_df.ReadText();
#pragma warning disable IDE0059 // Unnecessary assignment of a value - For Debugging
            PdfOutline outl = new PdfOutline(MyDocOutline[Hdrs.HdrCnt - 1].MyOutline, MyPdfDestTop, szStr);
#pragma warning restore IDE0059 // Unnecessary assignment of a value
                               //DestSample(outl);
            return szStr;
			//Console.WriteLine("Key Field");
			//Console.WriteLine("Key Text: {0}", szStr);
			//Console.WriteLine("----------------------------------------------");
		}
		public string ROIDField()
		{
			// use the key field as the PDF bookbark
			string szStr = RO_df.ReadText();
			//For Dubugging
			//PdfDestination pdfDest = new PdfDestination(PdfDestination.FITH, _MyPDFWriter.DirectContent.PdfDocument.PageSize.Height);
			//PdfOutline outl = new PdfOutline(MyDocOutline[Hdrs.HdrCnt - 1].MyOutline, MyPdfDestTop, szStr);
			//DestSample(outl);
			return szStr;
			//Console.WriteLine("Key Field");
			//Console.WriteLine("Key Text: {0}", szStr);
			//Console.WriteLine("----------------------------------------------");
		}

// Read in the image filename, height, and width
		public void ImageFile()
		{
			string fn = RO_df.ReadText();
#pragma warning disable IDE0059 // Unnecessary assignment of a value - for Debugging
            short ht = RO_df.ReadInteger16();
            short wd = RO_df.ReadInteger16();
#pragma warning restore IDE0059 // Unnecessary assignment of a value
            //m_pPrinterOut->PrintImage(fn, wd, ht);

            //Console.WriteLine("ImageFile");
            //Console.WriteLine("Name: {0}", fn);
            //Console.WriteLine("Height: {0}", ht);
            //Console.WriteLine("Width: {0}", wd);
            //Console.WriteLine("----------------------------------------------");
            AddImage(fn);
		}
// Read in the X/Y plot info.
		public void XYPlot()
		{
			// Get the lenght of the text string and read it in
			short iValue = RO_df.ReadInteger16();
			string szStr = RO_df.ReadText(iValue);
			Chunk chk = LastHeader(); 
			Phrase p = new Phrase();
			PdfPCell cell = new PdfPCell();
			p.Add(chk); // add the header chunk
			cell.BackgroundColor = Color.WHITE;
			cell.BorderColor = Color.WHITE;

			// the header goes on its own line
			cell.AddElement(p);
			datatable.AddCell(cell);
			AddXYPlot(szStr);

			//Console.WriteLine("XY Plot");
			//Console.WriteLine("Value: {0}", iValue);
			//Console.WriteLine("Text: {0}", szStr);
			//Console.WriteLine("----------------------------------------------");
		}

		// Output the string.  If it is a graph, print the graph.
		// ParseForGraph contains the code to print the text.
		public void PutText(string szStr)
		{
			if (szStr == null || szStr.Equals("NONE"))
			{
				//m_pPrinterOut->putchr("NONE");
				//m_pPrinterOut->newline(2);
				AddText("NONE", F10);
				return;
			}
			//m_pPrinterOut->SetNumberOfNewLines(0);
			AddText(szStr,F10);
			//m_pPrinterOut->newline(2);
			// Include margin so the Display Data can print with a margin of zero
			//m_pPrinterOut->ParseForGraph(temp, margin);
		}

		// Output the last header that was push onto the header stack
		// Printer::LastHeader contains the code to do this.
		public Chunk LastHeader()
		{
			Chunk chk;// = new Chunk(m.Value, fnt);
			string hdrtxt = "";
			if (Hdrs.HdrCnt > 0)
				hdrtxt = Hdrs.strHdrs[Hdrs.HdrCnt - 1];
			hdrtxt += ": ";
			chk = new Chunk(hdrtxt, F10Bold);
			Hdrs.printedLastHeader = true;
			return chk;
		}

	}// end CompSumROReport


	public class Headers
	{
		public List<string> strHdrs;
		public int HdrCnt;
		public List<int> repeatCount;
		public bool printedLastHeader;
		public Headers()
		{
			HdrCnt = 0;
			strHdrs = new List<string>();
			repeatCount = new List<int>();
			printedLastHeader = false;
		}
	}

	public class RODataFile
	{
        readonly FileStream fs = null;
        readonly BinaryReader br = null;
		public RODataFile(string fname)
		{
			fs = new FileStream(fname,FileMode.Open);
			br = new BinaryReader(fs);
		}
		public void close()
		{
			br.Close();
			fs.Close();
		}
        public long GetFileLength() => fs.Length;
        public long GetFilePointerPosition() => fs.Position;
        // Read an integer value from the data file
        public Int16 ReadInteger16()
		{
			try
			{
				return (Int16)br.ReadUInt16();
			}
			catch (Exception e)
			{
				Console.WriteLine("Exception : {0}", e.Message);
				return -1;
			}
		}
        // Read a text string from the data file and returns it.
        // The calling program is responsible for free it
        // with the "delete" operator.

        public string ReadText() => ReadText(-1);

        public string ReadText(Int16 i16CharCount)
		{
			short i16DataSize;
			if (i16CharCount == -1)
				i16DataSize = ReadInteger16();
			else
				i16DataSize = i16CharCount;

			if (i16DataSize <= 0)
				return null;
			else
			{
				byte[] charbuff = new byte[i16DataSize + 1];
				charbuff = br.ReadBytes(i16DataSize);
				string str = "";
				for (int i = 0; i < i16DataSize; i++)
					str += Convert.ToChar(charbuff[i]).ToString();
				return (str);
			}
		}

// Search through the file to find the next record
		public long NextRecord()
		{
			short iType;
			short RECORD_START = 255;
			// While not the next record and not end of file get the next meta item
			while ((iType = ReadInteger16()) != RECORD_START && iType != -1)
			{
				NextItem();
			}
			return fs.Seek(0, SeekOrigin.Current);
		}
// Get the next meta item and discard the data
		public long NextItem()
		{
            short iRecType = ReadInteger16();
            short iNewCnt;
            int iLoop;
            switch (iRecType)
			{
				case 1:         // Set Header
					iNewCnt = ReadInteger16();
					for (iLoop = 0; iLoop < iNewCnt; iLoop++)
					{
						ReadInteger16();
                        _ = ReadText();
					}
					break;
				case 2:         // Push Header
				case 6:         // Msg
				case 7:			// Key Field
				case 100:      // Text Field
				case 101:       // Plot Field
                    _ = ReadText();
					break;
				case 3:         // Pop Header
				case 4:         // RRO Begin
				case 5:         // RRO End
				case 103:       // Multi Begin
				case 104:       // Multi End
				case 0:         // Do Nothing
					// Do nothing
					break;
				case 102:       // Image Field
                    _ = ReadText();
					ReadInteger16();
					ReadInteger16();
					break;
			}
			return fs.Seek(0, SeekOrigin.Current);
		}
// Get the block of data that is the record
		public byte[] GetRecord(ref int size)
		{
			byte[] data;
			// Get the current position
			long lCurPos = fs.Seek(0, SeekOrigin.Current);

			// Go to the end of the record and get the file position
			ReadInteger16();
			NextRecord();
			long lEndRecord = fs.Seek(0, SeekOrigin.Current); 

			// Get the size of the record
			size = (int)(lEndRecord - lCurPos);

			// Retrieve the record from the file
			data = new byte[size +1];
			data = br.ReadBytes(size);

			return data;
		}
	}
}