using Sarand.BusinessMgr.Net.Standard.Base.App;
using Sarand.BusinessMgr.Net.Standard.Base.Bus;
using Sarand.BusinessMgr.Net.Standard.Dbas.Bus;
using Sarand.BusinessMgr.Net.Standard.Dbas.Internal;
using Sarand.BusinessMgr.Net.Standard.Dbas.UpdateLog;
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.Data.Common;
using System.Linq;

namespace Sarand.BusinessMgr.Net.Standard.Dbas.Mgr
{
	//=======================================================================
	// Stock manager - StockLevels.
	//=======================================================================
	partial class SbmStockMgr_Dbas
	{
		//-------------------------------------------------------------------
		// Utilities.
		private List<StringPair> GetLogProperties(SbmStockLevel stockLevel)
		{
			return new List<StringPair>()
			{
				new StringPair("Id",SysId.ToString(stockLevel.Id)),
				new StringPair("Type",$"{stockLevel.Type}"),
				new StringPair("Quantity",stockLevel.Quantity.ToString("N3")),
				new StringPair("Status",stockLevel.StatusCode)
			};
		}

		//-------------------------------------------------------------------
		// Get item.
		public override SbmStockLevel GetStockLevel(SbmStockLevel.Params prm)
		{
			return GetStockLevel(GetStockLevelQueryFilter(prm).Concat(" AND ", "(", ")"));
		}
		private SbmStockLevel GetStockLevel(String filter)
		{
			ClearErrorState();
			long count = GetStockLevelCount(filter);
			if (count == 0) return null;
			if (count != 1)
			{
				SetErrorState(ErrorMessage.MultipleItemsFound);
				return null;
			}
			SbmStockLevel stockLevel = null;
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					StockLevel_Db dbStockLevel = new StockLevel_Db(DbInfo);
					dbStockLevel.PopulateFrom(dbCommand, aliasStockLevel, filter);
					stockLevel = CreateStockLevel(dbStockLevel);
				}
				catch (Exception exc)
				{
					SetErrorState(ErrorMessage.DatabaseQueryException);
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return stockLevel;
		}

		//-------------------------------------------------------------------
		// Create item.
		public override SbmStockLevel CreateStockLevel(SysId idCommodity, SysId idLocation, Sbm.StockLevelType type, Sbm.StockLevelSource source)
		{
			return new SbmStockLevel_Dbas(new SysId(), idCommodity, idLocation, type, source, 0);
		}
		private SbmStockLevel_Dbas CreateStockLevel(StockLevel_Db dbStockLevel)
		{
			ClearErrorState();
			SbmStockLevel_Dbas stockLevel = new SbmStockLevel_Dbas(new SysId(dbStockLevel._Id), new SysId(dbStockLevel._CommodityId), new SysId(dbStockLevel._LocationId), (Sbm.StockLevelType)dbStockLevel._Type, (Sbm.StockLevelSource)dbStockLevel._Source, (ushort)dbStockLevel._Flags);
			PopulateFrom(dbStockLevel, stockLevel);
			return stockLevel;
		}

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

		//-------------------------------------------------------------------
		// Insert item.
		public override bool InsertStockLevel(SbmStockLevel stockLevel, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidStockLevel(stockLevel)) return false;
			if (SysId.IsValid(stockLevel.Id)) return SetErrorState(ErrorMessage.ValidItemId);
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					StockLevel_Db dbStockLevel = new StockLevel_Db(DbInfo);
					PopulateTo(dbStockLevel, stockLevel, dbUpdateInfo);
					if (StockLevel_Db.FieldsNonId.Contains("Id"))
					{
						// Generate next Id.
						dbStockLevel._Id = SysId.ToInt(Database.GetNextId("StockLevel", dbUpdateInfo));
					}
					dbStockLevel.ExecuteInsertCommand(dbCommand);
					stockLevel.Id = new SysId(dbStockLevel._Id);
					stockLevel.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Inserted. " + GetLogProperties(stockLevel).Concat(": ").Concat("", "\n\t"));
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Update item.
		public override bool UpdateStockLevel(SbmStockLevel stockLevel, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidStockLevel(stockLevel)) return false;
			if (!SysId.IsValid(stockLevel.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
			if (!stockLevel.Changed)
			{
				if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Data not changed. " + GetLogProperties(stockLevel).Concat(": ").Concat("", "\n\t"));
				return true;
			}
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve StockLevel.
					dbConnection.Open();
					StockLevel_Db dbStockLevel = new StockLevel_Db(DbInfo);
					dbStockLevel.PopulateFrom(dbCommand, aliasStockLevel, "Id=" + SysId.ToString(stockLevel.Id));
					SbmUpdateLogItemMonitor_StockLevel updateLogMonitor = new SbmUpdateLogItemMonitor_StockLevel(Internals, CreateStockLevel(dbStockLevel));

					// Update properties.
					PopulateTo(dbStockLevel, stockLevel, dbUpdateInfo);
					dbStockLevel.ExecuteUpdateCommand(dbCommand);
					stockLevel.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Updated. " + GetLogProperties(stockLevel).Concat(": ").Concat("", "\n\t"));

					// Record updates.
					updateLogMonitor.RecordUpdatedValues(stockLevel);
					updateLogMonitor.LogUpdates();
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Delete item.
		public override bool StockLevelCanBeDeleted(SbmStockLevel stockLevel)
		{
			ClearErrorState();
			if (!base.StockLevelCanBeDeleted(stockLevel)) return false;
			return true;
		}
		public override bool DeleteStockLevel(SbmStockLevel stockLevel, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!StockLevelCanBeDeleted(stockLevel)) return false;
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve StockLevel.
					dbConnection.Open();
					StockLevel_Db dbStockLevel = new StockLevel_Db(DbInfo);
					dbStockLevel.PopulateFrom(dbCommand, aliasStockLevel, "Id=" + stockLevel.Id.ToString());
					// Delete StockLevel.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = "DELETE FROM " + SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.StockLevel) + " WHERE Id=" + SysId.ToString(stockLevel.Id) + ";";
					dbCommand.ExecuteNonQuery();
					stockLevel.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Deleted. " + GetLogProperties(stockLevel).Concat(": ").Concat("", "\n\t"));
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Copy data properties to and from database.
		private void PopulateTo(StockLevel_Db dbStockLevel, SbmStockLevel stockLevel, DbUpdateInfo dbUpdateInfo)
		{
			dbStockLevel._Id = stockLevel.Id.ToInt();
			dbStockLevel._CommodityId = SysId.ToInt(stockLevel.CommodityId);
			dbStockLevel._LocationId = SysId.ToInt(stockLevel.LocationId);
			dbStockLevel._Type = (short)stockLevel.Type;
			dbStockLevel._Source = (short)stockLevel.Source;
			dbStockLevel._Quantity = stockLevel.Quantity;
			dbStockLevel._Recorded = stockLevel.Recorded;
			dbStockLevel._Bay1 = stockLevel.Bay1;
			dbStockLevel._Bay2 = stockLevel.Bay2;
			dbStockLevel._Bay3 = stockLevel.Bay3;
			// Common properties.
			dbStockLevel._Notes = stockLevel.Notes;
			dbStockLevel._Flags = (short)stockLevel.Flags;
			dbStockLevel._Status = SacsSystem.GetStatusCode(stockLevel.Status);
			if (!SysId.IsValid(stockLevel.Id))
			{
				dbStockLevel._CreateOn = DateTime.UtcNow;
				dbStockLevel._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbStockLevel._CreateHost = dbUpdateInfo.Host;
			}
			dbStockLevel._UpdateOn = DateTime.UtcNow;
			dbStockLevel._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbStockLevel._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom(StockLevel_Db dbStockLevel, SbmStockLevel stockLevel)
		{
			stockLevel.Id = new SysId(dbStockLevel._Id);
			stockLevel.CommodityId = new SysId(dbStockLevel._CommodityId);
			stockLevel.LocationId = new SysId(dbStockLevel._LocationId);
			stockLevel.Type = (Sbm.StockLevelType)dbStockLevel._Type;
			stockLevel.Source = (Sbm.StockLevelSource)dbStockLevel._Source;
			stockLevel.Quantity = dbStockLevel._Quantity;
			stockLevel.Recorded = dbStockLevel._Recorded;
			stockLevel.Bay1 = dbStockLevel._Bay1;
			stockLevel.Bay2 = dbStockLevel._Bay2;
			stockLevel.Bay3 = dbStockLevel._Bay3;
			// Common properties.
			stockLevel.Notes = dbStockLevel._Notes;
			stockLevel.Status = SacsSystem.GetStatusForCode(dbStockLevel._Status);
			stockLevel.SetCreateStamp(dbStockLevel._CreateOn, new SysId(dbStockLevel._CreateBy), dbStockLevel._CreateHost);
			stockLevel.SetUpdateStamp(dbStockLevel._UpdateOn ?? default(DateTime), new SysId(dbStockLevel._UpdateBy ?? 0), dbStockLevel._UpdateHost);
			stockLevel.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// Column definitions.
		private static readonly String aliasStockLevel = "aStl";
		private static String aliasStockLevel_Commodity = "Stl_Cmd";
		private static String prefixStockLevel_Commodity = aliasStockLevel_Commodity + "_";
		private static String aliasStockLevel_Location = "Stl_Loc";
		private static String prefixStockLevel_Location = aliasStockLevel_Location + "_";

		// Column definition population.
		private void SetStockLevelColDfn
			(ColumnDfn col, String caption, int width, SbmDbDfn.ColumnIdx dbCol,
			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
			String alias = "", String prefix = "")
		{
			if (String.IsNullOrEmpty(alias) && SbmDbDfn.GetTableForColumn(dbCol) == SbmDbDfn.TableIdx.StockLevel)
				alias = aliasStockLevel;
			col.Set(caption, width, (int)dbCol, prefix + SbmDbDfn.GetColumnName(dbCol, false), SbmDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
			if (dataType == DataValue.DataType.String && dbCol != SbmDbDfn.ColumnIdx.Unknown)
				col.MaxLength = (int)Internals.GetColTextLen(dbCol);
		}

		//-------------------------------------------------------------------
		// Item column definitions.
		public override ColumnDfn GetStockLevelColumnDfn(SbmStockLevel.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
			switch (columnId)
			{
				case SbmStockLevel.Column.Pos:
					SetStockLevelColDfn(columnDfn, "Pos", 45, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;

				// Item Properties.
				case SbmStockLevel.Column.Id:
					SetStockLevelColDfn(columnDfn, "Id", 60, SbmDbDfn.ColumnIdx.StockLevel_Id, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SbmStockLevel.Column.CommodityId:
					SetStockLevelColDfn(columnDfn, "Commodity Id", 70, SbmDbDfn.ColumnIdx.StockLevel_CommodityId, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmStockLevel.Column.LocationId:
					SetStockLevelColDfn(columnDfn, "Location Id", 70, SbmDbDfn.ColumnIdx.StockLevel_LocationId, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmStockLevel.Column.Type:
					SetStockLevelColDfn(columnDfn, "Type", 70, SbmDbDfn.ColumnIdx.StockLevel_Type, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmStockLevel.Column.Type_Desc:
					SetStockLevelColDfn(columnDfn, "Type", 100, SbmDbDfn.ColumnIdx.StockLevel_Type, ColumnAlignment.Center);
					break;
				case SbmStockLevel.Column.Source:
					SetStockLevelColDfn(columnDfn, "Source", 70, SbmDbDfn.ColumnIdx.StockLevel_Source, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmStockLevel.Column.Source_Desc:
					SetStockLevelColDfn(columnDfn, "Source", 100, SbmDbDfn.ColumnIdx.StockLevel_Source, ColumnAlignment.Center);
					break;
				case SbmStockLevel.Column.Recorded:
					SetStockLevelColDfn(columnDfn, "Recorded", 90, SbmDbDfn.ColumnIdx.StockLevel_Recorded, ColumnAlignment.Center, DataValue.DataType.DateTime);
					break;
				case SbmStockLevel.Column.RecordedDate:
					SetStockLevelColDfn(columnDfn, "Recorded on", 90, SbmDbDfn.ColumnIdx.StockLevel_Recorded, ColumnAlignment.Center, DataValue.DataType.Date);
					break;
				case SbmStockLevel.Column.RecordedTime:
					SetStockLevelColDfn(columnDfn, "Recorded at", 80, SbmDbDfn.ColumnIdx.StockLevel_Recorded, ColumnAlignment.Center, DataValue.DataType.Time);
					break;

				//---------------------------------------------------------------
				// Joined Commodity columns.
				case SbmStockLevel.Column.Commodity_Code:
					SetStockLevelColDfn(columnDfn, "Commodity code", 120, SbmDbDfn.ColumnIdx.Commodity_Code, ColumnAlignment.Default, DataValue.DataType.String, aliasStockLevel_Commodity, prefixStockLevel_Commodity);
					break;
				case SbmStockLevel.Column.Commodity_DescBrief:
					SetStockLevelColDfn(columnDfn, "Commodity", 160, SbmDbDfn.ColumnIdx.Commodity_DescBrief, ColumnAlignment.Default, DataValue.DataType.String, aliasStockLevel_Commodity, prefixStockLevel_Commodity);
					break;

				//---------------------------------------------------------------
				// Joined Location columns.
				case SbmStockLevel.Column.Location_CategoryDesc:
					SetStockLevelColDfn(columnDfn, "location cat", 120, SbmDbDfn.ColumnIdx.Location_Category, ColumnAlignment.Center, DataValue.DataType.String, aliasStockLevel_Location, prefixStockLevel_Location);
					break;
				case SbmStockLevel.Column.Location_Code:
					SetStockLevelColDfn(columnDfn, "location code", 100, SbmDbDfn.ColumnIdx.Location_Code, ColumnAlignment.Center, DataValue.DataType.String, aliasStockLevel_Location, prefixStockLevel_Location);
					break;
				case SbmStockLevel.Column.Location_Name:
					SetStockLevelColDfn(columnDfn, "location", 160, SbmDbDfn.ColumnIdx.Location_Name, ColumnAlignment.Center, DataValue.DataType.String, aliasStockLevel_Location, prefixStockLevel_Location);
					break;

				//---------------------------------------------------------------
				// Common properties.
				case SbmStockLevel.Column.Notes:
					SetStockLevelColDfn(columnDfn, "Notes", 200, SbmDbDfn.ColumnIdx.StockLevel_Notes);
					break;
				case SbmStockLevel.Column.Status:
					SetStockLevelColDfn(columnDfn, "Status", 50, SbmDbDfn.ColumnIdx.StockLevel_Status, ColumnAlignment.Center);
					break;
				case SbmStockLevel.Column.Status_Desc:
					SetStockLevelColDfn(columnDfn, "Status", 50, SbmDbDfn.ColumnIdx.StockLevel_Status, ColumnAlignment.Center);
					break;
				case SbmStockLevel.Column.Status_Ind:
					SetStockLevelColDfn(columnDfn, "Status", 50, SbmDbDfn.ColumnIdx.StockLevel_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					break;
				case SbmStockLevel.Column.CreateOn_Date:
					SetStockLevelColDfn(columnDfn, "Created", 65, SbmDbDfn.ColumnIdx.StockLevel_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SbmStockLevel.Column.UpdateOn_Date:
					SetStockLevelColDfn(columnDfn, "Updated", 65, SbmDbDfn.ColumnIdx.StockLevel_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;
		}
		//-------------------------------------------------------------------
		// StockLevel query filter.
		public override List<string> GetStockLevelQueryFilter(SbmStockLevel.Params prm)
		{
			return GetStockLevelQueryFilter(prm, aliasStockLevel);
		}
		public List<string> GetStockLevelQueryFilter(SbmStockLevel.Params prm, String aliasStockLevel)
		{
			List<String> filters = new List<String>();

			// Table Alias - if specified to this method, it implies that the corresponding table is already incorporated into the query e.g. as a join.
			String tableAlias_Commodity = prm.tableAlias_Commodity;
			bool tableAvailable_Commodity = true;
			if (StringUtil.IsEmpty(tableAlias_Commodity))
			{
				tableAlias_Commodity = "taMovCmd";
				tableAvailable_Commodity = false;
			}
			String tableAlias_Location = prm.tableAlias_Location;
			bool tableAvailable_Location = true;
			if (StringUtil.IsEmpty(tableAlias_Location))
			{
				tableAlias_Location = "taMovCnt";
				tableAvailable_Location = false;
			}

			// Item Id.
			String colStockLevel_Id = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Id, aliasStockLevel);
			if (prm.IdsIncluded.HasValidIds())
				filters.Add($"{colStockLevel_Id} IN ({prm.IdsIncluded.Concat(",")})");
			if (prm.IdsExcluded.HasValidIds())
				filters.Add($"{colStockLevel_Id} NOT IN ({prm.IdsExcluded.Concat(",")})");

			//---------------------------------------------------------------------
			// Commodity.
			String colStockLevel_CommodityId = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_CommodityId, aliasStockLevel);
			if (SysId.IsValid(prm.CommodityId))
				filters.Add($"{colStockLevel_CommodityId}={SysId.ToLong(prm.CommodityId)}");

			if (!StringUtil.IsBlank(prm.CommodityCodePartial))
			{
				String colCommodity_Code = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Commodity_Code, tableAlias_Commodity);
				String colCommodity_DescBrief = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Commodity_DescBrief, tableAlias_Commodity);
				if (tableAvailable_Commodity)
				{
					// Commodity properties can be filtered directly.
					if (!StringUtil.IsBlank(prm.CommodityCodePartial))
						filters.Add($"{colStockLevel_CommodityId}={SysId.ToLong(prm.CommodityId)}");
				}
				else
				{
					// ToDo: Sub query to filter commodity properties.
				}
			}

			//---------------------------------------------------------------------
			// Location.
			String colStockLevel_LocationId = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_LocationId, aliasStockLevel);
			if (SysId.IsValid(prm.LocationId))
				filters.Add($"{colStockLevel_LocationId}={SysId.ToLong(prm.LocationId)}");

			// Sales locations.
			if (prm.RestrictToSalesStockLocations)
				filters.Add($"{colStockLevel_LocationId} In (-1{GetLocationIds_Sales().Select(id => $"{SysId.ToLong(id)}").Concat(",")})");

			// Sales locations.
			if (prm.RestrictToCalculateStockLocations)
				filters.Add($"{colStockLevel_LocationId} In (-1{GetLocationIds_Calc().Select(id => $"{SysId.ToLong(id)}").Concat(",")})");

			//---------------------------------------------------------------------
			// Type.
			String colStockLevel_Type = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Type, aliasStockLevel);
			if (prm.Type > 0)
				filters.Add($"{colStockLevel_Type}={(int)prm.Type}");

			//---------------------------------------------------------------------
			// Recorded date.
			String colStockLevel_Recorded = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Recorded, aliasStockLevel);
			if (DateUtil.IsValid(prm.RecordedFrom))
				filters.Add($"{colStockLevel_Recorded}>={DbQuery.FormatDateForCondition(prm.RecordedFrom)}");
			if (DateUtil.IsValid(prm.RecordedTo))
				filters.Add($"{colStockLevel_Recorded}<{DbQuery.FormatDateForCondition(DateUtil.IncrementDate(prm.RecordedTo, 1))}");

			//---------------------------------------------------------------------
			// Most recent.
			if (prm.MostRecentOnly)
			{
				// Query the most recent recorded date that matches the other criteria:
				String aliasStockLevelMax = "aSLMax";
				SbmStockLevel.Params prmMax = new SbmStockLevel.Params(prm);
				prmMax.MostRecentOnly = false;
				DbQuery qry = new DbQuery(Database.DbmsType);
				qry.Tables.Add(SbmDbDfn.GetTableNameQual(SbmDbDfn.TableIdx.StockLevel), aliasStockLevelMax);
				qry.Columns.Add($"Max({SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Recorded, aliasStockLevelMax)})");
				qry.Filters.AddRange(GetStockLevelQueryFilter(prmMax, aliasStockLevelMax));
				if (!SysId.IsValid(prm.LocationId))
					qry.Filters.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_LocationId, aliasStockLevelMax)}={colStockLevel_LocationId}");
				filters.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Recorded, aliasStockLevel)}=({qry.BuildQuery()})");
			}

			//---------------------------------------------------------------------
			// StockLevel status.
			if (prm.StatusCat != SbmStockLevel.StatusCat.Any)
			{
				String colStockLevel_Status = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Status, aliasStockLevel);
				if (prm.StatusCat == SbmStockLevel.StatusCat.ActiveOnly)
					filters.Add($"{colStockLevel_Status} In ('{StatusCurrent}','{StatusConfirmed}','{StatusQueried}')");
				else if (prm.StatusCat == SbmStockLevel.StatusCat.ConfirmedOnly)
					filters.Add($"{colStockLevel_Status}='{StatusConfirmed}'");
				else if (prm.StatusCat == SbmStockLevel.StatusCat.QueriedOnly)
					filters.Add($"{colStockLevel_Status}='{StatusQueried}'");
				else if (prm.StatusCat == SbmStockLevel.StatusCat.NotDeleted)
					filters.Add($"{colStockLevel_Status}!='{StatusDeleted}'");
				else if (prm.StatusCat == SbmStockLevel.StatusCat.DeletedOnly)
					filters.Add($"{colStockLevel_Status}='{StatusDeleted}'");
			}

			if (filters.Count < 1) filters.Add("1=1");
			return filters;
		}

		//-------------------------------------------------------------------
		// StockLevel sort columns.
		public List<String> GetStockLevelSortColumns(SbmStockLevel.Params prm)
		{
			// Sort sequence:
			List<String> sortColumnNames = new List<String>();
			foreach (var columnDfn in prm.SortColumns)
			{
				// Need to ensure correct alias used for StockLevel columns in case of conflict.
				String sortCol = String.Empty;
				if (SbmDbDfn.GetTableForColumn((SbmDbDfn.ColumnIdx)columnDfn.DbColumn) == SbmDbDfn.TableIdx.StockLevel)
				{
					sortCol = SbmDbDfn.GetColumnNameQual((SbmDbDfn.ColumnIdx)columnDfn.DbColumn, aliasStockLevel);
				}
				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(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Type, aliasStockLevel) + " ASC");
			}
			return sortColumnNames;
		}

		//-------------------------------------------------------------------
		// StockLevel count.
		private long GetStockLevelCount(String filter)
		{
			ClearErrorState();
			return Database.GetRowCount(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.StockLevel) + " As " + aliasStockLevel, filter);
		}
		public override long GetStockLevelCount(SbmStockLevel.Params prm)
		{
			ClearErrorState();
			return GetStockLevelCount(GetStockLevelQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// StockLevel list.
		public override List<SbmStockLevel> GetStockLevelList(SbmStockLevel.Params prm)
		{
			ClearErrorState();
			List<SbmStockLevel> stockLevels = new List<SbmStockLevel>();
			DbQuery DbQuery = new DbQuery(Database.DbmsType);
			DbQuery.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.StockLevel), aliasStockLevel);
			StockLevel_Db dbStockLevel = new StockLevel_Db(DbInfo);
			DbQuery.Columns.AddRange(dbStockLevel.ExistingColumnNames);
			DbQuery.Filters.AddRange(GetStockLevelQueryFilter(prm));
			DbQuery.OrderBy.AddRange(GetStockLevelSortColumns(prm));
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					dbCommand.CommandText = DbQuery.BuildQuery(prm.ResultsPaging);
					using (DbDataReader dbDataReader = dbCommand.ExecuteReader())
					{
						while (dbDataReader.Read())
						{
							dbStockLevel = new StockLevel_Db(DbInfo);
							dbStockLevel.PopulateFrom(dbDataReader);
							stockLevels.Add(CreateStockLevel(dbStockLevel));
						}
					}
				}
				catch (Exception exc)
				{
					SetErrorState(ErrorMessage.DatabaseQueryException);
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return stockLevels;
		}

		//-------------------------------------------------------------------
		// StockLevel query execution.
		public override DbResultSet ExecuteStockLevelQuery(List<ColumnDfn> columns, SbmStockLevel.Params prm)
		{
			ClearErrorState();

			//---------------------------------------------------------------
			// Construct query.
			DbQuery query = new DbQuery(Database.DbmsType);
			query.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.StockLevel), aliasStockLevel);

			//---------------------------------------------------------------
			// StockLevel Properties - add columns as defined in query list.
			query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Id, aliasStockLevel));
			if (columns.HasId(SbmStockLevel.Column.CommodityId))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_CommodityId, aliasStockLevel));
			if (columns.HasId(SbmStockLevel.Column.LocationId))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_LocationId, aliasStockLevel));
			if (columns.HasId(SbmStockLevel.Column.Type) || columns.HasId(SbmStockLevel.Column.Type_Desc))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Type, aliasStockLevel));
			if (columns.HasId(SbmStockLevel.Column.Source) || columns.HasId(SbmStockLevel.Column.Source_Desc))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Source, aliasStockLevel));
			if (columns.HasId(SbmStockLevel.Column.Quantity))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Quantity, aliasStockLevel));
			if (columns.HasId(SbmStockLevel.Column.Recorded) || columns.HasId(SbmStockLevel.Column.RecordedDate) || columns.HasId(SbmStockLevel.Column.RecordedTime))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Recorded, aliasStockLevel));
			if (columns.HasId(SbmStockLevel.Column.Notes))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Notes, aliasStockLevel));
			if (columns.HasId(SbmStockLevel.Column.Status) || columns.HasId(SbmStockLevel.Column.Status_Desc) || columns.HasId(SbmStockLevel.Column.Status_Ind))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_Status, aliasStockLevel));
			if (columns.HasId(SbmStockLevel.Column.CreateOn_Date))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_CreateOn, aliasStockLevel));
			if (columns.HasId(SbmStockLevel.Column.UpdateOn_Date))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_UpdateOn, aliasStockLevel));

			//---------------------------------------------------------------------
			// Commodity join.
			bool commodityJoinRequired = columns.HasId(SbmStockLevel.Column.Commodity_Code) || columns.HasId(SbmStockLevel.Column.Commodity_DescBrief);
			if (commodityJoinRequired)
			{
				// Join to the Commodity.
				prm.tableAlias_Commodity = aliasStockLevel_Commodity;
				DbQueryJoin joinCmd = new DbQueryJoin(DbJoinType.LeftOuter);
				joinCmd.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Commodity), aliasStockLevel_Commodity);
				joinCmd.Filters.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Commodity_Id, aliasStockLevel_Commodity)}={SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_CommodityId, aliasStockLevel)}");
				query.Joins.Add(joinCmd);
				// Commodity columns.
				List<SbmDbDfn.ColumnIdx> commodityCols = new List<SbmDbDfn.ColumnIdx>()
				{
					SbmDbDfn.ColumnIdx.Commodity_Code,
					SbmDbDfn.ColumnIdx.Commodity_DescBrief
				};
				foreach (SbmDbDfn.ColumnIdx dbColumn in commodityCols)
					query.Columns.Add(SbmDbDfn.GetColumnNameQual(dbColumn, aliasStockLevel_Commodity), prefixStockLevel_Commodity + SbmDbDfn.GetColumnName(dbColumn, false));
			}

			//---------------------------------------------------------------------
			// Location join.
			bool locationJoinRequired = columns.HasId(SbmStockLevel.Column.Location_CategoryDesc) || columns.HasId(SbmStockLevel.Column.Location_Code) || columns.HasId(SbmStockLevel.Column.Location_Name);
			if (locationJoinRequired)
			{
				// Join to the Location.
				prm.tableAlias_Location = aliasStockLevel_Location;
				DbQueryJoin joinLocation = new DbQueryJoin(DbJoinType.LeftOuter);
				joinLocation.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Location), aliasStockLevel_Location);
				joinLocation.Filters.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Id, aliasStockLevel_Location)}={SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.StockLevel_LocationId)}");
				query.Joins.Add(joinLocation);
				// LocationTo columns.
				List<SbmDbDfn.ColumnIdx> locationToCols = new List<SbmDbDfn.ColumnIdx>()
				{
					SbmDbDfn.ColumnIdx.Location_Category,
					SbmDbDfn.ColumnIdx.Location_Code,
					SbmDbDfn.ColumnIdx.Location_Name
				};
				foreach (SbmDbDfn.ColumnIdx dbColumn in locationToCols)
					query.Columns.Add(SbmDbDfn.GetColumnNameQual(dbColumn, aliasStockLevel_Location), prefixStockLevel_Location + SbmDbDfn.GetColumnName(dbColumn, false));
			}

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

			if (prm.IdsIncluded.Count != 1)
			{
				// Configure sort sequence.
				foreach (String sortColumn in GetStockLevelSortColumns(prm))
					query.OrderBy.Add(sortColumn);
			}

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