using System;
using System.Collections.Generic;
using System.Data.Common;
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.Data;
using Sarand.Net.Standard.Base.Dbas;
using Sarand.Net.Standard.Base.ItemOptions;
using Sarand.Net.Standard.Dbas.Base;
using Sarand.Net.Standard.Dbas.Data;
using Sarand.Net.Standard.Dbas.ItemOptions.Internal;
using Sarand.Net.Standard.Base.Utils;

namespace Sarand.Net.Standard.Dbas.ItemOptions
{
	//=======================================================================
	internal class SaItemOptionMgr_Dbas : SaItemOptionMgr
	{
		//-------------------------------------------------------------------
		// Data members.
		private SaItemOptionConsole_Dbas itemOptionConsole = null;

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

		//-------------------------------------------------------------------
		// Construction.
		internal SaItemOptionMgr_Dbas (SaItemOptionConsole_Dbas itemOptionConsole)
		{
			this.itemOptionConsole = itemOptionConsole;
			DbInfo = new DbDataItem.DatabaseInfo(itemOptionConsole.Database);
		}

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

		//*******************************************************************
		//                      I t e m   O p t i o n s
		//*******************************************************************
		// Utilities.
		private String GetItemOptionFilter (SaItemOption itemOption)
		{
			return GetItemOptionFilter(itemOption.ItemId, itemOption.Name, itemOption.Context);
		}
		private String GetItemOptionFilter (ItemId itemId, String name, String context)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return "1=0";
			if (StringUtil.IsEmpty(name)) return "1=0";
			// Item identifying values.
			SaItemOption.Params prmItemOption = new SaItemOption.Params();
			prmItemOption.IncludedItemIds.Add(itemId);
			prmItemOption.IncludedNameContexts.Add(name,context);
			prmItemOption.StatusCat = SaItemOption.StatusCat.Any;
			return GetItemOptionQueryFilter(prmItemOption).Concat(" And ", "(", ")");
		}

		//-------------------------------------------------------------------
		// Associated data.

		//-------------------------------------------------------------------
		// Create Item.
		public override SaItemOption CreateItemOption (ItemId itemId, string name, string context)
		{
			ClearErrorState();
			return new SaItemOption_Dbas(itemId, name, context, 0);
		}
		public SaItemOption CreateItemOption (SaItemOption_Db dbItemOption)
		{
			ClearErrorState();
			SaItemOption itemOption = new SaItemOption_Dbas(new ItemId(dbItemOption._ItemType, new SysId(dbItemOption._ItemId)), dbItemOption._Name, dbItemOption._Context, (ushort)dbItemOption._Flags);
			PopulateFrom(dbItemOption, itemOption);
			return itemOption;
		}
		private SaItemOption CreateItemOption (DbDataReader dataReader)
		{
			SaItemOption_Db dbItemOption = new SaItemOption_Db(DbInfo);
			dbItemOption.PopulateFrom(dataReader);
			return CreateItemOption(dbItemOption);
		}

		//-------------------------------------------------------------------
		// Item exists.
		public override bool ItemOptionExists (SaItemOption itemOption)
		{
			return ItemOptionExists(itemOption.ItemId, itemOption.Name, itemOption.Context);
		}
		public override bool ItemOptionExists (ItemId itemId, String name, string context)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return false;
			if (StringUtil.IsEmpty(name)) return false;
			return GetItemOptionCount(GetItemOptionFilter(itemId, name, context)) == 1;
		}

		//-------------------------------------------------------------------
		// Get Item.
		private SaItemOption GetItemOption (String filter)
		{
			ClearErrorState();
			if (GetItemOptionCount(filter) != 1) return null;
			SaItemOption itemOption = null;
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					SaItemOption_Db dbItemOption = new SaItemOption_Db(DbInfo);
					dbItemOption.PopulateFrom(dbCommand, aliasItemOption, filter);
					itemOption = CreateItemOption(dbItemOption);
				}
				catch (Exception exc)
				{
					SetErrorState(ErrorMessage.DatabaseQueryException);
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return itemOption;
		}
		public override SaItemOption GetItemOption (SaItemOption itemOption)
		{
			ClearErrorState();
			if (itemOption == null) return null;
			if (!ItemId.IsValid(itemOption.ItemId)) return null;
			if (StringUtil.IsEmpty(itemOption.Name)) return null;
			return GetItemOption(GetItemOptionFilter(itemOption));
		}
		public override SaItemOption GetItemOption (ItemId itemId, string name, string context)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return null;
			if (StringUtil.IsEmpty(name)) return null;
			return GetItemOption(GetItemOptionFilter(itemId, name, context));
		}

		//-------------------------------------------------------------------
		// Validate Item.
		public override bool IsValidItemOptionData (SaItemOption.Data itemOptionData, SaItemOption.ErrField errField)
		{
			ClearErrorState();
			if (!base.IsValidItemOptionData(itemOptionData, errField)) return false;
			return true;
		}

		//-------------------------------------------------------------------
		// Insert Item.
		public override bool InsertItemOption (SaItemOption itemOption, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidItemOption(itemOption)) return false;
			//if (itemOption.Id.IsValid()) return SetErrorState(ErrorMessage.ValiditemId);
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					SaItemOption_Db dbItemOption = new SaItemOption_Db(DbInfo);
					PopulateTo(dbItemOption, itemOption, dbUpdateInfo);
					if (SaItemOption_Db.FieldsNonId.Contains("Id"))
					{
						// Item has no Id.
						//dbItemOption._Id = SysId.ToInt(Database.GetNextId("SaItemOption", dbUpdateInfo));
					}
					dbItemOption.ExecuteInsertCommand(dbCommand);
					//itemOption.Id = new SysId(dbItemOption._Id);
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Update Item.
		public override bool UpdateItemOption (SaItemOption itemOption, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidItemOption(itemOption)) return false;
			//if (!itemOption.Id.IsValid()) return SetErrorState(ErrorMessage.InvalidItemId);
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve item.
					dbConnection.Open();
					SaItemOption_Db dbItemOption = new SaItemOption_Db(DbInfo);
					dbItemOption.PopulateFrom(dbCommand, aliasItemOption, GetItemOptionFilter(itemOption));
					// Update item.
					PopulateTo(dbItemOption, itemOption, dbUpdateInfo);
					dbItemOption.ExecuteUpdateCommand(dbCommand);
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Delete Item.
		public override bool ItemOptionCanBeDeleted (SaItemOption itemOption)
		{
			ClearErrorState();
			if (!base.ItemOptionCanBeDeleted(itemOption)) return false;
			return true;
		}
		public override bool DeleteItemOption (SaItemOption itemOption, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!ItemOptionCanBeDeleted(itemOption)) return false;
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve item.
					dbConnection.Open();
					SaItemOption_Db dbItemOption = new SaItemOption_Db(DbInfo);
					dbItemOption.PopulateFrom(dbCommand, aliasItemOption, GetItemOptionFilter(itemOption));
					// Delete item.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = "DELETE FROM " + SaItemOptionDbDfn.GetTableName(SaItemOptionDbDfn.TableIdx.SaItemOption) + " WHERE " + GetItemOptionFilter(itemOption) + ";";
					dbCommand.ExecuteNonQuery();
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}
		public override bool ClearItemOptionsForItem (ItemId itemId, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return SetErrorState(ErrorMessage.ItemIdNotSpecified);
			String colItemType = SaItemOptionDbDfn.GetColumnName(SaItemOptionDbDfn.ColumnIdx.SaItemOption_ItemType);
			String colItemId   = SaItemOptionDbDfn.GetColumnName(SaItemOptionDbDfn.ColumnIdx.SaItemOption_ItemId);
			String query = "Delete From "+TableName_ItemOption+" WHERE "+colItemType+"="+itemId.Type.ToString()+" AND "+colItemId+"="+SysId.ToString(itemId.Id);
			Database.ExecuteNonQuery(query);
			if (Database.HasErrorState())
				SetErrorState("Failed to clear item options - " + Database.ErrorStateMessage);
			return OK;
		}

		//-------------------------------------------------------------------
		// Item Option Value encryption inherited from C++ Sapphire.
		// The encryption key must not be changed where data shared with Sapphire.
		private static String encryptedOptionValueKey = "SaItemOptionMgr_Odbc";
		// Copy data properties to and from database.
		private void PopulateTo (SaItemOption_Db dbItemOption, SaItemOption itemOption, DbUpdateInfo dbUpdateInfo)
		{
			dbItemOption._ItemType = itemOption.ItemId.Type;
			dbItemOption._ItemId = SysId.ToInt(itemOption.ItemId.Id);
			dbItemOption._Name = itemOption.Name;
			dbItemOption._Context = itemOption.Context;
			dbItemOption._Value = itemOption.Value;
			if (itemOption.Encrypted)
				dbItemOption._Value = SacsDataFn._saecs(itemOption.Value, new SacsData(encryptedOptionValueKey));
			// Common properties.
			dbItemOption._Notes = itemOption.Notes;
			dbItemOption._Status = SacsSystem.GetStatusCode(itemOption.Status);
			dbItemOption._Flags = (short)itemOption.Flags;
			if (!SysId.IsValid(itemOption.Id))
			{
				dbItemOption._CreateOn = DateTime.Now;
				dbItemOption._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbItemOption._CreateHost = dbUpdateInfo.Host;
			}
			dbItemOption._UpdateOn = DateTime.Now;
			dbItemOption._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbItemOption._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom (SaItemOption_Db dbItemOption, SaItemOption itemOption)
		{
			//itemOption.ItemId = new ItemId(dbItemOption._ItemType, new SysId(dbItemOption._ItemId));
			//itemOption.Name = dbItemOption._Name;
			//itemOption.Context = dbItemOption._Context;
			itemOption.Value = dbItemOption._Value;
			if (itemOption.Encrypted)
				itemOption.Value = SacsDataFn._sadcs(dbItemOption._Value, new SacsData(encryptedOptionValueKey));
			// Common properties.
			itemOption.Notes = dbItemOption._Notes;
			itemOption.Status = SacsSystem.GetStatusForCode(dbItemOption._Status);
			itemOption.SetCreateStamp(dbItemOption._CreateOn, new SysId(dbItemOption._CreateBy), dbItemOption._CreateHost);
			itemOption.SetUpdateStamp(dbItemOption._UpdateOn, new SysId(dbItemOption._UpdateBy), dbItemOption._UpdateHost);
			itemOption.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// Column definitions.
		private static readonly String aliasItemOption = "aItmOpt";
		private void SetItemOptionColDfn
			(ColumnDfn col, String caption, int width, SaItemOptionDbDfn.ColumnIdx dbCol,
			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
			String alias = "", String prefix = "")
		{
			if (String.IsNullOrEmpty(alias) && SaItemOptionDbDfn.GetTableForColumn(dbCol) == SaItemOptionDbDfn.TableIdx.SaItemOption)
				alias = aliasItemOption;
			col.Set(caption, width, (int)dbCol, prefix + SaItemOptionDbDfn.GetColumnName(dbCol, false), SaItemOptionDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
		}
		public override ColumnDfn GetItemOptionColumnDfn (SaItemOption.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId,caption,width);
			switch (columnId)
			{
				case SaItemOption.Column.Pos:
					SetItemOptionColDfn(columnDfn, "Pos", 45, SaItemOptionDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;
				case SaItemOption.Column.ItemType:
					SetItemOptionColDfn(columnDfn, "Item type", 80, SaItemOptionDbDfn.ColumnIdx.SaItemOption_ItemType, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SaItemOption.Column.ItemType_Desc:
					SetItemOptionColDfn(columnDfn, "Item type", 100, SaItemOptionDbDfn.ColumnIdx.SaItemOption_ItemType);
					break;
				case SaItemOption.Column.Group:
					SetItemOptionColDfn(columnDfn, "Group", 100, SaItemOptionDbDfn.ColumnIdx.Unknown);
					columnDfn.ReadOnly = true;
					break;
				case SaItemOption.Column.Name:
					SetItemOptionColDfn(columnDfn, "Name", 100, SaItemOptionDbDfn.ColumnIdx.SaItemOption_Name);
					columnDfn.MaxLength = (int)SaItemOptionDbDfn.GetColTextLen(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Name);
					break;
				case SaItemOption.Column.Name_Display:
					SetItemOptionColDfn(columnDfn, "Name", 100, SaItemOptionDbDfn.ColumnIdx.SaItemOption_Name);
					columnDfn.ReadOnly = true;
					break;
				case SaItemOption.Column.Context:
					SetItemOptionColDfn(columnDfn, "Context", 160, SaItemOptionDbDfn.ColumnIdx.SaItemOption_Context);
					columnDfn.MaxLength = (int)SaItemOptionDbDfn.GetColTextLen(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Context);
					break;
				case SaItemOption.Column.Context_Display:
					SetItemOptionColDfn(columnDfn, "Context", 160, SaItemOptionDbDfn.ColumnIdx.SaItemOption_Context);
					columnDfn.ReadOnly = true;
					break;
				case SaItemOption.Column.Value:
					SetItemOptionColDfn(columnDfn, "Value", 200, SaItemOptionDbDfn.ColumnIdx.SaItemOption_Value);
					columnDfn.MaxLength = (int)SaItemOptionDbDfn.GetColTextLen(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Value);
					break;
				case SaItemOption.Column.Value_Display:
					SetItemOptionColDfn(columnDfn, "Value", 200, SaItemOptionDbDfn.ColumnIdx.SaItemOption_Value);
					columnDfn.ReadOnly = true;
					break;
				case SaItemOption.Column.Password:
					SetItemOptionColDfn(columnDfn, "Password", 45, SaItemOptionDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Bool);
					columnDfn.BoolFormat = ColumnBoolFormat.YorN;
					break;
				// Common properties.
				case SaItemOption.Column.Notes:
					SetItemOptionColDfn(columnDfn, "Notes", 240, SaItemOptionDbDfn.ColumnIdx.SaItemOption_Notes);
					columnDfn.MaxLength = (int)SaItemOptionDbDfn.GetColTextLen(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Notes);
					break;
				case SaItemOption.Column.Status:
					SetItemOptionColDfn(columnDfn, "Status", 80, SaItemOptionDbDfn.ColumnIdx.SaItemOption_Status, ColumnAlignment.Center);
					break;
				case SaItemOption.Column.Status_Desc:
					SetItemOptionColDfn(columnDfn, "Status", 90, SaItemOptionDbDfn.ColumnIdx.SaItemOption_Status, ColumnAlignment.Center);
					break;
				case SaItemOption.Column.Status_Ind:
					SetItemOptionColDfn(columnDfn, "Status", 80, SaItemOptionDbDfn.ColumnIdx.SaItemOption_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					break;
				case SaItemOption.Column.CreateOn_Date:
					SetItemOptionColDfn(columnDfn, "Created", 80, SaItemOptionDbDfn.ColumnIdx.SaItemOption_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SaItemOption.Column.UpdateOn_Date:
					SetItemOptionColDfn(columnDfn, "Updated", 80, SaItemOptionDbDfn.ColumnIdx.SaItemOption_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
			}
			if (!String.IsNullOrEmpty(caption))
				columnDfn.Caption = caption;
			if (width > 0)
				columnDfn.Width = width;
			return columnDfn;
		}

		//-------------------------------------------------------------------
		// Query filter.
		public override List<string> GetItemOptionQueryFilter (SaItemOption.Params prm)
		{
			List<String> filter = new List<String>();

			// Item Ids.
			List<String> filterItemId = new List<String>();
			String colItemType = SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_ItemType, aliasItemOption);
			String colItemId = SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_ItemId, aliasItemOption);
			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 ", "(", ")"));

			// Included Name/Context combinations.
			List<String> nameContextFilters = new List<string>();
			String colName    = SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Name, aliasItemOption);
			String colContext = SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Context, aliasItemOption);
			foreach (StringPair nameContext in prm.IncludedNameContexts)
			{
				String nameContextFilter = colName + "='" + DbQuery.FormatForCondition(nameContext.Item1) +"'";
				if (!StringUtil.IsEmpty(nameContext.Item2))
					nameContextFilter += " And " + colContext + "='" + DbQuery.FormatForCondition(nameContext.Item2) + "'";
				nameContextFilters.Add(nameContextFilter);
			}
			if (nameContextFilters.Count > 0)
				filter.Add(nameContextFilters.Concat(" Or ","(",")"));

			// Status.
			String colStatus = SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Status, aliasItemOption);
			String statusCurrent = SacsSystem.GetStatusCode(SaStatus.Current);
			String statusDeleted = SacsSystem.GetStatusCode(SaStatus.Deleted);
			if (prm.StatusCat == SaItemOption.StatusCat.CurrentOnly)
				filter.Add(colStatus + " In ('" + statusCurrent + "')");
			else if (prm.StatusCat == SaItemOption.StatusCat.NotDeleted)
				filter.Add(colStatus + " Not In ('" + statusDeleted + "')");
			else if (prm.StatusCat == SaItemOption.StatusCat.DeletedOnly)
				filter.Add(colStatus + " In ('" + statusDeleted + "')");

			if (filter.Count < 1 && prm.IncludeDefaultFilter) filter.Add("1=1");
			return filter;
		}
		// Sort columns.
		public List<String> GetItemOptionSortColumns (SaItemOption.Params prm)
		{
			// Sort sequence:
			List<String> sortColumnNames = new List<String>();
			foreach (var columnDfn in prm.SortColumns)
			{
				// Need to ensure correct alias used for ItemOption columns in case of conflict.
				String sortCol = String.Empty;
				if (SaItemOptionDbDfn.GetTableForColumn((SaItemOptionDbDfn.ColumnIdx)columnDfn.DbColumn) == SaItemOptionDbDfn.TableIdx.SaItemOption)
				{
					sortCol = SaItemOptionDbDfn.GetColumnNameQual((SaItemOptionDbDfn.ColumnIdx)columnDfn.DbColumn, aliasItemOption);
				}
				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(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_ItemType, aliasItemOption) + " DESC");
				sortColumnNames.Add(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_ItemId, aliasItemOption) + " DESC");
				sortColumnNames.Add(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Name, aliasItemOption) + " DESC");
				sortColumnNames.Add(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Context, aliasItemOption) + " DESC");
			}
			return sortColumnNames;
		}

		//-------------------------------------------------------------------
		// Item count.
		private long GetItemOptionCount (String filter)
		{
			ClearErrorState();
			return Database.GetRowCount(SaItemOptionDbDfn.GetTableName(SaItemOptionDbDfn.TableIdx.SaItemOption) + " As " + aliasItemOption, filter);
		}
		public override long GetItemOptionCount (SaItemOption.Params prm)
		{
			ClearErrorState();
			return GetItemOptionCount(GetItemOptionQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// Item list.
		public override List<SaItemOption> GetItemOptionList (SaItemOption.Params prm)
		{
			List<SaItemOption> itemOptions = new List<SaItemOption>();
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(TableName_ItemOption, aliasItemOption);
			SaItemOption_Db dbItemOption = new SaItemOption_Db(DbInfo);
			qry.Columns.AddRange(dbItemOption.ExistingColumnNames);
			qry.Filters.AddRange(GetItemOptionQueryFilter(prm));
			qry.OrderBy.AddRange(GetItemOptionSortColumns(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())
							itemOptions.Add(CreateItemOption(dbDataReader));
					}
				}
				catch (Exception exc)
				{
					SetErrorState(ErrorMessage.DatabaseQueryException);
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return itemOptions;
		}

		//-------------------------------------------------------------------
		// Item query.
		public override DbResultSet ExecuteItemOptionQuery (List<ColumnDfn> columns, SaItemOption.Params prm)
		{
			ClearErrorState();

			//---------------------------------------------------------------------
			// Construct query.
			DbQuery query = new DbQuery(Database.DbmsType);
			query.Tables.Add(SaItemOptionDbDfn.GetTableName(SaItemOptionDbDfn.TableIdx.SaItemOption), aliasItemOption);

			// Add columns as defined in query list.
			if (columns.HasId(SaItemOption.Column.ItemType) || columns.HasId(SaItemOption.Column.ItemType_Desc))
				query.Columns.Add(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_ItemType, aliasItemOption));
			if (columns.HasId(SaItemOption.Column.ItemId))
				query.Columns.Add(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_ItemId, aliasItemOption));
			if (columns.HasId(SaItemOption.Column.Name) || columns.HasId(SaItemOption.Column.Name))
				query.Columns.Add(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Name, aliasItemOption));
			if (columns.HasId(SaItemOption.Column.Context) || columns.HasId(SaItemOption.Column.Context))
				query.Columns.Add(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Context, aliasItemOption));
			if (columns.HasId(SaItemOption.Column.Value) || columns.HasId(SaItemOption.Column.Value_Display))
				query.Columns.Add(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Value, aliasItemOption));
			if (columns.HasId(SaItemOption.Column.Notes))
				query.Columns.Add(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Notes, aliasItemOption));
			if (columns.HasId(SaItemOption.Column.Status) || columns.HasId(SaItemOption.Column.Status_Desc) || columns.HasId(SaItemOption.Column.Status_Ind))
				query.Columns.Add(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_Status, aliasItemOption));
			if (columns.HasId(SaItemOption.Column.CreateOn_Date))
				query.Columns.Add(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_CreateOn, aliasItemOption));
			if (columns.HasId(SaItemOption.Column.UpdateOn_Date))
				query.Columns.Add(SaItemOptionDbDfn.GetColumnNameQual(SaItemOptionDbDfn.ColumnIdx.SaItemOption_UpdateOn, aliasItemOption));

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

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

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

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