using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Text.RegularExpressions;
using System.Data;
using System.Data.SqlClient;
using System.Linq;

using Csla.Data;
using System.Threading;
using System.Threading.Tasks;

namespace VEPROMS.CSLA.Library
{

	[Flags]
	public enum E_ROValueType : uint
	{
		All = 0,
		Text = 1,
		Table = 2,
		Graph = 4,
		Image = 8,
		Video = 16,
		Hologram = 32
	}

	[Serializable]
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class ROFSTLookup
	{
		#region Log4Net

		private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

		#endregion

		#region Enums

		[Flags]
		public enum SearchTypes
		{
			StartsWith = 1,
			EndsWith = 2,
			Contains = 3,
			ExactMatch = 4
		}

		public enum HeaderStatuses
		{
			Unknown = 0,
			NotLoaded = 1,
			InProgress = 2,
			LoadComplete = 3,
			LoadFailed = 4
		}

		#endregion

		#region Structs / Internal Classes

		[Serializable]
		public struct roHdr
		{
			public int hSize;
			public int hYear;
			public byte hMonth;
			public byte hDay;
			public int hcYear;
			public byte hcMonth;
			public byte hcDay;
			public byte hcHour;
			public byte hcMin;
			public byte hcSec;
			public byte hcHund;
			public rodbi[] myDbs;
		};

		[Serializable]
		public struct rodbi
		{
			public int dbiID;
			public int dbiType;
			public int dbiAW;
			public string dbiTitle;
			public string dbiAP;
			public int ID;
			public int ParentID;
			public rochild[] children;
		};

		[Serializable]
		public struct rogrp
		{
			public string value;
			public string appid;
			public int ID;
			public int ParentID;
			public rochild[] children;
		};

		[Serializable]
		public struct rochild
		{
			public int ID;
			public int ParentID;
			public int type;
			public string title;		// gets used for treeview
			public string roid;			// roid unique identifier
			public string appid;		// accessory page id - user specified unique id
			public string value;		// return value, can be multiple values
			public rochild[] children;
		};


		public class roChild
		{
			//private static int _roChildUnique = 0;
			//private static int roChildUnique
			//{ get { return ++_roChildUnique; } }
			//private int _MyRoChildUnique = roChildUnique;
			//public int MyRoChildUnique // Absolutely Unique ID - Info
			//{ get { return _MyRoChildUnique; } }
			rochild _MyChild;
			public rochild MyChild
			{
				get { return _MyChild; }
				set { _MyChild = value; }
			}
			public roChild(rochild myChild)
			{
				_MyChild = myChild;
			}
			public override string ToString()
			{
				return _MyChild.title.Replace("\\u160?", " ");
			}
		};


		#endregion

		#region Fields

		public static Regex regRoKeyHigh = new Regex("( |-|_)(HIGH|HI)([0-9])");
		public static Regex regRoKeyLow = new Regex("( |-|_)(LOW|LO)([0-9])");

		// RofstLookup/Conversion Variables
		private int _rofstID;
		private DocVersionInfo _myDocVersionInfo;
		private int _selectedSlave;
		private string _otherChild = string.Empty;

		private List<string> _lstRoValues;
		private List<string> _multiRoValues;
		private Dictionary<string, string> _dicRoVars;

		private ItemInfo _itemInfo;

		#endregion

		#region Properties

		public int RofstID
		{
			get { return _rofstID; }
		}

		public DocVersionInfo MyDocVersionInfo
		{
			get { return _myDocVersionInfo; }
			set
			{
				_myDocVersionInfo = value;
				_selectedSlave = (_myDocVersionInfo == null) ? 0 : _myDocVersionInfo.DocVersionConfig.SelectedSlave;
			}
		}

		// C2021-065 see if we need to get the RO information for the "Other" Child applicability value
		public int SelectedSlave
		{
			get { return (!string.IsNullOrEmpty(_otherChild)) ? Convert.ToInt32(_otherChild) : _selectedSlave; }
		}

		//C2021-065 used by Barakah Alarms so that we get ROLookUp for the Other applicability
		public string OtherChild
		{
			get { return _otherChild; }
			set { _otherChild = value; }
		}

		// B2022-020 to pass information into error log if needed
		public ItemInfo MyItemInfo
		{
			get { return _itemInfo; }
			set { _itemInfo = value; }
		}

		#endregion

		#region Constructors

		public ROFSTLookup(int rofstID, DocVersionInfo dvi, string otherChild)
		{
			_rofstID = rofstID;
			MyDocVersionInfo = dvi;
			_otherChild = otherChild;

			if (!RofstDataExists(rofstID))
			{
				Load(rofstID);
			}
		}

		public ROFSTLookup(int rofstID, DocVersionInfo dvi)
		{
			_rofstID = rofstID;
			MyDocVersionInfo = dvi;

			if (!RofstDataExists(rofstID))
			{
				Load(rofstID);
			}
		}

		public ROFSTLookup(int rofstID)
		{
			_rofstID = rofstID;
			MyDocVersionInfo = null;

			if (!RofstDataExists(rofstID))
			{
				Load(rofstID);
			}
		}

		#endregion

		#region Public Methods

		#region (RO Info)

		public bool HasChildren(ref ROFSTLookup.rochild child)
		{
			LoadChildren(ref child);
			return child.children.Any();
		}

		public bool HasChildren(ref ROFSTLookup.rodbi db)
		{
			LoadChildren(ref db);
			return db.children.Any();
		}

		public void LoadChildren(ref ROFSTLookup.rochild child)
		{
			// If Children is null then it hasn't been loaded yet
			if (child.children == null || child.children.Length <= 0)
			{
				if (!string.IsNullOrEmpty(child.appid))
					child = GetRoChild12(child.roid, true);
				else
					child.children = GetRoChildrenByRoid(child.roid, true);
			}
		}

		public void LoadChildren(ref ROFSTLookup.rodbi db)
		{
			// If Children is null then it hasn't been loaded yet
			if (db.children == null || db.children.Length <= 0)
				db.children = GetRoChildrenByID(db.ID, db.dbiID, true);
		}



		public ROFSTLookup.rochild GetRoChild(string ROID, bool loadChildren = false, bool loadAllChildren = false)
		{
			ROFSTLookup.rochild rc = new ROFSTLookup.rochild() { ID = -1 };

			if (ROID.StartsWith("FFFF"))
			{
				rc.ID = 0;
				rc.ParentID = 0;
				rc.roid = ROID;
				rc.type = 1;
				rc.value = GetRoValue(ROID);

				if (ROID == "FFFF00000001") rc.appid = "U-Number";
				else if (ROID == "FFFF00000002") rc.appid = "U-Other Number";
				else if (ROID == "FFFF00000003") rc.appid = "U-Text";
				else if (ROID == "FFFF00000004") rc.appid = "U-Other Text";
				else if (ROID == "FFFF00000005") rc.appid = "U-ID";
				else if (ROID == "FFFF00000006") rc.appid = "U-Other ID";
				else if (ROID == "FFFF00000007") rc.appid = "U-Name";
				else if (ROID == "FFFF00000008") rc.appid = "U-Other Name";
				else rc.appid = "U-Unknown";
			}
			else
			{
				rc = GetRoChild12(ROID, loadChildren, loadAllChildren);

				if (rc.children != null && rc.children.Length > 0)
				{
					foreach (ROFSTLookup.rochild c in rc.children)
					{
						if (c.roid.ToUpper() == ROID.ToUpper())
						{
							return c;
						}
					}
				}
			}

			return rc;
		}

		public string GetRoValue(string ROID16)
		{
			// This only gets rochild values, not groups
			string ROID = ROID16.Substring(0, 12);

			if (ROID.StartsWith("FFFF"))
			{
				DocVersionConfig dvc = _myDocVersionInfo.DocVersionConfig;

				if (ROID == "FFFF00000001") return dvc.Unit_Number;
				if (ROID == "FFFF00000002") return dvc.Other_Unit_Number;
				if (ROID == "FFFF00000003") return dvc.Unit_Text;
				if (ROID == "FFFF00000004") return dvc.Other_Unit_Text;
				if (ROID == "FFFF00000005") return dvc.Unit_ID;
				if (ROID == "FFFF00000006") return dvc.Other_Unit_ID;
				if (ROID == "FFFF00000007") return dvc.Unit_Name;
				if (ROID == "FFFF00000008") return dvc.Other_Unit_Name;

			}

			ROFSTLookup.rochild rc = GetRoChild12(ROID);

			if (rc.ID > 0)
			{
				if (!string.IsNullOrEmpty(rc.value))
				{
					return FixUnitROs(GetParentChildROValue(rc));
				}

				if (rc.children != null && rc.children.Length > 0)
				{
					foreach (ROFSTLookup.rochild c in rc.children)
					{
						if (c.roid.ToUpper() == ROID16.ToUpper() || (c.roid.EndsWith("0041") && ROID16.EndsWith("0000")))
						{
							return FixUnitROs(GetParentChildROValue(c) ?? "?");
						}
					}

					// if there isn't a specific match for multi-return values, default to the first child. 
					return FixUnitROs(GetParentChildROValue(rc.children[0]) ?? "?");
				}
			}

			return "?"; 
		}

		public string GetParentChildROValue(ROFSTLookup.rochild roc)
		{
			// C2021-026 Get the child RO value if it exists, otherwise to the default (parent) RO value
			// C2022-001 new logic to handle new format of Parent/Child RO.FST
			//           The RO.FST will not have a specific child value if that child value is the same as the default value

			string roval = roc.value;

			// B2021-093 Don't look for child RO values if "roval" is null
			if (roval == null) return null;

			// B2022-020 remove a un-needed question mark that was in the search criteria "(<APL [^<]+) /APL>"
			// B2022-050 change the search string from "(<APL [^<]+) /APL>" to "<APL .*? /APL>" to handle when RO values have less then sign
			MatchCollection mm = Regex.Matches(roval, "<APL .*? /APL>");

			// C2022-014 commented write to error log. Keep for debugging purposes.
			//if (mm.Count == 0) // B2022-020 will now write in error log if there is a problem
			//	_MyLog.WarnFormat("Parent/Child Values not parsable for <APL ... /APL>\r\nItemId={0}\r\nROValue={1} ",MyDocVersionInfo.ItemID,roval);

			StringBuilder sb = new StringBuilder();
			int lastIndex = 0;

			// Get selected child Idx
			int selChldIdx = this.SelectedSlave;

			// Get Selected Child Value
			foreach (Match m in mm)
			{
				sb.Append(roval.Substring(lastIndex, m.Index - lastIndex));

				string aplString = m.Value;
				string chldValStr = string.Format("UnitIdx={0} Value=", selChldIdx);
				int offsetIdx = aplString.IndexOf(chldValStr);
				int nextIDX = -1;

				if (offsetIdx == -1)
				{
					offsetIdx = aplString.IndexOf("DefaultVal=") + 11;
				}
				else
				{
					offsetIdx += chldValStr.Length;
				}

				nextIDX = aplString.IndexOf(",UnitIdx", offsetIdx);
				if (nextIDX == -1) nextIDX = aplString.IndexOf(" /APL>");
				sb.Append(aplString.Substring(offsetIdx, nextIDX - offsetIdx));

				lastIndex = m.Index + m.Length;
			}

			// B2022-018 append any remaining text
			if (lastIndex < roval.Length)
			{
				sb.Append(roval.Substring(lastIndex));
			}

			return sb.ToString();
		}

		public string GetTranslatedRoValue(string ROID16, bool DoCaret, bool DoDOSSuperSubScript)
		{
			string retval = GetRoValue(ROID16);
			retval = ReplaceUnicode(retval, DoCaret);
			retval = ConvertFortranFormatToScienctificNotation(retval);

			// B2019-037 handle the super an sub scripts after getting the RO value from the FST
			//           the corrected RO text is added to the display text in the link info
			if (DoDOSSuperSubScript)
			{
				retval = Regex.Replace(retval, "[#](.*?)[#]", "\\up2 $1\\up0 ");//  Superscript
				retval = Regex.Replace(retval, "[~](.*?)[~]", "\\dn2 $1\\up0 ");//  Subscript
			}

			return retval.Replace("\r\n", @"\par ");
		}




		public Dictionary<string, string> Search(string value, int searchTypeID, int? maxNumRecords = null)
		{
			if (string.IsNullOrEmpty(value))
				return null;

			return RofstDataSearch(_rofstID, value, searchTypeID, maxNumRecords);
		}

		public ROFSTLookup.rochild[] GetRoChildrenByID(int id, int dbiID, bool loadChildren = false, bool loadAllChildren = false)
		{
			return RofstDataGetChildrenByID(_rofstID, dbiID, id, loadChildren, loadAllChildren);
		}

		public ROFSTLookup.rochild[] GetRoChildrenByRoid(string roid, bool loadChildren = false, bool loadAllChildren = false)
		{
			return RofstDataGetChildrenByRoid(_rofstID, roid, loadChildren, loadAllChildren);
		}

		public ROFSTLookup.rochild[] GetRoChildrenByType(E_ROValueType valueTypes, bool loadChildren = false, bool loadAllChildren = false)
		{
			return RofstDataGetRoChildrenByType(_rofstID, valueTypes, loadChildren, loadAllChildren);
		}

		public List<string> GetValueDifferences(int originalRofstID, ref List<string> delList)
		{
			return RofstDataGetValueDifferences(originalRofstID, _rofstID, ref delList);
		}

		public List<string> GetROTitleAndGroupPath(string ROID, bool reportMissingROs, bool convertCaretToDelta)
		{
			// Return the RO Title in a list of strings.  The last item in the list is the actual RO title,
			// the items preceding it are the titles of the groups and sub-groups containing the RO

			List<string> titlePath = new List<string>();

			ROFSTLookup.rochild roc = GetRoChild12(ROID);

			if (roc.appid != null)
			{
				string tmp = roc.title;

				if (roc.appid != string.Empty && roc.title.Contains(roc.appid))
				{
					tmp = roc.title.Replace(roc.appid, "").Trim();
				}

				tmp = string.Format("[{0}] {1}", roc.appid, tmp);
				tmp = tmp.Replace("`", "\u00B0"); //degree
				tmp = tmp.Replace("\xF8", "\u00B0"); //degree
				if (convertCaretToDelta) tmp = tmp.Replace("^", "\u0394"); // delta

				titlePath.Add(tmp);

				do
				{
					string parent = ROID.Substring(0, 4) + string.Format("{0:X8}", roc.ParentID);
					roc = GetRoChild12(parent);
					if (roc.ID > 0) titlePath.Add(roc.title.Trim());

				} while (roc.ID > 0);

				titlePath.Reverse();
			}
			else if (reportMissingROs)  // Missing RO, put a message with the ROID on the report...
			{
				titlePath.Add(string.Format("Missing RO for ROID {0}", ROID));
			}

			return titlePath;
		}

		public string GetROTitle(string ROID)
		{
			StringBuilder sb = new StringBuilder();

			ROFSTLookup.rochild rc = GetRoChild12(ROID);
			if (rc.value == null) rc = GetRoChild(ROID);
			
			//  B2020-125: View of Consistency check report displaying error message and crashing. And also in 'else' check for null
			if (rc.ID == -1)
			{
				sb.Append("Could not find RO data");
			}
			else
			{
				string tmp = string.Empty;
				if (!string.IsNullOrEmpty(rc.title)) tmp = rc.title;
				if (!string.IsNullOrEmpty(rc.appid)) tmp = tmp.Replace(rc.appid, string.Empty);
				if (!string.IsNullOrEmpty(rc.value)) tmp = tmp.Replace(rc.value, string.Empty);
				sb.Append(tmp.Trim());
			}

			do
			{
				string parentROID = ROID.Substring(0, 4) + string.Format("{0:X8}", rc.ParentID);
				rc = GetRoChild12(parentROID);
				if (rc.ID > 0) sb.Insert(0, rc.title + " - ");

			} while (rc.ID > 0);

			return sb.ToString();
		}

		public DateTime GetRoFSTdts()
		{
			return GetRofstDtsByID(_rofstID);
		}

		public static byte[] GetRofstLookupBytes(int rofstID)
		{
			return RofstDataGetRofstLookupBytes(rofstID);
		}

		#endregion

		#region (RO Database Info)

		public int GetRODatabaseTitleIndex(string roid)
		{
			return Convert.ToInt32("0x" + roid.Substring(0, 4), 16);
		}

		public string GetRODatabaseTitle(int idx)
		{
			ROFSTLookup.rodbi rd = RofstDataGetDatabaseByID(_rofstID, idx);
			return (!string.IsNullOrEmpty(rd.dbiTitle) ? rd.dbiTitle : "RO Database Title Not Found");
		}

		public ROFSTLookup.rodbi GetRODatabase(string roid, bool loadChildren = false, bool loadAllChildren = false)
		{
			int idx = GetRODatabaseTitleIndex(roid);
			ROFSTLookup.rodbi rd = RofstDataGetDatabaseByID(_rofstID, idx, loadChildren, loadAllChildren);
			return (rd.dbiID > 0) ? rd : RofstDataGetDatabaseByID(_rofstID, 1, loadChildren, loadAllChildren);
		}

		public ROFSTLookup.rodbi[] GetRODatabaseList(bool loadChildren = false, bool loadAllChildren = false)
		{
			return RofstDataGetDatabases(_rofstID, loadChildren, loadAllChildren);
		}

		#endregion

		#region (RO Info By AccPageID)

		public string GetROValueByAccPagID(string accPageID, string spDefault, string igDefault)
		{
			ROFSTLookup.rochild? child = GetROChildByAccPageID(accPageID, spDefault, igDefault);
			if (child == null) return null;
			return GetParentChildROValue((ROFSTLookup.rochild)child); // C2021-026 get the P/C value if it exists, otherwise get the non-P/C value
		}

		public int? GetROTypeByAccPagID(string accPageID, string spDefault, string igDefault)
		{
			ROFSTLookup.rochild? child = GetROChildByAccPageID(accPageID, spDefault, igDefault);
			if (child == null) return null;
			return ((ROFSTLookup.rochild)child).type;
		}

		public string GetROIDByAccPagID(string accPageID, string spDefault, string igDefault)
		{
			ROFSTLookup.rochild? child = GetROChildByAccPageID(accPageID, spDefault, igDefault);
			if (child == null) return null;
			return ((ROFSTLookup.rochild)child).roid;
		}

		public ROFSTLookup.rochild? GetROChildByAccPageID(string accPageID, string spDefault, string igDefault)
		{
			ROFSTLookup.rochild? child = GetRoChildByAccPagID(accPageID, spDefault, igDefault);

			if (child == null)
			{
				if (Regex.IsMatch(accPageID, @".*\.[A-Z]"))
				{
					string accpage = accPageID.Substring(0, accPageID.Length - 3);
					int index = accPageID.Substring(accPageID.Length - 2, 1)[0] - 'A';
					child = GetRoChildByAccPagID(accpage.TrimStart("<".ToCharArray()), spDefault, igDefault);

					if (child == null) return null;

					if (((ROFSTLookup.rochild)child).children != null && ((ROFSTLookup.rochild)child).children.Length > 0 && ((ROFSTLookup.rochild)child).children.Length > index)
					{
						return ((ROFSTLookup.rochild)child).children[index];
					}
				}

				return null;
			}

			if (((ROFSTLookup.rochild)child).children != null && ((ROFSTLookup.rochild)child).children.Length > 0)
				return ((ROFSTLookup.rochild)child).children[0];

			return (ROFSTLookup.rochild)child;
		}

		public ROFSTLookup.rochild? GetRoChildByAccPagID(string accPageID, string spDefault, string igDefault)
		{
			accPageID = accPageID.Replace("<SP-", "<" + spDefault + "-");
			accPageID = accPageID.Replace("<IG-", "<" + igDefault + "-");
			accPageID = accPageID.Trim("<>".ToCharArray()); // String < and >
			string key = FormatKey(accPageID);

			ROFSTLookup.rochild rc = RofstDataGetChildByAccPageID(_rofstID, key);
			if (rc.ID > 0) return rc;

			return null;
		}

		#endregion

		#endregion

		#region Private Methods

		#region (Database Calls)

		private bool RofstDataExists(int rofstID)
		{
			int headerStatusID = RofstDataGetHeaderLoadStatus(rofstID);

			while (headerStatusID == (int)HeaderStatuses.InProgress)
			{
				// Wait 5 sec(s) then Check Header Status Again
				Thread.Sleep(5000);

				headerStatusID = RofstDataGetHeaderLoadStatus(rofstID);
			}

			return (headerStatusID == (int)HeaderStatuses.LoadComplete); // false includes [NotLoaded = 1 || LoadFailed = 4 || Unknown = 0]
		}

		private int RofstDataGetHeaderLoadStatus(int rofstID)
		{
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataGetHeaderRofstByID";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;

						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							if (dr.Read()) return Convert.ToInt32(dr.GetValue("RofstHeaderStatusID"));
						}
					}
				}

				return 0; // Unknown Status
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDataGetHeaderRofstByID", ex);
			}
		}

		private static byte[] RofstDataGetRofstLookupBytes(int rofstID)
		{
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataGetRofstByID";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@IncludeRoLookup", SqlDbType.Bit)).Value = 1;

						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							if (dr.Read()) return (byte[])dr.GetValue("ROLookup");
						}
					}
				}

				return null;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDataGetRofstByID", ex);
			}
		}

		private DateTime GetRofstDtsByID(int rofstID)
		{
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataGetRofstByID";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@IncludeRoLookup", SqlDbType.Bit)).Value = 0;

						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							if (dr.Read()) return (DateTime)dr.GetValue("DTS");
						}
					}
				}

				return new DateTime();
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDataGetRofstByID", ex);
			}
		}

		private void RofstHeaderInsert(int rofstID, int hSize, int hMonth, int hDay, int hcYear, int hcMonth, int hcDay, int hcHour, int hcMin, int hcSec, int hcHund, string userID)
		{
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstHeaderInsert";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@hSize", SqlDbType.Int)).Value = hSize;
						cmd.Parameters.Add(new SqlParameter("@hMonth", SqlDbType.Int)).Value = hMonth;
						cmd.Parameters.Add(new SqlParameter("@hDay", SqlDbType.Int)).Value = hDay;
						cmd.Parameters.Add(new SqlParameter("@hcYear", SqlDbType.Int)).Value = hcYear;
						cmd.Parameters.Add(new SqlParameter("@hcMonth", SqlDbType.Int)).Value = hcMonth;
						cmd.Parameters.Add(new SqlParameter("@hcDay", SqlDbType.Int)).Value = hcDay;
						cmd.Parameters.Add(new SqlParameter("@hcHour", SqlDbType.Int)).Value = hcHour;
						cmd.Parameters.Add(new SqlParameter("@hcMin", SqlDbType.Int)).Value = hcMin;
						cmd.Parameters.Add(new SqlParameter("@hcSec", SqlDbType.Int)).Value = hcSec;
						cmd.Parameters.Add(new SqlParameter("@hcHund", SqlDbType.Int)).Value = hcHund;
						cmd.Parameters.Add(new SqlParameter("@userID", SqlDbType.VarChar)).Value = userID;

						cmd.ExecuteNonQuery();
					}
				}
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstHeaderInsert", ex);
			}
		}

		private void RofstHeaderFinalizeLoad(int rofstID)
		{
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstHeaderFinalizeLoad";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						
						cmd.ExecuteNonQuery();
					}
				}
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstHeaderFinalizeLoad", ex);
			}
		}

		private void RofstDatabaseInsert(int rofstID, int dbiID, int dbiType, int dbiAW, string dbiTitle, string dbiAP, int id, int parentID)
		{
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDatabaseInsert";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@dbiID", SqlDbType.Int)).Value = dbiID;
						cmd.Parameters.Add(new SqlParameter("@dbiType", SqlDbType.Int)).Value = dbiType;
						cmd.Parameters.Add(new SqlParameter("@dbiAW", SqlDbType.Int)).Value = dbiAW;
						cmd.Parameters.Add(new SqlParameter("@dbiTitle", SqlDbType.VarChar)).Value = dbiTitle;
						cmd.Parameters.Add(new SqlParameter("@dbiAP", SqlDbType.VarChar)).Value = dbiAP;
						cmd.Parameters.Add(new SqlParameter("@ID", SqlDbType.Int)).Value = id;
						cmd.Parameters.Add(new SqlParameter("@ParentID", SqlDbType.Int)).Value = parentID;

						cmd.ExecuteNonQuery();
					}
				}
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDatabaseInsert", ex);
			}
		}

		private void RofstChildInsert(int rofstID, int id, int parentID, int dbiID, int type, string title, string roid, string appid, string value)
		{
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstChildInsert";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@ID", SqlDbType.Int)).Value = id;
						cmd.Parameters.Add(new SqlParameter("@ParentID", SqlDbType.Int)).Value = parentID;
						cmd.Parameters.Add(new SqlParameter("@dbiID", SqlDbType.Int)).Value = dbiID;
						cmd.Parameters.Add(new SqlParameter("@type", SqlDbType.Int)).Value = type;
						cmd.Parameters.Add(new SqlParameter("@title", SqlDbType.VarChar)).Value = title;
						cmd.Parameters.Add(new SqlParameter("@roid", SqlDbType.VarChar)).Value = roid;
							
						if (!string.IsNullOrEmpty(appid))
							cmd.Parameters.Add(new SqlParameter("@appid", SqlDbType.VarChar)).Value = appid;
						if (!string.IsNullOrEmpty(value))
							cmd.Parameters.Add(new SqlParameter("@value", SqlDbType.VarChar)).Value = value;

						cmd.ExecuteNonQuery();
					}
				}
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstChildInsert", ex);
			}
		}

		private ROFSTLookup.rodbi RofstDataGetDatabaseByID(int rofstID, int dbiID, bool loadChildren = false, bool loadAllChildren = false)
		{
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataGetDatabaseByID";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@dbiID", SqlDbType.Int)).Value = dbiID;

						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							if (dr.Read())
							{
								return ConvertToRodbiObject(dr, loadChildren, loadAllChildren);
							}
						}
					}
				}

				return new ROFSTLookup.rodbi();
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDataGetDatabaseByID", ex);
			}
		}

		private ROFSTLookup.rodbi[] RofstDataGetDatabases(int rofstID, bool loadChildren = false, bool loadAllChildren = false)
		{
			try
			{
				List<ROFSTLookup.rodbi> dbs = new List<ROFSTLookup.rodbi>();

				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataGetDatabases";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;

						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							while (dr.Read())
							{
								dbs.Add(ConvertToRodbiObject(dr, loadChildren, loadAllChildren));
							}
						}
					}
				}

				return dbs.ToArray();
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDataGetDatabases", ex);
			}
		}

		private ROFSTLookup.rochild[] RofstDataGetChildrenByID(int rofstID, int dbiID, int id, bool loadChildren = false, bool loadAllChildren = false)
		{
			try
			{
				List<ROFSTLookup.rochild> lst = new List<ROFSTLookup.rochild>();

				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataGetChildrenByID";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@DbiID", SqlDbType.Int)).Value = dbiID;
						cmd.Parameters.Add(new SqlParameter("@ID", SqlDbType.Int)).Value = id;

						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							while (dr.Read())
							{
								lst.Add(ConvertToRochildObject(dr, loadChildren, loadAllChildren));
							}
						}
					}
				}

				return lst.ToArray();
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDataGetChildrenByID", ex);
			}
		}

		private ROFSTLookup.rochild RofstDataGetChildByRoid(int rofstID, string roid, bool loadChildren = false, bool loadAllChildren = false)
		{
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataGetChildByRoid";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@Roid", SqlDbType.VarChar)).Value = roid;

						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							if (dr.Read())
							{
								return ConvertToRochildObject(dr, loadChildren, loadAllChildren);
							}
						}
					}
				}

				return new ROFSTLookup.rochild() { ID = -1 };
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDataGetChildByRoid", ex);
			}
		}

		private ROFSTLookup.rochild RofstDataGetChildByAccPageID(int rofstID, string accPageID, bool loadChildren = false, bool loadAllChildren = false)
		{
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataGetChildByAccPageID";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@AccPageID", SqlDbType.VarChar)).Value = accPageID;

						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							if (dr.Read())
							{
								return ConvertToRochildObject(dr, loadChildren, loadAllChildren);
							}
						}
					}
				}

				return new ROFSTLookup.rochild() { ID = -1 };
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDataGetChildByAccPageID", ex);
			}
		}

		private ROFSTLookup.rochild[] RofstDataGetChildrenByRoid(int rofstID, string roid, bool loadChildren = false, bool loadAllChildren = false)
		{
			try
			{
				List<ROFSTLookup.rochild> lst = new List<ROFSTLookup.rochild>();

				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataGetChildrenByRoid";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@Roid", SqlDbType.VarChar)).Value = roid;

						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							while (dr.Read())
							{
								lst.Add(ConvertToRochildObject(dr, loadChildren, loadAllChildren));
							}
						}
					}
				}

				return lst.ToArray();
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDataGetChildrenByRoid", ex);
			}
		}

		private List<string> RofstDataGetValueDifferences(int originalRofstID, int currentRofstID, ref List<string> delList)
		{
			// use this list to see what differences are between the current and the original
			List<string> modList = new List<string>();
			List<string> roidList = new List<string>();

			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataGetValueDifferences";

						cmd.Parameters.Add(new SqlParameter("@OriginalRofstID", SqlDbType.Int)).Value = originalRofstID;
						cmd.Parameters.Add(new SqlParameter("@CurrentRofstID", SqlDbType.Int)).Value = currentRofstID;

						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							while (dr.Read())
							{
								roidList.Add((string)dr.GetValue("Roid"));
							}
						}
					}
				}

				ROFSTLookup.rochild originalRoChild;
				ROFSTLookup.rochild currentRoChild;

				Dictionary<string, string> originalRos = new Dictionary<string, string>();
				Dictionary<string, string> currentRos = new Dictionary<string, string>();

				foreach (string roid in roidList)
				{
					originalRoChild = RofstDataGetChildByRoid(originalRofstID, roid);
					originalRos.Add(originalRoChild.roid, originalRoChild.value);

					if (originalRoChild.children != null && originalRoChild.children.Length > 0)
					{
						foreach (ROFSTLookup.rochild roc in originalRoChild.children)
						{
							originalRos.Add(roc.roid, roc.value);
						}
					}

					currentRoChild = RofstDataGetChildByRoid(currentRofstID, roid);
					currentRos.Add(currentRoChild.roid, currentRoChild.value);

					if (currentRoChild.children != null && currentRoChild.children.Length > 0)
					{
						foreach (ROFSTLookup.rochild roc in currentRoChild.children)
						{
							currentRos.Add(roc.roid, roc.value);
						}
					}
				}

				string cvalue = string.Empty;
				string ovalue = string.Empty;

				foreach (string key in originalRos.Keys)
				{
					cvalue = null;
					ovalue = originalRos[key];

					if (currentRos.ContainsKey(key))
						cvalue = currentRos[key];

					if (cvalue == null && cvalue != ovalue)
						delList.Add(key);
					else if (cvalue != ovalue)
						modList.Add(key);
				}

				return modList;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDataGetValueDifferences", ex);
			}
		}

		private Dictionary<string, string> RofstDataSearch(int rofstID, string value, int searchTypeID, int? maxNumRecords)
		{
			Dictionary<string, string> dic = new Dictionary<string, string>();

			if (string.IsNullOrEmpty(value))
				return dic;

			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataSearch";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@Value", SqlDbType.VarChar)).Value = value;
						cmd.Parameters.Add(new SqlParameter("@SearchTypeID", SqlDbType.Int)).Value = searchTypeID;

						if (maxNumRecords != null)
							cmd.Parameters.Add(new SqlParameter("@MaxNumOfRecords", SqlDbType.Int)).Value = (int)maxNumRecords;

						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							while (dr.Read())
							{
								dic.Add((string)dr.GetValue("roid"), (string)dr.GetValue("value"));
							}
						}
					}
				}

				return dic;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDataSearch", ex);
			}
		}

		private ROFSTLookup.rochild RofstDataGetChildByID(int rofstID, int dbiID, int id, bool loadChildren = false, bool loadAllChildren = false)
		{
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataGetChildByID";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@DbiID", SqlDbType.Int)).Value = dbiID;
						cmd.Parameters.Add(new SqlParameter("@ID", SqlDbType.Int)).Value = id;

						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							if (dr.Read())
							{
								return ConvertToRochildObject(dr, loadChildren, loadAllChildren);
							}
						}
					}
				}

				return new ROFSTLookup.rochild() { ID = -1 };
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.vesp_RofstDataGetChildByID", ex);
			}
		}

		private ROFSTLookup.rochild[] RofstDataGetRoChildrenByType(int rofstID, E_ROValueType valueTypes, bool loadChildren = false, bool loadAllChildren = false)
		{
			try
			{
				List<ROFSTLookup.rochild> lst = new List<ROFSTLookup.rochild>();

				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cmd = cn.CreateCommand())
					{
						cmd.CommandTimeout = Database.DefaultTimeout;
						cmd.CommandType = CommandType.StoredProcedure;
						cmd.CommandText = "vesp_RofstDataGetChildrenByType";

						cmd.Parameters.Add(new SqlParameter("@RofstID", SqlDbType.Int)).Value = rofstID;
						cmd.Parameters.Add(new SqlParameter("@ValueTypes", SqlDbType.VarChar)).Value = valueTypes.ToCommaDelimString();
					
						using (SafeDataReader dr = new SafeDataReader(cmd.ExecuteReader()))
						{
							while (dr.Read())
							{
								lst.Add(ConvertToRochildObject(dr, loadChildren, loadAllChildren));
							}
						}
					}
				}

				return lst.ToArray();
			}
			catch (Exception ex)
			{
				throw new DbCslaException("RofstData.RofstDataGetRoChildrenByType", ex);
			}
		}

		#endregion

		#region (Parse/Load)

		private ROFSTLookup.roHdr ConvertFst2Objects(byte[] ab)
		{
			ROFSTLookup.roHdr roh = new ROFSTLookup.roHdr();

			roh.hSize = BitConverter.ToInt32(ab, 0);
			roh.hYear = BitConverter.ToInt16(ab, 4);
			roh.hMonth = ab[6];
			roh.hDay = ab[7];
			roh.hcYear = BitConverter.ToInt16(ab, 8);
			roh.hcMonth = ab[10];
			roh.hcDay = ab[11];
			roh.hcHour = ab[12];
			roh.hcMin = ab[13];
			roh.hcSec = ab[14];
			roh.hcHund = ab[15];

			int hdrOffset = BitConverter.ToInt32(ab, 16);
			int dbs = BitConverter.ToInt16(ab, hdrOffset + 4);

			roh.myDbs = new ROFSTLookup.rodbi[dbs];

			for (int i = 0; i < dbs; i++)
			{
				int offset = hdrOffset + 6 + (i * 30);

				roh.myDbs[i].dbiID = BitConverter.ToInt16(ab, offset + 0);
				int tableID = roh.myDbs[i].dbiID;

				roh.myDbs[i].dbiType = BitConverter.ToInt16(ab, offset + 2);
				roh.myDbs[i].dbiAW = BitConverter.ToInt16(ab, offset + 4);

				int iPtr = BitConverter.ToInt32(ab, offset + 22) + hdrOffset + 6;
				roh.myDbs[i].dbiTitle = Encoding.Default.GetString(ab, iPtr, StringLength(ab, iPtr));

				iPtr = BitConverter.ToInt32(ab, offset + 26) + hdrOffset + 6;
				roh.myDbs[i].dbiAP = Encoding.Default.GetString(ab, iPtr, StringLength(ab, iPtr));

				ROFSTLookup.rogrp tmp = LoadGroup(ab, BitConverter.ToInt32(ab, offset + 6), tableID);

				roh.myDbs[i].ID = tmp.ID;
				roh.myDbs[i].children = tmp.children;
			}

			return roh;
		}

		private ROFSTLookup.rogrp LoadGroup(byte[] ab, int offset, int tableID)
		{
			ROFSTLookup.rogrp myGrp = new ROFSTLookup.rogrp();

			myGrp.ID = BitConverter.ToInt32(ab, offset);
			myGrp.ParentID = BitConverter.ToInt32(ab, offset + 4);

			int numChildren = BitConverter.ToInt16(ab, offset + 8);

			if (numChildren > 0)
			{
				myGrp.children = new ROFSTLookup.rochild[numChildren];

				int myOffset = offset + 10;

				for (int i = 0; i < myGrp.children.Length; i++)
				{
					ROFSTLookup.rochild tmp = new ROFSTLookup.rochild();

					int childOffset = BitConverter.ToInt32(ab, myOffset);
					tmp.type = BitConverter.ToInt16(ab, myOffset + 4);

					int slen = StringLength(ab, myOffset + 6);
					tmp.title = Encoding.Default.GetString(ab, myOffset + 6, slen);

					myOffset += (7 + slen);

					ROFSTLookup.rogrp tmpg = LoadGroup(ab, childOffset, tableID);

					//MultipleReturnValuesInheritType(ref tmpg, tmp.type);

					tmp.ID = tmpg.ID;
					tmp.ParentID = tmpg.ParentID;
					tmp.value = tmpg.value;
					tmp.appid = tmpg.appid;
					tmp.roid = tableID.ToString("X4") + tmp.ID.ToString("X8");
					tmp.children = tmpg.children;

					int j;

					for (j = i - 1; j >= 0 && tmp.ID < myGrp.children[j].ID; j--)
					{
						myGrp.children[j + 1] = myGrp.children[j];
					}

					myGrp.children[j + 1] = tmp;
				}
			}
			else
			{
				int slen = StringLength(ab, offset + 12);
				myGrp.value = Encoding.Default.GetString(ab, offset + 12, slen);

				//ProcessROReturnValue(ref myGrp, Encoding.Default.GetString(ab, offset + 12, slen), tableID, dvi);

				int slen2 = StringLength(ab, offset + 13 + slen);
				myGrp.appid = Encoding.Default.GetString(ab, offset + 13 + slen, slen2);
			}

			return myGrp;
		}

		private void Load(int rofstID)
		{
			//Get Original ROLookup Bytes 
			byte[] bytes = RofstDataGetRofstLookupBytes(rofstID);

			//Convert Bytes to Objects
			ROFSTLookup.roHdr roh = ConvertFst2Objects(bytes);

			//Save FstObjects to Database
			string userID = "System";

			//Insert Rofst Header
			RofstHeaderInsert(rofstID, roh.hSize, roh.hMonth, roh.hDay, roh.hcYear, roh.hcMonth,
							  roh.hcDay, roh.hcHour, roh.hcMin, roh.hcSec, roh.hcHund, userID);

			for (int i = 0; i < roh.myDbs.Length; i++)
			{
				ROFSTLookup.rodbi rodbi = roh.myDbs[i];

				//Insert Rofst Database
				RofstDatabaseInsert(rofstID, rodbi.dbiID, rodbi.dbiType, rodbi.dbiAW,
									rodbi.dbiTitle, rodbi.dbiAP, rodbi.ID, rodbi.ParentID);

				if (rodbi.children != null && rodbi.children.Length > 0)
				{
					for (int j = 0; j < rodbi.children.Length; j++)
					{
						//Insert Rofst Child
						LoadChild(rofstID, rodbi.dbiID, rodbi.children[j]);
					}
				}
			}

			//Finalized Load for Rofst Header / Rebuild Indexes
			RofstHeaderFinalizeLoad(rofstID);

		}

		private void LoadChild(int rofstID, int dbiID, ROFSTLookup.rochild child)
		{
			//Insert Rofst Child
			RofstChildInsert(rofstID, child.ID, child.ParentID, dbiID, child.type, child.title, child.roid, child.appid, child.value);

			if (child.children != null && child.children.Length > 0)
			{
				for (int i = 0; i < child.children.Length; i++)
				{
					//Insert Rofst Child
					LoadChild(rofstID, dbiID, child.children[i]);
				}
			}
		}

		#endregion

		#region (Convert To Objects)

		private ROFSTLookup.roHdr ConvertToRoHdrObject(SafeDataReader dr, bool loadChildren)
		{
			ROFSTLookup.roHdr rh = new ROFSTLookup.roHdr();

			rh.hSize = (int)dr.GetValue("hSize");
			rh.hYear = (int)dr.GetValue("hYear");
			rh.hMonth = (byte)dr.GetValue("hMonth");
			rh.hDay = (byte)dr.GetValue("hDay");
			rh.hcYear = (int)dr.GetValue("hcYear");
			rh.hcMonth = (byte)dr.GetValue("hcMonth");
			rh.hcDay = (byte)dr.GetValue("hcDay");
			rh.hcHour = (byte)dr.GetValue("hcHour");
			rh.hcMin = (byte)dr.GetValue("hcMin");
			rh.hcSec = (byte)dr.GetValue("hcSec");
			rh.hcHund = (byte)dr.GetValue("hcHund");

			if (loadChildren)
			{
				rh.myDbs = RofstDataGetDatabases(_rofstID);
			}

			return rh;
		}

		private ROFSTLookup.rodbi ConvertToRodbiObject(SafeDataReader dr, bool loadChildren, bool loadAllChildren)
		{
			ROFSTLookup.rodbi rd = new ROFSTLookup.rodbi();

			rd.dbiID = (int)dr.GetValue("dbiID");
			rd.dbiType = (int)dr.GetValue("dbiType");
			rd.dbiAW = (int)dr.GetValue("dbiAW");
			rd.dbiAP = (string)dr.GetValue("dbiAP");
			rd.dbiTitle = (string)dr.GetValue("dbiTitle");
			rd.ID = (int)dr.GetValue("ID");
			rd.ParentID = (int)dr.GetValue("ParentID");

			if (loadChildren || loadAllChildren)
			{
				rd.children = RofstDataGetChildrenByID(_rofstID, rd.dbiID, rd.ID, false, loadAllChildren);
			}

			return rd;
		}

		private ROFSTLookup.rochild ConvertToRochildObject(SafeDataReader dr, bool loadChildren, bool loadAllChildren)
		{
			ROFSTLookup.rochild rc = new ROFSTLookup.rochild();

			rc.ID = (int)dr.GetValue("ID");
			rc.ParentID = (int)dr.GetValue("ParentID");
			rc.type = (int)dr.GetValue("type");
			rc.title = (string)dr.GetValue("title");
			rc.roid = (string)dr.GetValue("roid");

			if (!string.IsNullOrEmpty((string)dr.GetValue("appid"))) rc.appid = (string)dr.GetValue("appid");

			if (!string.IsNullOrEmpty((string)dr.GetValue("value")))
			{
				rc.value = (string)dr.GetValue("value");
				ProcessROReturnValue(ref rc, rc.value, GetRODatabaseTitleIndex(rc.roid));
			}
			else if (loadChildren || loadAllChildren)
			{
				rc.children = RofstDataGetChildrenByRoid(_rofstID, rc.roid, false, loadAllChildren);
			}

			return rc;
		}

		#endregion

		#region (RO Values)

		private ROFSTLookup.rochild GetRoChild12(string ROID16, bool loadChildren = false, bool loadAllChildren = false)
		{
			string ROID = (ROID16.Length < 12) ? ROID16 : ROID16.Substring(0, 12);

			ROFSTLookup.rochild rc = RofstDataGetChildByRoid(_rofstID, ROID, loadChildren, loadAllChildren);

			if (rc.ID <= 0 && ROID16.Length == 4)
			{
				rc.title = GetRODatabaseTitle(GetRODatabaseTitleIndex(ROID16));
			}

			return rc;
		}

		private List<string> GetROReturnValue(string roval)
		{
			_lstRoValues = new List<string>();
			_multiRoValues = new List<string>();
			_dicRoVars = new Dictionary<string, string>();

			string tmp = ProcessRO(_myDocVersionInfo == null ? roval : _myDocVersionInfo.ProcessDocVersionSpecificInfo(roval), false);

			if (!string.IsNullOrEmpty(tmp) && _lstRoValues.Count == 0) // was not a multiple return value
			{
				_lstRoValues.Add(tmp);
			}

			return _lstRoValues;
		}

		private void ProcessROReturnValue(ref ROFSTLookup.rochild child, string rawvalue, int tableID)
		{
			// This function will take the raw RO return value and resolve any macros, conditionals,
			// and generate the return value or a list of multiple return values.
			List<string> lstValues = GetROReturnValue(rawvalue);

			if (lstValues.Count > 1) // Multiple Return Values
			{
				child.children = new ROFSTLookup.rochild[lstValues.Count];

				for (int i = 0; i < lstValues.Count; i++)
				{
					string tsts = Convert.ToInt32(_multiRoValues[i][0]).ToString("X4");
					child.children[i].value = lstValues[i].Replace("\xFF", "\xa0");
					child.children[i].roid = tableID.ToString("X4") + child.ID.ToString("X8") + tsts;
					child.children[i].type = child.type; // Multiple return value inherit type from parent
					child.children[i].title = lstValues[i].Replace("\xFF", "\xa0");
					child.children[i].appid = child.appid;
				}

				child.value = null;
			}
			else
			{
				child.value = lstValues[0];
			}

			_lstRoValues.Clear();
			_multiRoValues.Clear();

			return;
		}

		private string ProcessRO(string roval, bool multiRtnVal)
		{
			string str = roval;
			string rtnstr = "";
			int len = roval.Length;

			while (len > 0)
			{
				int ptr = NextDelimiter("{", str);

				if (ptr == -1)
				{
					rtnstr += str; // add remaining text
					len = 0; // break out of while loop
				}
				else
				{
					int cnt = ptr;

					if (cnt > 0)
					{
						// add text
						rtnstr += str.Substring(0, cnt);
						len -= cnt;
						str = str.Substring(ptr);
					}

					ptr = MatchingBrace(str) + 1;
					cnt = ptr;

					bool nfnd = false;
					string pbstr = ProcessBrace(str.Substring(1, cnt - 2), cnt - 2, ref nfnd, multiRtnVal);

					if (pbstr == null) 
						return null;

					if (nfnd)
						rtnstr += str.Substring(0, cnt);
					else
						rtnstr += pbstr;

					len -= cnt;
					str = str.Substring(ptr);
				}
			}

			return ProcessMacros(rtnstr);
		}

		private string ProcessBrace(string str, int l, ref bool nfnd, bool multiRtnVal)
		{
			string rtnstr = "";
			int nxt = NextDelimiter("{=", str);

			if (nxt == -1) // no delimiter found
			{
				if (_dicRoVars.ContainsKey(str))
					rtnstr = _dicRoVars[str];
				else
					nfnd = true;
			}
			else
			{
				if (str[nxt] == '{')
				{
					if (nxt == 0) // Multiple Return Values
					{
						ProcessMultiReturnValues(str, l);
					}
					else // Conditional
					{
						rtnstr = ProcessConditional(str, str.Substring(nxt), nxt, str.Length - nxt - 1, multiRtnVal);
					}
				}
				else // must be variable definition
				{
					// 'l' is the length up to the matching brace of the variable definition
					string tmpval = ProcessRO(str.Substring(nxt + 1, l - nxt - 1), multiRtnVal);
					if (string.IsNullOrEmpty(tmpval)) tmpval = " "; // nothing assigned to variable

					if (!_dicRoVars.ContainsKey(str.Substring(0, nxt)))
					{
						_dicRoVars.Add(str.Substring(0, nxt), tmpval);
						if (nxt == 1) _multiRoValues.Add(str.Substring(0, nxt));
					}
					else
					{
						return null;
					}

					if (multiRtnVal) rtnstr = tmpval;
				}
			}

			return rtnstr;
		}

		private void ProcessMultiReturnValues(string str, int len)
		{
			string tstr = (!string.IsNullOrEmpty(str)) ? str.Substring(0, len) : string.Empty;

			while (tstr.Length > 0)
			{
				int idx = MatchingBrace(tstr);
				string tmpVal = ProcessRO(tstr.Substring(0, idx + 1), true);
				if (tmpVal != null) _lstRoValues.Add(tmpVal);   // duplicates get returned as null
				tstr = tstr.Substring(idx + 1);
			}
		}

		private string ProcessConditional(string cnd, string opt, int lencnd, int lenopt, bool multiRtnVal)
		{
			// Evaluate Condition
			string stat = (_myDocVersionInfo != null) ? _myDocVersionInfo.Evaluate(cnd, lencnd) : string.Empty;

			// if evaluation not defined then return an empty string - no matches can be made, look for match - remember default
			if (stat.Length == 0)
				return string.Empty;

			int ls = stat.Length;
			string match = null;
			string def = null;
			int deflen = 0;

			while (lenopt > 0 && match == null)
			{
				int end = MatchingBrace(opt);
				int eq = opt.IndexOf('=');
				int len = end + 1;
				int li = eq - 1;
				int ld = len - li - 3;

				if (def == null || eq == 1)
				{
					def = opt.Substring(eq + 1);
					deflen = ld;
				}

				if (ls == li && opt.Substring(1).StartsWith(stat + "="))
				{
					match = opt.Substring(eq + 1, ld);
				}

				opt = opt.Substring(len); // point to the next piece
				lenopt -= len;
			}

			// if match process option - or process default
			if (match == null) //(!match)
			{
				match = def.Substring(0, deflen);
			}

			return ProcessRO(match, multiRtnVal);
		}

		private string ProcessMacros(string str)
		{
			// Takes the RO text value and sees if a macro has been used.  
			// If so it will perform the macro operation on the substring in the text value
			// Note** Right now the only macro is @HSP(), where every space between the "(" and ")" will be replaced with a hard space

			if (string.IsNullOrEmpty(str))
				return str;

			string rtnstr = str;
			int indx; 

			while ((indx = rtnstr.ToUpper().IndexOf("@HSP(")) > -1)
			{
				string resstr = rtnstr.Substring(0, indx);
				int endHsp = rtnstr.IndexOf(")", indx);
				string tmpstr = rtnstr.Substring(indx + 5, endHsp - indx - 5);

				// B2017-012 Don't convert space to hard spaces for XY Plots.
				if (!tmpstr.Contains("<<G")) tmpstr = tmpstr.Replace(" ", @"\u160?");

				resstr = resstr + tmpstr;
				rtnstr = resstr + rtnstr.Substring(endHsp + 1);
			}

			return rtnstr;
		}

		private int StringLength(byte[] ab, int offset)
		{
			int i = 0;
			while (ab[i + offset] != 0) i++;
			return i;
		}

		private int NextDelimiter(string delim, string str)
		{
			return (!string.IsNullOrEmpty(str)) ? str.IndexOfAny(delim.ToCharArray()) : -1;
		}

		private int MatchingBrace(string str)
		{
			int level = 1;
			int idx = 0; // the while will skip the first position (the first brace)

			if (!string.IsNullOrEmpty(str))
			{
				while (level > 0 && idx++ < str.Length)
				{
					switch (str[idx])
					{
						case '{':
							level++;
							break;

						case '}':
							level--;
							break;
					}
				}
			}

			return (level != 0) ? -1 : idx; //return -1 if didn't find matching brace otherwise length including end brace
		}

		private string FormatKey(string keyStr)
		{
			if (!string.IsNullOrEmpty(keyStr))
			{
				keyStr = keyStr.ToUpper();
				keyStr = regRoKeyHigh.Replace(keyStr, "_HIGH$3");
				keyStr = regRoKeyLow.Replace(keyStr, "_LOW$3");
			}

			return keyStr;
		}

		private string ReplaceUnicode(string s2, bool DoCaret)
		{
			string orig = s2;

			s2 = s2.Replace(@"\u160?", "<HSP>");		// convert hard spaces bug fix:  B2016-206
			s2 = s2.Replace(@"\", @"\u9586?");          // convert backslashes to a backslash symbol
			s2 = s2.Replace("<HSP>", @"\u160?");		// convert hard spaces bug fix:  B2016-206
			s2 = s2.Replace("`", @"\'b0");              // convert backquote to degree - left over from DOS days.
			s2 = s2.Replace("\xf8", @"\'b0");			// convert \xf8 to degree.
			s2 = s2.Replace("\xa0", @"\u160?");         // hardspace
			s2 = s2.Replace("\xb0", @"\'b0");           // degree
			s2 = s2.Replace("\x7f", @"\u916?");         // delta 
			s2 = s2.Replace("\x2265", @"\u8805?");		// greater than or equal
			s2 = s2.Replace("\x2264", @"\u8804?");		// less than or equal
			s2 = s2.Replace("\xB1", @"\'b1");           // plus minus
			s2 = s2.Replace("\x3A3", @"\u931?");        // sigma
			s2 = s2.Replace("\x3C4", @"\u947?");        // gamma
			s2 = s2.Replace("\xBD", @"\'bd");           // half
			s2 = s2.Replace("\x25A0", @"\u9604?");      // accum 2584
			s2 = s2.Replace("\x7", @"\u9679?");         // bullet 25CF
			s2 = s2.Replace("\x2248", @"\u8776?");		// approx eq
			s2 = s2.Replace("\x2261", @"\u8773?");		// similar eq 2245
			s2 = s2.Replace("\xF7", @"\'f7");           // division
			s2 = s2.Replace("\x221A", @"\u8730?");      // square root
			s2 = s2.Replace("\x393", @"\u961?");        // rho 3C1
			s2 = s2.Replace("\x3C0", @"\u960?");        // pi
			s2 = s2.Replace("\xb5", @"\u956?");         // micro 3BC  (try e6, if not work try 109)
			s2 = s2.Replace("\x3B4", @"\u948?");		// lower case delta
			s2 = s2.Replace("\x3C3", @"\u963?");		// lower case sigma
			s2 = s2.Replace("\xBC", @"\'bc");           // quarter
			s2 = s2.Replace("\x3C6", @"\'d8");          // dist zero, D8
			s2 = s2.Replace("\xC9", @"\u274?");         // energy, 112
			s2 = s2.Replace("\xEC", @"\'ec");           // grave
			s2 = s2.Replace("\x2502", @"\u9474?");		// bar 
			s2 = s2.Replace("\x3B5", @"\u949?");		// epsilon            
			s2 = s2.Replace("\x398", @"\u952?");		// theta, 3B8
			s2 = s2.Replace("\x221E", @"\u8857?");		// dot in oval, 2299
			s2 = s2.Replace("\xBF", @"\u964?");         // tau, 3C4
			s2 = s2.Replace("\x2310", @"\u9830?");		// diamond, 2666
			s2 = s2.Replace("\x2192", @"\u8594?");      // Rightwards Arrow
			s2 = s2.Replace("\x2190", @"\u8592?");      // Leftwards Arrow
			s2 = s2.Replace("\x2191", @"\u8593?");		// Upwards Arrow
			s2 = s2.Replace("\x2193", @"\u8595?");		// Downwards Arrow
			s2 = s2.Replace("\x2207", @"\u8711?");      // Nabla  
			s2 = s2.Replace("\x2591", @"\'b0");			// Degree Symbol
			s2 = s2.Replace("\xFF", @"\u8593?");		// Up Arrow
			s2 = s2.Replace("\xD6", @"\u8595?");		// Down Arrow

			if (DoCaret) s2 = s2.Replace("^", @"\u916?");
			// Convert dash to a non-breaking dash.  This is a unicode character.  
			// This character will be used in veproms rather than a dash.
			//if the dash is preceeded byte a token remove the space following the token
			s2 = Regex.Replace(s2, @"(\\[^ \\?]*) \-", @"$1\u8209?");
			s2 = s2.Replace("-", @"\u8209?");

			return s2;
		}

		private string FixUnitROs(string val)
		{
			DocVersionInfo dvi = _myDocVersionInfo;

			if (dvi != null && !string.IsNullOrEmpty(val) && val.StartsWith("<U-"))
			{
				if (val.ToUpper() == "<U-TEXT>") val = dvi.DocVersionConfig.Unit_Text;
				else if (val.ToUpper() == "<U-NUMBER>") val = dvi.DocVersionConfig.Unit_Number;
				else if (val.ToUpper() == "<U-NAME>") val = dvi.DocVersionConfig.Unit_Name;
				else if (val.ToUpper() == "<U-ID>") val = dvi.DocVersionConfig.Unit_ID;
				// B2021-145: For applicability, the tree view & pdf file name are not getting resolved when using any of the ‘OTHER’ tokens
				// B2022-023 also check for other followed by a space
				else if (val.ToUpper() == "<U-OTHERTEXT>" || val.ToUpper() == "<U-OTHER TEXT>") val = dvi.DocVersionConfig.Other_Unit_Text;
				else if (val.ToUpper() == "<U-OTHERNUMBER>" || val.ToUpper() == "<U-OTHER NUMBER>") val = dvi.DocVersionConfig.Other_Unit_Number;
				else if (val.ToUpper() == "<U-OTHERNAME>" || val.ToUpper() == "<U-OTHER NAME>") val = dvi.DocVersionConfig.Other_Unit_Name;
				else if (val.ToUpper() == "<U-OTHERID>" || val.ToUpper() == "<U-OTHER ID>") val = dvi.DocVersionConfig.Other_Unit_ID;
			}

			return val;
		}

		#endregion

		#endregion

		#region Public Static Methods

		#region (FortranFormat)

		public static string ConvertFortranFormatToScienctificNotation(string str)
		{
			// ([+-]?|\\u8209\?)  either an optional single character Plus (+) or Minus (-) or non-breaking dash (\u8209?)
			// ([0-9]+)           a group of at least one digits
			// [.]                a decimal point
			// ([0-9]*?)          a group of zero or more digits
			// 0*E                optional zeros (spare zeros) followed 
			// ([+-]?|\\u8209\?)  either an optional single character Plus (+) or Minus (-) or non-breaking dash (\u8209?)
			// ([0-9]+)           a group of at least one digits

			return Regex.Replace(str, @"([+-]?|\\u8209\?)([0-9]+)[.]([0-9]*?)0*E([+-]?|\\u8209\?)([0-9]+)", new MatchEvaluator(FixFortranNumber));
		}

		public static string FixFortranNumber(Match match)
		{
			StringBuilder sb = new StringBuilder(match.Groups[1].Value.Replace("-", @"\u8209?"));

			if (match.Groups[3].Length == 0) // Nothing to the right of the decimal
			{
				if (match.Groups[2].Value != "1") // Other than "1", multiply it times 10 raised to a power
				{
					sb.Append(match.Groups[2].Value + "x10");
				}
				else // The number is simply 1 so it can be ignored and 10 can be raised to a power
				{
					sb.Append("10");
				}
			}
			else // A number with a decimal point
			{
				sb.Append(match.Groups[2].Value + "." + match.Groups[3].Value + "x10");
			}

			// Add the exponent as superscript
			return sb.ToString() + "\\up2 " + match.Groups[4].Value.Replace("-", @"\u8209?") + match.Groups[5].Value + "\\up0 ";
		}

		#endregion

		#endregion

	}
}