GestionIntegralWeb/Backend/GestionIntegral.Api/Data/Repositories/Distribucion/PublicacionRepository.cs

// src/Data/Repositories/PublicacionRepository.cs
using Dapper;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System; // Añadido para Exception
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
    public class PublicacionRepository : IPublicacionRepository
    {
        private readonly DbConnectionFactory _connectionFactory;
        private readonly ILogger<PublicacionRepository> _logger;

        public PublicacionRepository(DbConnectionFactory connectionFactory, ILogger<PublicacionRepository> logger)
        {
            _connectionFactory = connectionFactory;
            _logger = logger;
        }

        public async Task<IEnumerable<(Publicacion Publicacion, string NombreEmpresa)>> GetAllAsync(string? nombreFilter, int? idEmpresaFilter, bool? soloHabilitadas)
        {
            var sqlBuilder = new StringBuilder(@"
                SELECT
                    p.Id_Publicacion AS IdPublicacion, p.Nombre, p.Observacion, p.Id_Empresa AS IdEmpresa,
                    p.CtrlDevoluciones, p.Habilitada,
                    e.Nombre AS NombreEmpresa
                FROM dbo.dist_dtPublicaciones p
                INNER JOIN dbo.dist_dtEmpresas e ON p.Id_Empresa = e.Id_Empresa
                WHERE 1=1");
            var parameters = new DynamicParameters();

            if (soloHabilitadas.HasValue)
            {
                sqlBuilder.Append(soloHabilitadas.Value ? " AND (p.Habilitada = 1 OR p.Habilitada IS NULL)" : " AND p.Habilitada = 0");
            }
            if (!string.IsNullOrWhiteSpace(nombreFilter))
            {
                sqlBuilder.Append(" AND p.Nombre LIKE @NombreParam");
                parameters.Add("NombreParam", $"%{nombreFilter}%");
            }
            if (idEmpresaFilter.HasValue && idEmpresaFilter > 0)
            {
                sqlBuilder.Append(" AND p.Id_Empresa = @IdEmpresaParam");
                parameters.Add("IdEmpresaParam", idEmpresaFilter.Value);
            }
            sqlBuilder.Append(" ORDER BY p.Nombre;");

            try
            {
                using var connection = _connectionFactory.CreateConnection();
                var result = await connection.QueryAsync<Publicacion, string, (Publicacion, string)>(
                    sqlBuilder.ToString(),
                    (publicacion, nombreEmpresa) => (publicacion, nombreEmpresa),
                    parameters,
                    splitOn: "NombreEmpresa"
                );
                return result;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al obtener todas las Publicaciones. Filtros: Nombre='{NombreFilter}', IdEmpresa='{IdEmpresaFilter}', SoloHabilitadas='{SoloHabilitadas}'", nombreFilter, idEmpresaFilter, soloHabilitadas);
                return Enumerable.Empty<(Publicacion, string)>();
            }
        }

        public async Task<(Publicacion? Publicacion, string? NombreEmpresa)> GetByIdAsync(int id)
        {
            const string sql = @"
                SELECT
                    p.Id_Publicacion AS IdPublicacion, p.Nombre, p.Observacion, p.Id_Empresa AS IdEmpresa,
                    p.CtrlDevoluciones, p.Habilitada,
                    e.Nombre AS NombreEmpresa
                FROM dbo.dist_dtPublicaciones p
                INNER JOIN dbo.dist_dtEmpresas e ON p.Id_Empresa = e.Id_Empresa
                WHERE p.Id_Publicacion = @IdParam";
            try
            {
                using var connection = _connectionFactory.CreateConnection();
                var result = await connection.QueryAsync<Publicacion, string, (Publicacion?, string?)>(
                    sql,
                    (publicacion, nombreEmpresa) => (publicacion, nombreEmpresa),
                    new { IdParam = id },
                    splitOn: "NombreEmpresa"
                );
                return result.SingleOrDefault();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al obtener Publicación por ID: {IdPublicacion}", id);
                return (null, null);
            }
        }

        public async Task<Publicacion?> GetByIdSimpleAsync(int id)
        {
            const string sql = @"
                SELECT
                    Id_Publicacion AS IdPublicacion, Nombre, Observacion, Id_Empresa AS IdEmpresa,
                    CtrlDevoluciones, Habilitada
                FROM dbo.dist_dtPublicaciones
                WHERE Id_Publicacion = @IdParam";
            try
            {
                using var connection = _connectionFactory.CreateConnection();
                return await connection.QuerySingleOrDefaultAsync<Publicacion>(sql, new { IdParam = id });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al obtener Publicación (simple) por ID: {IdPublicacion}", id);
                return null;
            }
        }

        public async Task<bool> ExistsByNameAndEmpresaAsync(string nombre, int idEmpresa, int? excludeIdPublicacion = null)
        {
            var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_dtPublicaciones WHERE Nombre = @NombreParam AND Id_Empresa = @IdEmpresaParam");
            var parameters = new DynamicParameters();
            parameters.Add("NombreParam", nombre);
            parameters.Add("IdEmpresaParam", idEmpresa);
            if (excludeIdPublicacion.HasValue)
            {
                sqlBuilder.Append(" AND Id_Publicacion != @ExcludeIdParam");
                parameters.Add("ExcludeIdParam", excludeIdPublicacion.Value);
            }
            try
            {
                using var connection = _connectionFactory.CreateConnection();
                return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error en ExistsByNameAndEmpresaAsync. Nombre: {Nombre}, IdEmpresa: {IdEmpresa}", nombre, idEmpresa);
                return true; // Asumir que existe en caso de error para prevenir duplicados
            }
        }

        public async Task<bool> IsInUseAsync(int idPublicacion)
        {
            using var connection = _connectionFactory.CreateConnection();
            string[] checkQueries = {
                "SELECT TOP 1 1 FROM dbo.dist_EntradasSalidas WHERE Id_Publicacion = @IdParam",
                "SELECT TOP 1 1 FROM dbo.dist_EntradasSalidasCanillas WHERE Id_Publicacion = @IdParam",
                "SELECT TOP 1 1 FROM dbo.dist_SalidasOtrosDestinos WHERE Id_Publicacion = @IdParam",
                "SELECT TOP 1 1 FROM dbo.bob_RegPublicaciones WHERE Id_Publicacion = @IdParam",
                "SELECT TOP 1 1 FROM dbo.bob_RegTiradas WHERE Id_Publicacion = @IdParam",
                "SELECT TOP 1 1 FROM dbo.bob_StockBobinas WHERE Id_Publicacion = @IdParam AND Id_EstadoBobina != 1" // Ejemplo: si una bobina EN USO o DAÑADA está asociada
            };
            try
            {
                foreach (var query in checkQueries)
                {
                    if (await connection.ExecuteScalarAsync<int?>(query, new { IdParam = idPublicacion }) == 1)
                    {
                        _logger.LogInformation("Publicacion ID {IdPublicacion} está en uso (Tabla: {Tabla})", idPublicacion, query.Split("FROM")[1].Split("WHERE")[0].Trim());
                        return true;
                    }
                }
                return false;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error en IsInUseAsync para Publicacion ID: {IdPublicacion}", idPublicacion);
                return true; // Asumir en uso si hay error
            }
        }

        public async Task<Publicacion?> CreateAsync(Publicacion nuevaPublicacion, int idUsuario, IDbTransaction transaction)
        {
            nuevaPublicacion.Habilitada ??= true;

            const string sqlInsert = @"
                INSERT INTO dbo.dist_dtPublicaciones (Nombre, Observacion, Id_Empresa, CtrlDevoluciones, Habilitada)
                OUTPUT INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Nombre, INSERTED.Observacion, INSERTED.Id_Empresa AS IdEmpresa, INSERTED.CtrlDevoluciones, INSERTED.Habilitada
                VALUES (@Nombre, @Observacion, @IdEmpresa, @CtrlDevoluciones, @Habilitada);";

            var connection = transaction.Connection!;
            var inserted = await connection.QuerySingleAsync<Publicacion>(sqlInsert, nuevaPublicacion, transaction);
            if (inserted == null || inserted.IdPublicacion == 0) throw new DataException("Error al crear la publicación o al obtener el ID generado.");

            const string sqlInsertHistorico = @"
                INSERT INTO dbo.dist_dtPublicaciones_H
                    (Id_Publicacion, Nombre, Observacion, Id_Empresa, Habilitada, Id_Usuario, FechaMod, TipoMod)
                VALUES (@IdPublicacionParam, @NombreParam, @ObservacionParam, @IdEmpresaParam, @HabilitadaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";

            await connection.ExecuteAsync(sqlInsertHistorico, new
            {
                IdPublicacionParam = inserted.IdPublicacion,
                NombreParam = inserted.Nombre,
                ObservacionParam = inserted.Observacion,
                IdEmpresaParam = inserted.IdEmpresa,
                HabilitadaParam = inserted.Habilitada ?? true,
                IdUsuarioParam = idUsuario, // Renombrado para claridad con el parámetro de la función
                FechaModParam = DateTime.Now,
                TipoModParam = "Creada"
            }, transaction);
            return inserted;
        }

        public async Task<bool> UpdateAsync(Publicacion publicacionAActualizar, int idUsuario, IDbTransaction transaction)
        {
            var connection = transaction.Connection!;
            var actual = await connection.QuerySingleOrDefaultAsync<Publicacion>(
                @"SELECT Id_Publicacion AS IdPublicacion, Nombre, Observacion, Id_Empresa AS IdEmpresa, CtrlDevoluciones, Habilitada 
                  FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @IdPublicacionParam", // Usar alias
                new { IdPublicacionParam = publicacionAActualizar.IdPublicacion }, transaction);
            if (actual == null) throw new KeyNotFoundException("Publicación no encontrada.");

            publicacionAActualizar.Habilitada ??= true;

            const string sqlUpdate = @"
                UPDATE dbo.dist_dtPublicaciones SET
                    Nombre = @Nombre, Observacion = @Observacion, Id_Empresa = @IdEmpresa,
                    CtrlDevoluciones = @CtrlDevoluciones, Habilitada = @Habilitada
                WHERE Id_Publicacion = @IdPublicacion;"; // Usar nombres de propiedad del objeto
            const string sqlInsertHistorico = @"
                INSERT INTO dbo.dist_dtPublicaciones_H
                    (Id_Publicacion, Nombre, Observacion, Id_Empresa, Habilitada, Id_Usuario, FechaMod, TipoMod)
                VALUES (@IdPublicacionParam, @NombreParam, @ObservacionParam, @IdEmpresaParam, @HabilitadaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";

            await connection.ExecuteAsync(sqlInsertHistorico, new
            {
                IdPublicacionParam = actual.IdPublicacion,
                NombreParam = actual.Nombre, // Valor ANTES de la actualización
                ObservacionParam = actual.Observacion,
                IdEmpresaParam = actual.IdEmpresa,
                HabilitadaParam = actual.Habilitada ?? true,
                IdUsuarioParam = idUsuario,
                FechaModParam = DateTime.Now,
                TipoModParam = "Actualizada"
            }, transaction);

            var rowsAffected = await connection.ExecuteAsync(sqlUpdate, publicacionAActualizar, transaction);
            return rowsAffected == 1;
        }

        public async Task<bool> DeleteAsync(int id, int idUsuario, IDbTransaction transaction)
        {
            var connection = transaction.Connection!;
            var actual = await connection.QuerySingleOrDefaultAsync<Publicacion>(
                 @"SELECT Id_Publicacion AS IdPublicacion, Nombre, Observacion, Id_Empresa AS IdEmpresa, CtrlDevoluciones, Habilitada 
                   FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @IdParam", // Usar alias
                 new { IdParam = id }, transaction);
            if (actual == null) throw new KeyNotFoundException("Publicación no encontrada.");

            const string sqlDelete = "DELETE FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @IdParam";
            const string sqlInsertHistorico = @"
                INSERT INTO dbo.dist_dtPublicaciones_H
                    (Id_Publicacion, Nombre, Observacion, Id_Empresa, Habilitada, Id_Usuario, FechaMod, TipoMod)
                VALUES (@IdPublicacionParam, @NombreParam, @ObservacionParam, @IdEmpresaParam, @HabilitadaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";

            await connection.ExecuteAsync(sqlInsertHistorico, new
            {
                IdPublicacionParam = actual.IdPublicacion,
                NombreParam = actual.Nombre,
                ObservacionParam = actual.Observacion,
                IdEmpresaParam = actual.IdEmpresa,
                HabilitadaParam = actual.Habilitada ?? true,
                IdUsuarioParam = idUsuario,
                FechaModParam = DateTime.Now,
                TipoModParam = "Eliminada"
            }, transaction);

            var rowsAffected = await connection.ExecuteAsync(sqlDelete, new { IdParam = id }, transaction);
            return rowsAffected == 1;
        }

        public async Task<IEnumerable<PublicacionDiaSemana>> GetConfiguracionDiasAsync(int idPublicacion)
        {
            const string sql = @"
        SELECT IdPublicacionDia, Id_Publicacion AS IdPublicacion, DiaSemana, Activo
        FROM dbo.dist_PublicacionDiaSemana
        WHERE Id_Publicacion = @IdPublicacion AND Activo = 1;"; // Solo los activos
            try
            {
                using var connection = _connectionFactory.CreateConnection();
                return await connection.QueryAsync<PublicacionDiaSemana>(sql, new { IdPublicacion = idPublicacion });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al obtener configuración de días para Publicacion ID: {IdPublicacion}", idPublicacion);
                return Enumerable.Empty<PublicacionDiaSemana>();
            }
        }

        public async Task<IEnumerable<int>> GetPublicacionesIdsPorDiaSemanaAsync(byte diaSemana)
        {
            const string sql = @"
        SELECT pds.Id_Publicacion
        FROM dbo.dist_PublicacionDiaSemana pds
        INNER JOIN dbo.dist_dtPublicaciones p ON pds.Id_Publicacion = p.Id_Publicacion
        WHERE pds.DiaSemana = @DiaSemana AND pds.Activo = 1 AND (p.Habilitada = 1 OR p.Habilitada IS NULL);"; // Solo publicaciones habilitadas
            try
            {
                using var connection = _connectionFactory.CreateConnection();
                return await connection.QueryAsync<int>(sql, new { DiaSemana = diaSemana });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al obtener IDs de publicaciones por día de semana: {DiaSemana}", diaSemana);
                return Enumerable.Empty<int>();
            }
        }

        public async Task UpdateConfiguracionDiasAsync(int idPublicacion, IEnumerable<byte> diasActivos, IDbTransaction transaction)
        {
            var connection = transaction.Connection!;

            // 1. Eliminar configuraciones existentes para esta publicación (más simple que hacer upserts complejos)
            const string sqlDelete = "DELETE FROM dbo.dist_PublicacionDiaSemana WHERE Id_Publicacion = @IdPublicacion;";
            await connection.ExecuteAsync(sqlDelete, new { IdPublicacion = idPublicacion }, transaction);

            // 2. Insertar las nuevas configuraciones activas
            if (diasActivos != null && diasActivos.Any())
            {
                const string sqlInsert = @"
            INSERT INTO dbo.dist_PublicacionDiaSemana (Id_Publicacion, DiaSemana, Activo)
            VALUES (@IdPublicacion, @DiaSemana, 1);"; // Siempre activo al insertar

                var insertTasks = diasActivos.Select(dia =>
                    connection.ExecuteAsync(sqlInsert, new { IdPublicacion = idPublicacion, DiaSemana = dia }, transaction)
                );
                await Task.WhenAll(insertTasks);
            }
        }

        public async Task<IEnumerable<(PublicacionHistorico Historial, string NombreUsuarioModifico)>> GetHistorialAsync(
        DateTime? fechaDesde, DateTime? fechaHasta,
        int? idUsuarioModifico, string? tipoModificacion,
        int? idPublicacionOriginal)
        {
            using var connection = _connectionFactory.CreateConnection(); // Asumiendo _connectionFactory
            var sqlBuilder = new StringBuilder(@"
            SELECT 
                h.Id_Publicacion, h.Nombre, h.Observacion, h.Id_Empresa, h.Habilitada,
                h.Id_Usuario, h.FechaMod, h.TipoMod,
                u.Nombre + ' ' + u.Apellido AS NombreUsuarioModifico
            FROM dbo.dist_dtPublicaciones_H h
            JOIN dbo.gral_Usuarios u ON h.Id_Usuario = u.Id
            WHERE 1=1");

            var parameters = new DynamicParameters();

            if (fechaDesde.HasValue) { sqlBuilder.Append(" AND h.FechaMod >= @FechaDesdeParam"); parameters.Add("FechaDesdeParam", fechaDesde.Value.Date); }
            if (fechaHasta.HasValue) { sqlBuilder.Append(" AND h.FechaMod <= @FechaHastaParam"); parameters.Add("FechaHastaParam", fechaHasta.Value.Date.AddDays(1).AddTicks(-1)); }
            if (idUsuarioModifico.HasValue) { sqlBuilder.Append(" AND h.Id_Usuario = @IdUsuarioModificoParam"); parameters.Add("IdUsuarioModificoParam", idUsuarioModifico.Value); }
            if (!string.IsNullOrWhiteSpace(tipoModificacion)) { sqlBuilder.Append(" AND h.TipoMod = @TipoModParam"); parameters.Add("TipoModParam", tipoModificacion); }
            if (idPublicacionOriginal.HasValue) { sqlBuilder.Append(" AND h.Id_Publicacion = @IdPublicacionOriginalParam"); parameters.Add("IdPublicacionOriginalParam", idPublicacionOriginal.Value); }

            sqlBuilder.Append(" ORDER BY h.FechaMod DESC;");

            try
            {
                var result = await connection.QueryAsync<PublicacionHistorico, string, (PublicacionHistorico, string)>(
                    sqlBuilder.ToString(),
                    (hist, userName) => (hist, userName),
                    parameters,
                    splitOn: "NombreUsuarioModifico"
                );
                return result;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al obtener historial de Publicaciones (Maestro)."); // Asumiendo _logger
                return Enumerable.Empty<(PublicacionHistorico, string)>();
            }
        }
    }
}