using Sarand.BusinessMgr.Net.Standard.Base.App;
using Sarand.BusinessMgr.Net.Standard.Base.Bus;
using Sarand.BusinessMgr.Net.Standard.Dbas.Bus;
using Sarand.Net.Standard.Base.App;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Dbas;
using Sarand.Net.Standard.Base.Utils;
using Sarand.Net.Standard.Dbas.Data;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Sarand.BusinessMgr.Net.Standard.Dbas.Mgr
{
	//=======================================================================
	partial class SbmProcessMgr_Dbas
	{
		//*******************************************************************
		//                    I t e m   P r o c e s s e s
		//*******************************************************************
		// Data members.

		//-------------------------------------------------------------------
		// Utilites.
		public override bool StoreItemProcesses(Sbm.ItemType itemType, SysId itemId, List<SbmItemProcess> itemProcesses, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();

			// Validate parameters.
			if (itemType != Sbm.ItemType.Commodity && itemType != Sbm.ItemType.AssetCategory && itemType != Sbm.ItemType.Asset) return SetErrorState("invalid item type");
			if (!SysId.IsValid(itemId)) return SetErrorState("invalid item Id");

			//---------------------------------------------------------------
			// Validate the content of the list.
			List<SbmItemProcess> itemProcessesToStore = new List<SbmItemProcess>(itemProcesses);
			itemProcessesToStore.Resequence();
			foreach (SbmItemProcess itemProcess in itemProcessesToStore)
			{
				if (itemProcess == null) return SetErrorState("invalid item in list");
				if (itemProcess.ItemType > 0 && itemProcess.ItemType != itemType) return SetErrorState("invalid item type in list");
				if (SysId.IsValid(itemProcess.ItemId) && itemProcess.ItemId != itemId) return SetErrorState("invalid item id in list");
				// Set the item's attributes.
				itemProcess.ItemType = itemType;
				itemProcess.ItemId = itemId;
			}

			//---------------------------------------------------------------
			// Retrieve all links of this type that already exist.
			SbmItemLink.Params prm = new SbmItemLink.Params();
			prm.ItemTypeFrom = itemType;
			prm.ItemIdFrom = itemId;
			prm.ItemTypeTo = Sbm.ItemType.Process;
			foreach (SbmItemLink itemLink in DataItemMgr.GetItemLinkList(prm))
			{
				// Is this process still in the list.
				SysId processId = itemLink.ItemIdTo;
				SbmItemProcess itemProcess = itemProcessesToStore.Find(item => item.ProcessId.Equals(processId));
				if (itemProcess != null)
				{
					// Process is still in the list - update it.
					if (itemProcess.Changed)
					{
						// Process is still in the list - update the link.
						itemLink.ItemLinkType = Sbm.ItemLinkType.ItemProcess;
						if (!DataItemMgr.UpdateItemLink(itemLink, dbUpdateInfo))
							return SetErrorState("failed to update item link - " + DataItemMgr.ErrorStateMessage);
					}
					// Remove this Process from the list so that it is not processed again.
					itemProcessesToStore.Remove(itemProcess);
				}
				else
				{
					// Process is no longer in the list - remove it.
					if (!DataItemMgr.DeleteItemLink(itemLink, dbUpdateInfo))
						return SetErrorState("failed to remove item link - " + DataItemMgr.ErrorStateMessage);
				}
			}

			//---------------------------------------------------------------------
			// Create any process links that remain in the list.
			foreach (SbmItemProcess itemProcess in itemProcessesToStore)
			{
				SbmItemLink itemLink = DataItemMgr.CreateItemLink(prm.ItemLinkType, prm.ItemTypeFrom, prm.ItemIdFrom, prm.ItemTypeTo, prm.ItemIdTo);
				{
					// Create and insert item link.
					itemType = itemProcess.ItemType;
					itemLink.ItemLinkType = Sbm.ItemLinkType.ItemProcess; // Nov-08 Was Sbm.ItemLink_ItemCostEstimate
					itemLink.ItemTypeFrom = itemType;
					itemLink.ItemIdFrom = itemProcess.ItemId;
					itemLink.ItemTypeTo = Sbm.ItemType.Process;
					itemLink.ItemIdTo = itemProcess.ProcessId;
					if (!DataItemMgr.InsertItemLink(itemLink, dbUpdateInfo))
						return SetErrorState("failed to insertitem link - " + DataItemMgr.ErrorStateMessage);
				}
			}
			return false;
		}

		//-------------------------------------------------------------------
		// Get ItemProcess.
		public override SbmItemProcess GetProcessForItem(Sbm.ItemType itemType, SysId itemId, SysId processId)
		{
			ClearErrorState();
			if ((int)itemType < 1 && !SysId.IsValid(itemId) && !SysId.IsValid(processId)) return null;
			SbmItemProcess.Params prmItemProcess = new SbmItemProcess.Params();
			prmItemProcess.ItemType = itemType;
			prmItemProcess.ItemId = itemId;
			prmItemProcess.ProcessId = processId;
			List<SbmItemProcess> itemProcesses = GetProcessesForItem(prmItemProcess);
			foreach (SbmItemProcess itemProcess in itemProcesses)
			{
				if (itemProcess.ProcessId.Equals(processId))
					return itemProcess;
			}
			return null;
		}
		public override List<SbmItemProcess> GetProcessesForItem(Sbm.ItemType itemType, SysId itemId, bool activeOnly)
		{
			ClearErrorState();
			if ((int)itemType < 1 && !SysId.IsValid(itemId) && activeOnly) return null;
			SbmItemProcess.Params prmItemProcess = new SbmItemProcess.Params();
			prmItemProcess.ItemType = itemType;
			prmItemProcess.ItemId = itemId;
			prmItemProcess.RestrictToActive = activeOnly;
			return GetProcessesForItem(prmItemProcess);
		}

		public override List<SbmItemProcess> GetProcessesForItem(SbmItemProcess.Params prm)
		{
			ClearErrorState();
			List<SbmItemProcess> itemProcesses = new List<SbmItemProcess>();
			if (prm.ItemType != Sbm.ItemType.Commodity && prm.ItemType != Sbm.ItemType.AssetCategory && prm.ItemType != Sbm.ItemType.Asset) SetErrorState("invalid item type");
			if (!SysId.IsValid(prm.ItemId)) SetErrorState("invalid item Id");

			// Various aliases to distinguish column names.
			String aliasCol_ItemType = "ItemType";
			String aliasCol_ProcessCategory = "ProcCategory";
			String aliasCol_ProcessType = "ProcType";
			// Build the query to retrieve item processes and associated process details.
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.ItemLink));
			qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Process));
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_ItemTypeFrom), aliasCol_ItemType);
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_ItemIdFrom));
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_ItemTypeTo));
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_ItemIdTo));
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_Completed));
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_Seq));
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_Notes));
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_Flags));
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_Status));
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Id));
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Category), aliasCol_ProcessCategory);
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Type), aliasCol_ProcessType);
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_DescBrief));
			qry.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_DescOutline));

			// Filter the link type - NB 'Sbm.ItemLink_ItemCostEstimate' is included as a valid value as this was used (incorrectly) in versions of the system up to Nov-08.
			qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_Type) + "=" + ((int)Sbm.ItemLinkType.ItemProcess).ToString() + " OR " + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_Type) + "=" + ((int)Sbm.ItemLinkType.ItemCostEstimate).ToString());
			// Filter to the required 'From' item (the data item):
			qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_ItemTypeFrom) + "=" + ((int)prm.ItemType).ToString());
			qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_ItemIdFrom) + "=" + prm.ItemId.ToString());
			qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_ItemTypeTo) + "=" + ((int)Sbm.ItemType.Process).ToString());
			qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_ItemIdTo) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Process_Id));
			if (SysId.IsValid(prm.ProcessId))
				qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_ItemIdTo) + "=" + prm.ProcessId.ToString());

			// 'Active' processes.
			if (prm.RestrictToActive)
			{
				String statusActive = SacsSystem.GetStatusCode(SaStatus.Active);
				qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_Status) + "='" + statusActive + "'");
			}
#if _DEBUG
			//qry.Dump (::afxDump);
#endif

			// Filter the 'To' item to match the process.
			using (DbResultSet dbResultSet = DbResultSet_DataReader.ExecuteQuery(Database, qry.ToString()))
			{
				if (dbResultSet != null && dbResultSet.NextRecord())
				{
					NamedValue.Map values = dbResultSet.GetRecordValues();

					// Create the list if required.
					if (itemProcesses.Count == 0) itemProcesses = new List<SbmItemProcess>();
					// Create the item process.
					Sbm.ItemType itemType = EnumUtil.ParseEnum(values.GetValue(aliasCol_ItemType).ToString(), Sbm.ItemType.Unknown);
					SysId itemId = new SysId((int)values.GetValue(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.ItemLink_ItemIdFrom)).AsLong());
					SysId processId = new SysId((int)values.GetValue(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.ItemLink_ItemIdTo)).AsLong());
					SbmItemProcess_Dbas itemProcess_Dbas = new SbmItemProcess_Dbas(Internals, itemType, itemId, processId, (ushort)values.GetValue(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.ItemLink_Flags)).AsLong());

					if (itemProcess_Dbas != null)
					{
						itemProcess_Dbas.Completed = values.GetValue(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.ItemLink_Completed)).AsDateTime();
						itemProcess_Dbas.Seq = (short)values.GetValue(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.ItemLink_Seq)).AsLong();
						itemProcess_Dbas.Notes = values.GetValue(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.ItemLink_Notes)).AsString();
						itemProcess_Dbas.Status = SbmSystem.GetStatusForCode(values.GetValue(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.ItemLink_Status)).AsString());
						itemProcess_Dbas.ProcessCategory = EnumUtil.ParseEnum(values.GetValue(aliasCol_ProcessCategory).AsString(), Sbm.ProcessCategory.Unknown);
						//itemProcess_Dbas.ProcessType ((Sbm.ProcessType)values.GetValue(sAliasColProcType)).AsShort();
						itemProcess_Dbas.ProcessDescBrief = values.GetValue(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Process_DescBrief)).AsString();
						itemProcess_Dbas.ProcessDescOutline = values.GetValue(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Process_DescOutline)).AsString();
					}
					itemProcess_Dbas.AcceptChanges();
					// Ensure that the process is unique:
					if (!itemProcesses.FindByProcessId(itemProcess_Dbas.ProcessId))
						itemProcesses.Add(itemProcess_Dbas);
					itemProcess_Dbas = null;  // Item now owned by the list.
				}
			}


			if (itemProcesses.Count > 0) itemProcesses.Sort();
			return itemProcesses;
		}

		//-------------------------------------------------------------------
		// Has ItemProcess.
		public override bool HasItemProcesses(Sbm.ItemType itemType, SysId itemId)
		{
			ClearErrorState();
			if (itemType != Sbm.ItemType.Commodity && itemType != Sbm.ItemType.AssetCategory && itemType != Sbm.ItemType.Asset) return SetErrorState("invalid item type");
			if (!SysId.IsValid(itemId)) return SetErrorState("invalid item Id");
			if (Database == null) return SetErrorState("database unavailable");
			// Query the number of matching links.
			List<String> filters = new List<String>();
			filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_ItemTypeFrom) + "=" + ((int)itemType).ToString());
			filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_ItemIdFrom) + "=" + itemId.ToString());
			filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.ItemLink_ItemTypeTo) + "=" + ((int)Sbm.ItemType.Process).ToString());
			return Database.GetRowCount(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.ItemLink), filters.Concat(" AND ")) > 0;
		}


		//-------------------------------------------------------------------
		// Create ItemProcess.
		public override SbmItemProcess CreateItemProcess(Sbm.ItemType itemType, SysId itemId, SysId processId)
		{
			ClearErrorState();
			SbmItemProcess_Dbas itemProcess_Dbas = null;
			if (itemType == Sbm.ItemType.Commodity || itemType == Sbm.ItemType.Requirement || itemType == Sbm.ItemType.AssetCategory || itemType == Sbm.ItemType.Asset)
			{
				// Retrieve the stated process:
				SbmProcess process = GetProcessById(processId);
				if (process != null)
				{
					itemProcess_Dbas = new SbmItemProcess_Dbas(Internals, itemType, itemId, processId, 0);
					//itemProcess_Dbas.Status  = process.Status;
					itemProcess_Dbas.Notes = process.Notes;
					itemProcess_Dbas.ProcessCategory = process.ProcessCategory;
					//itemProcess_Dbas.ProcessType  = process.Type;
					itemProcess_Dbas.ProcessDescBrief = process.DescBrief;
					itemProcess_Dbas.ProcessDescOutline = process.DescOutline;
				}
			}
			else SetErrorState("invalid item type");
			return itemProcess_Dbas;
		}

		public override SbmItemProcess CreateItemProcessForConstituent(SbmConstituent constituent)
		{
			ClearErrorState();
			SbmItemProcess_Dbas itemProcess_Dbas = null;
			if (constituent != null)
			{
				// Retrieve the stated process.
				SbmProcess process = GetProcessById(constituent.ProcessId);
				if (process != null)
				{
					// Create an item process from this constituent. - NB constituent flags should not be relevant.
					itemProcess_Dbas = new SbmItemProcess_Dbas(Internals, Sbm.ItemType.Requirement, constituent.RequirementId, constituent.ProcessId, 0);
					itemProcess_Dbas.Seq = constituent.Seq;
					itemProcess_Dbas.Completed = constituent.Completed;
					itemProcess_Dbas.AssocIdContractor = constituent.AssociationIdContractor;
					itemProcess_Dbas.AmountNet = constituent.AmountNet;
					itemProcess_Dbas.Notes = constituent.Notes;
					itemProcess_Dbas.Status = constituent.Status;
					// Copy the process details (for reference only).
					itemProcess_Dbas.ProcessCategory = process.ProcessCategory;
					//itemProcess_Dbas.ProcessType = process.ProcessType;
					itemProcess_Dbas.ProcessDescBrief = process.DescBrief;
					itemProcess_Dbas.ProcessDescOutline = process.DescOutline;
				}
			}
			else SetErrorState("invalid item type");
			return itemProcess_Dbas;
		}


		//-------------------------------------------------------------------
		// Validate ItemProcess.
		public override bool IsValidItemProcessData(SbmItemProcess.Data data, SbmItemProcess.ErrField errField)
		{
			ClearErrorState();
			if (!base.IsValidItemProcessData(data, errField)) return false;
			return true;
		}

		//-------------------------------------------------------------------
		// Update ItemProcess.
		public override bool UpdateProcessesForItem(Sbm.ItemType itemType, SysId itemId, List<SbmItemProcess> itemProcesses)
		{
			bool update = true;
			ClearErrorState();
			//---------------------------------------------------------------------
			if (itemType != Sbm.ItemType.Commodity && itemType != Sbm.ItemType.AssetCategory && itemType != Sbm.ItemType.Asset) return SetErrorState("invalid item type");
			if (!SysId.IsValid(itemId)) return SetErrorState("invalid item Id");

			//---------------------------------------------------------------------
			// Validate the content of the list.
			if (itemProcesses.Count > 0) itemProcesses.Resequence();
			if (itemProcesses.Count > 0)
			{
				foreach (SbmItemProcess itemProcess in itemProcesses)
				{
					if (itemProcess == null)
					{
						update = SetErrorState("invalid item in list");
						break;
					}
					if (itemProcess.ItemType > 0 && itemProcess.ItemType != itemType)
					{
						update = SetErrorState("invalid item type in list");
						break;
					}
					if (SysId.IsValid(itemProcess.ItemId) && itemProcess.ItemId != itemId)
					{
						update = SetErrorState("invalid item id in list");
						break;
					}
					// Set the item's attributes.
					itemProcess.ItemType = itemType;
					itemProcess.ItemId = itemId;
				}
			}
			//---------------------------------------------------------------------
			// Make a copy of the list of process Ids so that we can keep track of those that have been updated already.
			List<SysId> processIds = new List<SysId>();
			if (itemProcesses.Count > 0) processIds = itemProcesses.GetProcessIds();
#if _DEBUG
			if (itemProcesses.Count > 0)
			{
				int i = itemProcesses.Len();
				String s = i.ToString();
			}
#endif

			//---------------------------------------------------------------------
			// Retrieve all links of this type that already exist.
			SbmItemLink.Params prm = new SbmItemLink.Params();
			prm.ItemTypeFrom = itemType;
			prm.ItemIdFrom = itemId;
			prm.ItemTypeTo = Sbm.ItemType.Process;

			List<SbmItemLink> itemLinks = DataItemMgr.GetItemLinkList(prm);
			if (itemLinks != null)
			{
				foreach (SbmItemLink itemLink in itemLinks)
				{
					// Is this process still in the list.
					SysId processId = itemLink.ItemIdTo;
					if (processIds.Exists(item => item.Id.Equals(processId)) && itemProcesses != null && itemProcesses.FindByProcessId(processId))
					{
						SbmItemProcess itemProcess = itemProcesses[0];
						if (itemProcess != null && itemProcess.Changed)
						{
							// Process is still in the list - update it.
							itemLink.ItemLinkType = Sbm.ItemLinkType.ItemProcess;
							CopyFrom(itemProcess, itemLink);
							if (!DataItemMgr.UpdateItemLink(itemLink, DbUpdateInfo)) update = SetErrorState("failed to update item link");
						}
						// Remove this Id from the list so that it is not processed again.
						processIds.Clear();
					}
					else
					{
						// Process is no longer in the list - remove it.
						if (!DataItemMgr.DeleteItemLink(itemLink, DbUpdateInfo))
							update = SetErrorState("failed to remove item link");
					}
				}
			}

			//---------------------------------------------------------------------
			// Create any process links that remain in the list.
			if (itemLinks.Count > 0)
			{
				foreach (SysId processId in processIds)
				{
					SbmItemProcess itemProcess = itemProcesses[0];
					if (itemProcess != null)
					{
						foreach (SbmItemLink itemLink in itemLinks)
						{
							// Identify the item and link types.
							Sbm.ItemType itemProcessType = itemProcess.ItemType;
							// Process is still in the list - update it.
							itemLink.ItemLinkType = Sbm.ItemLinkType.ItemProcess; // Nov-08 Was Sbm.ItemLink_ItemCostEstimate
							itemLink.ItemTypeFrom = itemProcessType;
							itemLink.ItemIdFrom = itemProcess.ItemId;
							itemLink.ItemTypeTo = Sbm.ItemType.Process;
							itemLink.ItemIdTo = processId;
							CopyFrom(itemProcess, itemLink);
							if (!DataItemMgr.UpdateItemLink(itemLink, DbUpdateInfo))
								update = SetErrorState("failed to update item link");
						}
					}
				}
			}
			return update;
		}

		private void CopyFrom(SbmItemProcess itemProcess, SbmItemLink itemLink)
		{
			itemLink.Seq = itemProcess.Seq;
			itemLink.Completed = itemProcess.Completed;
			itemLink.Notes = itemProcess.Notes;
			//itemLink.Flags = itemProcess.Flags;
			itemLink.Status = itemProcess.Status;
			/* Time stamp the record.
			TimeZone now = TimeZone.CurrentTimeZone;
			if (itemLink.CreateOn == 0)
			{
				itemLink.CreateOn = now;
				itemLink.CreateBy = SaSystem::GetUserId();
				itemLink.CreateHost = SaSystem::GetComputerName();
			}
			itemLink.UpdateOn = now;
			itemLink.UpdateBy = SaSystem::GetUserId();
			itemLink->sUpdateHost = SaSystem::GetComputerName();*/
		}

		//-------------------------------------------------------------------
	}
	//=======================================================================
}