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

namespace Saxonite.Net.Standard.Base.Consoles
{
	//=======================================================================
	// The index data is intended to provide a common, performance effective route
	// to identifying the activities that are relevant to a User or other context
	// that defines at least one region/sport combination and an effective date (usually today).
	//=======================================================================
	public abstract class SaxActivityConsole : SaErrorStateItem
	{
		//-------------------------------------------------------------------
		// Definitions.
		/// <summary>
		/// Parameters required to query the index for activities to identify relevant activities.
		/// </summary>
		public class IndexContext
		{
			// ToDo Include Localiser.
			public IndexContext (SysId userAccountId)
			{
				UserAccountId = userAccountId;
			}
			public SysId UserAccountId { get; }
			public List<SysId> SportIds { get; } = new List<SysId>();
			public List<SysId> RegionIds { get; } = new List<SysId>();
			// Default period is ~12 months ago up to ~3 months in the future.
			public DateTime EffectiveFrom { get; } = DateUtil.IncrementDate(DateTime.Today, -365);
			public DateTime EffectiveTo { get; } = DateUtil.IncrementDate(DateTime.Today, 30);
			public bool IsValid()
			{
				// Context must contain at least a sport, a region and a valid effective period.
				if (!SportIds.HasValidIds()) return false;
				if (!RegionIds.HasValidIds()) return false;
				if (!DateUtil.IsValid(EffectiveFrom) || EffectiveTo < EffectiveFrom) return false;
				return true;
			}
			public DbQuery.Paging Paging { get; } = new DbQuery.Paging();
		}
		/// <summary>
		/// Activities identified by querying index with context.
		/// </summary>
		public class IndexResults
		{
			public class ActivityData
			{
				public ActivityData(ItemId itemId, DateTime effectiveOn)
				{
					ItemId = itemId;
					EffectiveOn = effectiveOn;
				}
				public ItemId ItemId { get; }
				public DateTime EffectiveOn { get; }
				public SysId OrganisationId { get; set; }
				public String Organisation { get; set; }
				public SysId UserAccountIdAuthor { get; set; }
				public String Author { get; set; }
				public String Caption { get; protected set; }
				public String Blurb { get; protected set; }
				public SysId SportId { get; protected set; }
				public String SportName { get; protected set; }
				public SysId RegionId { get; protected set; }
				public String RegionName { get; protected set; }
				// User Activity.
				public DateTime LastListedAt { get; protected set; }
				public DateTime LastViewedAt { get; protected set; }
				public Sax.ActivityReaction Reaction { get; protected set; }
				public DateTime LastReactedAt { get; protected set; }
			}
			public List<ActivityData> Items { get; } = new List<ActivityData>();
		}

		//-------------------------------------------------------------------
		// Data members.
		private SaxInternals internals = null;
		private readonly List<Sax.DataItemType> validActivityItemTypes = new List<Sax.DataItemType>()
		{
			Sax.DataItemType.Article,
			Sax.DataItemType.OrganisationEvent,
			Sax.DataItemType.OrganisationOpportunity,
		};

		//-------------------------------------------------------------------
		// Protected construction.
		protected SaxActivityConsole(SaxSessionContext sessionContext)
		{
			SessionContext = sessionContext;
		}
		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				if (internals != null) internals.Dispose(); internals = null;
			}
		}

		//-------------------------------------------------------------------
		// Properties.
		protected SaxSessionContext SessionContext { get; }
		protected SaxInternals Internals { get { if (internals == null) internals = new SaxInternals(SessionContext); return internals; } }
		protected List<Sax.DataItemType> ValidActivityItemTypes { get { return validActivityItemTypes.ToList(); } }

		//-------------------------------------------------------------------
		// Query Activity Index Entries for User Context.
		//-------------------------------------------------------------------
		public abstract IndexResults QueryIndex(IndexContext context);

		//-------------------------------------------------------------------
		// Store Activity Index for Specific activities.
		//-------------------------------------------------------------------
		/// <summary>
		/// Store the Activity Index for an Article.
		/// </summary>
		public bool StoreActivityIndex(SaxArticle article, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();

			// Determine whether article should be included in the Activity Index.
			bool includeInActivityIndex = true;

			// Only published articles have an activity index.
			if (!DateUtil.IsValid(article.PublishedAt)) includeInActivityIndex = false;

			// Only active articles have an activity index.
			if (!article.IsStatusActive) includeInActivityIndex = false;

			// NB There will be other rules as well, eg. whether expired.

			if (includeInActivityIndex)
			{
				// Activity Index properties.
				IndexData indexData = new IndexData(article.GetItemId());
				indexData.SportIds.Add(article.SportIdPrimary);
				indexData.RegionIds.Add(article.RegionIdPrimary);
				indexData.EffectiveOn = DateUtil.OnInvalid(article.PublishedAt.Date, article.CreateStamp.On.Date);
				return StoreActivityIndexData(indexData, dbUpdateInfo);
			}
			return ClearActivityIndex(article.GetItemId(), dbUpdateInfo);
		}
		public bool ClearActivityIndex(SaxArticle article, DbUpdateInfo dbUpdateInfo)
		{
			return ClearActivityIndex(article.GetItemId(), dbUpdateInfo);
		}

		//-------------------------------------------------------------------
		/// <summary>
		/// Store the Activity Index for a Organisation Event.
		/// </summary>
		public bool StoreActivityIndex(SaxOrganisationEvent organisationEvent, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();

			// Only active opportunities have an activity index.
			if (!organisationEvent.IsStatusActive) ClearActivityIndex(organisationEvent.GetItemId(), dbUpdateInfo);

			// NB There will be other rules as well, eg. whether published.

			// Activity Index properties.
			IndexData indexData = new IndexData(organisationEvent.GetItemId());
			indexData.SportIds.Add(organisationEvent.SportIdPrimary);
			indexData.RegionIds.Add(organisationEvent.RegionIdCountry);
			indexData.EffectiveOn = DateUtil.OnInvalid(organisationEvent.PublishedAt.Date, organisationEvent.CreateStamp.On.Date);
			return StoreActivityIndexData(indexData, dbUpdateInfo);
		}
		public bool ClearActivityIndex(SaxOrganisationEvent organisationEvent, DbUpdateInfo dbUpdateInfo)
		{
			return ClearActivityIndex(organisationEvent.GetItemId(), dbUpdateInfo);
		}

		//-------------------------------------------------------------------
		/// <summary>
		/// Store the Activity Index for a Organisation Opportunity.
		/// </summary>
		public bool StoreActivityIndex(SaxOrganisationOpportunity opportunity, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();

			// Only active opportunities have an activity index.
			if (!opportunity.IsStatusActive) ClearActivityIndex(opportunity.GetItemId(), dbUpdateInfo);

			// NB There will be other rules as well, eg. whether published.

			// Activity Index properties.
			IndexData indexData = new IndexData(opportunity.GetItemId());
			indexData.SportIds.Add(opportunity.SportIdPrimary);
			indexData.RegionIds.Add(opportunity.RegionIdPrimary);
			indexData.EffectiveOn = DateUtil.OnInvalid(opportunity.PublishedAt.Date, opportunity.CreateStamp.On.Date);
			return StoreActivityIndexData(indexData, dbUpdateInfo);
		}
		public bool ClearActivityIndex(SaxOrganisationOpportunity opportunity, DbUpdateInfo dbUpdateInfo)
		{
			return ClearActivityIndex(opportunity.GetItemId(), dbUpdateInfo);
		}

		//-------------------------------------------------------------------
		// Store Activity Index.
		//-------------------------------------------------------------------
		/// <summary>Data values that make up the index for an activity.</summary>
		protected class IndexData
		{
			public IndexData(ItemId itemId)
			{
				ItemId = itemId;
			}
			public ItemId ItemId { get; }
			public List<SysId> SportIds { get; } = new List<SysId>();
			public List<SysId> RegionIds { get; } = new List<SysId>();
			public DateTime EffectiveOn { get; set; }
			public bool IsValid()
			{
				if (!ItemId.IsValid(ItemId)) return false;
				if (!SportIds.HasValidIds()) return false;
				if (!RegionIds.HasValidIds()) return false;
				if (!DateUtil.IsValid(EffectiveOn)) return false;
				return true;
			}
		}
		/// <summary>Single entry in the index for an activity.</summary>
		protected class IndexEntryData
		{
			public IndexEntryData(ItemId itemId, SysId sportId, SysId regionId, DateTime effectiveOn)
			{
				ItemId = itemId;
				SportId = sportId;
				RegionId = regionId;
				EffectiveOn = effectiveOn;
			}
			public ItemId ItemId { get; }
			public SysId SportId { get; }
			public SysId RegionId { get; }
			public DateTime EffectiveOn { get; }
			public bool IsValid()
			{
				if (!ItemId.IsValid(ItemId)) return false;
				if (!SysId.IsValid(SportId)) return false;
				if (!SysId.IsValid(RegionId)) return false;
				if (!DateUtil.IsValid(EffectiveOn)) return false;
				return true;
			}
			/// <summary>Compare index entry Ids - Item, Sport & Region.</summary>
			public bool MatchesIds(SaxActivityIndex activityIndex)
			{
				if (!ItemId.Equals(activityIndex.ItemId)) return false;
				if (!SportId.Equals(activityIndex.SportId)) return false;
				if (!RegionId.Equals(activityIndex.RegionId)) return false;
				return true;
			}
			/// <summary>Compare index entry Ids - Item, Sport & Region - and effective date.</summary>
			public bool Matches(SaxActivityIndex activityIndex)
			{
				if (!MatchesIds(activityIndex)) return false;
				if (!EffectiveOn.Equals(activityIndex.EffectiveOn)) return false;
				return true;
			}
		}

		//-------------------------------------------------------------------
		// Activity Index data.
		protected abstract bool StoreActivityIndexData(IndexData indexData, DbUpdateInfo dbUpdateInfo);
		protected abstract bool ClearActivityIndex(ItemId itemId, DbUpdateInfo dbUpdateInfo);

		//-------------------------------------------------------------------
		// Activity Index Utilities.
		protected List<IndexEntryData> GetEntriesForIndex(IndexData indexData)
		{
			ClearErrorState();
			List<IndexEntryData> indexEntries = new List<IndexEntryData>();
			if (ItemId.IsValid(indexData.ItemId) && DateUtil.IsValid(indexData.EffectiveOn))
			{
				foreach (SysId sportId in indexData.SportIds.FindAll(item => SysId.IsValid(item)))
				{
					foreach (SysId regionId in indexData.RegionIds.FindAll(item => SysId.IsValid(item)))
					{
						IndexEntryData indexEntry = new IndexEntryData(indexData.ItemId, sportId, regionId, indexData.EffectiveOn);
						if (indexEntry.IsValid())
							indexEntries.Add(indexEntry);
					}
				}
			}
			return indexEntries;
		}

		//-------------------------------------------------------------------
		// User Activities
		//-------------------------------------------------------------------
		public abstract bool RecordUserActivitiesListed(SysId userAccountId, List<ItemId> activityItemIds, DbUpdateInfo dbUpdateInfo);
		public abstract bool RecordUserActivityViewed(SysId userAccountId, ItemId activityItemId, DbUpdateInfo dbUpdateInfo);
		public abstract bool RecordUserActivityReaction(SysId userAccountId, ItemId activityItemId, Sax.ActivityReaction activityReaction, DbUpdateInfo dbUpdateInfo);

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