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

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

namespace GestionIntegral.Api.Services.Suscripciones
{
    public class SuscripcionService : ISuscripcionService
    {
        private readonly ISuscripcionRepository _suscripcionRepository;
        private readonly ISuscriptorRepository _suscriptorRepository;
        private readonly IPublicacionRepository _publicacionRepository;
        private readonly IPromocionRepository _promocionRepository;
        private readonly DbConnectionFactory _connectionFactory;
        private readonly ILogger<SuscripcionService> _logger;

        public SuscripcionService(
            ISuscripcionRepository suscripcionRepository,
            ISuscriptorRepository suscriptorRepository,
            IPublicacionRepository publicacionRepository,
            IPromocionRepository promocionRepository,
            DbConnectionFactory connectionFactory,
            ILogger<SuscripcionService> logger)
        {
            _suscripcionRepository = suscripcionRepository;
            _suscriptorRepository = suscriptorRepository;
            _publicacionRepository = publicacionRepository;
            _promocionRepository = promocionRepository;
            _connectionFactory = connectionFactory;
            _logger = logger;
        }

        private PromocionDto MapPromocionToDto(Promocion promo) => new PromocionDto
        {
            IdPromocion = promo.IdPromocion,
            Descripcion = promo.Descripcion,
            TipoPromocion = promo.TipoPromocion,
            Valor = promo.Valor,
            FechaInicio = promo.FechaInicio.ToString("yyyy-MM-dd"),
            FechaFin = promo.FechaFin?.ToString("yyyy-MM-dd"),
            Activa = promo.Activa
        };

        private async Task<SuscripcionDto?> MapToDto(Suscripcion suscripcion)
        {
            if (suscripcion == null) return null;
            var publicacion = await _publicacionRepository.GetByIdSimpleAsync(suscripcion.IdPublicacion);
            return new SuscripcionDto
            {
                IdSuscripcion = suscripcion.IdSuscripcion,
                IdSuscriptor = suscripcion.IdSuscriptor,
                IdPublicacion = suscripcion.IdPublicacion,
                NombrePublicacion = publicacion?.Nombre ?? "Desconocida",
                FechaInicio = suscripcion.FechaInicio.ToString("yyyy-MM-dd"),
                FechaFin = suscripcion.FechaFin?.ToString("yyyy-MM-dd"),
                Estado = suscripcion.Estado,
                DiasEntrega = suscripcion.DiasEntrega,
                Observaciones = suscripcion.Observaciones
            };
        }

        public async Task<SuscripcionDto?> ObtenerPorId(int idSuscripcion)
        {
            var suscripcion = await _suscripcionRepository.GetByIdAsync(idSuscripcion);
            if (suscripcion == null)
                return null;
            return await MapToDto(suscripcion);
        }

        public async Task<IEnumerable<SuscripcionDto>> ObtenerPorSuscriptorId(int idSuscriptor)
        {
            var suscripciones = await _suscripcionRepository.GetBySuscriptorIdAsync(idSuscriptor);
            var dtosTasks = suscripciones.Select(s => MapToDto(s));
            var dtos = await Task.WhenAll(dtosTasks);
            return dtos.Where(dto => dto != null)!;
        }

        public async Task<(SuscripcionDto? Suscripcion, string? Error)> Crear(CreateSuscripcionDto createDto, int idUsuario)
        {
            if (await _suscriptorRepository.GetByIdAsync(createDto.IdSuscriptor) == null)
                return (null, "El suscriptor no existe.");
            if (await _publicacionRepository.GetByIdSimpleAsync(createDto.IdPublicacion) == null)
                return (null, "La publicación no existe.");
            if (createDto.FechaFin.HasValue && createDto.FechaFin.Value < createDto.FechaInicio)
                return (null, "La fecha de fin no puede ser anterior a la fecha de inicio.");

            var nuevaSuscripcion = new Suscripcion
            {
                IdSuscriptor = createDto.IdSuscriptor,
                IdPublicacion = createDto.IdPublicacion,
                FechaInicio = createDto.FechaInicio,
                FechaFin = createDto.FechaFin,
                Estado = createDto.Estado,
                DiasEntrega = string.Join(",", createDto.DiasEntrega),
                Observaciones = createDto.Observaciones,
                IdUsuarioAlta = idUsuario
            };

            using var connection = _connectionFactory.CreateConnection();
            await (connection as System.Data.Common.DbConnection)!.OpenAsync();
            using var transaction = connection.BeginTransaction();
            try
            {
                var creada = await _suscripcionRepository.CreateAsync(nuevaSuscripcion, transaction);
                if (creada == null) throw new DataException("Error al crear la suscripción.");

                transaction.Commit();
                _logger.LogInformation("Suscripción ID {Id} creada por Usuario ID {UserId}.", creada.IdSuscripcion, idUsuario);
                return (await MapToDto(creada), null);
            }
            catch (Exception ex)
            {
                try { transaction.Rollback(); } catch { }
                _logger.LogError(ex, "Error al crear suscripción para suscriptor ID {IdSuscriptor}", createDto.IdSuscriptor);
                return (null, $"Error interno: {ex.Message}");
            }
        }

        public async Task<(bool Exito, string? Error)> Actualizar(int idSuscripcion, UpdateSuscripcionDto updateDto, int idUsuario)
        {
            var existente = await _suscripcionRepository.GetByIdAsync(idSuscripcion);
            if (existente == null) return (false, "Suscripción no encontrada.");

            if (updateDto.FechaFin.HasValue && updateDto.FechaFin.Value < updateDto.FechaInicio)
                return (false, "La fecha de fin no puede ser anterior a la fecha de inicio.");

            existente.FechaInicio = updateDto.FechaInicio;
            existente.FechaFin = updateDto.FechaFin;
            existente.Estado = updateDto.Estado;
            existente.DiasEntrega = string.Join(",", updateDto.DiasEntrega);
            existente.Observaciones = updateDto.Observaciones;
            existente.IdUsuarioMod = idUsuario;
            existente.FechaMod = DateTime.Now;

            using var connection = _connectionFactory.CreateConnection();
            await (connection as System.Data.Common.DbConnection)!.OpenAsync();
            using var transaction = connection.BeginTransaction();
            try
            {
                var actualizado = await _suscripcionRepository.UpdateAsync(existente, transaction);
                if (!actualizado) throw new DataException("Error al actualizar la suscripción.");

                transaction.Commit();
                _logger.LogInformation("Suscripción ID {Id} actualizada por Usuario ID {UserId}.", idSuscripcion, idUsuario);
                return (true, null);
            }
            catch (Exception ex)
            {
                try { transaction.Rollback(); } catch { }
                _logger.LogError(ex, "Error al actualizar suscripción ID: {IdSuscripcion}", idSuscripcion);
                return (false, $"Error interno: {ex.Message}");
            }
        }

        public async Task<IEnumerable<PromocionDto>> ObtenerPromocionesAsignadas(int idSuscripcion)
        {
            var promociones = await _suscripcionRepository.GetPromocionesBySuscripcionIdAsync(idSuscripcion);
            return promociones.Select(MapPromocionToDto);
        }

        public async Task<IEnumerable<PromocionDto>> ObtenerPromocionesDisponibles(int idSuscripcion)
        {
            var todasLasPromosActivas = await _promocionRepository.GetAllAsync(true);
            var promosAsignadas = await _suscripcionRepository.GetPromocionesBySuscripcionIdAsync(idSuscripcion);
            var idsAsignadas = promosAsignadas.Select(p => p.IdPromocion).ToHashSet();

            return todasLasPromosActivas
                .Where(p => !idsAsignadas.Contains(p.IdPromocion))
                .Select(MapPromocionToDto);
        }

        public async Task<(bool Exito, string? Error)> AsignarPromocion(int idSuscripcion, int idPromocion, int idUsuario)
        {
            using var connection = _connectionFactory.CreateConnection();
            await (connection as System.Data.Common.DbConnection)!.OpenAsync();
            using var transaction = connection.BeginTransaction();
            try
            {
                // Validaciones
                if (await _suscripcionRepository.GetByIdAsync(idSuscripcion) == null) return (false, "Suscripción no encontrada.");
                if (await _promocionRepository.GetByIdAsync(idPromocion) == null) return (false, "Promoción no encontrada.");

                await _suscripcionRepository.AsignarPromocionAsync(idSuscripcion, idPromocion, idUsuario, transaction);
                transaction.Commit();
                return (true, null);
            }
            catch (Exception ex)
            {
                // Capturar error de Primary Key duplicada
                if (ex.Message.Contains("PRIMARY KEY constraint"))
                {
                    return (false, "Esta promoción ya está asignada a la suscripción.");
                }
                try { transaction.Rollback(); } catch { }
                _logger.LogError(ex, "Error al asignar promoción {IdPromocion} a suscripción {IdSuscripcion}", idPromocion, idSuscripcion);
                return (false, "Error interno al asignar la promoción.");
            }
        }

        public async Task<(bool Exito, string? Error)> QuitarPromocion(int idSuscripcion, int idPromocion)
        {
            using var connection = _connectionFactory.CreateConnection();
            await (connection as System.Data.Common.DbConnection)!.OpenAsync();
            using var transaction = connection.BeginTransaction();
            try
            {
                var exito = await _suscripcionRepository.QuitarPromocionAsync(idSuscripcion, idPromocion, transaction);
                if (!exito) return (false, "La promoción no estaba asignada a esta suscripción.");

                transaction.Commit();
                return (true, null);
            }
            catch (Exception ex)
            {
                try { transaction.Rollback(); } catch { }
                _logger.LogError(ex, "Error al quitar promoción {IdPromocion} de suscripción {IdSuscripcion}", idPromocion, idSuscripcion);
                return (false, "Error interno al quitar la promoción.");
            }
        }
    }
}