using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.IO;
using VEPROMS.CSLA.Library;
using DevComponents.DotNetBar;
using DevComponents.AdvTree;
using System.Text.RegularExpressions;
using Volian.Base.Library;


namespace Volian.Controls.Library
{
	public partial class DisplayReports : UserControl
	{
		#region Public Events/Handlers

		public event DisplayReportsEvent PrintRequest;

		private void OnPrintRequest(DisplayReportsEventArgs args)
		{
			if (PrintRequest != null)
				PrintRequest(this, args);
		}

		#endregion

		#region Fields

		// B2022-026 RO Memeory reduction logic change - defined dummy node text variable to ensure consistancy
		private const string DummyNodeText = "VLN_DUMMY_NODE";

		private List<DocVersionInfo> lstCheckedDocVersions = new List<DocVersionInfo>();
		private List<object> lstCheckedROs = new List<object>();
		private List<ItemInfoList> lstReportResults = new List<ItemInfoList>();
		private List<string> ROList = new List<string>();
		private List<object> lstROObj = new List<object>();
		private int _MyRODbID;

		private DocVersionInfo _MyDocVersion;
		private ROFSTLookup _MyROFSTLookup;
		private ItemInfoList _ReportResult;
		private Dictionary<string, string> AccIDROIDdic = new Dictionary<string, string>();
		static int blankKeyCnt = 0;

		#endregion

		#region Properties
		
		private string DocVersionList
		{
			get
			{
				// append list of document versions to search
				if (lstCheckedDocVersions.Count > 0)
				{
					string strRtnStr = "";
					// get list of doc versions to search
					foreach (DocVersionInfo dvi in lstCheckedDocVersions)
					{
						strRtnStr += string.Format(",{0}", dvi.VersionID.ToString());
					}
					return strRtnStr.Substring(1);
				}
				return "";
			}
		}

		public DocVersionInfo Mydocversion
		{
			get { return _MyDocVersion; }
			set
			{
				if (DesignMode) return; // B2019-043 need to check if we are just saving changes to the user interface

				_MyDocVersion = value;
				if (_MyDocVersion != null)
				{
					if (_MyDocVersion.DocVersionAssociationCount > 0)
					{
						// if the count variable is not consistent with the actual list count,
						// do a refresh. There was a bug, B2012-040, that was not reproducable..
						// so this is an attempt to fix it.
						if (_MyDocVersion.DocVersionAssociations.Count == 0)
						{
							_MyDocVersion.RefreshDocVersionAssociations();
							if (_MyDocVersion.DocVersionAssociations.Count == 0) return;
						}

						MyROFSTLookup = _MyDocVersion.DocVersionAssociations[0].MyROFst.GetROFSTLookup(_MyDocVersion);
						_MyRODbID = _MyDocVersion.DocVersionAssociations[0].MyROFst.RODbID;
					}
				}
			}
		}
		
		public ROFSTLookup MyROFSTLookup
		{
			get { return _MyROFSTLookup; }
			set
			{
				if (DesignMode) return; // B2019-043 need to check if we are just saving changes to the user interface
				//if (!Visible) return;		// don't reset anything if the form is invisible.
				_MyROFSTLookup = value;			// define the tree nodes based on this rofst
				advTreeROFillIn(true);
				//LoadROComboTree();
			}
		}

		public ItemInfoList ReportResult
		{
			get { return _ReportResult; }
			set
			{
				_ReportResult = value;
			}
		}

		#endregion

		#region Constructors

		public DisplayReports()
		{
			InitializeComponent();
			EnableOrDisablePrintButton();

			cmbxROUsageSort.SelectedIndex = 0;
			tabTransitionReports.Visible = false;
			cbxComplete.Enabled = true;
			cbxSummary.Enabled = true;

			if (cbxROUsage.Checked)
				cbxIncldMissingROs.Text = "Include Missing ROs (red ? in the editor)";
			else if (cbxComplete.Checked)
				cbxIncldMissingROs.Text = "Include Empty RO Fields";

			cbxIncldMissingROs.Checked = false;// !cbxSummary.Checked;
			cbxIncldMissingROs.Visible = cbxROUsage.Checked || cbxComplete.Checked;
			cbxSortBySetpointID.Checked = false;
			cbxSortBySetpointID.Visible = cbxComplete.Checked || cbxSummary.Checked;
		}

		#endregion

		#region Public Methods
		
		public void SelectReferencedObjectTab()
		{
			tabROReports.PerformClick();
		}

		public void advTreeROFillIn(bool blSeachTabClicked)
		{
			DevComponents.AdvTree.Node topnode = null;
			advTreeRO.Nodes.Clear();

			if (_MyROFSTLookup == null) return;

			advTreeRO.BeforeExpand += new AdvTreeNodeCancelEventHandler(advTreeRO_BeforeExpand);
			advTreeRO.AfterExpand += new AdvTreeNodeEventHandler(advTreeRO_AfterExpandorCollapse);
			advTreeRO.AfterCollapse += new AdvTreeNodeEventHandler(advTreeRO_AfterExpandorCollapse);

			topnode = new DevComponents.AdvTree.Node();
			topnode.Text = "All Referenced Objects";
			topnode.Tag = null;
			topnode.CheckBoxVisible = true;

			advTreeRO.Nodes.Add(topnode);

			ROFSTLookup.rodbi[] dbs = _MyROFSTLookup.GetRODatabaseList(true);

			if (dbs != null && dbs.Length > 0)
			{
				for (int i = 0; i < dbs.Length; i++)
				{
					DevComponents.AdvTree.Node tn = new DevComponents.AdvTree.Node();
					ROFSTLookup.rodbi db = dbs[i];

					tn.Text = db.dbiTitle;
					tn.Tag = db;
					tn.CheckBoxVisible = true;
					topnode.Nodes.Add(tn);

					AddDummyGroup(db, tn);
				}
			}
		}

		public void advTreeProcSetsFillIn(bool blSeachTabClicked)
		{
			DevComponents.AdvTree.Node topnode = null;
			int cntnd = 0;
			VETreeNode vtn = VETreeNode.GetFolder(1);
			FolderInfo fi = vtn.VEObject as FolderInfo;
			int fiCount = fi.ChildFolderCount;
			advTreeProcSets.Nodes.Clear();
			lstCheckedDocVersions.Clear();
			topnode = new DevComponents.AdvTree.Node();
			topnode.Text = "Available Procedure Sets";
			topnode.Tag = fi;
			advTreeProcSets.Nodes.Add(topnode);
			//advTreeProcSets.AfterNodeInsert += new TreeNodeCollectionEventHandler(advTreeProcSets_AfterNodeInsert);


			foreach (FolderInfo fic in fi.SortedChildFolders)
			{
				DevComponents.AdvTree.Node newnode = new DevComponents.AdvTree.Node();
				newnode.Text = fic.ToString();
				newnode.Tag = fic;

				//int tmp;
				//if (topnode == null)
				//{
				//    newnode.Text = "Available Procedure Sets";
				//    tmp = advTreeProcSets.Nodes.Add(newnode);
				//    topnode = newnode;
				//}
				//else
				//{
				//    newnode.Selectable = true;
				//    newnode.CheckBoxAlignment = DevComponents.AdvTree.eCellPartAlignment.NearCenter;
				//    newnode.CheckBoxStyle = eCheckBoxStyle.CheckBox;
				//    newnode.CheckBoxThreeState = false;
				//    newnode.CheckBoxVisible = true;
				//    tmp = topnode.Nodes.Add(newnode);
				//}
				cntnd++;
				if (fic.ChildFolderCount > 0 || fic.FolderDocVersionCount > 0)      // allow for '+' for tree expansion
				{
					DevComponents.AdvTree.Node tnt = new DevComponents.AdvTree.Node();
					tnt.Text = DummyNodeText;
					newnode.Nodes.Add(tnt);
					topnode.Nodes.Add(newnode);
				}
			}

			// if nothing was added to the tree, just put in the node above the docversions...
			if (advTreeProcSets.Nodes.Count == 0)
			{
				cntnd++;
				fi = Mydocversion.MyFolder;
				topnode = new DevComponents.AdvTree.Node();
				topnode.Text = fi.ToString();
				advTreeProcSets.Nodes.Add(topnode);
				topnode.Tag = fi;
			}

			advTreeProcSets.BeforeExpand += new DevComponents.AdvTree.AdvTreeNodeCancelEventHandler(advTreeProcSets_BeforeExpand);

			// position to the procedure set in the tree if we have a procedure open
			if (Mydocversion != null)
				advTreeProcSetsPreSelect();
			else
				advTreeProcSets.Nodes[0].SelectedCell = advTreeProcSets.Nodes[0].Cells[0]; // select the first node - fixes cosmetic problem

			//if (blSeachTabClicked)
			//    cbxTextSearchText.Focus(); // set initial focus to enter search text
		}

		#endregion

		#region Private Methods
		
		private void GenerateAccIDSortedROList()
		{
			//Dictionary<string, string> AccIDROIDdic = new Dictionary<string, string>();
			List<string> AccPgIDsList = new List<string>();
			AccIDROIDdic.Clear();

			string rtnStr = "";
			ROFSTLookup.rochild[] chld = null;
			ROFSTLookup.rochild ch;
			ROList.Clear();

			foreach (object rolkup in lstCheckedROs)
			{
				if (rolkup == null) // All Referenced Objects selected, return list of RO databases
				{
					foreach (ROFSTLookup.rodbi rodbi in _MyROFSTLookup.GetRODatabaseList(true))
					{
						rtnStr = _MyRODbID.ToString() + ":" + string.Format("{0}", rodbi.dbiID.ToString("X4"));

						if (rodbi.children != null)
						{
							foreach (ROFSTLookup.rochild roc in rodbi.children)
							{
								PutROChildrenInDictionary(_MyRODbID.ToString() + ":", roc);
							}
						}
						else
						{
							ROList.Add(rtnStr);
						}
					}

					continue;
				}
				else if (rolkup is ROFSTLookup.rodbi)
				{
					ROFSTLookup.rodbi rodbi = (ROFSTLookup.rodbi)rolkup;

					//Try to lazy load the children - B2022-026 RO Memory Reduction code
					if (rodbi.children == null || rodbi.children.Length <= 0)
						rodbi.children = MyROFSTLookup.GetRoChildrenByID(rodbi.ID, rodbi.dbiID, true);

					if (rodbi.children != null)
					{
						foreach (ROFSTLookup.rochild roc in rodbi.children)
						{
							PutROChildrenInDictionary(_MyRODbID.ToString() + ":", roc);
						}
					}
					else
					{
						ROList.Add(_MyRODbID.ToString() + ":" + string.Format("{0}", rodbi.dbiID.ToString("X4")));
					}
				}
				else if (rolkup is ROFSTLookup.rochild)
				{
					ch = (ROFSTLookup.rochild)rolkup;
					chld = ch.children;

					//Try to lazy load the children - B2022-026 RO Memory Reduction code
					if (ch.children == null || ch.children.Length <= 0)
						ch.children = MyROFSTLookup.GetRoChildrenByRoid(ch.roid, true);

					PutROChildrenInDictionary(_MyRODbID.ToString() + ":", rolkup);
				}
			}

			foreach (string k in AccIDROIDdic.Keys)
			{
				AccPgIDsList.Add(k);
			}

			string[] AccPgIdListArray = AccPgIDsList.ToArray();
			Array.Sort(AccPgIdListArray, new AlphanumComparatorFast());

			foreach (string accid in AccPgIdListArray)
			{
				ROList.Add(AccIDROIDdic[accid]);
			}
		}

		private string GetNextBlankKey()
		{
			return string.Format(" _{0}", blankKeyCnt++);
		}

		private void PutROChildrenInDictionary(string rodbidPrefix, object roObj)
		{
			ROFSTLookup.rochild chld = (ROFSTLookup.rochild)roObj;
			string rtnstr = rodbidPrefix;// "";
			string keystr = ((chld.appid == "") ? GetNextBlankKey() : chld.appid) + chld.roid.Substring(0,4);

			//Try to lazy load the children - B2022-026 RO Memory Reduction
			if (chld.children == null || chld.children.Length <= 0)
				chld.children = MyROFSTLookup.GetRoChildrenByRoid(chld.roid, true);

			// If still no children - B2022-026 RO Memory Reduction code - check children length
			if (chld.children == null || chld.children.Length <= 0) // get a single ROID
			{
				rtnstr = rodbidPrefix + string.Format("{0}", chld.roid);
				if (rtnstr.Length == 12) rtnstr += "0000"; // last four digits are used for multiple return values
				// B2023-094: Don't crash when trying to add another ro if it has same key.  Note that this is coming in as an RO but is really a group.  
				if (!AccIDROIDdic.ContainsKey(keystr))AccIDROIDdic.Add(keystr, rtnstr);
			}
			else if (!cbxROUsage.Checked && chld.children[0].ParentID == 0)
			{
				rtnstr = rodbidPrefix + string.Format("{0},", chld.roid); // doing a RO Summary or RO Complete report - don't want children that are multiple return values
				AccIDROIDdic.Add(keystr, rtnstr);
			}
			else
			{
				// spin through the child list and get the ROIDs.
				// if the child has children, then call this function recursively 
				for (int i = 0; i < chld.children.Length; i++)
				{
					ROFSTLookup.rochild roc = chld.children[i];

					//Try to lazy load the children - B2022-026 RO Memory Reduction code
					if (roc.children == null || roc.children.Length <= 0)
						roc.children = MyROFSTLookup.GetRoChildrenByRoid(roc.roid, true);

					// Don't get the children if we are doing a RO Summary or RO Complete report & children are the multiple return values
					if (roc.children != null && roc.children.Length > 0 && (cbxROUsage.Checked || roc.children[0].ParentID != 0))
					{
						PutROChildrenInDictionary(rodbidPrefix, roc);
					}
					else if (roc.appid != null && roc.appid != "")
					{
						rtnstr = rodbidPrefix + string.Format("{0}", roc.roid);
						keystr = ((roc.appid == "") ? GetNextBlankKey() : roc.appid) + chld.roid.Substring(0, 4);

						if (AccIDROIDdic.ContainsKey(keystr))  // For duplicates, append the parent title (B2017-011) so adding to dictionary doesn't crash.
						{
							keystr = keystr + "|" + chld.title;
						}

						AccIDROIDdic.Add(keystr, rtnstr);
					}
				}

			}
		}

		private void GenerateROList()
		{
			string rtnStr = "";
			ROFSTLookup.rochild[] chld = null;
			ROFSTLookup.rochild ch;
			ROList.Clear();

			foreach (object rolkup in lstCheckedROs)
			{
				if (rolkup == null) // All Referenced Objects selected, return list of RO databases
				{
					// B2022-026 RO Memory Reduction code - added flag to load all children
					foreach (ROFSTLookup.rodbi rodbi in _MyROFSTLookup.GetRODatabaseList(true))
					{
						rtnStr = _MyRODbID.ToString() + ":" + string.Format("{0}", rodbi.dbiID.ToString("X4"));
						ROList.Add(rtnStr);
					}
					continue;
				}
				else if (rolkup is ROFSTLookup.rodbi)
				{
					rtnStr = _MyRODbID.ToString() + ":" + string.Format("{0}", ((ROFSTLookup.rodbi)rolkup).dbiID.ToString("X4"));
				}
				else if (rolkup is ROFSTLookup.rochild)
				{
					ch = (ROFSTLookup.rochild)rolkup;

					//Try to lazy load the children - B2022-026 RO Memory Reduction code
					if (ch.children == null || ch.children.Length <= 0)
						ch.children = MyROFSTLookup.GetRoChildrenByRoid(ch.roid, true);

					chld = ch.children;

					rtnStr = _MyRODbID.ToString() + ":" + GetROChildren(rolkup).TrimEnd(','); // GetROChildren(rolkup).TrimEnd(',') grabs the children of the selected item
				}
				
				ROList.Add(rtnStr);
			}
		}

		// same function as GetROsToSearch in DisplaySearch.cs
		private string GetROChildren(object roObj)
		{
			ROFSTLookup.rochild chld = (ROFSTLookup.rochild)roObj;
			string rtnstr = "";

			//Try to lazy load the children - B2022-026 RO Memory Reduction code
			if (chld.children == null || chld.children.Length <= 0)
				chld.children = MyROFSTLookup.GetRoChildrenByRoid(chld.roid, true);

			// If still no children
			if (chld.children == null || chld.children.Length <= 0) // get a single ROID
			{
				rtnstr += string.Format("{0}", chld.roid);
				if (rtnstr.Length == 12) rtnstr += "0000"; // last four digits are used for multiple return values
			}
			else if (!cbxROUsage.Checked && chld.children[0].ParentID == 0)
			{
				rtnstr += string.Format("{0},", chld.roid); // doing a RO Summary or RO Complete report - don't want children that are multiple return values
			}
			else
			{ // spin through the child list and get the ROIDs.
				// if the child has children, then call this function recursivly 
				foreach (ROFSTLookup.rochild roc in chld.children)
				{
					// Don't get the children if we are doing a RO Summary or RO Complete report & children are the multiple return values
					// B2022-062: Proms crashes on Complete or Summary RO report without 'Sort by SetpointID'.  With new ROfst logic,
					//	need to check for children length > 0 also.
					if (roc.children != null &&  roc.children.Length > 0 && (cbxROUsage.Checked || roc.children[0].ParentID != 0))
						rtnstr += GetROChildren(roc);
					else
						rtnstr += string.Format("{0},", roc.roid);
				}
			}
			return rtnstr;
		}

		private string GetListOfROs(bool keepRODbID)
		{
			string rtnStr = "";
			string strRODbID = "";
			int cnt = 0;
			foreach (string rostr in ROList)
			{
				int ndxOf = rostr.IndexOf(":");
				if (ndxOf > 0)
				{
					string tstr = rostr.Substring(0, ndxOf + 1);
					if (tstr != strRODbID && keepRODbID)
					{
						strRODbID = tstr;
						rtnStr += rostr;
					}
					else
						rtnStr += rostr.Substring(ndxOf + 1);
				}
				else
					rtnStr += rostr;
				if (rtnStr.EndsWith(",")) rtnStr = rtnStr.Substring(0, rtnStr.Length - 1);
				if (++cnt < ROList.Count)
					rtnStr += ",";
			}
			return rtnStr;
		}

		private void AddSelectedROChildren(DevComponents.AdvTree.NodeCollection chldrn)
		{
			if (chldrn.Count > 0)
			{
				foreach (DevComponents.AdvTree.Node n in chldrn)
				{
					if (n.Checked)
						lstCheckedROs.Add(n.Tag);
					else
						AddSelectedROChildren(n.Nodes);
				}
			}
		}

		private void BuildCheckedROsList()
		{
			lstCheckedROs.Clear();
			if (advTreeRO.Nodes.Count == 0) return;

			DevComponents.AdvTree.Node node = advTreeRO.Nodes[0];
			if (node.Checked) // top node (all Referenced Objects) selected
				lstCheckedROs.Add(node.Tag);
			else
				AddSelectedROChildren(node.Nodes);
		}

		private void EnableOrDisablePrintButton()
		{
			switch (tctrlReports.SelectedTabIndex)
			{
				case 0: // Transition Reports
					btnPrintReport.Enabled = (lstCheckedDocVersions.Count > 0);
					break;

				case 1: // Referenced Objects Reports
					BuildCheckedROsList();  // this list is sent to the report generator
					if (cbxROUsage.Checked)
						btnPrintReport.Enabled = (lstCheckedDocVersions.Count > 0 && lstCheckedROs.Count > 0);
					else
						btnPrintReport.Enabled = ((cbxComplete.Checked || cbxSummary.Checked) && lstCheckedROs.Count > 0);
					break;
			}

			if (cbxROUsage.Checked)
				cbxIncldMissingROs.Text = "Include Missing ROs (red ? in the editor)";
			else if (cbxComplete.Checked)
				cbxIncldMissingROs.Text = "Include Empty RO Fields";

			//cbxIncldMissingROs.Checked = cbxROUsage.Checked || cbxComplete.Checked;
			cbxIncldMissingROs.Visible = cbxROUsage.Checked || cbxComplete.Checked;
			cbxSortBySetpointID.Visible = cbxComplete.Checked || cbxSummary.Checked;
			labelX1.Visible = cmbxROUsageSort.Visible = !cbxSortBySetpointID.Visible;
		}

		private void tabTransitionReports_Click(object sender, EventArgs e)
		{
			xpSetToReport.Enabled = true;
			xpSetToReport.Expanded = true;
			xpSelROs.Expanded = false;
			xpSelROs.Enabled = false;

			EnableOrDisablePrintButton();
		}

		private void tabROReports_Click(object sender, EventArgs e)
		{
			xpSetToReport.Enabled = cbxROUsage.Checked;
			xpSetToReport.Expanded = cbxROUsage.Checked;
			labelX1.Visible = cmbxROUsageSort.Visible = cbxROUsage.Checked;
			xpSelROs.Enabled = true;
			xpSelROs.Expanded = true;
			cbxIncldMissingROs.Checked = false;// !cbxSummary.Checked;
			cbxSortBySetpointID.Checked = false;
			cbxSortBySetpointID.Visible = !cbxROUsage.Checked;

			EnableOrDisablePrintButton();
		}

		private void cbxROUsage_CheckedChanged(object sender, EventArgs e)
		{
			xpSetToReport.Enabled = cbxROUsage.Checked;
			xpSetToReport.Expanded = cbxROUsage.Checked;
			labelX1.Visible = cmbxROUsageSort.Visible = cbxROUsage.Checked;

			// reset the RO tree and clear anything that was selected
			advTreeROFillIn(true);
			lstCheckedROs.Clear();

			cbxIncldMissingROs.Checked = false;// !cbxSummary.Checked;
			cbxSortBySetpointID.Checked = false;
			cbxSortBySetpointID.Visible = !cbxROUsage.Checked;

			EnableOrDisablePrintButton();
		}

		private void DisplayReports_Load(object sender, EventArgs e)
		{
			tabTransitionReports.PerformClick();
		}

		// when a node is checked (selected) then uncheck any of its children
		private void UncheckChildren(DevComponents.AdvTree.NodeCollection chldrn)
		{
			if (chldrn.Count > 0)
			{
				foreach (DevComponents.AdvTree.Node n in chldrn)
				{
					if (n.Checked)
						n.Checked = false;
					else
						UncheckChildren(n.Nodes);
				}
			}
		}

		// when a node is checked (selected), uncheck the parents, grand parents, great grand parents, etc.
		private void UncheckParents(DevComponents.AdvTree.Node pNode)
		{
			while (pNode != null)
			{
				if (pNode.Checked) pNode.Checked = false;
				pNode = pNode.Parent;
			}
		}

		private void advTreeRO_AfterCheck(object sender, AdvTreeCellEventArgs e)
		{
			DevComponents.AdvTree.Node n = advTreeRO.SelectedNode;

			if (n.Checked)
			{
				UncheckChildren(n.Nodes);
				UncheckParents(n.Parent);
			}

			EnableOrDisablePrintButton();
		}

		private void cbxTransToProcs_CheckedChanged(object sender, EventArgs e)
		{
			EnableOrDisablePrintButton();
		}

		private void cbxTransFromProcs_CheckedChanged(object sender, EventArgs e)
		{
			EnableOrDisablePrintButton();
		}

		private void cbxComplete_CheckedChanged(object sender, EventArgs e)
		{
			cbxIncldMissingROs.Checked = false;// !cbxSummary.Checked;
			cbxSortBySetpointID.Checked = false;
			EnableOrDisablePrintButton();
		}

		private void cbxSummary_CheckedChanged(object sender, EventArgs e)
		{
			EnableOrDisablePrintButton();
		}

		private string BuildRODataFile(string ROList)
		{
			DocVersionInfo MyDVI = Mydocversion;
			string roDataFile = "PRINT.TMP";

			if (VlnSettings.ReleaseMode.Equals("DEMO"))
			{
				MessageBox.Show("Referenced Object Reports not available in the Demo version.", "PROMS Demo Version");
				return "";
			}

			//string roapp = Environment.GetEnvironmentVariable("roapp");
			string roapp = Volian.Base.Library.ExeInfo.GetROEditorPath(); // get the path to the RO Editor Executable
			if (roapp == null)
			{
				MessageBox.Show("Could not find path to Ro Editor, check 'roapp' environment variable");
				return "";
			}

			if (MyDVI == null || MyDVI.DocVersionAssociationCount < 1)
			{
				MessageBox.Show("Could not find associated path for ro data.", "No RO Data", MessageBoxButtons.OK, MessageBoxIcon.Information);
				return "";
			}

			//string roloc = "\"" + MyDVI.DocVersionAssociations[0].MyROFst.MyRODb.FolderPath + "\" " + "\"" + ROList + "\"";
			if (!Directory.Exists(MyDVI.DocVersionAssociations[0].MyROFst.MyRODb.FolderPath))
			{
				MessageBox.Show(string.Format("RO Database directory does not exist: {0}", MyDVI.DocVersionAssociations[0].MyROFst.MyRODb.FolderPath));
				return "";
			}

			string cmpRptExePath = roapp.Substring(0, roapp.LastIndexOf("\\")) + "\\CmpRpt.exe ";
			roDataFile = MyDVI.DocVersionAssociations[0].MyROFst.MyRODb.FolderPath + "\\" + roDataFile;

			try
			{
				if (File.Exists(roDataFile)) File.Delete(roDataFile);
				Application.DoEvents();

				string fname = VlnSettings.TemporaryFolder + "\\ROCompleteRprt.txt";
				FileInfo fi = new FileInfo(fname);
				using (StreamWriter sw = fi.CreateText())
				{
					sw.Write(ROList);
					sw.Close();
				}

				string roloc = "\"" + MyDVI.DocVersionAssociations[0].MyROFst.MyRODb.FolderPath + "\" \"/f=" + fname + "\"";
				// C2017-003: ro data in sql server, check for sql connection string
				if (MyDVI.DocVersionAssociations[0].MyROFst.MyRODb.DBConnectionString != "cstring") roloc = roloc + " \"/sql=" + MyDVI.DocVersionAssociations[0].MyROFst.MyRODb.DBConnectionString + "\"";

				// C2021-026 pass in Parent/Child information (list of the children)
				// B2022-019 look at all DocVersions to find ParentChild information
				//           to ensure we pass in Parent/Child even when not coming from a Parent/Child procedure set
				DocVersionInfoList dvil = DocVersionInfoList.Get();
				foreach (DocVersionInfo dvi in dvil)
				{
					DocVersionConfig dvc = dvi.DocVersionConfig as DocVersionConfig;
					if (dvc != null && dvc.Unit_Name != "" && dvc.Unit_Count > 1) // B2021-089 only pass in applicability info if defined for more than one unit
						roloc += " \"/PC=" + dvc.Unit_Name + "\"";
					break;
				}

				System.Diagnostics.Process p = System.Diagnostics.Process.Start(cmpRptExePath, roloc);
				// need to wait, sometimes the Print.tmp file that is generated is not available
				p.WaitForExit(); // without arguments, this will wait indefinitely
				Application.DoEvents();
			}
			catch (Exception ex)
			{
				while (ex.InnerException != null)
					ex = ex.InnerException;
				string tmpmsg = ex.Message;
				MessageBox.Show(tmpmsg, "RO Report Error: " + ex.GetType().Name);
			}
			return roDataFile;
		}

		private void btnPrintReport_Click(object sender, EventArgs e)
		{
			string paperSize = "Letter";

			if (Mydocversion != null && Mydocversion.ActiveFormat != null)
				paperSize = Mydocversion.ActiveFormat.PlantFormat.FormatData.PDFPageSize.PaperSize; // C2020-002 paper size is now set in the format files

			//B2019-144 Set the document text color to Red (overlay) or Black (normal)
			Color lastColor = MSWordToPDF.OverrideColor;// B2019-144 Remember override color
			if (MSWordToPDF.OverrideColor != Color.Black)
				MSWordToPDF.OverrideColor = Color.Black;

			Cursor curcur = Cursor;
			Cursor = Cursors.WaitCursor;

			if (cbxSummary.Checked) // RO Summary Report
			{
				if (cbxSortBySetpointID.Checked)
					GenerateAccIDSortedROList();
				else
					GenerateROList();

				OnPrintRequest(new DisplayReportsEventArgs("RO Summary Report", "RO Summary Report", MyROFSTLookup, ROList, paperSize));
			}
			else if (cbxComplete.Checked) // Complete RO Report
			{
				if (cbxSortBySetpointID.Checked)
					GenerateAccIDSortedROList();
				else
					GenerateROList();

				string ROList = GetListOfROs(false);//don't include the RODbID in the RO list
				string roDataFile = BuildRODataFile(ROList);

				// B2023-028: RO report generates report with error when RO path not set.  Return if datafile is not set
				//	by BuildRODataFile
				if (roDataFile == null || roDataFile == "")
				{
					Cursor = curcur;		// B2023-094:  restore cursor (was wait).  Not part of bug, found during fix
					return;
				}

				if (Mydocversion != null)
					OnPrintRequest(new DisplayReportsEventArgs("Complete RO Report", "Complete RO Report", roDataFile, MyROFSTLookup, cbxComplete.Checked, Mydocversion.ActiveFormat.PlantFormat.FormatData.SectData.ConvertCaretToDelta, cbxIncldMissingROs.Checked, paperSize));
			}
			else if (cbxROUsage.Checked)
			{
				bool usageSortedByProcedure = (cmbxROUsageSort.SelectedIndex == 1);
				GenerateROList();
				string SearchString = GetListOfROs(true);// Include the RODbID in the RO list
				ItemInfoList SearchResults = ItemInfoList.GetListFromROReport(DocVersionList, "", SearchString, "");

				List<ItemInfo> sortedResults = SearchResults.SortedList(!usageSortedByProcedure);
				OnPrintRequest(new DisplayReportsEventArgs("Referenced Objects Usage By RO", "RO Usage", sortedResults, usageSortedByProcedure, cbxIncldMissingROs.Checked, paperSize));
			}
			else if (cbxTransFromProcs.Checked)
			{
			}
			else if (cbxTransToProcs.Checked)
			{
			}

			Cursor = curcur;
			//B2019-144 Set the document text color to Red (overlay) or Black (normal)
			if (MSWordToPDF.OverrideColor != lastColor)// B2019-144 Restore override color
				MSWordToPDF.OverrideColor = lastColor;
		}

		#region (Procedure List)

		private DevComponents.AdvTree.Node NewAdvTreeNode(string nodetext, bool selectable, bool chxbxvisable)
		{
			DevComponents.AdvTree.Node newnode;
			newnode = new DevComponents.AdvTree.Node();
			newnode.Text = nodetext;
			newnode.Selectable = selectable;
			newnode.CheckBoxAlignment = DevComponents.AdvTree.eCellPartAlignment.NearCenter;
			newnode.CheckBoxStyle = eCheckBoxStyle.CheckBox;
			newnode.CheckBoxThreeState = false;
			newnode.CheckBoxVisible = chxbxvisable;
			return newnode;
		}

		private void advTreeProcSets_BeforeExpand(object sender, DevComponents.AdvTree.AdvTreeNodeCancelEventArgs e)
		{
			DevComponents.AdvTree.Node par = e.Node;
			// get first child's text, if it has one & if the text is "VLN_DUMMY_NODE", load children
			DevComponents.AdvTree.Node tn = null;
			if (par.Nodes.Count > 0) tn = par.Nodes[0];
			if (tn.Text == DummyNodeText)		// expand this
			{
				par.Nodes.Clear();
				Object obj = par.Tag;
				if (!(obj is FolderInfo)) return;   // should always be folderinfo on expand
				FolderInfo fi = (FolderInfo)obj;
				if (fi.ChildFolderCount > 0)
				{
					foreach (FolderInfo fic in fi.SortedChildFolders)
					{
						DevComponents.AdvTree.Node newnode = new DevComponents.AdvTree.Node();
						newnode.Text = fic.ToString();
						newnode.Tag = fic;
						par.Nodes.Add(newnode);
						if (fic.HasChildren)		// allow for '+' for tree expansion
						{
							DevComponents.AdvTree.Node tnt = new DevComponents.AdvTree.Node();
							tnt.Text = DummyNodeText;
							newnode.Nodes.Add(tnt);
						}
					}
				}
				else if (fi.FolderDocVersionCount > 0)
				{
					foreach (DocVersionInfo dv in fi.FolderDocVersions)
					{
						DevComponents.AdvTree.Node newnode = new DevComponents.AdvTree.Node();
						newnode.Text = dv.ToString();
						newnode.Tag = dv;
						newnode.Selectable = true;
						newnode.CheckBoxAlignment = DevComponents.AdvTree.eCellPartAlignment.NearCenter;
						newnode.CheckBoxStyle = eCheckBoxStyle.CheckBox;
						newnode.CheckBoxThreeState = false;
						newnode.CheckBoxVisible = true;
						par.Nodes.Add(newnode);
					}
				}
			}
		}

		private void advTreeProcSets_AfterCheck(object sender, DevComponents.AdvTree.AdvTreeCellEventArgs e)
		{
			DevComponents.AdvTree.Node n = advTreeProcSets.SelectedNode;
			if (n.Checked)
			{
				n.Style = DevComponents.AdvTree.NodeStyles.Apple;
				lstCheckedDocVersions.Add((DocVersionInfo)n.Tag);
				if (lstCheckedDocVersions.Count == 1)//Mydocversion == null)
				{
					Mydocversion = (DocVersionInfo)n.Tag;
				}
			}
			else
			{
				n.Style = null;
				lstCheckedDocVersions.Remove((DocVersionInfo)n.Tag);
				if (lstCheckedDocVersions.Count == 1)
				{
					if (Mydocversion != lstCheckedDocVersions[0])
					{
						Mydocversion = lstCheckedDocVersions[0];
					}
				}
				else
				{
					if (lstCheckedDocVersions.Count == 0)
						Mydocversion = null;
					// do this if either none, or more than one procedure set selected
					//advTreeStepTypes.Nodes.Clear();
					//lstCheckedStepTypes.Clear();
					//lstCheckedStepTypesStr.Clear();
					//Node newnode = new DevComponents.AdvTree.Node();
					//newnode.Text = "....select a procedure set for types to appear...";
					//advTreeStepTypes.Nodes.Add(newnode);
					//buildStepTypePannelTitle();
				}
			}
			//// Enable the RO combo list only if at least one procedure set node
			//// is selected
			//cmboTreeROs.Enabled = (lstCheckedDocVersions.Count > 0);
			//gpFindROs.Enabled = cmboTreeROs.Enabled;

			//SetupContextMenu();

			//buildSetToSearchPanelTitle();
			EnableOrDisablePrintButton();
		}

		private void advTreeProcSets_AfterNodeSelect(object sender, AdvTreeNodeEventArgs e)
		{
			DevComponents.AdvTree.Node n = advTreeProcSets.SelectedNode;
		}

		private void advTreeProcSetsPreSelect()
		{
			bool keeplooking = true;
			//build a stack (bread crumb trail) of where is procedure set came from within the tree.
			Stack<string> crumbs = new Stack<string>();

			crumbs.Push(Mydocversion.Name); // ex: "working draft"
			crumbs.Push(Mydocversion.MyFolder.Name); // ex: "Emergency Procedures"
			FolderInfo fi = Mydocversion.MyFolder.MyParent;
			while (fi != null)
			{
				if (fi.MyParent != null)
					crumbs.Push(fi.Name);
				fi = fi.MyParent;
			}
			crumbs.Push(advTreeProcSets.Nodes[0].Text); //top node of my tree

			// now walk the tree, looking for the node names we saved in the stack.
			NodeCollection monkeys = advTreeProcSets.Nodes;
			while (keeplooking)
			{
				Node climber = LookInTree(monkeys, crumbs.Pop());
				keeplooking = (climber != null && crumbs.Count > 0);
				if (keeplooking)
					monkeys = climber.Nodes;
				if (!keeplooking && climber != null)
				{
					climber.Checked = true;
				}
			}
		}

		private Node LookInTree(NodeCollection monkeys, string bananna)
		{
			Node foundit = null;
			foreach (Node chimp in monkeys)
			{
				if (chimp.Text.Equals(bananna))
				{
					foundit = chimp;
					// need to select the node (cell) for it to be checked
					chimp.SelectedCell = chimp.Cells[0];
					if (chimp.Nodes.Count > 0)
						chimp.Expand();
					break;
				}
				chimp.Collapse();
			}
			return foundit;
		}

		#endregion

		#region (RO Tree)

		private void AddDummyGroup(ROFSTLookup.rodbi rodbi, DevComponents.AdvTree.Node tn)
		{
			if (rodbi.children != null && rodbi.children.Length > 0)
			{
				DevComponents.AdvTree.Node tmp = new DevComponents.AdvTree.Node();
				tmp.Text = DummyNodeText;
				tn.Nodes.Add(tmp);
			}
		}

		private void advTreeRO_BeforeExpand(object sender, DevComponents.AdvTree.AdvTreeNodeCancelEventArgs e)
		{
			LoadChildren(e.Node);
		}

		private void LoadChildren(DevComponents.AdvTree.Node tn)
		{
			//Check if node has already been loaded
			if (tn.HasChildNodes && tn.Nodes[0].Text != DummyNodeText) return;  // already loaded.
			if (tn.HasChildNodes && tn.Nodes[0].Text == DummyNodeText) tn.Nodes[0].Remove();

			object tag = tn.Tag;
			ROFSTLookup.rochild[] chld = null;

			if (tn.Tag is ROFSTLookup.rodbi)
			{
				ROFSTLookup.rodbi db = (ROFSTLookup.rodbi)tn.Tag;

				//Try to lazy load the children - B2022-026 RO Memory Reduction code
				if (db.children == null || db.children.Length <= 0)
					db.children = MyROFSTLookup.GetRoChildrenByID(db.ID, db.dbiID, true);

				chld = db.children;
			}
			else if (tn.Tag is ROFSTLookup.rochild)
			{
				ROFSTLookup.rochild ch = (ROFSTLookup.rochild)tn.Tag;

				//Try to lazy load the children - B2022-026 RO Memory Reduction code
				if (ch.children == null || ch.children.Length <= 0)
					ch.children = MyROFSTLookup.GetRoChildrenByRoid(ch.roid, true);

				chld = ch.children;
			}
			else
			{
				Console.WriteLine("error - no type");
				return;
			}

			// if children, add dummy node
			// B2022-026 RO Memory Reduction code - check child length
			if (chld != null && chld.Length > 0)
			{
				//ProgressBar_Initialize(chld.Length, tn.Text);
				for (int i = 0; i < chld.Length; i++)
				{
					//ProgressBar_SetValue(i);
					DevComponents.AdvTree.Node tmp = null;

					// Try to Lazy Load children - B2022-026 RO Memory Reduction code
					if (chld[i].children == null || chld[i].children.Length <= 0)
						chld[i].children = MyROFSTLookup.GetRoChildrenByRoid(chld[i].roid, true);

					// if this is a group, i.e. type 0, add a dummy node
					if (chld[i].type == 0 && chld[i].children == null)
					{
						// Ignore: Junk Scenario
						continue;
					}
					// B2023-094: don't crash if chld[i].children count is 0, signals an empty group
					else if (chld[i].value == null && (cbxROUsage.Checked || (chld[i].children != null && chld[i].children.Length > 0 && chld[i].children[0].ParentID != 0)))
					{
						tmp = new DevComponents.AdvTree.Node();
						tmp.Text = chld[i].title;
						tmp.Tag = chld[i];
						tmp.CheckBoxVisible = true;
						int index = FindIndex(tn.Nodes, tmp.Text);
						tn.Nodes.Insert(index, tmp);
						DevComponents.AdvTree.Node sub = new DevComponents.AdvTree.Node();
						sub.Text = DummyNodeText;
						tmp.Nodes.Add(sub);
					}
					else
					{
						tmp = new DevComponents.AdvTree.Node();
						tmp.Text = chld[i].title;
						tmp.Tag = chld[i];
						tmp.CheckBoxVisible = true;
						int index = FindIndex(tn.Nodes, tmp.Text);
						tn.Nodes.Insert(index, tmp);
					}
				}
			}
		}

		private void advTreeRO_AfterExpandorCollapse(object sender, AdvTreeNodeEventArgs e)
		{
			Node bottomNode = BottomTreeNode(advTreeRO.Nodes);
			Node lastNode = advTreeRO.Nodes[advTreeRO.Nodes.Count - 1];

			int top = advTreeRO.Nodes[0].Bounds.Top;
			int bottom = bottomNode.Bounds.Bottom + 5;
			int hScrollBarHeight = advTreeRO.HScrollBar != null ? advTreeRO.HScrollBar.Height : 0;
			bottom = bottomNode.Bounds.Bottom + 5;
			advTreeRO.Size = new Size(advTreeRO.Size.Width, Math.Min(525, bottom - top + hScrollBarHeight));

			if (advTreeRO.VScrollBar != null && bottom < advTreeRO.Size.Height)
			{
				int yLookFor = (bottom - advTreeRO.Size.Height) + 2 * hScrollBarHeight;
				Node topNode = FindTreeNodeAt(advTreeRO.Nodes, yLookFor);

				if (topNode != null)
					topNode.EnsureVisible();
			}
		}

		private Node FindTreeNodeAt(NodeCollection nodes, int y)
		{
			foreach (Node node in nodes)
			{
				if (node.Bounds.Top <= y && node.Bounds.Bottom >= y)
					return node;

				if (node.Bounds.Top > y)
				{
					if (node.PrevNode != null && node.PrevNode.Expanded)
						return FindTreeNodeAt(node.PrevNode.Nodes, y);

					return node;
				}
			}
			return null;
		}

		private Node BottomTreeNode(NodeCollection nodes)
		{
			Node bottomNode = nodes[nodes.Count - 1]; // Return bottom node in collection

			if (bottomNode.Expanded) // If expanded return bottom child
				return BottomTreeNode(bottomNode.Nodes);

			return bottomNode;
		}

		private int FindIndex(NodeCollection nodes, string value)
		{
			int index = 0;
			foreach (Node node in nodes)
			{
				if (GreaterValue(node.Text, value)) return index;
				index++;
			}
			return index;
		}

		private bool GreaterValue(string value1, string value2)
		{
			return DisplayRO.GreaterValue(value1, value2);
		}

		#endregion

		#endregion
	}

	#region DisplayReportsEventArgs Class

	public class DisplayReportsEventArgs
	{
		#region Fields

		private string _ReportTitle;
		private string _TypesSelected;
		private ICollection<ItemInfo> _MyItemInfoList;
		private bool _SortUsageByProcedure;
		private string _RODataFile = "";
		private bool _CompleteROReport = true;
		private ROFSTLookup _rofstLookup;
		private List<string> _ROListForReport;
		private bool _IncludeMissingROs = true;
		private bool _ConvertCaretToDelta = true;
		private bool _IncludeEmptyROFields = true;
		private string _PaperSize = "Letter";

		#endregion

		#region Properties

		public string ReportTitle
		{
			get { return _ReportTitle; }
			set { _ReportTitle = value; }
		}

		public string TypesSelected
		{
			get { return _TypesSelected; }
			set { _TypesSelected = value; }
		}

		public ICollection<ItemInfo> MyItemInfoList
		{
			get { return _MyItemInfoList; }
			set { _MyItemInfoList = value; }
		}

		public bool SortUsageByProcedure
		{
			get { return _SortUsageByProcedure; }
			set { _SortUsageByProcedure = value; }
		}

		public string RODataFile
		{
			get { return _RODataFile; }
			set { _RODataFile = value; }
		}

		public bool CompleteROReport
		{
			get { return _CompleteROReport; }
			set { _CompleteROReport = value; }
		}

		public ROFSTLookup RofstLookup
		{
			get { return _rofstLookup; }
			set { _rofstLookup = value; }
		}

		public List<string> ROListForReport
		{
			get { return _ROListForReport; }
			set { _ROListForReport = value; }
		}

		public bool IncludeMissingROs
		{
			get { return _IncludeMissingROs; }
			set { _IncludeMissingROs = value; }
		}

		public bool ConvertCaretToDelta
		{
			get { return _ConvertCaretToDelta; }
			set { _ConvertCaretToDelta = value; }
		}

		public bool IncludeEmptyROFields
		{
			get { return _IncludeEmptyROFields; }
			set { _IncludeEmptyROFields = value; }
		}

		public string PaperSize // C2020-002 paper size is now set in the format files
		{
			get { return _PaperSize; }
			set { _PaperSize = value; }
		}

		#endregion

		#region Constructors

		/// <summary>
		/// RO Usage Report
		/// </summary>
		/// <param name="reportTitle"></param>
		/// <param name="typesSelected"></param>
		/// <param name="myItemInfoList"></param>
		/// <param name="sortByProcedure"></param>
		/// <param name="includeMissingROs"></param>
		/// <param name="paperSize"></param>
		public DisplayReportsEventArgs(string reportTitle, string typesSelected, ICollection<ItemInfo> myItemInfoList, bool sortByProcedure, bool includeMissingROs, string paperSize)
		{
			_ReportTitle = reportTitle;
			_TypesSelected = typesSelected;
			_MyItemInfoList = myItemInfoList;
			_SortUsageByProcedure = sortByProcedure;
			_IncludeMissingROs = includeMissingROs;
			_PaperSize = paperSize; // C2020-002 paper size is now set in the format files
		}

		/// <summary>
		/// RO Complete
		/// </summary>
		/// <param name="reportTitle"></param>
		/// <param name="typesSelected"></param>
		/// <param name="roDataFile"></param>
		/// <param name="rofstLookUp"></param>
		/// <param name="completeROReport"></param>
		/// <param name="convertCaretToDelta"></param>
		/// <param name="includeEmptyROFields"></param>
		/// <param name="paperSize"></param>
		public DisplayReportsEventArgs(string reportTitle, string typesSelected, string roDataFile, ROFSTLookup rofstLookUp, bool completeROReport, bool convertCaretToDelta, bool includeEmptyROFields, string paperSize)
		{
			_ReportTitle = reportTitle;
			_TypesSelected = typesSelected;
			_RODataFile = roDataFile;
			_CompleteROReport = completeROReport;
			_ConvertCaretToDelta = convertCaretToDelta;
			_rofstLookup = rofstLookUp;
			_IncludeEmptyROFields = includeEmptyROFields;
			_PaperSize = paperSize; // C2020-002 paper size is now set in the format files
		}

		/// <summary>
		/// RO Summary Report
		/// </summary>
		/// <param name="reportTitle"></param>
		/// <param name="typesSelected"></param>
		/// <param name="rofstLookUp"></param>
		/// <param name="roListForReport"></param>
		/// <param name="paperSize"></param>
		public DisplayReportsEventArgs(string reportTitle, string typesSelected, ROFSTLookup rofstLookUp, List<string> roListForReport, string paperSize)
		{
			_ReportTitle = reportTitle;
			_TypesSelected = typesSelected;
			_rofstLookup = rofstLookUp;
			_ROListForReport = roListForReport;
			_PaperSize = paperSize; // C2020-002 paper size is now set in the format files
		}

		#endregion
	}

	#endregion

	public delegate void DisplayReportsEvent(object sender, DisplayReportsEventArgs args);

	#region AlphanumComparatorFast Class

	public class AlphanumComparatorFast : IComparer<string>
	{
		#region Public Methods
		
		public List<string> GetList(string s1)
		{
			List<string> SB1 = new List<string>();
			string st1, st2, st3;
			st1 = "";
			bool flag = char.IsDigit(s1[0]);

			foreach (char c in s1)
			{
				if (flag != char.IsDigit(c) || !(char.IsDigit(c) || char.IsLetter(c)))// || c == '\'')
				{
					if (st1 != "")
						SB1.Add(st1);
					st1 = "";
					flag = char.IsDigit(c);
				}
				if (char.IsDigit(c))
				{
					st1 += c;
				}
				if (char.IsLetter(c))
				{
					st1 += c;
				}
			}
			SB1.Add(st1);
			return SB1;
		}

		public int Compare(string x, string y)
		{
			string s1 = x;// as string;
			if (s1 == null)
			{
				return 0;
			}
			string s2 = y;// as string;
			if (s2 == null)
			{
				return 0;
			}
			if (s1 == s2)
			{
				return 0;
			}
			int len1 = s1.Length;
			int len2 = s2.Length;
			int marker1 = 0;
			int marker2 = 0;

			// Walk through two the strings with two markers.
			List<string> str1 = GetList(s1);
			List<string> str2 = GetList(s2);
			while (str1.Count != str2.Count)
			{
				if (str1.Count < str2.Count)
				{
					str1.Add("");
				}
				else
				{
					str2.Add("");
				}
			}
			int x1 = 0; int res = 0; int x2 = 0; string y2 = "";
			bool status = false;
			string y1 = ""; bool s1Status = false; bool s2Status = false;
			//s1status ==false then string ele int;
			//s2status ==false then string ele int;
			int result = 0;
			for (int i = 0; i < str1.Count && i < str2.Count; i++)
			{
				status = int.TryParse(str1[i].ToString(), out res);
				if (res == 0)
				{
					y1 = str1[i].ToString();
					s1Status = false;
				}
				else
				{
					x1 = Convert.ToInt32(str1[i].ToString());
					s1Status = true;
				}

				status = int.TryParse(str2[i].ToString(), out res);
				if (res == 0)
				{
					y2 = str2[i].ToString();
					s2Status = false;
				}
				else
				{
					x2 = Convert.ToInt32(str2[i].ToString());
					s2Status = true;
				}
				//checking --the data comparision
				if (!s2Status && !s1Status)    //both are strings
				{
					result = str1[i].CompareTo(str2[i]);
				}
				else if (s2Status && s1Status) //both are intergers
				{
					if (x1 == x2)
					{
						if (str1[i].ToString().Length < str2[i].ToString().Length)
						{
							result = 1;
						}
						else if (str1[i].ToString().Length > str2[i].ToString().Length)
							result = -1;
						else
							result = 0;
					}
					else
					{
						int st1ZeroCount = str1[i].ToString().Trim().Length - str1[i].ToString().TrimStart(new char[] { '0' }).Length;
						int st2ZeroCount = str2[i].ToString().Trim().Length - str2[i].ToString().TrimStart(new char[] { '0' }).Length;
						if (st1ZeroCount > st2ZeroCount)
							result = -1;
						else if (st1ZeroCount < st2ZeroCount)
							result = 1;
						else
							result = x1.CompareTo(x2);

					}
				}
				else
				{
					result = str1[i].CompareTo(str2[i]);
				}
				if (result == 0)
				{
					continue;
				}
				else
					break;

			}
			return result;
		}

		#endregion
	}

	#endregion
}