// ***********************************************************************
// <copyright file="FurnitureVariantController.cs">
//     Core.Inventory
// </copyright>
// ***********************************************************************
using Asp.Versioning;
using Core.Adapters.Lib;
using Core.Blueprint.Logging;
using Core.Blueprint.Mongo;
using Core.Inventory.Domain.Contexts.Inventory.Request;
using Core.Inventory.Provider.Contracts;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Core.Inventory.DAL.API.Controllers
{
    /// <summary>
    /// Handles all requests for furniture variant CRUD operations.
    /// </summary>
    [ApiVersion(MimeTypes.ApplicationVersion)]
    [Route("api/v{api-version:apiVersion}/[controller]")]
    [Produces(MimeTypes.ApplicationJson)]
    [Consumes(MimeTypes.ApplicationJson)]
    [ApiController]
    [AllowAnonymous]
    public class FurnitureVariantController(IFurnitureVariantProvider service) : ControllerBase
    {

        /// <summary>
        /// Gets all furniture variant records.
        /// </summary>
        [HttpGet]
        [ProducesResponseType(typeof(IEnumerable<FurnitureVariant>), StatusCodes.Status200OK)]
        public async Task<IActionResult> GetAllAsync(CancellationToken cancellationToken)
        {
            var result = await service.GetAllAsync(cancellationToken);
            return Ok(result);
        }

        /// <summary>
        /// Gets all furniture variant records by ModelId.
        /// </summary>
        [HttpGet]
        [Route("ByModel/{modelId}")]
        [ProducesResponseType(typeof(IEnumerable<FurnitureVariant>), StatusCodes.Status200OK)]
        public async Task<IActionResult> GetAllVariantsByModelIdAsync(string modelId, CancellationToken cancellationToken)
        {
            var result = await service.GetAllByModelIdAsync(modelId, cancellationToken).ConfigureAwait(false);

            if (result is null || !result.Any())
            {
                return NotFound($"No variants found for base model with ID '{modelId}'.");
            }

            return Ok(result);
        }

        /// <summary>
        /// Gets a furniture variant record by ID.
        /// </summary>
        [HttpGet]
        [Route("{mongoId}")]
        [ProducesResponseType(typeof(FurnitureVariant), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<IActionResult> GetByIdAsync([FromRoute] string mongoId, CancellationToken cancellationToken)
        {
            var result = await service.GetByIdAsync(mongoId, cancellationToken);
            return result is not null ? Ok(result) : NotFound("Entity not found");
        }

        /// <summary>
        /// Gets multiple furniture variants by their identifiers.
        /// </summary>
        /// <param name="request">List of variant IDs.</param>
        /// <param name="cancellationToken">Cancellation token.</param>
        /// <returns>A list of <see cref="FurnitureVariant"/>.</returns>
        [HttpPost("ByIds")]
        [ProducesResponseType(typeof(IEnumerable<FurnitureVariant>), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        public async Task<IActionResult> GetVariantsByIdsAsync([FromBody] string[] ids, CancellationToken cancellationToken)
        {
            if (ids is null || ids.Length == 0)
                return BadRequest("At least one variant ID must be provided.");

            var result = await service.GetAllByIdsAsync(ids, cancellationToken);

            if (result is null || !result.Any())
                return NoContent();

            return Ok(result);
        }

        /// <summary>
        /// Creates a new furniture variant.
        /// </summary>
        [HttpPost]
        [ProducesResponseType(typeof(FurnitureVariant), StatusCodes.Status201Created)]
        public async Task<IActionResult> CreateAsync([FromBody] FurnitureVariantRequest request, CancellationToken cancellationToken)
        {
            var result = await service.CreateAsync(request, cancellationToken);
            return Created("CreatedWithIdAsync", result);
        }

        /// <summary>
        /// Updates a furniture variant record by ID.
        /// </summary>
        [HttpPut]
        [Route("{id}")]
        [ProducesResponseType(typeof(FurnitureVariant), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        public async Task<IActionResult> UpdateAsync([FromRoute] string id, [FromBody] FurnitureVariant entity, CancellationToken cancellationToken)
        {
            if (id != entity.Id?.ToString())
                return BadRequest("Furniture Variant ID mismatch");

            var result = await service.UpdateAsync(id, entity, cancellationToken);
            return Ok(result);
        }

        /// <summary>
        /// Changes the status of a furniture variant record.
        /// </summary>
        [HttpPatch]
        [Route("{mongoId}/{newStatus}/ChangeStatus")]
        [ProducesResponseType(typeof(FurnitureVariant), StatusCodes.Status200OK)]
        public async Task<IActionResult> ChangeStatusAsync([FromRoute] string mongoId, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
        {
            var result = await service.ChangeStatusAsync(mongoId, newStatus, cancellationToken);
            return Ok(result);
        }
    }
}