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.Linq;
using System.Text;

namespace Saxonite.Net.Standard.Base.Mgr
{
	//=======================================================================
	partial class SaxAccountMgr
	{
		//*******************************************************************
		// Account Mgr - User Role
		//*******************************************************************
		// Utilities.
		public bool UserHasRole(SysId userAccountId, Sax.UserRole userRole, SaxUserRole.StatusCat statusCat = SaxUserRole.StatusCat.ActiveOnly)
		{
			if (!SysId.IsValid(userAccountId) || userRole <= 0) return false;
			SaxUserRole.Params prmUserRole = new SaxUserRole.Params();
			prmUserRole.UserAccountIdsIncluded.Add(userAccountId);
			prmUserRole.UserRolesIncluded.Add(userRole);
			prmUserRole.StatusCat = statusCat;
			return GetUserRoleCount(prmUserRole) > 0;
		}
		public List<SaxUserRole> GetRolesForUser(SysId userAccountId, SaxUserRole.StatusCat statusCat = SaxUserRole.StatusCat.ActiveOnly)
		{
			if (!SysId.IsValid(userAccountId)) return new List<SaxUserRole>();
			SaxUserRole.Params prmUserRole = new SaxUserRole.Params();
			prmUserRole.UserAccountIdsIncluded.Add(userAccountId);
			prmUserRole.StatusCat = statusCat;
			return GetUserRoleList(prmUserRole);
		}

		//-------------------------------------------------------------------
		// Create item.
		public abstract SaxUserRole CreateUserRole(SysId userAccountId, Sax.UserRole userRole);

		//-------------------------------------------------------------------
		// Item exists.
		public bool UserRoleExistsById(SysId id)
		{
			ClearErrorState();
			if (!SysId.IsValid(id)) return false;
			SaxUserRole.Params prmUserRole = new SaxUserRole.Params();
			prmUserRole.IdsIncluded.Add(id);
			prmUserRole.StatusCat = SaxUserRole.StatusCat.Any;
			return GetUserRoleCount(prmUserRole) == 1;
		}

		//-------------------------------------------------------------------
		// Retrieve individual items.
		public abstract SaxUserRole GetUserRole(SaxUserRole.Params prmUserRole);
		public SaxUserRole GetUserRoleById(SysId id)
		{
			ClearErrorState();
			if (!SysId.IsValid(id)) return null;
			SaxUserRole.Params prmUserRole = new SaxUserRole.Params();
			prmUserRole.IdsIncluded.Add(id);
			prmUserRole.StatusCat = SaxUserRole.StatusCat.Any;
			return GetUserRole(prmUserRole);
		}

		//-------------------------------------------------------------------
		// Validate item data.
		public bool IsValidUserRole(SaxUserRole userRole)
		{
			ClearErrorState();
			if (userRole == null) return SetErrorState(ErrorMessage.ItemNotSpecified);
			return IsValidUserRoleData(userRole.GetData(), new SaxUserRole.ErrField());
		}
		public virtual bool IsValidUserRoleData(SaxUserRole.Data data, SaxUserRole.ErrField errField)
		{
			ClearErrorState();

			// User Account.
			if (errField.UserAccountId != SacsHierarchyItem.ValidValue.Ignore && !SysId.IsValid(data.UserAccountId))
			{
				errField.UserAccountId = SacsHierarchyItem.ValidValue.Invalid;
				return SetErrorState("User Account Id must be specified");
			}
			// User Role.
			if (errField.UserRole != SacsHierarchyItem.ValidValue.Ignore && (int)data.UserRole < 1)
			{
				errField.UserRole = SacsHierarchyItem.ValidValue.Invalid;
				return SetErrorState("User Role must be specified");
			}

			// Login - Admin application for System users.
			if (errField.LastLogin != SacsHierarchyItem.ValidValue.Ignore && DateUtil.IsValid(data.LastLoginAt))
			{
				if (data.UserRole != Sax.UserRole.SystemAdmin)
				{
					errField.LastLogin = SacsHierarchyItem.ValidValue.Invalid;
					return SetErrorState("Last Login can only be set for System Admin role");
				}
			}
			if (errField.LastInvalidLogin != SacsHierarchyItem.ValidValue.Ignore && DateUtil.IsValid(data.LastInvalidLoginAt))
			{
				if (data.UserRole != Sax.UserRole.SystemAdmin)
				{
					errField.LastLogin = SacsHierarchyItem.ValidValue.Invalid;
					return SetErrorState("Last Invalid Login can only be set for System Admin role");
				}
			}
			if (errField.InvalidLoginCount != SacsHierarchyItem.ValidValue.Ignore && data.InvalidLoginCount > 0)
			{
				if (data.UserRole != Sax.UserRole.SystemAdmin)
				{
					errField.LastLogin = SacsHierarchyItem.ValidValue.Invalid;
					return SetErrorState("Invalid Login Count can only be set for System Admin role");
				}
			}

			//---------------------------------------------------------------
			// Common properties.
			if (errField.Notes != SacsHierarchyItem.ValidValue.Ignore && !IsValidValue(data.Notes, "notes", (long)SaxDbDfn_Core.GetColTextLen(SaxDbDfn_Core.ColumnIdx.UserRole_Notes)))
			{
				errField.Notes = SacsHierarchyItem.ValidValue.Invalid;
				return false;
			}
			if (errField.Status != SacsHierarchyItem.ValidValue.Ignore)
			{
				if (!IsValidValue(data.StatusCode, "status", (long)SaxDbDfn_Core.GetColTextLen(SaxDbDfn_Core.ColumnIdx.UserRole_Status), true, true))
				{
					errField.Status = SacsHierarchyItem.ValidValue.Invalid;
					return false;
				}
				if (!SaxUserRole.ValidStatuses.Contains(data.Status))
				{
					errField.Status = SacsHierarchyItem.ValidValue.Invalid;
					return SetErrorState(ErrorMessage.InvalidStatus);
				}
			}

			//---------------------------------------------------------------
			// User & Role combination must be unique.
			if (errField.UserAccountId != SacsHierarchyItem.ValidValue.Ignore && errField.UserRole != SacsHierarchyItem.ValidValue.Ignore)
			{
				if (SysId.IsValid(data.UserAccountId) && data.UserRole > 0)
				{
					SaxUserRole.Params prmUserRole = new SaxUserRole.Params();
					if (SysId.IsValid(data.Id))
						prmUserRole.IdsExcluded.Add(data.Id);
					prmUserRole.UserAccountIdsIncluded.Add(data.UserAccountId);
					prmUserRole.UserRolesIncluded.Add(data.UserRole);
					prmUserRole.StatusCat = SaxUserRole.StatusCat.Any;
					if (GetUserRoleCount(prmUserRole) > 0)
					{
						errField.UserRole = SacsHierarchyItem.ValidValue.Invalid;
						return SetErrorState("Role must be unique for user");
					}
				}
			}

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

		//-------------------------------------------------------------------
		// Item database interface.
		public abstract bool InsertUserRole(SaxUserRole userRole, DbUpdateInfo dbUpdateInfo);
		public abstract bool UpdateUserRole(SaxUserRole userRole, DbUpdateInfo dbUpdateInfo);
		public virtual bool UserRoleCanBeDeleted(SaxUserRole userRole)
		{
			ClearErrorState();
			return true;
		}
		public abstract bool DeleteUserRole(SaxUserRole userRole, DbUpdateInfo dbUpdateInfo);

		//-------------------------------------------------------------------
		// Item list.
		public abstract ColumnDfn GetUserRoleColumnDfn(SaxUserRole.Column columnId, String caption = "", int width = 0);
		public abstract List<String> GetUserRoleQueryFilter(SaxUserRole.Params prmUserRole);
		public abstract long GetUserRoleCount(SaxUserRole.Params prmUserRole);
		public abstract List<SaxUserRole> GetUserRoleList(SaxUserRole.Params prmUserRole);
		public abstract DbResultSet ExecuteUserRoleQuery(List<ColumnDfn> columns, SaxUserRole.Params prmUserRole);

		//-------------------------------------------------------------------
		/// <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 GetUserRoleDataValue(ColumnDfn column, NamedValue.Map values)
		{
			DataValue value = new DataValue();
			switch ((SaxUserRole.Column)column.Id)
			{
				//-----------------------------------------------------------
				// User Display Name.
				case SaxUserRole.Column.User_DisplayName:
					{
						String userTitle = values.GetValue(GetUserRoleColumnDfn(SaxUserRole.Column.User_Title).DataName).ToString();
						String userFirstName = values.GetValue(GetUserRoleColumnDfn(SaxUserRole.Column.User_FirstName).DataName).ToString();
						String userLastName = values.GetValue(GetUserRoleColumnDfn(SaxUserRole.Column.User_LastName).DataName).ToString();
						value = new DataValue(SaxUserAccount.GetDisplayName(userTitle, userFirstName, userLastName));
					}
					break;

				//-----------------------------------------------------------
				// User Role.
				case SaxUserRole.Column.UserRole_Desc:
					{
						String userRoleCode = values.GetValue(column.DataName).ToString();
						value = new DataValue(UserRoleCodes.GetDescForCode(userRoleCode));
					}
					break;

				//-----------------------------------------------------------
				// Notes.
				case SaxUserRole.Column.Notes:
					{
						value = new DataValue(SacsHierarchyItem.FormatForDisplay(values.GetValue(column.DataName).ToString(), 200));
					}
					break;

				//-----------------------------------------------------------
				// Status.
				case SaxUserRole.Column.Status_Desc:
				case SaxUserRole.Column.Status_Ind:
					{
						String statusCode = values.GetValue(column.DataName).ToString();
						SaStatus status = SacsSystem.GetStatusForCode(statusCode);
						if (column.Id == (int)SaxUserRole.Column.Status_Desc)
							value = new DataValue(SacsSystem.GetStatusDesc(status));
						else if (column.Id == (int)SaxUserRole.Column.Status_Ind)
							value = new DataValue(SaxUserRole.GetStatusTriState(status));
					}
					break;

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

			}
			return value;
		}

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