using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Text.RegularExpressions;
using Csla;
using Csla.Data;

namespace VEPROMS.CSLA.Library
{
	public partial class AnnotationInfo
	{
		public override string ToString()
		{
			return _SearchText;
		}
		#region JCB Annotation Status
		private bool _IsAnnotationNew = false;

		public bool IsAnnotationNew
		{
			get
			{
				ProcedureInfo pi = this.MyItem.MyProcedure;
				if (pi != null)
					//todo figure out audit count
					_IsAnnotationNew = (this.DTS > pi.DTS);
				return _IsAnnotationNew;
			}
		}
		private bool _IsAnnotationChanged;

		public bool IsAnnotationChanged
		{
			get
			{
				ProcedureInfo pi = this.MyItem.MyProcedure;
				if (pi != null)
				{
					//todo figure out audit count
					_IsAnnotationChanged = (this.DTS > pi.DTS);
				}
				return _IsAnnotationChanged;
			}
		}
		#endregion

	}
	public partial class AnnotationType
	{
		public override string ToString()
		{
			return _Name;
		}
		[NonSerialized]
		private AnnotationTypeConfig _AnnotationTypeConfig;
		public AnnotationTypeConfig AnnotationTypeConfig
		{
			get
			{
				if (_AnnotationTypeConfig == null)
				{
					_AnnotationTypeConfig = new AnnotationTypeConfig(this);
				}
				return _AnnotationTypeConfig;
			}
		}

  }
	public partial class AnnotationTypeInfo
	{
		[NonSerialized]
		private AnnotationTypeConfig _AnnotationTypeConfig;
		public AnnotationTypeConfig AnnotationTypeConfig
		{
			get
			{
				if (_AnnotationTypeConfig == null)
				{
					_AnnotationTypeConfig = new AnnotationTypeConfig(this);
				}
				return _AnnotationTypeConfig;
			}
		}
		public static List<AnnotationTypeInfo> AllList()
		{
			//return _AllList;
			return AnnotationTypeInfo._CacheList;
		}
		public override string ToString()
		{
			return _Name;
		}
    public static AnnotationTypeInfo GetByName(string name)
    {
      try
      {
        AnnotationTypeInfo tmp = DataPortal.Fetch<AnnotationTypeInfo>(new GetByNameCriteria(name));
        if (tmp.ErrorMessage == "No Record Found")
        {
          tmp.Dispose(); // Clean-up AnnotationTypeInfo
          tmp = null;
        }
        return tmp;
      }
      catch (Exception ex)
      {
        throw new DbCslaException("Error on AnnotationTypeInfo.GetByName", ex);
      }
    }
    [Serializable()]
    protected class GetByNameCriteria
    {
      private string _Name;
      public string Name { get { return _Name; } }
      public GetByNameCriteria(string name)
      {
        _Name = name;
      }
    }
    private void DataPortal_Fetch(GetByNameCriteria criteria)
    {
      if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] AnnotationTypeInfo.DataPortal_Fetch", GetHashCode());
      try
      {
        using (SqlConnection cn = Database.VEPROMS_SqlConnection)
        {
          ApplicationContext.LocalContext["cn"] = cn;
          using (SqlCommand cm = cn.CreateCommand())
          {
            cm.CommandType = CommandType.StoredProcedure;
            cm.CommandText = "getAnnotationTypeByName";
						cm.CommandTimeout = Database.SQLTimeout;
            cm.Parameters.AddWithValue("@Name", criteria.Name);
            using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
            {
              if (!dr.Read())
              {
                _ErrorMessage = "No Record Found";
                return;
              }
              ReadData(dr);
            }
          }
          // removing of item only needed for local data portal
          if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
            ApplicationContext.LocalContext.Remove("cn");
        }
      }
      catch (Exception ex)
      {
        if (_MyLog.IsErrorEnabled) _MyLog.Error("AnnotationTypeInfo.DataPortal_Fetch", ex);
        _ErrorMessage = ex.Message;
        throw new DbCslaException("AnnotationTypeInfo.DataPortal_Fetch", ex);
      }
    }
  }
	public partial class AnnotationTypeInfoList
	{
		public static void Refresh()
		{
			Reset();
			_AnnotationTypeInfoList = Get();
		}
	}
	public partial class Annotation
	{
		/// <summary>
		/// Change the annotation type and update the Annotation record
		/// </summary>
		/// <param name="anotypeid"></param>
		public void Update(int anotypeid)
		{
			if (_TypeID != anotypeid)
			{
				_TypeID = anotypeid;
				MarkDirty(); // force the record update
				Save();
				//Update(); // commit record to database
			}
		}
		public void CommitChanges()
		{
			MarkDirty(); // force the record update
			Save(true);
			//Update();
		}

		public static void DeleteAnnotation(AnnotationInfo obj)
		{
			if (!CanDeleteObject())
				throw new System.Security.SecurityException("User not authorized to remove a Annotation");
			try
			{
				//				ItemInfo nextItem = item.NextItem;
				//				ItemInfo prevItem = item.MyPrevious;
				//				item.OnBeforeDelete();
				DataPortal.Delete(new DeleteCriteria(obj.AnnotationID, Volian.Base.Library.VlnSettings.UserID));
				AnnotationInfo.StaticOnInfoChanged();
				//				if (nextItem != null) // Adjust PreviousID for NextItem
				//				{
				//					ItemInfo.RefreshPrevious(nextItem.ItemID, item.PreviousID);
				//					// The order of the next two methods was required to fix a null reference
				//					// when getting myparent. This bug was found when deleting a node from the 
				//					// tree when the RTBItem was not open (i.e. in the step editor window).
				//					nextItem.RefreshItemParts();
				//					//nextItem.ResetOrdinal(); - UpdateTransitionText calls ResetOrdinal
				//					nextItem.UpdateTransitionText();
				//				}
				//				else if (prevItem != null)
				//				{
				//					prevItem.RefreshNextItems();
				//					if (prevItem.IsCaution || prevItem.IsNote) prevItem.ResetOrdinal();
				//					prevItem.UpdateTransitionText();
				//				}
				//				ItemInfo.DeleteItemInfoAndChildren(item.ItemID); // Dispose ItemInfo and Children
			}
			catch (Exception ex)
			{
				System.Data.SqlClient.SqlException exSQL = SqlException(ex);
				if (exSQL != null && exSQL.Message.Contains("###Cannot Delete Item###"))
					throw exSQL;
				Console.WriteLine("AnnotationExt: Stacktrace = {0}", ex.StackTrace);
				throw new DbCslaException("Error on Annotation.Delete", ex);
			}
		}

		public static void DeleteAnnotationProcByType(int typID, string procList)
		{
			if (!CanDeleteObject())
				throw new System.Security.SecurityException("User not authorized to remove a Annotation");
			try
			{
				DataPortal.Delete(new DeleteAnnotationProcByTypeCriteria(typID, procList));
				AnnotationInfo.StaticOnInfoChanged();
			}
			catch (Exception ex)
			{
				System.Data.SqlClient.SqlException exSQL = SqlException(ex);
				if (exSQL != null && exSQL.Message.Contains("###Cannot Delete Item###"))
					throw exSQL;
				Console.WriteLine("AnnotationExt: Stacktrace = {0}", ex.StackTrace);
				throw new DbCslaException("Error on Annotation.Delete", ex);
			}
		}

		public static void DeleteAnnotationDocvByType(int typID, string versionID)
		{
			if (!CanDeleteObject())
				throw new System.Security.SecurityException("User not authorized to remove a Annotation");
			try
			{
				DataPortal.Delete(new DeleteAnnotationDocvByTypeCriteria(typID, versionID));
				AnnotationInfo.StaticOnInfoChanged();
			}
			catch (Exception ex)
			{
				System.Data.SqlClient.SqlException exSQL = SqlException(ex);
				if (exSQL != null && exSQL.Message.Contains("###Cannot Delete Item###"))
					throw exSQL;
				Console.WriteLine("AnnotationExt: Stacktrace = {0}", ex.StackTrace);
				throw new DbCslaException("Error on Annotation.Delete", ex);
			}
		}

		public static int getAnnotationProcCnt(int typID, string procList)
		{
			if (!CanGetObject())
				throw new System.Security.SecurityException("User not authorized to remove a Annotation");
			try
			{
				Annotation ProcCnt  = DataPortal.Fetch<Annotation>(new getAnnotationCountProcCriteria(typID, procList));
				AnnotationInfo.StaticOnInfoChanged();
				return Annotation.ProcCnt;
				//return Int32.Parse(ProcCnt);
			}
			catch (Exception ex)
			{
				System.Data.SqlClient.SqlException exSQL = SqlException(ex);
				if (exSQL != null && exSQL.Message.Contains("###Cannot retrieve Item###"))
					throw exSQL;
				Console.WriteLine("AnnotationExt: Stacktrace = {0}", ex.StackTrace);
				throw new DbCslaException("Error on getAnnotationCountProcCriteria", ex);
			}
		}

		public static int getAnnotationCountDocv(int typID, string procList)
		{
			if (!CanGetObject())
				throw new System.Security.SecurityException("User not authorized to remove a Annotation");
			try
			{
				Annotation DocvCnt = DataPortal.Fetch<Annotation>(new getAnnotationCountDocvCriteria(typID, procList));
				AnnotationInfo.StaticOnInfoChanged();
				return Annotation.DocvCnt;
			}
			catch (Exception ex)
			{
				System.Data.SqlClient.SqlException exSQL = SqlException(ex);
				if (exSQL != null && exSQL.Message.Contains("###Cannot retrieve Item###"))
					throw exSQL;
				Console.WriteLine("AnnotationExt: Stacktrace = {0}", ex.StackTrace);
				throw new DbCslaException("Error on getAnnotationCountDocvCriteria", ex);
			}
		}

		private static System.Data.SqlClient.SqlException SqlException(Exception ex)
		{
			Type sqlExType = typeof(System.Data.SqlClient.SqlException);
			while (ex != null)
			{
				if (ex.GetType() == sqlExType) return ex as System.Data.SqlClient.SqlException;
				ex = ex.InnerException;
			}
			return null;
		}

		[Serializable()]
		protected class DeleteCriteria
		{
			private int _AnnotationID;
			public int AnnotationID
			{ get { return _AnnotationID; } }
			private string _UserID;
			public string UserID
			{
				get { return _UserID; }
				set { _UserID = value; }
			}
			public DeleteCriteria(int annotationID, String userID)
			{
				_AnnotationID = annotationID;
				_UserID = userID;
			}
		}
		[Transactional(TransactionalTypes.TransactionScope)]
		private void DataPortal_Delete(DeleteCriteria criteria)
		{
			if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] Item.DataPortal_Delete", GetHashCode());
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandTimeout = Database.SQLTimeout;
						cm.CommandText = "deleteAnnotationWithUserID";
						cm.Parameters.AddWithValue("@AnnotationID", criteria.AnnotationID);
						cm.Parameters.AddWithValue("@UserID", criteria.UserID);
						cm.ExecuteNonQuery();
					}
				}
			}
			catch (Exception ex)
			{
				if (_MyLog.IsErrorEnabled) _MyLog.Error("Item.DataPortal_Delete", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("Item.DataPortal_Delete", ex);
			}
		}

		[Serializable()]
		protected class DeleteAnnotationProcByTypeCriteria
		{
			private int _typeID;
			public int TypeID
			{ get { return _typeID; } }

			private string _procList;
			public string ProcList
			{ get { return _procList; } }
			public DeleteAnnotationProcByTypeCriteria(int typeID, string procList)
			{
				_typeID = typeID;
				_procList = procList;
			}
		}
		[Transactional(TransactionalTypes.TransactionScope)]
		private void DataPortal_Delete(DeleteAnnotationProcByTypeCriteria criteria)
		{
			if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] Item.DataPortal_Delete", GetHashCode());
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandTimeout = Database.SQLTimeout;
						cm.CommandText = "deleteAnnotationsProcByType";
						cm.Parameters.AddWithValue("@typeid", criteria.TypeID);
						cm.Parameters.AddWithValue("@procList", criteria.ProcList);
						cm.ExecuteNonQuery();
					}
				}
			}
			catch (Exception ex)
			{
				if (_MyLog.IsErrorEnabled) _MyLog.Error("Item.DataPortal_Delete", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("Item.DataPortal_Delete Annotations by group", ex);
			}
		}

		[Serializable()]
		protected class DeleteAnnotationDocvByTypeCriteria
		{
			private int _typeID;
			public int TypeID
			{ get { return _typeID; } }

			private string _versionID;
			public string VersionID
			{ get { return _versionID; } }
			public DeleteAnnotationDocvByTypeCriteria(int typeID, string versionID)
			{
				_typeID = typeID;
				_versionID = versionID;
			}
		}
		[Transactional(TransactionalTypes.TransactionScope)]
		private void DataPortal_Delete(DeleteAnnotationDocvByTypeCriteria criteria)
		{
			if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] Delete Annotations by Type Docv", GetHashCode());
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandTimeout = Database.SQLTimeout;
						cm.CommandText = "deleteAnnotationsDocvByType";
						cm.Parameters.AddWithValue("@typeid", criteria.TypeID);
						cm.Parameters.AddWithValue("@docvList", criteria.VersionID);
						cm.ExecuteNonQuery();
					}
				}
			}
			catch (Exception ex)
			{
				if (_MyLog.IsErrorEnabled) _MyLog.Error("Item.DataPortal_Delete", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("Item.DataPortal_Delete Annotations by type Docv", ex);
			}
		}

		private static int _procCnt;
		public static int ProcCnt
		{
			get { return _procCnt; }
			set { _procCnt = value; }
		}

		[Serializable()]
		protected class getAnnotationCountProcCriteria
		{
			private int _procCnt;
			public int ProcCnt
			{ get { return _procCnt; }
			  set { _procCnt = value; }
			}
			private int _typeID;
			public int TypeID
			{ get { return _typeID; } }
			private string _procList;
			public string ProcList
			{ get { return _procList; } }
			public getAnnotationCountProcCriteria(int typeID, string procList, int procCnt = 0)
			{
				_typeID = typeID;
				_procList = procList;
				_procCnt = procCnt;
			}
		}

		[Transactional(TransactionalTypes.TransactionScope)]
		private getAnnotationCountProcCriteria DataPortal_Fetch(getAnnotationCountProcCriteria criteria)
		{
			if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] Item.DataPortal_Fetch", GetHashCode());
			try
			{
				//int ProcCnt;
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandTimeout = Database.SQLTimeout;
						cm.CommandText = "getAnnotationProcCount";						
						cm.Parameters.AddWithValue("@procList", criteria.ProcList);
						cm.Parameters.AddWithValue("@typeid", criteria.TypeID);
						Annotation.ProcCnt = (int)cm.ExecuteScalar();

					}
				}
				return criteria; //_procCnt.ToString();
			}
			catch (Exception ex)
			{
				if (_MyLog.IsErrorEnabled) _MyLog.Error("Annotation.GetAnnotationProcCnt", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("Annotation.GetAnnotationProcCnt by group", ex);
			}
		}

		private static int _docvCnt;
		public static int DocvCnt
		{ get { return _docvCnt; } 
		set { _docvCnt = value; }
		}

		[Serializable()]
		protected class getAnnotationCountDocvCriteria
		{
			private int _docvCnt;
			public int DocvCnt
			{ get { return _docvCnt; }
			  set { _docvCnt = value; }
			}
			private int _TypeID;
			public int TypeID
			{ get { return _TypeID; } }
			private string _docvList;
			public string DocvList
			{ get { return _docvList; } }
			public getAnnotationCountDocvCriteria(int typeID, string docvList, int docvCnt = 0)
			{
				_TypeID = typeID;
				_docvList = docvList;
				_docvCnt = docvCnt;
			}
		}

		[Transactional(TransactionalTypes.TransactionScope)]
		private getAnnotationCountDocvCriteria DataPortal_Fetch(getAnnotationCountDocvCriteria criteria)
		{
			if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] Annotation.DataPortal_Fetch", GetHashCode());
			try
			{
				//int ProcCnt;
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandTimeout = Database.SQLTimeout;
						cm.CommandText = "getAnnotationDocvCount";
						cm.Parameters.AddWithValue("@typeid", criteria.TypeID);
						cm.Parameters.AddWithValue("@DocvList", criteria.DocvList);
						Annotation.DocvCnt = (int)cm.ExecuteScalar();
					}
					return criteria;
				}
			}
			catch (Exception ex)
			{
				if (_MyLog.IsErrorEnabled) _MyLog.Error("Item.DataPortal_Delete", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("Item.DataPortal_Delete Annotations by group", ex);
			}
		}
	}
}