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 Saxonite.Base.App;
using Saxonite.Net.Standard.Base.App;
using Saxonite.Net.Standard.Base.Bus;
using System;
using System.Collections.Generic;
using System.Text;

namespace Saxonite.Net.Standard.Base.Mgr
{
	//=======================================================================
	partial class SaxActivityMgr
	{
		//*******************************************************************
		// Activity Mgr - Activity Index
		//*******************************************************************
		// Utilities.
		public Boolean IsValidItemForFeedback(ItemId itemId)
		{
			if (!ItemId.IsValid(itemId))
				return false;
			if (!SaxActivityFeedback.ValidItemTypes.Contains((Sax.DataItemType)itemId.Type))
				return false;
			return true;
		}

		//-------------------------------------------------------------------
		public SaxActivityFeedback GetActivityFeedbackForItem(ItemId itemId)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId))
				return null;
			SaxActivityFeedback.Params prmActivityFeedback = new SaxActivityFeedback.Params();
			prmActivityFeedback.ItemIdsIncluded.Add(itemId);
			return GetActivityFeedback(prmActivityFeedback);
		}

		//-------------------------------------------------------------------
		public Boolean UpdateActivityFeedback(ItemId itemId, int viewCountIncrement, int feedbackCountIncrement, int feedbackTotalIncrement, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId))
				return SetErrorState("Unable to update activity feedback - Item Id must be supplied");
			if (viewCountIncrement == 0 && feedbackCountIncrement == 0 && feedbackTotalIncrement == 0)
				return true;
			if (DebugMode)
				SaLogger.Info($"{SysUtil.Fn} View count incr: {viewCountIncrement}. Feedback count incr: {feedbackCountIncrement}. Feedback total incr: {feedbackTotalIncrement}.");
			using (DisposableCollection<IDisposable> disposableItems = new DisposableCollection<IDisposable>())
			{
				bool activityFeedbackCreated = false;
				SaxActivityFeedback activityFeedback = GetActivityFeedbackForItem(itemId);
				if (activityFeedback == null)
				{
					activityFeedback = CreateActivityFeedback(itemId);
					activityFeedbackCreated = true;
				}
				disposableItems.Add(activityFeedback);
				// Update properties.
				activityFeedback.ViewCount = Math.Max(0, activityFeedback.ViewCount + viewCountIncrement);
				activityFeedback.FeedbackCount = Math.Max(0, activityFeedback.FeedbackCount + feedbackCountIncrement);
				activityFeedback.FeedbackTotal = Math.Max(0, activityFeedback.FeedbackTotal + feedbackTotalIncrement);
				activityFeedback.FeedbackAverage = activityFeedback.FeedbackCount > 0 ? (decimal)activityFeedback.FeedbackTotal / activityFeedback.FeedbackCount : 0;
				// Store feedback.
				if (activityFeedbackCreated)
					InsertActivityFeedback(activityFeedback, dbUpdateInfo);
				else
					UpdateActivityFeedback(activityFeedback, dbUpdateInfo);
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Create item.
		public abstract SaxActivityFeedback CreateActivityFeedback(ItemId itemId);

		//-------------------------------------------------------------------
		// Retrieve individual items.
		public abstract SaxActivityFeedback GetActivityFeedback(SaxActivityFeedback.Params prmActivityFeedback);

		//-------------------------------------------------------------------
		// Validate item data.
		public bool IsValidActivityFeedback(SaxActivityFeedback activityIndex)
		{
			ClearErrorState();
			if (activityIndex == null) return SetErrorState(ErrorMessage.ItemNotSpecified);
			return IsValidActivityFeedbackData(activityIndex.GetData(), new SaxActivityFeedback.ErrField());
		}
		public virtual bool IsValidActivityFeedbackData(SaxActivityFeedback.Data data, SaxActivityFeedback.ErrField errField)
		{
			ClearErrorState();

			//---------------------------------------------------------------
			// Item Id.
			if (errField.ItemId != SacsHierarchyItem.ValidValue.Ignore)
			{
				if (!ItemId.IsValid(data.ItemId))
				{
					errField.ItemId = SacsHierarchyItem.ValidValue.Invalid;
					return SetErrorState("item id must be specified");
				}
				if (!IsValidItemForFeedback(data.ItemId))
				{
					errField.ItemId = SacsHierarchyItem.ValidValue.Invalid;
					return SetErrorState("invalid item type specified");
				}
			}
			// View Count.
			if (errField.ViewCount != SacsHierarchyItem.ValidValue.Ignore && data.ViewCount < 0)
			{
				errField.ViewCount = SacsHierarchyItem.ValidValue.Invalid;
				return SetErrorState("View count must not be negative");
			}
			// Feedback Count.
			if (errField.FeedbackCount != SacsHierarchyItem.ValidValue.Ignore && data.FeedbackCount < 0)
			{
				errField.FeedbackCount = SacsHierarchyItem.ValidValue.Invalid;
				return SetErrorState("Feedback count must not be negative");
			}
			// Feedback Total.
			if (errField.FeedbackTotal != SacsHierarchyItem.ValidValue.Ignore && data.FeedbackTotal < 0)
			{
				errField.FeedbackTotal = SacsHierarchyItem.ValidValue.Invalid;
				return SetErrorState("Feedback count must not be negative");
			}
			// Feedback Average.
			if (errField.FeedbackAverage != SacsHierarchyItem.ValidValue.Ignore && data.FeedbackAverage < 0)
			{
				errField.FeedbackAverage = SacsHierarchyItem.ValidValue.Invalid;
				return SetErrorState("Feedback count must not be negative");
			}

			//---------------------------------------------------------------
			return true;
		}

		//-------------------------------------------------------------------
		// ActivityFeedback database interface.
		public abstract bool InsertActivityFeedback(SaxActivityFeedback activityIndex, DbUpdateInfo dbUpdateInfo);
		public abstract bool UpdateActivityFeedback(SaxActivityFeedback activityIndex, DbUpdateInfo dbUpdateInfo);
		public virtual bool ActivityFeedbackCanBeDeleted(SaxActivityFeedback activityIndex)
		{
			ClearErrorState();
			return true;
		}
		public abstract bool DeleteActivityFeedback(SaxActivityFeedback activityIndex, DbUpdateInfo dbUpdateInfo);

		//-------------------------------------------------------------------
		// ActivityFeedback list:
		public abstract ColumnDfn GetActivityFeedbackColumnDfn(SaxActivityFeedback.Column columnId, String caption = "", int width = 0);
		public abstract List<String> GetActivityFeedbackQueryFilter(SaxActivityFeedback.Params prmActivityFeedback);
		public abstract long GetActivityFeedbackCount(SaxActivityFeedback.Params prmActivityFeedback);
		public abstract List<SaxActivityFeedback> GetActivityFeedbackList(SaxActivityFeedback.Params prmActivityFeedback);
		public abstract DbResultSet ExecuteActivityFeedbackQuery(List<ColumnDfn> columns, SaxActivityFeedback.Params prmActivityFeedback);

		//-------------------------------------------------------------------
		/// <summary>
		/// Extract and format result set data value where specific handling is required.
		/// <para>Where response is an invalid data value, format value using column.FormatValue(values).</para>
		/// </summary>
		public virtual DataValue GetActivityFeedbackDataValue(ColumnDfn column, NamedValue.Map values)
		{
			DataValue value = new DataValue();
			switch ((SaxActivityFeedback.Column)column.Id)
			{
				//-----------------------------------------------------------
				// Data item type.
				case SaxActivityFeedback.Column.ItemType_Code:
					{
						value = new DataValue(DataItemTypeCodes.GetCodeForType(values.GetLong(column.DataName)));
					}
					break;
				case SaxActivityFeedback.Column.ItemType_Desc:
					{
						value = new DataValue(DataItemTypeCodes.GetDescForType(values.GetLong(column.DataName)));
					}
					break;

				//-----------------------------------------------------------
				default:
					value = values.GetValue(column.DataName);
					break;

			}
			return value;
		}

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