// ========================================================================
// Copyright 2006 - Volian Enterprises, Inc. All rights reserved.          
// Volian Enterprises - Proprietary Information - DO NOT COPY OR DISTRIBUTE
// ------------------------------------------------------------------------
// $Workfile: $     $Revision: $                                           
// $Author: $   $Date: $                                                   
//                                                                         
// $History: $                                                             
// ========================================================================

using System;
using System.Data;
using System.Data.SqlClient;
using Csla;
using Csla.Data;
using System.Configuration;
using System.IO;
using System.Drawing;
using System.Collections.Generic;
using System.ComponentModel;
using System.Text.RegularExpressions;
using System.Linq;

namespace VEPROMS.CSLA.Library
{
	public partial class Folder : IVEDrillDown
	{
		#region Folder Config
		[NonSerialized]
		private FolderConfig _FolderConfig;
		public FolderConfig FolderConfig
		{
			get
			{
				if (_FolderConfig == null)
				{
					_FolderConfig = new FolderConfig(this);
					_FolderConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_FolderConfig_PropertyChanged);
				}
				return _FolderConfig;
			}
		}
		public void FolderConfigRefresh()
		{
			_FolderConfig = null;
		}
		private void _FolderConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
		{
			Config = _FolderConfig.ToString();
		}
		#endregion
		public override string ToString()
		{
			return _Title;
		}
		#region IVEReadOnlyItem
		//public System.Collections.IList GetChildren()
		//{
		//  if (FolderDocVersionCount != 0) return FolderDocVersions;
		//  if (ChildFolderCount != 0) return ChildFolders;
		//  return null;
		//}
		//public bool HasChildren
		//{
		//  get { return _FolderDocVersionCount > 0 || _ChildFolderCount > 0; }
		//}
		//public IVEDrillDown ActiveParent
		//{
		//  get
		//  {
		//    return MyParent;
		//  }
		//}
		//private Format _ActiveFormat = null;
		//public Format ActiveFormat
		//{
		//  get
		//  {
		//    if (_ActiveFormat == null)
		//      _ActiveFormat = (LocalFormat != null ? LocalFormat : ActiveParent != null ? ActiveParent.ActiveFormat : null);
		//    return _ActiveFormat;
		//  }
		//  set
		//  {
		//    _ActiveFormat = null; // Reset
		//  }
		//}
		//public Format LocalFormat
		//{
		//  get { return MyFormat; }
		//}
		public ConfigDynamicTypeDescriptor MyConfig
		{
			get { return FolderConfig; }
		}
		#endregion
		#region MakeFolders for ManualOrder
		public static Folder MakeFolder(Folder myParent, Connection myConnection, string name, string title, string shortName, Format myFormat, string config, DateTime dts, string usrID)
		{
			return MakeFolder(myParent, myConnection, name, title, shortName, myFormat, null, config, dts, usrID);
		}
		public static Folder MakeFolder(Folder myParent, Connection myConnection, string name, string title, string shortName, Format myFormat, string config)
		{
			return MakeFolder(myParent, myConnection, name, title, shortName, myFormat, null, config);
		}
		#endregion
		public FolderInfo MyFolderInfo
		{ get { return FolderInfo.Get(FolderID); } }
	}
	public partial class FolderInfo:IVEDrillDownReadOnly
	{
		#region Search Paths
		public string _SearchDVPath;
		public string SearchDVPath 
		{
			get 
			{
				if (_SearchDVPath == null)
				{
					if (ActiveParent == null) 
						_SearchDVPath = Name;
					else
						_SearchDVPath = ActiveParent.SearchDVPath + "\u0007" + Name;
				}
				return _SearchDVPath;
			} 
		}
		public string SearchPath { get { return ""; } }

		// B2021-076: Proms search results are not presented in order when printed to PDF
		public string SearchDefaultSort { get { return string.Empty; } }
		
		#endregion
		#region Folder Config (Read-Only)
		[NonSerialized]
		private FolderConfig _FolderConfig;
		public FolderConfig FolderConfig
		{ get {
			return (_FolderConfig != null ? _FolderConfig : _FolderConfig = new FolderConfig(this)); 
		} }
		private void FolderConfigRefresh()
		{
			_FolderConfig = null;
		}
		#endregion
		#region SortingChildren
		private static bool IsInManualOrderNullFix = false;

		[NonSerialized]
		public Csla.SortedBindingList<FolderInfo> _SortedChildFolders;
		public Csla.SortedBindingList<FolderInfo> SortedChildFolders
		{
			get
			{
				if (ChildFolders != null)
				{
					//B2025-018 Issues with folder order in tree view
					// if any ChildFolders with a missing Manual Order
					// set them to the end of the list
					// use IsInManualOrderNullFix - so, if setting ChildFolders Currently, 
					// do not try to set them (thus creating an infinite loop)
					if (!IsInManualOrderNullFix && ChildFolders.Any(x => x.ManualOrder == null))
					{
						IsInManualOrderNullFix = true;
						foreach (FolderInfo fi in ChildFolders.Where(x => x.ManualOrder == null))
						{
							using (FolderInfo parfolderinfo = FolderInfo.Get(fi.ParentID))
							{
								using (Folder fldr = fi.Get())
								{
									fldr.ManualOrder = parfolderinfo.NewManualOrder(9999);
									fldr.Save();
								}
							}
						}
						RefreshChildFolders();
						IsInManualOrderNullFix = false;
					}

					if (_SortedChildFolders == null)
					{
						_SortedChildFolders = new SortedBindingList<FolderInfo>(ChildFolders);
						//_SortedChildFolders.ApplySort("FolderID", ListSortDirection.Ascending);
						//_SortedChildFolders.ApplySort("Name", ListSortDirection.Ascending);
					}
					else if (_SortedChildFolders.Count != ChildFolders.Count)
					{
						_SortedChildFolders = new SortedBindingList<FolderInfo>(ChildFolders);
					}
					_SortedChildFolders.ApplySort("ManualOrder", ListSortDirection.Ascending);
				}
				return _SortedChildFolders;
			}
		}

		//B2025-018 Issues with folder order in tree view
		//Note: this should be called from the parent item
		//As you want to put this into the sorted order of the parent item
		public double? NewManualOrder(int index)
		{
			double? retval = 1;
			if (SortedChildFolders == null || SortedChildFolders.Count == 0)
				retval = 1; // First value
			else if (index == 0)
			{
				if (retval >= SortedChildFolders[index].ManualOrder) // If one is too big, then divide first value in half
					retval = SortedChildFolders[index].ManualOrder / 2.0;
			}
			else if (SortedChildFolders.Count > index)
			{
				//B2025-018 Issues with folder order in tree view
				//filter to just items with the same parent
				//want new order to be halfway between the previous item
				//and the next ManualOrder
				var tmp = SortedChildFolders.Where(x => x.ParentID == FolderID);
				var lbound = SortedChildFolders[index - 1].ManualOrder;
				var ubound = tmp.OrderBy(y => y.ManualOrder).FirstOrDefault(x => x.ManualOrder > lbound)?.ManualOrder;
				if (ubound != null)
				{
					retval = ((ubound - lbound) / 2.0) + lbound;
				}
				else
				{
					//in this case, item before is highest for that parent
					//so just make this 1 more
					retval = lbound + 1;
				}
			}
			else
			{
				if (index >= SortedChildFolders.Count) index = SortedChildFolders.Count;
				retval += SortedChildFolders[index - 1].ManualOrder;
			}
			return retval;
		}
		/// <summary>
		/// UniqueChildName will check the existing children to assure that the name is not a duplicate name.
		/// </summary>
		/// <param name="folderName"></param>
		/// <returns></returns>
		public string UniqueChildName(string folderName)
		{
			string retval = folderName;
			int iSuffix = -1;
			RefreshChildFolders();
			foreach (FolderInfo fi in ChildFolders)
			{
				if (fi.Name.StartsWith(folderName))
				{
					if (fi.Name == folderName)
						iSuffix = 0;
					else if (Regex.IsMatch(fi.Name, folderName + "[_][0-9]+"))
					{
						int ii = int.Parse(fi.Name.Substring(1 + folderName.Length));
						if (ii > iSuffix) iSuffix = ii;
					}
				}
			}
			if (iSuffix >= 0)
				retval = string.Format("{0}_{1}", folderName, iSuffix + 1);
			// Console.WriteLine("FolderName = '{0}'", retval);
			return retval;
		}
		#endregion
		#region IVEReadOnlyItem
		public System.Collections.IList GetChildren()
		{
			if(FolderDocVersionCount != 0)return FolderDocVersions;
			//if (ChildFolderCount != 0) return ChildFolders;
			if (ChildFolderCount != 0) return SortedChildFolders;
			return null;
		}
		//public bool ChildrenAreLoaded
		//{
		//  get { return _FolderDocVersions != null || _ChildFolders != null; }
		//}
		public bool HasChildren
		{
			get { return FolderDocVersionCount > 0 || ChildFolderCount > 0; }
		}
		public IVEDrillDownReadOnly ActiveParent
		{
			get
			{
				return MyParent;
			}
		}
		public FormatInfo ActiveFormat
		{
			get { return LocalFormat != null ? LocalFormat : ( ActiveParent != null ? ActiveParent.ActiveFormat : null); }
		}
		public FormatInfo LocalFormat
		{
			get { return MyFormat; }
		}
		public ConfigDynamicTypeDescriptor MyConfig
		{
			get { return FolderConfig; }
		}
		/// <summary>
		/// These settings are set on the user interface side.
		/// This is used to control whether the Name and/or Title is displayed
		/// next to the tree nodes in the user interface
		/// </summary>
		private bool _DisplayTreeNodeNames =   true;
		public bool DisplayTreeNodeNames
		{
			get { return _DisplayTreeNodeNames; }
			set { _DisplayTreeNodeNames = value; }
		}
		private bool _DisplayTreeNodeTitles = false;

		public bool DisplayTreeNodeTitles
		{
			get { return _DisplayTreeNodeTitles; }
			set { _DisplayTreeNodeTitles = value; }
		}
		public override string ToString()
		{
			// assume that at least one of the two options was selected
			string rtnstr = "";
			if ( _DisplayTreeNodeNames) rtnstr = Name;
			if (_DisplayTreeNodeTitles)
			{
				if (rtnstr.Length > 0) rtnstr += " - ";
				rtnstr += Title;
			}
			return rtnstr;
			//return string.Format("{0} - {1}", Name, Title);
		}
		//public string ToString(string str, System.IFormatProvider ifp)
		//{
		//  return ToString();
		//}
		#endregion
		public Color BackColor
		{ get { return FolderConfig.Default_BkColor; } }
		public bool HasWorkingDraft
		{
			get
			{
				if (FolderDocVersionCount > 0)
				{
					foreach (DocVersionInfo dvi in FolderDocVersions)
						if (dvi.VersionType == 0)
							return true;
				}
				return false;
			}
		}
		#region Extension
		partial class FolderInfoExtension : extensionBase
		{
			public override void Refresh(FolderInfo tmp)
			{
				tmp.FolderConfigRefresh();
			}
		}
		public static FolderInfo GetTop()
		{
			//if (!CanGetObject())
			//  throw new System.Security.SecurityException("User not authorized to view a Folder");
			try
			{
				FolderInfo tmp = DataPortal.Fetch<FolderInfo>(new TopCriteria());
				if (tmp.ErrorMessage == "No Record Found")
				{
					tmp.Dispose(); // Clean-up FolderInfo
					tmp = null;
				}
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on FolderInfo.GetTop", ex);
			}
		}
		private void DataPortal_Fetch(TopCriteria criteria)
		{
			if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] FolderInfo.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 = "getTopFolder";
						cm.CommandTimeout = Database.DefaultTimeout;
						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("FolderInfo.DataPortal_Fetch", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("FolderInfo.DataPortal_Fetch", ex);
			}
		}
		#endregion
		[Serializable()]
		protected class TopCriteria
		{
			public TopCriteria() { ;}
		}
		public bool IsFolder
		{
			get
			{
				return true;
			}
		}
		public bool IsDocVersion
		{
			get
			{
				return false;
			}
		}
		public bool IsProcedure
		{
			get
			{
				return false;
			}
		}
		public bool IsSection
		{
			get
			{
				return false;
			}
		}
		public bool IsStep
		{
			get
			{
				return false;
			}
		}
	}
	
}