using System;
using System.Collections.Generic;
using System.Text;
using Csla;
using Csla.Data;
using System.Data;
using System.Data.SqlClient;
using System.Xml;
using System.Drawing;

namespace VEPROMS.CSLA.Library
{
	#region Item
	public partial class Item:IVEDrillDown
	{
		public override string ToString()
		{
			return string.Format("{0} {1}", MyContent.Number, MyContent.Text);
		}
		// TODO: Move to ItemInfo Extension

		#region IVEDrillDown
		public System.Collections.IList GetChildren()
		{
			return this.MyContent.ContentParts;
		}
		public bool HasChildren
		{
			get { return this.MyContent.ContentPartCount > 0; }
		}
		public Item MyProcedure
		{
			get
			{
				// Walk up active parents until the parent is not an item
				Item tmp = this;
				while (tmp.ActiveParent.GetType().Name != "DocVersion") tmp = (Item)tmp.ActiveParent;
				return tmp;
			}
		}		private IVEDrillDown _ActiveParent = null;
		public IVEDrillDown ActiveParent
		{
			get
			{
				if (_ActiveParent == null)
				{
					if (MyPrevious != null)
						_ActiveParent = _MyPrevious.ActiveParent;
					else
					{
						if (ItemDocVersionCount > 0)
							_ActiveParent = this.ItemDocVersions[0].MyDocVersion;
						else
						{
							if (this.ItemParts == null || this.ItemPartCount == 0) 
								_ActiveParent = this;
							else
								_ActiveParent = this.ItemParts[0].MyContent.ContentItems[0].MyItem;
						}
					}
				}
				return _ActiveParent==this ? null : _ActiveParent;
			}
		}
		private Format _ActiveFormat=null;// Added to cache ActiveFormat
		public Format ActiveFormat
		{
			get
			{
				if(_ActiveFormat == null)
					_ActiveFormat = (LocalFormat != null ? LocalFormat : ActiveParent.ActiveFormat);
				return _ActiveFormat;
			}
		}
		public Format LocalFormat
		{
			get { return MyContent.MyFormat; }
		}
		public DynamicTypeDescriptor MyConfig
		{
			get { return null; }
		}
		#endregion
	}
	#endregion
	#region ItemInfo
	public partial class ItemInfo:IVEDrillDownReadOnly 
	{
		public bool IsType(string type)
		{
			int stepType = ((int)MyContent.Type) % 10000;
			StepDataList sdlist = ActiveFormat.PlantFormat.FormatData.StepDataList;
			StepData sd = sdlist[stepType];
			// TODO: RHM20071115 while (sd.Index != 0)
			// TODO: RHM20071115 {
				// TODO: RHM20071115 if (sd.Type == type) return true;
				// TODO: RHM20071115 sd = sdlist[sd.ParentType];
			// TODO: RHM20071115 }
			return false;
		}
		public bool IsCaution
		{
			get
			{
				return IsType("CAUTION");
			}
		}
		public bool IsNote
		{
			get
			{
				return IsType("NOTE");
			}
		}
		public bool IsTable
		{
			get
			{
				return IsType("TABLE");
			}
		}
		public bool IsFigure
		{
			get
			{
				return IsType("FIGURE");
			}
		}
		public bool IsOr
		{
			get
			{
				return IsType("OR");
			}
		}
		public bool IsAnd
		{
			get
			{
				return IsType("AND");
			}
		}
		public bool IsEquipmentList
		{
			get
			{
				return IsType("EQUIPMENTLIST");
			}
		}
		public bool IsTitle
		{
			get
			{
				return IsType("TITLE");
			}
		}
		public bool IsAccPages
		{
			get
			{
				return IsType("ACCPAGES");
			}
		}
		public bool IsParagraph
		{
			get
			{
				return IsType("PARAGRAPH");
			}
		}
		public bool IsDefault
		{
			get
			{
				return IsType("DEFAULT");
			}
		}
		public bool IsContAcSequential
		{
			get
			{
				return IsType("CONTACSEQUENTIAL");
			}
		}
		public bool IsHigh
		{
			get
			{
				// check to see if ActiveParent is a section, if so it is a high level step
				if (MyContent.Type / 10000 != 2) return false;
				ItemInfo parent = (ItemInfo)ActiveParent;
				if ((parent.MyContent.Type / 10000) == 1)
					return true;
				return false;
			}
		}
		public bool IsSequential
		{
			get
			{
				if (((MyContent.Type / 10000) == 2) && ((((int)MyContent.Type) % 10000) == 0)) return true;
				return false;
			}
		}
		public bool IsRNO
		{
			get
			{
				return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.RNO));
			}
		}
		public bool IsInRNO
		{
			get 
			{
				if (IsHigh) return false;
				if (IsRNO) return true;
				return ((ItemInfo)ActiveParent).IsInRNO;
			}
		}
		public ItemInfo FirstSibling
		{
			get
			{
				ItemInfo temp = this;
				while (temp.MyPrevious != null) temp = temp.MyPrevious;
				return temp;
			}
		}
		public bool IsSubStep
		{
			get
			{
				ItemInfo temp = FirstSibling;
				return ((temp.ItemPartCount > 0) && (temp.ItemParts[0].PartType == E_FromType.Step));
			}
		}
		public bool IsInSubStep
		{
			get
			{
				if (IsHigh) return false;
				if (IsSubStep) return true;
				return ((ItemInfo)ActiveParent).IsInSubStep;
			}
		}
		public bool IsInFirstLevelSubStep
		{
			get
			{
				ItemInfo temp = FirstSibling;
				while (((ItemInfo)temp.ActiveParent).IsHigh == false) temp = ((ItemInfo)temp.ActiveParent).FirstSibling;
				return temp.IsSubStep;
			}
		}
		private E_FromType ItemType
		{
			get
			{
				if (MyContent.Type == 0) return E_FromType.Procedure;
				if (MyContent.Type < 20000) return E_FromType.Section;
				return E_FromType.Step;
			}
		}
		public Item GetByType()
		{
			Item tmp = null;
			switch (ItemType)
			{
				case E_FromType.Procedure:
					tmp = Procedure.Get(_ItemID);
					break;
				//case E_FromType.Section:
				//  itemInfo = new Section(dr);
				//  break;
				//default:
				//  itemInfo = new Step(dr);
				//  break;
			}
			return tmp;
		}
		private int? _Ordinal;
		public int Ordinal
		{
			get
			{
				//int retval = 1;
				//for (ItemInfo ii = MyParent; ii != null; ii = ii.MyParent) retval++;
				//return retval;
				//if (_Ordinal != null) return (int)_Ordinal; // Cache Ordinal
				if (MyPrevious != null) return (int)(_Ordinal = MyPrevious.Ordinal + 1);
				return (int)(_Ordinal = 1);
			}
		}
		public string CslaType
		{ get { return this.GetType().FullName; } }
		public override string ToString()
		{
			//Item editable = Item.GetExistingByPrimaryKey(_ItemID);
			//return string.Format("{0}{1} {2}", (editable == null ? "" : (editable.IsDirty ? "* " : "")), 
			//  (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : MyContent.Number), MyContent.Text);
			ContentInfo cont = MyContent;
			string number = cont.Number;
			if (cont.Type >= 20000) number = Ordinal.ToString() + ".";
			return string.Format("{0} {1}", number, cont.Text);
			//return string.Format("{0} {1}", cont.Number, cont.Text);
			//return "Now is the time for all good men to come to the aid of their country!";
		}
		//public string ToString(string str,System.IFormatProvider ifp)
		//{
		//  return ToString();
		//}
		public string nz(string str, string def)
		{
			return (str == null ? def : str);
		}
		public string Path
		{
			get
			{
				string number = (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : (nz(MyContent.Number,"")==""? MyContent.Text: MyContent.Number));
				ItemInfo parent = this;
				while (parent.MyPrevious != null) parent = parent.MyPrevious;
				if (parent.ItemPartCount == 0)
					return number + ", " + MyContent.Text;
				else
				{
					PartInfo partInfo = parent.ItemParts[0];
					return partInfo.MyContent.ContentItems.Items[0].Path + " " + ((E_FromType)partInfo.FromType).ToString() + " " + number;
				}
			}
		}
		public ContentInfo ParentContent
		{
			get
			{
				string number = (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : (nz(MyContent.Number, "") == "" ? MyContent.Text : MyContent.Number));
				ItemInfo parent = this;
				while (parent.MyPrevious != null) parent = parent.MyPrevious;
				if (parent.ItemPartCount == 0)
					return null;
				else
				{
					return parent.ItemParts[0].MyContent;
				}
			}
		}
		public ItemInfo MyParent
		{
			get
			{
				//if (ItemDocVersionCount > 0) return ItemDocVersions[0]; Need to create one interface to support Folders, DocVersions and Items				
				ContentInfo parentContent = ParentContent;
				if (parentContent == null || parentContent.ContentItemCount == 0) return null;
				return parentContent.ContentItems[0];
			}
		}
		private ItemInfoList Lookup(int fromType, ref ItemInfoList itemInfoList)
		{
			if (itemInfoList != null) return itemInfoList;
			if (MyContent.ContentPartCount != 0)
				foreach (PartInfo partInfo in MyContent.ContentParts)
					if (partInfo.FromType == fromType)
					{
						itemInfoList = partInfo._MyItems = ItemInfoList.GetList(partInfo.ItemID,partInfo.FromType);
						return itemInfoList;
					}
			return null;
		}
		private ItemInfoList _Procedures;
		public ItemInfoList Procedures
		{ get { return Lookup(1,ref _Procedures); } }
		private ItemInfoList _Sections;
		public ItemInfoList Sections
		{ get { return Lookup(2,ref _Sections); } }
		private ItemInfoList _Cautions;
		public ItemInfoList Cautions
		{ get { return Lookup(3,ref _Cautions); } }
		private ItemInfoList _Notes;
		public ItemInfoList Notes
		{ get { return Lookup(4,ref _Notes); } }
		private ItemInfoList _RNOs;
		public ItemInfoList RNOs
		{ get { return Lookup(5,ref _RNOs); } }
		private ItemInfoList _Steps;
		public ItemInfoList Steps
		{ get { return Lookup(6,ref _Steps); } }
		private ItemInfoList _Tables;
		public ItemInfoList Tables
		{ get { return Lookup(7,ref _Tables); } }
		//public XmlDocument ToXml()
		//{
		//  XmlDocument retval = new XmlDocument();
		//  retval.LoadXml("<root/>");
		//  return ToXml(retval.DocumentElement);
		//}
		//public void AddList(XmlNode xn,string name, ItemInfoList itemInfoList)
		//{
		//  if (itemInfoList != null)
		//  {
		//    XmlNode nd = xn.OwnerDocument.CreateElement(name);
		//    xn.AppendChild(nd);
		//    itemInfoList.ToXml(xn);
		//  }
		//}
		//public XmlDocument ToXml(XmlNode xn)
		//{
		//  XmlNode nd  = MyContent.ToXml(xn);
		//  // Now add the children
		//  AddList(nd, "Procedures", Procedures);
		//  AddList(nd, "Sections", Sections);
		//  AddList(nd, "Cautions", Cautions);
		//  AddList(nd, "Notes", Notes);
		//  AddList(nd, "RNOs", RNOs);
		//  AddList(nd, "Steps", SubItems);
		//  AddList(nd, "Tables", Tables);
		//  return xn.OwnerDocument;
		//}
		public string TabToolTip
		{
			get
			{
				if (MyContent.MyEntry == null)
					return MyContent.Number + " - " + MyContent.Text;
				string toolTip = MyProcedure.TabToolTip + "\r\n";
				if (MyContent.Number != "")
					toolTip += MyContent.Number + " - " + MyContent.Text;
				else
					toolTip += MyContent.Text;
				DocumentInfo myDocument = MyContent.MyEntry.MyDocument;
				if (myDocument.LibTitle != "")
				{
					toolTip += string.Format("\r\n(Library Document - {0})", myDocument.LibTitle);
					toolTip += myDocument.LibraryDocumentUsage;
				}
				return toolTip;
			}
		}
		public string TabTitle
		{
			get
			{
				if (MyContent.MyEntry == null)
					return MyContent.Number;
				if (MyContent.Number != "")
					return MyContent.Number;
				if (MyContent.Text.Length <= 10)
					return MyContent.Text;
				return MyContent.Text.Split(" ,.;:-_".ToCharArray())[0] + "...";
			}
		}
		#region IVEReadOnlyItem
		PartInfoList _PartInfoList;
		public System.Collections.IList GetChildren()
		{
			_PartInfoList = this.MyContent.ContentParts;
			if (_PartInfoList.Count == 1 && ( _PartInfoList[0].ToString() == "Sections" || _PartInfoList[0].ToString() == "Steps"))
				return _PartInfoList[0].GetChildren();
			return _PartInfoList;
		}
		//public bool ChildrenAreLoaded
		//{
		//  get { return _PartInfoList == null; }
		//}
		public bool HasChildren
		{
			get { return this.MyContent.ContentPartCount > 0; }
		}
		public ItemInfo MyProcedure
		{
			get
			{
				// Walk up active parents until the parent is not an item
				ItemInfo tmp = this;
				while (tmp.ActiveParent.GetType().Name != "DocVersionInfo") tmp = (ItemInfo)tmp.ActiveParent;
				return tmp;
			}
		}
		private IVEDrillDownReadOnly _ActiveParent = null;
		public IVEDrillDownReadOnly ActiveParent
		{
			get
			{
				if (_ActiveParent == null)
				{
					if (MyPrevious != null)
						_ActiveParent = _MyPrevious.ActiveParent;
					else
					{
						if (ItemDocVersionCount > 0)
							_ActiveParent = this.ItemDocVersions[0];
						else
						{
							ContentInfo parentContent = ParentContent;
							if (parentContent == null || parentContent.ContentItemCount == 0)
								_ActiveParent = this;
							else
								_ActiveParent = parentContent.ContentItems[0];
						}
					}
				}
				return _ActiveParent==this ? null : _ActiveParent;
			}
			//get 
			//{
			//  if (MyPrevious != null) return _MyPrevious.ActiveParent; 
			//  if (ItemDocVersionCount > 0) return ItemDocVersions[0]; 			
			//  ContentInfo parentContent = ParentContent;
			//  if (parentContent == null || parentContent.ContentItemCount == 0) return null;
			//  return parentContent.ContentItems[0];
			//}
		}
		private FormatInfo _ActiveFormat = null;
		public FormatInfo ActiveFormat
		{
			get
			{
				if(_ActiveFormat == null)
					_ActiveFormat = (LocalFormat != null ? LocalFormat : ActiveParent.ActiveFormat);
				return _ActiveFormat;
			}
			//get { return LocalFormat != null ? LocalFormat : ActiveParent.ActiveFormat; }
		}
		public FormatInfo LocalFormat
		{
			get { return MyContent.MyFormat; }
		}
		public DynamicTypeDescriptor MyConfig
		{
			get { return null; }
		}
		//public bool HasStandardSteps()
		//{ return MyContent.ContentItemCount > 1; }
		public Color ForeColor
		{ get { return (HasBrokenRules != null ? Color.Red : (MyContent.ContentItemCount > 1 ? Color.Blue : Color.Black)); } }
		public Color BackColor
		{ get { return (ItemAnnotationCount  > 0 ? Color.Yellow : Color.White); } }
		#endregion
	}
	#endregion ItemInfo
	#region ItemInfoList
	public partial class ItemInfoList
	{
		//public void ToXml(XmlNode xn)
		//{
		//  foreach (ItemInfo itemInfo in this)
		//  {
		//    itemInfo.ToXml(xn);
		//  }
		//}
		public static ItemInfoList GetList(int? itemID,int type)
		{
			try
			{
				ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListCriteria(itemID,type));
				ItemInfo.AddList(tmp);
				tmp.AddEvents();
				ContentInfoList.GetList(itemID);
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
			}
		}
		[Serializable()]
		private class ItemListCriteria
		{
			public ItemListCriteria(int? itemID,int type)
			{
				_ItemID = itemID;
				_Type = type;
			}
			private int? _ItemID;
			public int? ItemID
			{
				get { return _ItemID; }
				set { _ItemID = value; }
			}
			private int _Type;
			public int Type
			{
				get { return _Type; }
				set { _Type = value; }
			}
		}
		private void DataPortal_Fetch(ItemListCriteria criteria)
		{
			this.RaiseListChangedEvents = false;
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "vesp_ListItems";
						cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							IsReadOnly = false;
							while (dr.Read())
							{
								ItemInfo itemInfo = null;
								switch ((E_FromType)criteria.Type)
								{
									case E_FromType.Procedure:
										itemInfo = new ProcedureInfo(dr);
										break;
									case E_FromType.Section:
										itemInfo = new SectionInfo(dr);
										break;
									default:
										itemInfo = new StepInfo(dr);
										break;
								}
								this.Add(itemInfo);
							}
							IsReadOnly = true;
						}
					}
				}
			}
			catch (Exception ex)
			{
				Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
				throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
			}
			this.RaiseListChangedEvents = true;
		}
	}
	#endregion
	#region ProcedureInfo
	[Serializable()]
	public partial class ProcedureInfo : ItemInfo, IVEDrillDownReadOnly
	{
		public ProcedureInfo(SafeDataReader dr) : base(dr) { }
		public new Procedure Get()
		{
			return (Procedure) (_Editable = Procedure.Get(ItemID));
		}
		#region ProcedureConfig
		[NonSerialized]
		private ProcedureConfig _ProcedureConfig;
		public ProcedureConfig ProcedureConfig
		{ get { return (_ProcedureConfig != null ? _ProcedureConfig : _ProcedureConfig = new ProcedureConfig(this)); } }
		#endregion
		public new DynamicTypeDescriptor MyConfig
		{
			get { return ProcedureConfig ; }
		}
	}
	#endregion
	#region Procedure
	[Serializable()]
	public partial class Procedure : Item
	{
		public new static Procedure Get(int itemID)
		{
			if (!CanGetObject())
				throw new System.Security.SecurityException("User not authorized to view a Item");
			try
			{
				Procedure tmp = (Procedure)GetExistingByPrimaryKey(itemID);
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<Procedure>(new PKCriteria(itemID));
					_AllList.Add(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found") tmp = null;
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on Item.Get", ex);
			}
		}
		public new Procedure Save()
		{
			return (Procedure)base.Save();
		}
		#region ProcedureConfig
		[NonSerialized]
		private ProcedureConfig _ProcedureConfig;
		public ProcedureConfig ProcedureConfig
		{
			get
			{
				if (_ProcedureConfig == null)
				{
					_ProcedureConfig = new ProcedureConfig(this);
					_ProcedureConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_ProcedureConfig_PropertyChanged);
				}
				return _ProcedureConfig;
			}
		}
		private void _ProcedureConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
		{
			MyContent.Config = _ProcedureConfig.ToString();
		}
		#endregion
	}
	#endregion
	#region SectionInfo
	[Serializable()]
	public partial class SectionInfo : ItemInfo, IVEDrillDownReadOnly
	{
		public SectionInfo(SafeDataReader dr) : base(dr) { }
		public new Section Get()
		{
			return (Section)(_Editable = Section.Get(ItemID));
		}
		#region SectionConfig
		[NonSerialized]
		private SectionConfig _SectionConfig;
		public SectionConfig SectionConfig
		{ get { return (_SectionConfig != null ? _SectionConfig : _SectionConfig = new SectionConfig(this)); } }
		#endregion
		public new DynamicTypeDescriptor MyConfig
		{
			get { return SectionConfig; }
		}
	}
	#endregion
	#region Section
	[Serializable()]
	public partial class Section : Item
	{
		public new static Section Get(int itemID)
		{
			if (!CanGetObject())
				throw new System.Security.SecurityException("User not authorized to view a Item");
			try
			{
				Section tmp = (Section)GetExistingByPrimaryKey(itemID);
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<Section>(new PKCriteria(itemID));
					_AllList.Add(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found") tmp = null;
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on Item.Get", ex);
			}
		}

		public new Section Save()
		{
			return (Section)base.Save();
		}

		#region SectionConfig
		[NonSerialized]
		private SectionConfig _SectionConfig;
		public SectionConfig SectionConfig
		{
			get
			{
				if (_SectionConfig == null)
				{
					_SectionConfig = new SectionConfig(this);
					_SectionConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_SectionConfig_PropertyChanged);
				}
				return _SectionConfig;
			}
		}
		private void _SectionConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
		{
			MyContent.Config = _SectionConfig.ToString();
		}
		#endregion
	}
	#endregion
	#region StepInfo
	[Serializable()]
	public partial class StepInfo : ItemInfo
	{
		//public override string ToString()
		//{
		//  return "Step " + base.ToString();
		//}
		public StepInfo(SafeDataReader dr) : base(dr) { }
		public new Step Get()
		{
			return (Step)(_Editable = Step.Get(ItemID));
		}
		//public E_FromType FromType
		//{ get { return E_FromType.Step; } }
	}

	#endregion
	#region Step
	[Serializable()]
	public partial class Step : Item
	{
		public new static Step Get(int itemID)
		{
			if (!CanGetObject())
				throw new System.Security.SecurityException("User not authorized to view a Item");
			try
			{
				Step tmp = (Step)GetExistingByPrimaryKey(itemID);
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<Step>(new PKCriteria(itemID));
					_AllList.Add(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found") tmp = null;
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on Item.Get", ex);
			}
		}
		//#region StepConfig
		//[NonSerialized]
		//private StepConfig _StepConfig;
		//public StepConfig StepConfig
		//{
		//  get
		//  {
		//    if (_StepConfig == null)
		//    {
		//      _StepConfig = new StepConfig(this);
		//      _StepConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_StepConfig_PropertyChanged);
		//    }
		//    return _SectionConfig;
		//  }
		//}
		//private void _StepConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
		//{
		//  MyContent.Config = _StepConfig.ToString();
		//}
		//#endregion
	}
	#endregion
}