using Microsoft.AspNetCore.Mvc;
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.Net.Core.Web.Admin.Models;
using Saxonite.Net.Standard.Base.App;
using Saxonite.Net.Standard.Base.Bus;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Saxonite.Net.Core.Web.Admin.Controllers
{
	//=======================================================================
	partial class UserController
	{
		//-------------------------------------------------------------------
		// User data.
		public class UserData_List
		{
			public String Id { get; set; }
			public String EmailAddress { get; set; }
			public String DisplayName { get; set; }
			public String Title { get; set; }
			public String FirstName { get; set; }
			public String LastName { get; set; }
			public int UserRoleCount { get; set; }
			public bool SystemAdmin { get; set; }
			public String StatusCode { get; set; }
			public String StatusDesc { get; set; }
		}
		public class UserData_Full : UserData_List
		{
			public List<String> userRoleCodes { get; } = new List<string>();
		}
		private void PopulateUserResponseData(UserData_List data, SaxUserAccount user, List<SaxUserRole> userRoles)
		{
			data.Id = SysId.ToString(user.Id);
			data.EmailAddress = user.EmailAddress;
			data.DisplayName = user.GetDisplayName();
			data.Title = user.Title;
			data.FirstName = user.FirstName;
			data.LastName = user.LastName;
			data.UserRoleCount = userRoles?.GetUserRolesByStatus(SaStatus.Active).Count ?? 0;
			data.StatusCode = user.StatusCode;
			data.StatusDesc = user.StatusDesc;
		}
		private void PopulateUserResponseData(UserData_Full data, SaxUserAccount user, List<SaxUserRole> userRoles)
		{
			PopulateUserResponseData(data as UserData_List, user, userRoles);

			if (userRoles != null)
			{
				foreach (SaxUserRole userRole in userRoles.GetUserRolesByStatus(SaStatus.Active))
					data.userRoleCodes.Add(UserRoles.GetCodeForType(userRole.UserRole));
			}
		}

		//-------------------------------------------------------------------
		// Get User List ajax request.
		//-------------------------------------------------------------------
		public class AjaxResponse_UserList : AjaxResponse_Data
		{
			public List<UserData_List> Users { get; } = new List<UserData_List>();
			public List<CodeDesc> UserRoles { get; } = new List<CodeDesc>();
		}
		//-------------------------------------------------------------------
		[HttpPost]
		[Route("User/Ajax/GetList")]
		public IActionResult Ajax_GetList(Model_User model)
		{
			String fn = GetType().Name + ".Ajax_GetList";
			String messageTitle = Localiser["user.caption.users"];
			AjaxResponse_UserList responseData = new AjaxResponse_UserList();

			// Validate session.
			if (!ValidUserSession)
				return GetAjaxResult_InvalidSession(responseData);

			// Reference data - user roles.
			foreach (TypeCodeDesc userRole in UserRoles)
				responseData.UserRoles.Add(userRole.Code, Localiser.GetUserRoleCaption((Sax.UserRole)userRole.Type));

			// Item filter.
			SaxUserAccount.Params prmUserAccount = new SaxUserAccount.Params();
			prmUserAccount.UserAccountFilter = model.Filter.User;
			prmUserAccount.StatusCat = SaxUserAccount.StatusCat.NotDeleted;
			model.DataItemTotal = (ulong)AccountMgr.GetUserAccountCount(prmUserAccount);
			model.PopulatePagingTo(prmUserAccount.ResultsPaging);

			// Item columns.
			ColumnDfn colId = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.Id);
			ColumnDfn colEmail = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.EmailAddress);
			ColumnDfn colTitle = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.Title);
			ColumnDfn colFirstName = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.FirstName);
			ColumnDfn colLastName = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.LastName);
			ColumnDfn colUserRoleCount = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.UserRoleCount);
			ColumnDfn colSystemAdminUser = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.SystemAdminUser);
			ColumnDfn colStatus = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.Status);
			List<ColumnDfn> columns = new List<ColumnDfn>()
			{
				colId,
				colEmail,
				colTitle,
				colFirstName,
				colLastName,
				colUserRoleCount,
				colSystemAdminUser,
				colStatus
			};

			// Query items.
			model.DataItemCount = 0;
			using (DbResultSet resultSet = AccountMgr.ExecuteUserAccountQuery(columns, prmUserAccount))
			{
				while (resultSet != null && resultSet.HasRows && resultSet.NextRecord())
				{
					model.DataItemCount++;
					NamedValue.Map values = resultSet.GetRecordValues();
					UserData_List userData = new UserData_List()
					{
						Id = values.GetString(colId.DataName),
						EmailAddress = values.GetString(colEmail.DataName),
						Title = values.GetString(colTitle.DataName),
						FirstName = values.GetString(colFirstName.DataName),
						LastName = values.GetString(colLastName.DataName),
						UserRoleCount = StringUtil.ToInt(values.GetString(colUserRoleCount.DataName)),
						SystemAdmin = StringUtil.ToBool(values.GetString(colSystemAdminUser.DataName)),
						StatusCode = values.GetString(colStatus.DataName),
						StatusDesc = SacsSystem.GetStatusDescForCode(values.GetString(colStatus.DataName))
					};
					userData.DisplayName = SaxUserAccount.GetDisplayName(userData.Title, userData.FirstName, userData.LastName);
					responseData.Users.Add(userData);
				}
			}

			// Complete response.
			responseData.SetPaging(model);
			responseData.Success = true;

			return Json(responseData);
		}

		//-------------------------------------------------------------------
		// Get User ajax request.
		//-------------------------------------------------------------------
		public class AjaxResponse_User : AjaxResponse_Data
		{
			public UserData_Full user { get; } = new UserData_Full();
		}
		//-------------------------------------------------------------------
		[HttpPost]
		[Route("User/Ajax/GetItem")]
		public IActionResult Ajax_GetItem(Model_User model)
		{
			String fn = GetType().Name + ".Ajax_GetItem";
			String messageTitle = Localiser["user.caption.user"];
			AjaxResponse_User responseData = new AjaxResponse_User();

			// Validate session.
			if (!ValidUserSession)
				return GetAjaxResult_InvalidSession(responseData);

			// Identify item.
			if (!SysId.IsValid(model.UserAccountId))
				return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.id.not.specified"]));

			// Retrieve item.
			SaxUserAccount user = AccountMgr.GetUserAccountById(model.UserAccountId);
			if (user == null)
			{
				SaLogger.Warn(fn + " Failed to retrieve user for Id: '" + model.UserAccountIdValue + "'");
				return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.id.not.found"]));
			}

			// User's roles.

			// Construct response.
			PopulateUserResponseData(responseData.user, user, GetUserRoles(user.Id).GetUserRolesByStatus(SaStatus.Active));

			// Complete response.
			responseData.Success = true;

			return Json(responseData);
		}

		//-------------------------------------------------------------------
		private List<SaxUserRole> GetUserRoles(SysId userAccountId, SaxUserRole.StatusCat statusCat = SaxUserRole.StatusCat.NotDeleted)
		{
			if (!SysId.IsValid(userAccountId)) return new List<SaxUserRole>();
			SaxUserRole.Params prmUserRole = new SaxUserRole.Params();
			prmUserRole.UserAccountIdsIncluded.Add(userAccountId);
			prmUserRole.StatusCat = statusCat;
			return AccountMgr.GetUserRoleList(prmUserRole);
		}

		//-------------------------------------------------------------------
		// Store User ajax request.
		//-------------------------------------------------------------------
		[HttpPost]
		[Route("User/Ajax/StoreItem")]
		public IActionResult Ajax_StoreItem(Model_User model)
		{
			String fn = GetType().Name + ".Ajax_StoreItem";
			String messageTitle = Localiser["user.caption.user"];
			AjaxResponse_User responseData = new AjaxResponse_User();

			// Validate session.
			if (!ValidUserSession)
				return GetAjaxResult_InvalidSession(responseData);

			// Validate item properties.
			model.ValidateUserData(responseData);
			if (responseData.HasControlErrors())
				return Json(responseData);

			// Retrieve existing item.
			SaxUserAccount user = AccountMgr.GetUserAccountById(model.UserAccountId);
			if (user == null && SysId.IsValid(model.UserAccountId))
			{
				SaLogger.Warn(fn + " Failed to retrieve user for Id: '" + model.UserAccountIdValue + "'");
				return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.id.not.found"]));
			}

			// User roles, including deleted.
			List<String> userRoleCodes = model.GetUserRoleCodes();
			List<SaxUserRole> userRoles = new List<SaxUserRole>();
			if (user != null) userRoles = GetUserRoles(user.Id, SaxUserRole.StatusCat.Any);
			foreach (String userRoleCode in userRoleCodes)
			{
				// Role to activate.
				Sax.UserRole role = (Sax.UserRole)UserRoles.GetTypeForCode(userRoleCode);
				SaxUserRole userRole = userRoles.GetUserRoleByRole(role);
				if (userRole == null)
				{
					userRole = AccountMgr.CreateUserRole(user?.Id, role);
					userRoles.Add(userRole);
				}
				userRole.Status = SaStatus.Active;
			}
			// Roles to deactivate.
			foreach (SaxUserRole userRole in userRoles)
			{
				if (!userRoleCodes.Exists(item => item.EqualsCI(UserRoles.GetCodeForType(userRole.UserRole))))
					userRole.Status = SaStatus.Inactive;
			}

			// Create new item if required.
			if (user == null)
			{
				user = AccountMgr.CreateUserAccount();
				if (model.UserEmailAddress != null)
					user.EmailAddress = model.UserEmailAddress;
			}

			// Populate item properties.
			if (model.UserTitle != null)
				user.Title = model.UserTitle;
			if (model.UserFirstName != null)
				user.FirstName = model.UserFirstName;
			if (model.UserLastName != null)
				user.LastName = model.UserLastName;
			if (model.UserStatusCode != null)
				user.Status = model.UserStatus;

			// Store item.
			if (!SysId.IsValid(user.Id))
			{
				if (!AccountMgr.InsertUserAccount(user, DbUpdateInfo))
				{
					SaLogger.Warn(fn + " Failed to insert user: " + AccountMgr.ErrorStateMessage);
					return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.insert.failed"] + "\n\n" + AccountMgr.ErrorStateMessage));
				}
				// Apply User Account Id to dependent items.
				foreach (SaxUserRole userRole in (userRoles))
					userRole.UserAccountId = user.Id;
			}
			else
			{
				if (!AccountMgr.UpdateUserAccount(user, DbUpdateInfo))
				{
					SaLogger.Warn(fn + " Failed to update user [Id:" + SysId.ToString(user.Id) + "]: " + AccountMgr.ErrorStateMessage);
					return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.update.failed"] + "\n\n" + AccountMgr.ErrorStateMessage));
				}
			}

			// Associated data - User Roles.
			foreach (SaxUserRole userRole in (userRoles))
			{
				// Store User Role.
				if (!SysId.IsValid(userRole.Id))
				{
					if (!AccountMgr.InsertUserRole(userRole, DbUpdateInfo))
						SaLogger.Warn(fn + " Failed to insert user role: " + AccountMgr.ErrorStateMessage);
				}
				else
				{
					if (!AccountMgr.UpdateUserRole(userRole, DbUpdateInfo))
						SaLogger.Warn(fn + " Failed to update user role [Id:" + SysId.ToString(userRole.Id) + "]: " + AccountMgr.ErrorStateMessage);
				}
			}

			// Construct response.
			PopulateUserResponseData(responseData.user, user, userRoles.GetUserRolesByStatus(SaStatus.Active));

			// Complete response.
			responseData.Success = true;

			return Json(responseData);
		}

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