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 Events
		public event DisplayReportsEvent PrintRequest;
		private void OnPrintRequest(DisplayReportsEventArgs args)
		{
			if (PrintRequest != null)
				PrintRequest(this, args);
		}
		#endregion
		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 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 "";
			}
		}
		private DocVersionInfo _MyDocVersion;
		public DocVersionInfo Mydocversion
		{
			get { return _MyDocVersion; }
			set
			{
				_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;
					}
				}
			}
		}
		private ROFSTLookup _MyROFSTLookup;
		public ROFSTLookup MyROFSTLookup
		{
			get { return _MyROFSTLookup; }
			set
			{
				//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();
			}
		}

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

		private Dictionary<string, string> AccIDROIDdic = new Dictionary<string, string>();

		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())
					{
						rtnStr = _MyRODbID.ToString() + ":" + string.Format("{0}", rodbi.dbiID.ToString("X4"));
						//ROList.Add(rtnStr);
						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)
				{
					//rtnStr = _MyRODbID.ToString() + ":" + string.Format("{0}", ((ROFSTLookup.rodbi)rolkup).dbiID.ToString("X4"));
					ROFSTLookup.rodbi rodbi = (ROFSTLookup.rodbi)rolkup;
					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;
					//rtnStr = _MyRODbID.ToString() + ":" + GetROChildren(rolkup).TrimEnd(',');
					PutROChildrenInDictionary(_MyRODbID.ToString() + ":", rolkup);
				}
				//else if (rolkup is ROFSTLookup.rogrp)
				//    Console.WriteLine("RO Group");
				//else if (rolkup is ROFSTLookup.roHdr)
				//    Console.WriteLine("RO Header");
				//ROList.Add(rtnStr);
			}
			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]);
		}
		static int blankKeyCnt = 0;
		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);
			if (chld.children == null) // 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
				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 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
					if (roc.children != null && (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);
						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
				{
					foreach (ROFSTLookup.rodbi rodbi in _MyROFSTLookup.GetRODatabaseList())
					{
						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;
					chld = ch.children;
					rtnStr = _MyRODbID.ToString() + ":" + GetROChildren(rolkup).TrimEnd(',');
				}
				//else if (rolkup is ROFSTLookup.rogrp)
				//    Console.WriteLine("RO Group");
				//else if (rolkup is ROFSTLookup.roHdr)
				//    Console.WriteLine("RO Header");
				ROList.Add(rtnStr);
			}
		}

		// same function as GetROsToSearch in DisplaySearch.cs
		private string GetROChildren(object roObj)
		{
			ROFSTLookup.rochild chld = (ROFSTLookup.rochild)roObj;
			string rtnstr = "";
			if (chld.children == null) // 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
					if (roc.children != null && (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;
		}
		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;
		}

		public void SelectReferencedObjectTab()
		{
			tabROReports.PerformClick();
		}

		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();
		}
		#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;
		}


		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.ChildFolders)
			{
				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 = "VLN_DUMMY";
					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
		}
		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, load children
			DevComponents.AdvTree.Node tn = null;
			if (par.Nodes.Count > 0) tn = par.Nodes[0];
			if (tn.Text == "VLN_DUMMY")		// 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.ChildFolders)
					{
						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 = "VLN_DUMMY";
							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
		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);

			for (int i = 0; i < _MyROFSTLookup.myHdr.myDbs.Length; i++)
			{
				DevComponents.AdvTree.Node tn = new DevComponents.AdvTree.Node();
				tn.Text = _MyROFSTLookup.myHdr.myDbs[i].dbiTitle;
				tn.Tag = _MyROFSTLookup.myHdr.myDbs[i];
				tn.CheckBoxVisible = true;
				topnode.Nodes.Add(tn);
				AddDummyGroup(_MyROFSTLookup.myHdr.myDbs[i], tn);
			}


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

			//    cntnd++;
			//    if (fic.ChildFolderCount > 0 || fic.FolderDocVersionCount > 0)		// allow for '+' for tree expansion
			//    {
			//        DevComponents.AdvTree.Node tnt = new DevComponents.AdvTree.Node();
			//        tnt.Text = "VLN_DUMMY";
			//        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
		}

		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 = "VLN_DUMMY_FOR_TREE";
				tn.Nodes.Add(tmp);
			}
		}
		private void advTreeRO_BeforeExpand(object sender, DevComponents.AdvTree.AdvTreeNodeCancelEventArgs e)
		{
			LoadChildren(e.Node);
		}

		private void LoadChildren(DevComponents.AdvTree.Node tn)
		{
			object tag = tn.Tag;
			if (tn.HasChildNodes && tn.Nodes[0].Text != "VLN_DUMMY_FOR_TREE") return;  // already loaded.
			if (tn.HasChildNodes && tn.Nodes[0].Text == "VLN_DUMMY_FOR_TREE") tn.Nodes[0].Remove();
			ROFSTLookup.rochild[] chld = null;

			if (tn.Tag is ROFSTLookup.rodbi)
			{
				ROFSTLookup.rodbi db = (ROFSTLookup.rodbi)tn.Tag;
				chld = db.children;
			}
			else if (tn.Tag is ROFSTLookup.rochild)
			{
				ROFSTLookup.rochild ch = (ROFSTLookup.rochild)tn.Tag;
				chld = ch.children;
			}
			else
			{
				Console.WriteLine("error - no type");
				return;
			}
			// if children, add dummy node
			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;
					// if this is a group, i.e. type 0, add a dummy node
					if (chld[i].type == 0 && chld[i].children == null)
						//skip it.
						// TODO: KBR how to handle this?
						//Console.WriteLine("ro junk");
						continue;
					else if (chld[i].value == null && (cbxROUsage.Checked || 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 = "VLN_DUMMY_FOR_TREE";
						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);
					}
				}
			}
			//ProgressBar_Clear();
		}
		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 static Regex _RegExGetNumber = new Regex(@"^ *[+-]?[.,0-9]+(E[+-]?[0-9]+)?");
		private bool GreaterValue(string value1, string value2)
		{
			return DisplayRO.GreaterValue(value1, value2);
			//  Match match1 = _RegExGetNumber.Match(value1);
			//  Match match2 = _RegExGetNumber.Match(value2);
			//  if (match1.Success && match2.Success) // Compare the numeric value
			//  {
			//    double dbl1 = double.Parse(match1.ToString());
			//    double dbl2 = double.Parse(match2.ToString());
			//    return dbl1 > dbl2;
			//  }
			//  return String.Compare(value1, value2, true) > 0;
		}


		#endregion

		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 + "\"";
				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 indefinately
				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)
		{
			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));
			}
			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);
				OnPrintRequest(new DisplayReportsEventArgs("Complete RO Report", "Complete RO Report", roDataFile, MyROFSTLookup, cbxComplete.Checked, this.Mydocversion.ActiveFormat.PlantFormat.FormatData.SectData.ConvertCaretToDelta, cbxIncldMissingROs.Checked));
			}
			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, "");
				if (!usageSortedByProcedure) // sort on ROs
				{
					Csla.SortedBindingList<ItemInfo> sortedResults = new Csla.SortedBindingList<ItemInfo>(SearchResults);
					sortedResults.ApplySort("FoundROID", ListSortDirection.Ascending);
					OnPrintRequest(new DisplayReportsEventArgs("Referenced Objects Usage By RO", "RO Usage", sortedResults, usageSortedByProcedure, cbxIncldMissingROs.Checked));
				}
				else
					OnPrintRequest(new DisplayReportsEventArgs("Referenced Objects Usage By Procedure", "RO Usage", SearchResults, usageSortedByProcedure, cbxIncldMissingROs.Checked));
			}
			else if (cbxTransFromProcs.Checked)
			{
			}
			else if (cbxTransToProcs.Checked)
			{
			}
			Cursor = curcur;
		}

	}
	public class DisplayReportsEventArgs
	{
		private string _ReportTitle;
		public string ReportTitle
		{
			get { return _ReportTitle; }
			set { _ReportTitle = value; }
		}
		private string _TypesSelected;
		public string TypesSelected
		{
			get { return _TypesSelected; }
			set { _TypesSelected = value; }
		}
		private ICollection<ItemInfo> _MyItemInfoList;
		public ICollection<ItemInfo> MyItemInfoList
		{
			get { return _MyItemInfoList; }
			set { _MyItemInfoList = value; }
		}
		private bool _SortUsageByProcedure;
		public bool SortUsageByProcedure
		{
			get { return _SortUsageByProcedure; }
			set { _SortUsageByProcedure = value; }
		}
		private string _RODataFile = "";
		public string RODataFile
		{
			get { return _RODataFile; }
			set { _RODataFile = value; }
		}
		private bool _CompleteROReport = true;
		public bool CompleteROReport
		{
			get { return _CompleteROReport; }
			set { _CompleteROReport = value; }
		}
		private ROFSTLookup _rofstLookup;
		public ROFSTLookup RofstLookup
		{
			get { return _rofstLookup; }
			set { _rofstLookup = value; }
		}
		private List<string> _ROListForReport;

		public List<string> ROListForReport
		{
			get { return _ROListForReport; }
			set { _ROListForReport = value; }
		}
		private bool _IncludeMissingROs = true;

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

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

		public bool IncludeEmptyROFields
		{
			get { return _IncludeEmptyROFields; }
			set { _IncludeEmptyROFields = value; }
		}
		public DisplayReportsEventArgs(string reportTitle, string typesSelected, ICollection<ItemInfo> myItemInfoList, bool sortByProcedure, bool includeMissingROs)
		{
			// RO Usage Report
			_ReportTitle = reportTitle;
			_TypesSelected = typesSelected;
			_MyItemInfoList = myItemInfoList;
			_SortUsageByProcedure = sortByProcedure;
			_IncludeMissingROs = includeMissingROs;

		}
		public DisplayReportsEventArgs(string reportTitle, string typesSelected, string roDataFile, ROFSTLookup rofstLookUp, bool completeROReport, bool convertCaretToDelta, bool includeEmptyROFields)
		{
			_ReportTitle = reportTitle;
			_TypesSelected = typesSelected;
			_RODataFile = roDataFile;
			_CompleteROReport = completeROReport;
			_ConvertCaretToDelta = convertCaretToDelta;
			_rofstLookup = rofstLookUp;
			_IncludeEmptyROFields = includeEmptyROFields;
		}
		public DisplayReportsEventArgs(string reportTitle, string typesSelected, ROFSTLookup rofstLookUp, List<string> roListForReport)
		{
			// RO Summary Report
			_ReportTitle = reportTitle;
			_TypesSelected = typesSelected;
			_rofstLookup = rofstLookUp;
			_ROListForReport = roListForReport;
		}
	}
	public delegate void DisplayReportsEvent(object sender, DisplayReportsEventArgs args);
	public class AlphanumComparatorFast : IComparer<string>
	{
		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;
		}

		// sample usage
		//            List<string> marks = new List<string>();
		//            marks.Add("M'00Z1");
		//            marks.Add("M'0A27");
		//            marks.Add("M'00Z0");
		//            marks.Add("0000A27");
		//            marks.Add("100Z0");

		//string[] Markings = marks.ToArray();

		//            Array.Sort(Markings, new AlphanumComparatorFast());
	}


}