// ***********************************************************************
// <copyright file="UserController.cs">
//     AgileWebs
// </copyright>
// ***********************************************************************

using Asp.Versioning;
using Core.Thalos.BuildingBlocks;
using Core.Thalos.Provider.Contracts;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using StatusEnum = Core.Blueprint.Mongo.StatusEnum;
using UserRequest = Core.Thalos.Domain.Contexts.Onboarding.Request.UserRequest;

namespace LSA.Core.Thalos.API.Controllers
{
    /// <summary>
    /// Handles all requests for user authentication.
    /// </summary>
    [ApiVersion("1.0")]
    [Route("api/v{api-version:apiVersion}/[controller]")]
    [Produces(MimeTypes.ApplicationJson)]
    [Consumes(MimeTypes.ApplicationJson)]
    [ApiController]
    public class UserController(IUserProvider service) : ControllerBase
    {
        /// <summary>
        /// Gets all users.
        /// </summary>
        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
        /// <returns>The <see cref="IEnumerable{UserAdapter}"/> found entity.</returns>
        [HttpGet]
        [ProducesResponseType(typeof(IEnumerable<UserAdapter>), StatusCodes.Status200OK)]
        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
        [Permission("UserManagement.Read")]
        public async Task<IActionResult> GetAllUsers(CancellationToken cancellationToken)
        {
            var result = await service.GetAllUsers(cancellationToken).ConfigureAwait(false);
            return Ok(result);
        }

        /// <summary>
        /// Gets the user by mongo identifier.
        /// </summary>
        /// <param name="_id">The user Mongo identifier.</param>
        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
        /// <returns>The <see cref="UserAdapter"/> found entity.</returns>
        [HttpGet]
        [Route(Routes.Id)]
        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
        [Permission("UserManagement.Read")]
        public async Task<IActionResult> GetUserById([FromRoute] string _id, CancellationToken cancellationToken)
        {
            var result = await service.GetUserById(_id, cancellationToken).ConfigureAwait(false);
            return result == null ? NotFound("User not found") : Ok(result);
        }

        /// <summary>
        /// Gets the user by email.
        /// </summary>
        /// <param name="email">The user's email.</param>
        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
        /// <returns>The <see cref="UserAdapter"/> found entity.</returns>
        [HttpGet]
        [Route(Routes.Email)]
        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
        [Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
        public async Task<IActionResult> GetUserByEmail([FromRoute] string email, CancellationToken cancellationToken)
        {
            var result = await service.GetUserByEmail(email, cancellationToken).ConfigureAwait(false);
            return result == null ? NotFound("User not found") : Ok(result);
        }

        /// <summary>
        /// Validates if a user exists on the database.
        /// </summary>
        /// <param name="email">The user's email.</param>
        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
        /// <returns>The <see cref="UserExistenceAdapter"/> indicating existence.</returns>
        [HttpGet]
        [Route("{email}/ValidateExistence")]
        [ProducesResponseType(typeof(UserExistenceAdapter), StatusCodes.Status200OK)]
        [AllowAnonymous]
        public async Task<IActionResult> ValidateUserExistence([FromRoute] string email, CancellationToken cancellationToken)
        {
            var result = await service.ValidateUserExistence(email, cancellationToken).ConfigureAwait(false);
            return result == null ? NotFound("User not found") : Ok(result);
        }

        /// <summary>
        /// Creates a new user.
        /// </summary>
        /// <param name="newUser">The user to be added.</param>
        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
        /// <returns>The <see cref="UserAdapter"/> created entity.</returns>
        [HttpPost(Routes.Register)]
        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status201Created)]
        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
        [Permission("UserManagement.Write")]
        public async Task<IActionResult> CreateUserAsync([FromBody] UserRequest newUser, CancellationToken cancellationToken)
        {
            var result = await service.CreateUser(newUser, cancellationToken).ConfigureAwait(false);
            return Created("CreatedWithIdAsync", result);
        }

        /// <summary>
        /// Updates a full user by mongo identifier.
        /// </summary>
        /// <param name="_id">The user Mongo identifier.</param>
        /// <param name="entity">The user to update.</param>
        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
        /// <returns>The <see cref="UserAdapter"/> updated entity.</returns>
        [HttpPut]
        [Route(Routes.Id)]
        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
        [Permission("UserManagement.Write")]
        public async Task<IActionResult> UpdateUserAsync([FromRoute] string _id, [FromBody] UserAdapter entity, CancellationToken cancellationToken)
        {
            if (_id != entity._Id)
                return BadRequest("User ID mismatch");

            var result = await service.UpdateUser(entity, cancellationToken).ConfigureAwait(false);
            return Ok(result);
        }

        /// <summary>
        /// Logs in the user.
        /// </summary>
        /// <param name="email">The user's email.</param>
        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
        /// <returns>The <see cref="UserAdapter"/> found entity.</returns>
        [HttpPatch(Routes.LogIn)]
        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
        [Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
        public async Task<IActionResult> LoginUserAsync([FromRoute] string email, CancellationToken cancellationToken)
        {
            var result = await service.LogInUser(email, cancellationToken).ConfigureAwait(false);
            return result == null ? NotFound($"The user with email: '{email}' was not found") : Ok(result);
        }

        /// <summary>
        /// Logs out the user.
        /// </summary>
        /// <param name="email">The user's email.</param>
        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
        /// <returns>The <see cref="UserAdapter"/> updated entity.</returns>
        [HttpPatch(Routes.LogOut)]
        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
        [Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
        public async Task<IActionResult> LogOutUserSessionAsync([FromRoute] string email, CancellationToken cancellationToken)
        {
            var result = await service.LogOutUserSession(email, cancellationToken).ConfigureAwait(false);
            return Ok(result);
        }

        /// <summary>
        /// Changes the status of the user.
        /// </summary>
        /// <param name="_id">The user Mongo identifier.</param>
        /// <param name="newStatus">The new status of the user.</param>
        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
        /// <returns>The <see cref="UserAdapter"/> updated entity.</returns>
        [HttpPatch]
        [Route(Routes.ChangeStatus)]
        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
        [Permission("UserManagement.Write")]
        public async Task<IActionResult> ChangeUserStatus([FromRoute] string _id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
        {
            var result = await service.ChangeUserStatus(_id, newStatus, cancellationToken).ConfigureAwait(false);

            if (result == null)
                return NotFound("User not found");

            return Ok(result);
        }

        /// <summary>
        /// Gets a token for the user, including roles, permissions, and modules.
        /// </summary>
        /// <param name="email">The user's email.</param>
        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
        /// <returns>The <see cref="TokenAdapter"/> with user details.</returns>
        [HttpGet]
        [Route("{email}/GetTokenAdapter")]
        [ProducesResponseType(typeof(TokenAdapter), StatusCodes.Status200OK)]
        [Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
        public async Task<IActionResult> GetTokenAdapter([FromRoute] string email, CancellationToken cancellationToken)
        {
            var tokenAdapter = await service.GetToken(email, cancellationToken).ConfigureAwait(false);
            return tokenAdapter == null ? NotFound($"User with email: {email} not found") : Ok(tokenAdapter);
        }

        /// <summary>
        /// Deletes a user by mongo identifier.
        /// </summary>
        /// <param name="_id">The user Mongo identifier.</param>
        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
        /// <returns>The deleted <see cref="UserAdapter"/> entity.</returns>
        /// <response code="200">The user deleted.</response>
        /// <response code="404">The user not found.</response>
        [HttpDelete]
        [Route(Routes.Id)]
        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
        [Permission("UserManagement.Write")]
        public async Task<IActionResult> DeleteUserAsync([FromRoute] string _id, CancellationToken cancellationToken)
        {
            var result = await service.DeleteUser(_id, cancellationToken).ConfigureAwait(false);
            return result == null ? NotFound("User not found") : Ok(result);
        }
    }
}