GestionIntegralWeb/Backend/GestionIntegral.Api/Services/Suscripciones/PagoService.cs

using GestionIntegral.Api.Data;
using GestionIntegral.Api.Data.Repositories.Suscripciones;
using GestionIntegral.Api.Data.Repositories.Usuarios;
using GestionIntegral.Api.Dtos.Suscripciones;
using GestionIntegral.Api.Models.Suscripciones;
using System.Data;

namespace GestionIntegral.Api.Services.Suscripciones
{
    public class PagoService : IPagoService
    {
        private readonly IPagoRepository _pagoRepository;
        private readonly IFacturaRepository _facturaRepository;
        private readonly IFormaPagoRepository _formaPagoRepository;
        private readonly IUsuarioRepository _usuarioRepository;
        private readonly DbConnectionFactory _connectionFactory;
        private readonly ILogger<PagoService> _logger;

        public PagoService(
            IPagoRepository pagoRepository,
            IFacturaRepository facturaRepository,
            IFormaPagoRepository formaPagoRepository,
            IUsuarioRepository usuarioRepository,
            DbConnectionFactory connectionFactory,
            ILogger<PagoService> logger)
        {
            _pagoRepository = pagoRepository;
            _facturaRepository = facturaRepository;
            _formaPagoRepository = formaPagoRepository;
            _usuarioRepository = usuarioRepository;
            _connectionFactory = connectionFactory;
            _logger = logger;
        }

        private async Task<PagoDto?> MapToDto(Pago pago)
        {
            if (pago == null) return null;
            var formaPago = await _formaPagoRepository.GetByIdAsync(pago.IdFormaPago);
            var usuario = await _usuarioRepository.GetByIdAsync(pago.IdUsuarioRegistro);
            return new PagoDto
            {
                IdPago = pago.IdPago,
                IdFactura = pago.IdFactura,
                FechaPago = pago.FechaPago.ToString("yyyy-MM-dd"),
                IdFormaPago = pago.IdFormaPago,
                NombreFormaPago = formaPago?.Nombre ?? "Desconocida",
                Monto = pago.Monto,
                Estado = pago.Estado,
                Referencia = pago.Referencia,
                Observaciones = pago.Observaciones,
                IdUsuarioRegistro = pago.IdUsuarioRegistro,
                NombreUsuarioRegistro = usuario != null ? $"{usuario.Nombre} {usuario.Apellido}" : "Usuario Desconocido"
            };
        }

        public async Task<IEnumerable<PagoDto>> ObtenerPagosPorFacturaId(int idFactura)
        {
            var pagos = await _pagoRepository.GetByFacturaIdAsync(idFactura);
            var dtosTasks = pagos.Select(p => MapToDto(p));
            var dtos = await Task.WhenAll(dtosTasks);
            return dtos.Where(dto => dto != null)!;
        }

        public async Task<(PagoDto? Pago, string? Error)> RegistrarPagoManual(CreatePagoDto createDto, int idUsuario)
        {
            using var connection = _connectionFactory.CreateConnection();
            await (connection as System.Data.Common.DbConnection)!.OpenAsync();
            using var transaction = connection.BeginTransaction();

            try
            {
                var factura = await _facturaRepository.GetByIdAsync(createDto.IdFactura);
                if (factura == null) return (null, "La factura especificada no existe.");
                if (factura.Estado == "Pagada") return (null, "La factura ya se encuentra pagada.");
                if (factura.Estado == "Anulada") return (null, "No se puede registrar un pago sobre una factura anulada.");

                var formaPago = await _formaPagoRepository.GetByIdAsync(createDto.IdFormaPago);
                if (formaPago == null || !formaPago.Activo) return (null, "La forma de pago no es válida.");

                var nuevoPago = new Pago
                {
                    IdFactura = createDto.IdFactura,
                    FechaPago = createDto.FechaPago,
                    IdFormaPago = createDto.IdFormaPago,
                    Monto = createDto.Monto,
                    Estado = "Aprobado", // Los pagos manuales se asumen aprobados
                    Referencia = createDto.Referencia,
                    Observaciones = createDto.Observaciones,
                    IdUsuarioRegistro = idUsuario
                };

                // 1. Crear el registro del pago
                var pagoCreado = await _pagoRepository.CreateAsync(nuevoPago, transaction);
                if (pagoCreado == null) throw new DataException("No se pudo registrar el pago.");

                // 2. Si el monto pagado es igual o mayor al importe de la factura, actualizar la factura
                // (Permitimos pago mayor por si hay redondeos, etc.)
                if (pagoCreado.Monto >= factura.ImporteFinal)
                {
                    bool actualizado = await _facturaRepository.UpdateEstadoAsync(factura.IdFactura, "Pagada", transaction);
                    if (!actualizado) throw new DataException("No se pudo actualizar el estado de la factura a 'Pagada'.");
                }
                
                transaction.Commit();
                _logger.LogInformation("Pago manual ID {IdPago} registrado para Factura ID {IdFactura} por Usuario ID {IdUsuario}", pagoCreado.IdPago, pagoCreado.IdFactura, idUsuario);
                
                var dto = await MapToDto(pagoCreado);
                return (dto, null);
            }
            catch (Exception ex)
            {
                try { transaction.Rollback(); } catch { }
                _logger.LogError(ex, "Error al registrar pago manual para Factura ID {IdFactura}", createDto.IdFactura);
                return (null, $"Error interno al registrar el pago: {ex.Message}");
            }
        }
    }
}