GestionIntegralWeb/Backend/GestionIntegral.Api/Controllers/Contables/TiposPagoController.cs

using GestionIntegral.Api.Dtos.Contables; // Para los DTOs
using GestionIntegral.Api.Services.Contables;     // Para ITipoPagoService
using Microsoft.AspNetCore.Authorization; // Para [Authorize]
using Microsoft.AspNetCore.Mvc;
using System.Security.Claims; // Para obtener el IdUsuario del token

namespace GestionIntegral.Api.Controllers.Contables
{
    [Route("api/[controller]")] // Ruta base: /api/tipospago
    [ApiController]
    [Authorize] // <-- Proteger todos los endpoints de este controlador por defecto
    public class TiposPagoController : ControllerBase
    {
        private readonly ITipoPagoService _tipoPagoService;
        private readonly ILogger<TiposPagoController> _logger;

        public TiposPagoController(ITipoPagoService tipoPagoService, ILogger<TiposPagoController> logger)
        {
            _tipoPagoService = tipoPagoService;
            _logger = logger;
        }

        // GET: api/tipospago
        [HttpGet]
        [ProducesResponseType(typeof(IEnumerable<TipoPagoDto>), StatusCodes.Status200OK)]
        // Podrías añadir un permiso específico si lo tienes, ej: [Authorize(Policy = "VerTiposPago")]
        // Por ahora, [Authorize] a nivel de controlador es suficiente si todos los métodos lo requieren.
        public async Task<IActionResult> GetAllTiposPago([FromQuery] string? nombre) // Filtro opcional por nombre
        {
            try
            {
                var tiposPago = await _tipoPagoService.ObtenerTodosAsync(nombre);
                return Ok(tiposPago);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al obtener todos los Tipos de Pago.");
                return StatusCode(StatusCodes.Status500InternalServerError, "Error interno al procesar la solicitud.");
            }
        }

        // GET: api/tipospago/{id}
        [HttpGet("{id:int}", Name = "GetTipoPagoById")] // Darle un nombre a la ruta para CreatedAtRoute
        [ProducesResponseType(typeof(TipoPagoDto), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<IActionResult> GetTipoPagoById(int id)
        {
            try
            {
                var tipoPago = await _tipoPagoService.ObtenerPorIdAsync(id);
                if (tipoPago == null)
                {
                    return NotFound(new { message = $"Tipo de pago con ID {id} no encontrado." });
                }
                return Ok(tipoPago);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al obtener Tipo de Pago por ID: {Id}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, "Error interno al procesar la solicitud.");
            }
        }

        // POST: api/tipospago
        [HttpPost]
        [ProducesResponseType(typeof(TipoPagoDto), StatusCodes.Status201Created)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        // Aquí podrías requerir un permiso más específico: [Authorize(Policy = "CrearTiposPago")]
        public async Task<IActionResult> CreateTipoPago([FromBody] CreateTipoPagoDto createDto)
        {
            if (!ModelState.IsValid) // Validaciones del DTO (Required, StringLength)
            {
                return BadRequest(ModelState);
            }

            var idUsuario = GetCurrentUserId();
            if (idUsuario == null) return Unauthorized("No se pudo obtener el ID del usuario del token.");


            try
            {
                var (tipoPagoCreado, error) = await _tipoPagoService.CrearAsync(createDto, idUsuario.Value);

                if (error != null)
                {
                    // Error de lógica de negocio (ej: nombre duplicado)
                    return BadRequest(new { message = error });
                }
                if (tipoPagoCreado == null) // Fallo inesperado en el repositorio/servicio
                {
                    return StatusCode(StatusCodes.Status500InternalServerError, "Error al crear el tipo de pago.");
                }

                // Devuelve 201 Created con la ubicación del nuevo recurso y el recurso mismo
                return CreatedAtRoute("GetTipoPagoById", new { id = tipoPagoCreado.IdTipoPago }, tipoPagoCreado);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al crear Tipo de Pago. Nombre: {Nombre}", createDto.Nombre);
                return StatusCode(StatusCodes.Status500InternalServerError, "Error interno al procesar la solicitud.");
            }
        }

        // PUT: api/tipospago/{id}
        [HttpPut("{id:int}")]
        [ProducesResponseType(StatusCodes.Status204NoContent)] // Éxito sin contenido
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<IActionResult> UpdateTipoPago(int id, [FromBody] UpdateTipoPagoDto updateDto)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var idUsuario = GetCurrentUserId();
            if (idUsuario == null) return Unauthorized("No se pudo obtener el ID del usuario del token.");

            try
            {
                var (exito, error) = await _tipoPagoService.ActualizarAsync(id, updateDto, idUsuario.Value);

                if (!exito)
                {
                    if (error == "Tipo de pago no encontrado.") return NotFound(new { message = error });
                    return BadRequest(new { message = error }); // Otro error de lógica de negocio
                }
                return NoContent(); // Éxito
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al actualizar Tipo de Pago ID: {Id}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, "Error interno al procesar la solicitud.");
            }
        }

        // DELETE: api/tipospago/{id}
        [HttpDelete("{id:int}")]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)] // Si está en uso
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<IActionResult> DeleteTipoPago(int id)
        {
            var idUsuario = GetCurrentUserId();
            if (idUsuario == null) return Unauthorized("No se pudo obtener el ID del usuario del token.");

            try
            {
                var (exito, error) = await _tipoPagoService.EliminarAsync(id, idUsuario.Value);

                if (!exito)
                {
                    if (error == "Tipo de pago no encontrado.") return NotFound(new { message = error });
                    return BadRequest(new { message = error }); // Ej: "En uso"
                }
                return NoContent(); // Éxito
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al eliminar Tipo de Pago ID: {Id}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, "Error interno al procesar la solicitud.");
            }
        }

        // Helper para obtener el ID del usuario del token
        private int? GetCurrentUserId()
        {
            var userIdClaim = User.FindFirstValue(ClaimTypes.NameIdentifier) ?? User.FindFirstValue("sub");
            if (int.TryParse(userIdClaim, out int userId))
            {
                return userId;
            }
            _logger.LogWarning("No se pudo obtener el UserId del token JWT.");
            return null;
        }
    }
}