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

namespace Sarand.Net.Standard.Dbas.UpdateLog
{
	//=======================================================================
	internal class SaUpdateLogMgr_Dbas : SaUpdateLogMgr
	{
		//-------------------------------------------------------------------
		// Data members.

		//-------------------------------------------------------------------
		// Static initialisation.
		static SaUpdateLogMgr_Dbas ()
		{
		}

		//-------------------------------------------------------------------
		// Construction.
		internal SaUpdateLogMgr_Dbas (SaUpdateLogConsole_Dbas updateLogConsole) :
			base(updateLogConsole)
		{
			Database = updateLogConsole.Database;
			DbInfo = new DbDataItem.DatabaseInfo(updateLogConsole.Database);
		}

		//-------------------------------------------------------------------
		// Properties.
		public String TableName_UpdateLog { get { return SaUpdateLogDbDfn.GetTableName(SaUpdateLogDbDfn.TableIdx.SaAttrUpdate); } }
		internal ISacsDatabase Database { get; }
		private DbDataItem.DatabaseInfo DbInfo { get; }
		public override bool DatabaseIsValid { get { return (Database != null && Database.GetTableNames().Contains(TableName_UpdateLog)); } }
		public override bool CanUpdateDatabase { get { return DatabaseIsValid; } }

		//*******************************************************************
		//                U p d a t e   L o g   E n t r i e s
		//*******************************************************************
		// Utilities.
		private String GetUpdateLogEntryFilter (SaUpdateLogEntry updateLogEntry)
		{
			return GetUpdateLogEntryFilter(updateLogEntry.ItemId, updateLogEntry.Attribute, updateLogEntry.Logged);
		}
		private String GetUpdateLogEntryFilter (ItemId itemId, String attribute, DateTime logged)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return "1=0";
			if (StringUtil.IsEmpty(attribute)) return "1=0";
			// Update Log Entry identifying values.
			SaUpdateLogEntry.Params prmLogEntry = new SaUpdateLogEntry.Params();
			prmLogEntry.IncludedItemIds.Add(itemId);
			prmLogEntry.IncludedAttributes.Add(attribute);
			prmLogEntry.Logged = logged;
			return GetLogEntryQueryFilter(prmLogEntry).Concat(" And ", "(", ")");
		}

		//-------------------------------------------------------------------
		// Update Log Entry exists.
		public override bool LogEntryExists (SaUpdateLogEntry updateLogEntry)
		{
			return LogEntryExists(updateLogEntry.ItemId, updateLogEntry.Attribute, updateLogEntry.Logged);
		}
		public override bool LogEntryExists (ItemId itemId, String attribute, DateTime logged)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return false;
			if (StringUtil.IsEmpty(attribute)) return false;
			return GetUpdateLogEntryCount(GetUpdateLogEntryFilter(itemId, attribute, logged)) == 1;
		}

		//-------------------------------------------------------------------
		// Get Log Entry.
		private SaUpdateLogEntry GetUpdateLogEntry (String filter)
		{
			ClearErrorState();
			if (GetUpdateLogEntryCount(filter) != 1) return null;
			SaUpdateLogEntry logEntry = null;
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					SaAttrUpdate_Db dbUpdateLog = new SaAttrUpdate_Db(DbInfo);
					dbUpdateLog.PopulateFrom(dbCommand, aliasUpdateLog, filter);
					logEntry = CreateLogEntry(new ItemId(dbUpdateLog._ItemType, new SysId(dbUpdateLog._ItemId)), dbUpdateLog._Attribute);
					PopulateFrom(dbUpdateLog, logEntry);
				}
				catch (Exception exc)
				{
					SetErrorState(Msg_DatabaseQueryException);
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return logEntry;
		}
		public override SaUpdateLogEntry GetLogEntry (ItemId itemId, String attribute, DateTime logged)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return null;
			if (StringUtil.IsEmpty(attribute)) return null;
			return GetUpdateLogEntry(GetUpdateLogEntryFilter(itemId, attribute, logged));
		}

		//-------------------------------------------------------------------
		// Create UpdateLog.
		public override SaUpdateLogEntry CreateLogEntry (ItemId itemId, String attribute)
		{
			ClearErrorState();
			return new SaUpdateLogEntry_Dbas(itemId, attribute, DateTime.Now, 0);
		}

		//-------------------------------------------------------------------
		// Validate UpdateLog.
		public override bool IsValidLogEntryData (SaUpdateLogEntry.Data logEntryData, SaUpdateLogEntry.ErrField errField)
		{
			ClearErrorState();
			if (!base.IsValidLogEntryData(logEntryData, errField)) return false;
			return true;
		}

		//-------------------------------------------------------------------
		// Log updates.
		public override bool LogUpdates (SaUpdateLogItemMonitor updateLogItemMonitor, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (updateLogItemMonitor == null) return SetErrorState("Invalid item update monitor");
			if (updateLogItemMonitor.ItemType < 1) return SetErrorState("Invalid item type");
			if (!SysId.IsValid(updateLogItemMonitor.ItemId)) return SetErrorState("Invalid item Id");
			if (!DatabaseIsValid) return SetErrorState("Update Log is not supported");
			if (!CanUpdateDatabase) return SetErrorState("Database cannot be updated");

			// Force initialisation of SaDbQuery DBMS type.
			DbQuery dbQry = new DbQuery(Database.DbmsType);

			// Retrieve list of attribute updates to be recorded:
			List<SaUpdateLogItemMonitor.AttrData> updatedAttributes = updateLogItemMonitor.AttrUpdates;
			if (updatedAttributes.Count < 1) return true;
			DateTime now = DateTime.Now;
			DateTime logged = DateTime.Now;

			// Build query details to insert new entries in update log:
			List<String> updateLogQueries = new List<string>();
			String qryPrefix = "INSERT INTO "+TableName_UpdateLog;

			// Add the column names:
			List<String> columnNames = new List<string>();
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemType, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemId, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Attribute, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataBefore, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataAfter, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Notes, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Flags, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Status, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateOn, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateBy, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateHost, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_UpdateOn, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_UpdateBy, false));
			columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_UpdateHost, false));
			qryPrefix += " (" + columnNames.Concat(",") + ")";

			// Add the column values.
			foreach (SaUpdateLogItemMonitor.AttrData attrData in updatedAttributes)
			{
				// Data values.
				String dataBefore = attrData.ValueBefore.ToString();
				String dataAfter  = attrData.ValueAfter.ToString();

				// Prepare list of column values:
				List<String> columnValue = new List<string>();
				columnValue.Add(updateLogItemMonitor.ItemType.ToString());
				columnValue.Add(SysId.ToString(updateLogItemMonitor.ItemId));
				columnValue.Add("'" + DbQuery.FormatForCondition(DbQuery.FormatForCondition(attrData.Name)) + "'");
				columnValue.Add(DbQuery.FormatDateTimeForCondition(logged, true, true));
				columnValue.Add("'" + DbQuery.FormatForCondition(dataBefore.Left((int)SaUpdateLogDbDfn.GetColTextLen(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataBefore))) + "'");
				columnValue.Add("'" + DbQuery.FormatForCondition(dataAfter.Left((int)SaUpdateLogDbDfn.GetColTextLen(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataAfter))) + "'");
				columnValue.Add("''");    // Notes
				columnValue.Add("0");     // Flags.
				columnValue.Add("'" + DbQuery.FormatForCondition(SacsSystem.GetStatusCode(SaStatus.Logged)) + "'");
				// Create stamp.
				columnValue.Add(DbQuery.FormatDateTimeForCondition(now, true, true));
				columnValue.Add(SysId.ToString(dbUpdateInfo.UserId, "0"));
				columnValue.Add("'" + DbQuery.FormatForCondition(dbUpdateInfo.Host) + "'");
				// Update stamp.
				columnValue.Add(DbQuery.FormatDateTimeForCondition(now, true, true));
				columnValue.Add(SysId.ToString(dbUpdateInfo.UserId, "0"));
				columnValue.Add("'" + DbQuery.FormatForCondition(dbUpdateInfo.Host) + "'");

				// Construct and add the query for this insert:
				updateLogQueries.Add(qryPrefix + " VALUES(" + columnValue.Concat(",") + ")");
			}

			// Execute the query to insert update log entries.
			if (!updateLogQueries.IsEmpty())
			{
				// Turn off display of database exceptions during update logging.
				bool ddDisplayErrorsPrev = Database.DisplayErrors;
				Database.DisplayErrors = false;
				// MS Access only allows a single statement to be executed at a time.
				bool executeStatementsSeparately = true;
				if (executeStatementsSeparately)
				{
					foreach (String query in updateLogQueries)
					{
						SaLogger.Debug($"{SysUtil.Fn} Query: {query}");
						Database.ExecuteNonQuery(query);
						if (Database.HasErrorState())
							SetErrorState("Failed to insert update log entries - " + Database.ErrorStateMessage);
					}
				}
				else
				{
					String query = updateLogQueries.Concat(";");
					SaLogger.Debug($"{SysUtil.Fn} Query: {query}");
					Database.ExecuteNonQuery(query);
					if (Database.HasErrorState())
						SetErrorState("Failed to insert update log entries - " + Database.ErrorStateMessage);
				}
				Database.DisplayErrors = ddDisplayErrorsPrev;
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Insert item.
		public override bool InsertLogEntry (SaUpdateLogEntry logEntry, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidLogEntry(logEntry)) return false;
			//if (logEntry.Id.IsValid()) return SetErrorState(ErrorMessage.ValiditemId);
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					SaAttrUpdate_Db dbUpdateLog = new SaAttrUpdate_Db(DbInfo);
					PopulateTo(dbUpdateLog, logEntry, dbUpdateInfo);
					if (SaAttrUpdate_Db.FieldsNonId.Contains("Id"))
					{
						// Update Log has no Id.
						//dbUpdateLog._Id = SysId.ToInt(Database.GetNextId("SaAttrUpdate", dbUpdateInfo));
					}
					dbUpdateLog.ExecuteInsertCommand(dbCommand);
					//logEntry.Id = new SysId(dbUpdateLog._Id);
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Update item.
		public override bool UpdateLogEntry (SaUpdateLogEntry logEntry, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidLogEntry(logEntry)) return false;
			//if (!logEntry.Id.IsValid()) return SetErrorState(ErrorMessage.InvalidItemId);
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve item.
					dbConnection.Open();
					SaAttrUpdate_Db dbUpdateLog = new SaAttrUpdate_Db(DbInfo);
					dbUpdateLog.PopulateFrom(dbCommand, aliasUpdateLog, GetUpdateLogEntryFilter(logEntry));
					// Update item.
					PopulateTo(dbUpdateLog, logEntry, dbUpdateInfo);
					dbUpdateLog.ExecuteUpdateCommand(dbCommand);
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Delete item.
		public override bool LogEntryCanBeDeleted (SaUpdateLogEntry logEntry)
		{
			ClearErrorState();
			if (!base.LogEntryCanBeDeleted(logEntry)) return false;
			return true;
		}
		public override bool DeleteLogEntry (SaUpdateLogEntry logEntry, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!LogEntryCanBeDeleted(logEntry)) return false;
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve item.
					dbConnection.Open();
					SaAttrUpdate_Db dbUpdateLog = new SaAttrUpdate_Db(DbInfo);
					dbUpdateLog.PopulateFrom(dbCommand, aliasUpdateLog, GetUpdateLogEntryFilter(logEntry));
					// Delete item.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = "DELETE FROM " + SaUpdateLogDbDfn.GetTableName(SaUpdateLogDbDfn.TableIdx.SaAttrUpdate) + " WHERE " + GetUpdateLogEntryFilter(logEntry) + ";";
					dbCommand.ExecuteNonQuery();
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}
		public override bool ClearLogEntriesForItem (ItemId itemId, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return SetErrorState(Msg_ItemIdNotSpecified);
			String colItemType = SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemType);
			String colItemId   = SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemId);
			String query = "Delete From "+TableName_UpdateLog+" WHERE "+colItemType+"="+itemId.Type.ToString()+" AND "+colItemId+"="+SysId.ToString(itemId.Id);
			Database.ExecuteNonQuery(query);
			if (Database.HasErrorState())
				SetErrorState("Failed to clear update log entries - " + Database.ErrorStateMessage);
			return OK;
		}

		//-------------------------------------------------------------------
		// Copy data properties to and from database.
		private void PopulateTo (SaAttrUpdate_Db dbUpdateLog, SaUpdateLogEntry logEntry, DbUpdateInfo dbUpdateInfo)
		{
			dbUpdateLog._ItemType = logEntry.ItemId.Type;
			dbUpdateLog._ItemId = SysId.ToInt(logEntry.ItemId.Id);
			dbUpdateLog._Attribute = logEntry.Attribute;
			dbUpdateLog._Logged = logEntry.Logged;
			dbUpdateLog._DataBefore = logEntry.DataBefore;
			dbUpdateLog._DataAfter = logEntry.DataAfter;
			// Common properties.
			dbUpdateLog._Notes = logEntry.Notes;
			dbUpdateLog._Status = SacsSystem.GetStatusCode(logEntry.Status);
			dbUpdateLog._Flags = (short)logEntry.Flags;
			if (!SysId.IsValid(logEntry.Id))
			{
				dbUpdateLog._CreateOn = DateTime.Now;
				dbUpdateLog._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbUpdateLog._CreateHost = dbUpdateInfo.Host;
			}
			dbUpdateLog._UpdateOn = DateTime.Now;
			dbUpdateLog._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbUpdateLog._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom (SaAttrUpdate_Db dbUpdateLog, SaUpdateLogEntry logEntry)
		{
			//logEntry.ItemId = new ItemId(dbUpdateLog._ItemType, new SysId(dbUpdateLog._ItemId);
			//logEntry.Attribute = dbUpdateLog._Attribute;
			//logEntry.Logged = dbUpdateLog._Logged;
			logEntry.DataBefore = dbUpdateLog._DataBefore;
			logEntry.DataAfter = dbUpdateLog._DataAfter;
			// Common properties.
			logEntry.Notes = dbUpdateLog._Notes;
			logEntry.Status = SacsSystem.GetStatusForCode(dbUpdateLog._Status);
			logEntry.SetCreateStamp(dbUpdateLog._CreateOn, new SysId(dbUpdateLog._CreateBy), dbUpdateLog._CreateHost);
			logEntry.SetUpdateStamp(dbUpdateLog._UpdateOn, new SysId(dbUpdateLog._UpdateBy), dbUpdateLog._UpdateHost);
			logEntry.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// UpdateLog column definitions.
		private static readonly String aliasUpdateLog              = "aUpdLog";
		private void SetUpdateLogColDfn
			(ColumnDfn col, String caption, int width, SaUpdateLogDbDfn.ColumnIdx dbCol,
			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
			String alias = "", String prefix = "")
		{
			if (String.IsNullOrEmpty(alias) && SaUpdateLogDbDfn.GetTableForColumn(dbCol) == SaUpdateLogDbDfn.TableIdx.SaAttrUpdate)
				alias = aliasUpdateLog;
			col.Set(caption, width, (int)dbCol, prefix + SaUpdateLogDbDfn.GetColumnName(dbCol, false), SaUpdateLogDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
		}
		public override ColumnDfn GetLogEntryColumnDfn (SaUpdateLogEntry.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId,caption,width);
			switch (columnId)
			{
				case SaUpdateLogEntry.Column.Pos:
					SetUpdateLogColDfn(columnDfn, "Pos", 45, SaUpdateLogDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;
				case SaUpdateLogEntry.Column.ItemType:
					SetUpdateLogColDfn(columnDfn, "Item type", 80, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemType, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.ItemType_Desc:
					SetUpdateLogColDfn(columnDfn, "Item type", 100, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemType);
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.Attribute:
					SetUpdateLogColDfn(columnDfn, "Attribute", 100, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Attribute);
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.Logged:
					SetUpdateLogColDfn(columnDfn, "Logged", 110, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, ColumnAlignment.Center, DataValue.DataType.DateTime);
					columnDfn.TimeFormat = "HH:mm:ss";
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.Logged_Date:
					SetUpdateLogColDfn(columnDfn, "Logged", 100, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.Logged_Time:
					SetUpdateLogColDfn(columnDfn, "Logged", 100, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, ColumnAlignment.Center, DataValue.DataType.Time);
					columnDfn.TimeFormat = "HH:mm:ss";
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.DataBefore:
					SetUpdateLogColDfn(columnDfn, "Value before", 120, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataBefore);
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.DataAfter:
					SetUpdateLogColDfn(columnDfn, "Value after", 120, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataAfter);
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.Notes:
					SetUpdateLogColDfn(columnDfn, "Notes", 240, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Notes);
					break;
				case SaUpdateLogEntry.Column.Status:
					SetUpdateLogColDfn(columnDfn, "Status", 80, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Status, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.Status_Desc:
					SetUpdateLogColDfn(columnDfn, "Status", 90, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Status, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.Status_Ind:
					SetUpdateLogColDfn(columnDfn, "Status", 80, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.CreateOn_Date:
					SetUpdateLogColDfn(columnDfn, "Created", 80, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.CreateBy:
					SetUpdateLogColDfn(columnDfn, "Modified by", 80, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateBy, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.CreateBy_Name:
					SetUpdateLogColDfn(columnDfn, "Modified by", 120, SaUpdateLogDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.String);
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.UpdateOn_Date:
					SetUpdateLogColDfn(columnDfn, "Updated", 80, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SaUpdateLogEntry.Column.Hidden:
					SetUpdateLogColDfn(columnDfn, "", 0, SaUpdateLogDbDfn.ColumnIdx.Unknown);
					columnDfn.Hidden = true;
					break;
			}
			if (!String.IsNullOrEmpty(caption))
				columnDfn.Caption = caption;
			if (width > 0)
				columnDfn.Width = width;
			return columnDfn;
		}

		//-------------------------------------------------------------------
		// UpdateLog query filter.
		public override List<string> GetLogEntryQueryFilter (SaUpdateLogEntry.Params prm)
		{
			List<String> filter = new List<String>();

			// Item Ids.
			List<String> filterItemId = new List<String>();
			String colItemType = SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemType, aliasUpdateLog);
			String colItemId = SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemId, aliasUpdateLog);
			foreach (ItemId itemId in prm.IncludedItemIds)
			{
				filterItemId.Add(colItemType + "=" + itemId.Type.ToString() + " And " + colItemId + "=" + SysId.ToString(itemId.Id));
			}
			if (filterItemId.Count > 0)
				filter.Add(filterItemId.Concat(" Or ", "(", ")"));

			// Attributes.
			String colAttribute = SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Attribute, aliasUpdateLog);
			if (prm.IncludedAttributes.Count > 0)
				filter.Add(colAttribute + " IN (" + DbQuery.FormatForIn(prm.IncludedAttributes, true, true) + ")");

			// Logged at.
			String colLogged = SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, aliasUpdateLog);
			if (DateUtil.IsValid(prm.Logged))
				filter.Add(colLogged + "=" + DbQuery.FormatDateTimeForCondition(prm.LoggedFrom, true, true));
			else
			{
				if (DateUtil.IsValid(prm.LoggedFrom))
					filter.Add(colLogged + ">=" + DbQuery.FormatDateTimeForCondition(prm.LoggedFrom, true, true));
				if (DateUtil.IsValid(prm.LoggedTo))
					filter.Add(colLogged + "<=" + DbQuery.FormatDateTimeForCondition(prm.LoggedTo, true, true));
			}

			if (filter.Count < 1 && prm.IncludeDefaultFilter) filter.Add("1=1");
			return filter;
		}
		// UpdateLog sort columns.
		public List<String> GetUpdateLogSortColumns (SaUpdateLogEntry.Params prm)
		{
			// Sort sequence:
			List<String> sortColumnNames = new List<String>();
			foreach (var columnDfn in prm.SortColumns)
			{
				// Need to ensure correct alias used for UpdateLog columns in case of conflict.
				String sortCol = String.Empty;
				if (SaUpdateLogDbDfn.GetTableForColumn((SaUpdateLogDbDfn.ColumnIdx)columnDfn.DbColumn) == SaUpdateLogDbDfn.TableIdx.SaAttrUpdate)
				{
					sortCol = SaUpdateLogDbDfn.GetColumnNameQual((SaUpdateLogDbDfn.ColumnIdx)columnDfn.DbColumn, aliasUpdateLog);
				}
				else
				{
					sortCol = columnDfn.DataName;
					if (!StringUtil.IsEmpty(columnDfn.SortDataName))
					{
						sortCol = columnDfn.SortDataName;
					}
				}
				if (!sortCol.IsEmpty())
				{
					DbOrderByNullMode orderByNullMode = DbOrderByNullMode.Default; // eSaOrderByDemoteNulls, eSaOrderByPromoteNulls
					sortColumnNames.Add(DbQuery.FormatForOrderBy(sortCol, columnDfn.SortAscending, orderByNullMode).Concat(", "));
				}
			}
			sortColumnNames.RemoveBlanks();
			if (sortColumnNames.IsEmpty())
			{
				// Default sort columns:
				sortColumnNames.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, aliasUpdateLog) + " DESC");
			}
			return sortColumnNames;
		}

		//-------------------------------------------------------------------
		// UpdateLog count.
		private long GetUpdateLogEntryCount (String filter)
		{
			ClearErrorState();
			return Database.GetRowCount(SaUpdateLogDbDfn.GetTableName(SaUpdateLogDbDfn.TableIdx.SaAttrUpdate) + " As " + aliasUpdateLog, filter);
		}
		public override long GetLogEntryCount (SaUpdateLogEntry.Params prm)
		{
			ClearErrorState();
			return GetUpdateLogEntryCount(GetLogEntryQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// Update Log Entry list.
		public override List<SaUpdateLogEntry> GetLogEntryList (SaUpdateLogEntry.Params prm)
		{
			ClearErrorState();
			List<SaUpdateLogEntry> logEntries = new List<SaUpdateLogEntry>();
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(TableName_UpdateLog, aliasUpdateLog);
			SaAttrUpdate_Db dbLogEntry = new SaAttrUpdate_Db(DbInfo);
			qry.Columns.AddRange(dbLogEntry.ExistingColumnNames);
			qry.Filters.AddRange(GetLogEntryQueryFilter(prm));
			qry.OrderBy.AddRange(GetUpdateLogSortColumns(prm));
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					dbCommand.CommandText = qry.BuildQuery(prm.ResultsPaging);
					using (DbDataReader dbDataReader = dbCommand.ExecuteReader())
					{
						while (dbDataReader.Read())
						{
							dbLogEntry = new SaAttrUpdate_Db(DbInfo);
							dbLogEntry.PopulateFrom(dbDataReader);
							SaUpdateLogEntry logEntry = CreateLogEntry(new ItemId(dbLogEntry._ItemType,new SysId(dbLogEntry._ItemId)),dbLogEntry._Attribute);
							PopulateFrom(dbLogEntry, logEntry);
							logEntries.Add(logEntry);
						}
					}
				}
				catch (Exception exc)
				{
					SetErrorState(Msg_DatabaseQueryException);
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return logEntries;
		}

		//-------------------------------------------------------------------
		// Update Log Entry query.
		public override DbResultSet ExecuteLogEntryQuery (List<ColumnDfn> columns, SaUpdateLogEntry.Params prm)
		{
			ClearErrorState();

			//---------------------------------------------------------------------
			// Construct query.
			DbQuery query = new DbQuery(Database.DbmsType);
			query.Tables.Add(SaUpdateLogDbDfn.GetTableName(SaUpdateLogDbDfn.TableIdx.SaAttrUpdate), aliasUpdateLog);

			// Add columns as defined in query list.
			if (columns.HasId(SaUpdateLogEntry.Column.ItemType) || columns.HasId(SaUpdateLogEntry.Column.ItemType_Desc))
				query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemType, aliasUpdateLog));
			if (columns.HasId(SaUpdateLogEntry.Column.ItemId))
				query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemId, aliasUpdateLog));
			if (columns.HasId(SaUpdateLogEntry.Column.Attribute) || columns.HasId(SaUpdateLogEntry.Column.DataBefore) || columns.HasId(SaUpdateLogEntry.Column.DataAfter))
				query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Attribute, aliasUpdateLog));
			if (columns.HasId(SaUpdateLogEntry.Column.Logged) || columns.HasId(SaUpdateLogEntry.Column.Logged_Date) || columns.HasId(SaUpdateLogEntry.Column.Logged_Time))
				query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, aliasUpdateLog));
			if (columns.HasId(SaUpdateLogEntry.Column.DataBefore))
				query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataBefore, aliasUpdateLog));
			if (columns.HasId(SaUpdateLogEntry.Column.DataAfter))
				query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataAfter, aliasUpdateLog));
			if (columns.HasId(SaUpdateLogEntry.Column.Notes))
				query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Notes, aliasUpdateLog));
			if (columns.HasId(SaUpdateLogEntry.Column.Status) || columns.HasId(SaUpdateLogEntry.Column.Status_Desc) || columns.HasId(SaUpdateLogEntry.Column.Status_Ind))
				query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Status, aliasUpdateLog));
			if (columns.HasId(SaUpdateLogEntry.Column.CreateOn_Date))
				query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateOn, aliasUpdateLog));
			if (columns.HasId(SaUpdateLogEntry.Column.CreateBy) || columns.HasId(SaUpdateLogEntry.Column.CreateBy_Name))
				query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateBy, aliasUpdateLog));
			if (columns.HasId(SaUpdateLogEntry.Column.UpdateOn_Date))
				query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_UpdateOn, aliasUpdateLog));

			//---------------------------------------------------------------------
			// Populate filter.
			query.Filters.AddRange(GetLogEntryQueryFilter(prm));

			// Configure sort sequence.
			foreach (String sortColumn in GetUpdateLogSortColumns(prm))
				query.OrderBy.Add(sortColumn);

			//---------------------------------------------------------------------
			//return new DbResultSet_DataTableReader(Database, query.BuildQuery(prm.ResultsPaging));
			return DbResultSet_DataReader.ExecuteQuery(Database, query.BuildQuery(prm.ResultsPaging));
		}

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