using Dapper;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq; // Necesario para .Any()
using System.Text;
using System.Threading.Tasks;

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

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

        public async Task<IEnumerable<(RecargoZona Recargo, string NombreZona)>> GetByPublicacionIdAsync(int idPublicacion)
        {
            const string sql = @"
                SELECT 
                    rz.Id_Recargo AS IdRecargo, rz.Id_Publicacion AS IdPublicacion, rz.Id_Zona AS IdZona,
                    rz.VigenciaD, rz.VigenciaH, rz.Valor,
                    z.Nombre AS NombreZona
                FROM dbo.dist_RecargoZona rz
                INNER JOIN dbo.dist_dtZonas z ON rz.Id_Zona = z.Id_Zona
                WHERE rz.Id_Publicacion = @IdPublicacionParam
                ORDER BY z.Nombre, rz.VigenciaD DESC";
            try
            {
                using var connection = _connectionFactory.CreateConnection();
                return await connection.QueryAsync<RecargoZona, string, (RecargoZona, string)>(
                    sql,
                    (recargo, nombreZona) => (recargo, nombreZona),
                    new { IdPublicacionParam = idPublicacion },
                    splitOn: "NombreZona"
                );
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al obtener Recargos por Zona para Publicacion ID: {IdPublicacion}", idPublicacion);
                return Enumerable.Empty<(RecargoZona, string)>();
            }
        }

        public async Task<bool> IsInUseAsync(int idRecargo, DateTime vigenciaD, DateTime? vigenciaH)
        {
            // Similar a Precios, verificar en dist_EntradasSalidas y dist_EntradasSalidasCanillas
            // si Id_Recargo se usa en movimientos DENTRO del rango de vigencia del recargo.
            var sql = @"
                SELECT TOP 1 1 
                FROM (
                    SELECT Id_Recargo, Fecha FROM dbo.dist_EntradasSalidas
                    UNION ALL
                    SELECT Id_Recargo, Fecha FROM dbo.dist_EntradasSalidasCanillas
                ) AS Movimientos
                WHERE Movimientos.Id_Recargo = @IdRecargoParam 
                AND Movimientos.Fecha >= @VigenciaDParam
                AND (@VigenciaHParam IS NULL OR Movimientos.Fecha <= @VigenciaHParam);";
            try
            {
                using var connection = _connectionFactory.CreateConnection();
                var parameters = new
                {
                    IdRecargoParam = idRecargo,
                    VigenciaDParam = vigenciaD.Date,
                    VigenciaHParam = vigenciaH?.Date
                };
                var inUse = await connection.ExecuteScalarAsync<int?>(sql, parameters);
                return inUse.HasValue && inUse.Value == 1;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error en IsInUseAsync para Recargo ID: {IdRecargo}", idRecargo);
                return true;
            }
        }

        public async Task<RecargoZona?> GetByIdAsync(int idRecargo)
        {
            const string sql = @"
                SELECT 
                    Id_Recargo AS IdRecargo, Id_Publicacion AS IdPublicacion, Id_Zona AS IdZona,
                    VigenciaD, VigenciaH, Valor
                FROM dbo.dist_RecargoZona 
                WHERE Id_Recargo = @IdRecargoParam";
            try
            {
                using var connection = _connectionFactory.CreateConnection();
                return await connection.QuerySingleOrDefaultAsync<RecargoZona>(sql, new { IdRecargoParam = idRecargo });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error al obtener Recargo por Zona por ID: {IdRecargo}", idRecargo);
                return null;
            }
        }

        public async Task<RecargoZona?> GetActiveByPublicacionZonaAndDateAsync(int idPublicacion, int idZona, DateTime fecha, IDbTransaction? transaction = null)
        {
            const string sql = @"
                SELECT TOP 1 
                    Id_Recargo AS IdRecargo, Id_Publicacion AS IdPublicacion, Id_Zona AS IdZona,
                    VigenciaD, VigenciaH, Valor
                FROM dbo.dist_RecargoZona
                WHERE Id_Publicacion = @IdPublicacionParam AND Id_Zona = @IdZonaParam
                  AND VigenciaD <= @FechaParam
                  AND (VigenciaH IS NULL OR VigenciaH >= @FechaParam)
                ORDER BY VigenciaD DESC;";

            var cn = transaction?.Connection ?? _connectionFactory.CreateConnection();
            bool ownConnection = transaction == null;
            RecargoZona? result = null;
            try
            {
                if (ownConnection && cn.State == ConnectionState.Closed && cn is System.Data.Common.DbConnection dbConn)
                {
                    await dbConn.OpenAsync();
                }
                result = await cn.QuerySingleOrDefaultAsync<RecargoZona>(sql,
                    new { IdPublicacionParam = idPublicacion, IdZonaParam = idZona, FechaParam = fecha.Date },
                    transaction);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error en GetActiveByPublicacionZonaAndDateAsync. IdPublicacion: {IdPublicacion}, IdZona: {IdZona}, Fecha: {Fecha}", idPublicacion, idZona, fecha);
                throw;
            }
            finally
            {
                if (ownConnection && cn.State == ConnectionState.Open && cn is System.Data.Common.DbConnection dbConnClose)
                {
                    await dbConnClose.CloseAsync();
                }
                if (ownConnection) (cn as IDisposable)?.Dispose();
            }
            return result;
        }

        public async Task<RecargoZona?> GetPreviousActiveRecargoAsync(int idPublicacion, int idZona, DateTime vigenciaDNuevo, IDbTransaction transaction)
        {
            const string sql = @"
                SELECT TOP 1 
                    Id_Recargo AS IdRecargo, Id_Publicacion AS IdPublicacion, Id_Zona AS IdZona,
                    VigenciaD, VigenciaH, Valor
                FROM dbo.dist_RecargoZona
                WHERE Id_Publicacion = @IdPublicacionParam AND Id_Zona = @IdZonaParam
                  AND VigenciaD < @VigenciaDNuevoParam
                  AND VigenciaH IS NULL
                ORDER BY VigenciaD DESC;";
            return await transaction.Connection!.QuerySingleOrDefaultAsync<RecargoZona>(sql,
                new { IdPublicacionParam = idPublicacion, IdZonaParam = idZona, VigenciaDNuevoParam = vigenciaDNuevo.Date },
                transaction);
        }

        public async Task<RecargoZona?> CreateAsync(RecargoZona nuevoRecargo, int idUsuario, IDbTransaction transaction)
        {
            const string sqlInsert = @"
                INSERT INTO dbo.dist_RecargoZona (Id_Publicacion, Id_Zona, VigenciaD, VigenciaH, Valor)
                OUTPUT INSERTED.Id_Recargo AS IdRecargo, INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Id_Zona AS IdZona, 
                       INSERTED.VigenciaD, INSERTED.VigenciaH, INSERTED.Valor 
                VALUES (@IdPublicacion, @IdZona, @VigenciaD, @VigenciaH, @Valor);";
            const string sqlInsertHistorico = @"
                INSERT INTO dbo.dist_RecargoZona_H (Id_Recargo, Id_Publicacion, Id_Zona, VigenciaD, VigenciaH, Valor, Id_Usuario, FechaMod, TipoMod)
                VALUES (@IdRecargoParam, @IdPublicacionParam, @IdZonaParam, @VigenciaDParam, @VigenciaHParam, @ValorParam, @Id_UsuarioParam, @FechaModParam, @TipoModParam);";

            var inserted = await transaction.Connection!.QuerySingleAsync<RecargoZona>(sqlInsert, nuevoRecargo, transaction);
            if (inserted == null || inserted.IdRecargo == 0) throw new DataException("Error al crear recargo por zona o al obtener el ID generado.");

            await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
            {
                IdRecargoParam = inserted.IdRecargo,
                IdPublicacionParam = inserted.IdPublicacion,
                IdZonaParam = inserted.IdZona,
                VigenciaDParam = inserted.VigenciaD,
                VigenciaHParam = inserted.VigenciaH,
                ValorParam = inserted.Valor,
                Id_UsuarioParam = idUsuario,
                FechaModParam = DateTime.Now,
                TipoModParam = "Creado"
            }, transaction);
            return inserted;
        }

        public async Task<bool> UpdateAsync(RecargoZona recargoAActualizar, int idUsuario, IDbTransaction transaction)
        {
            var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<RecargoZona>(
                @"SELECT Id_Recargo AS IdRecargo, Id_Publicacion AS IdPublicacion, Id_Zona AS IdZona, 
                         VigenciaD, VigenciaH, Valor 
                  FROM dbo.dist_RecargoZona WHERE Id_Recargo = @IdRecargoParam", // Usar parámetro con alias
                new { IdRecargoParam = recargoAActualizar.IdRecargo }, transaction);
            if (actual == null) throw new KeyNotFoundException("Recargo por zona no encontrado.");

            const string sqlUpdate = @"
                UPDATE dbo.dist_RecargoZona SET
                    Valor = @Valor, VigenciaH = @VigenciaH
                WHERE Id_Recargo = @IdRecargo;";
            const string sqlInsertHistorico = @"
                INSERT INTO dbo.dist_RecargoZona_H (Id_Recargo, Id_Publicacion, Id_Zona, VigenciaD, VigenciaH, Valor, Id_Usuario, FechaMod, TipoMod)
                VALUES (@IdRecargoParam, @IdPublicacionParam, @IdZonaParam, @VigenciaDParam, @VigenciaHParam, @ValorParam, @Id_UsuarioParam, @FechaModParam, @TipoModParam);";

            await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
            {
                IdRecargoParam = actual.IdRecargo,
                IdPublicacionParam = actual.IdPublicacion,
                IdZonaParam = actual.IdZona,
                VigenciaDParam = actual.VigenciaD,
                VigenciaHParam = actual.VigenciaH,
                ValorParam = actual.Valor,
                Id_UsuarioParam = idUsuario,
                FechaModParam = DateTime.Now,
                TipoModParam = "Actualizado"
            }, transaction);

            var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlUpdate, recargoAActualizar, transaction);
            return rowsAffected == 1;
        }

        public async Task<bool> DeleteAsync(int idRecargo, int idUsuario, IDbTransaction transaction)
        {
            var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<RecargoZona>(
               @"SELECT Id_Recargo AS IdRecargo, Id_Publicacion AS IdPublicacion, Id_Zona AS IdZona, 
                        VigenciaD, VigenciaH, Valor 
                 FROM dbo.dist_RecargoZona WHERE Id_Recargo = @IdRecargoParam", new { IdRecargoParam = idRecargo }, transaction);
            if (actual == null) throw new KeyNotFoundException("Recargo por zona no encontrado para eliminar.");

            const string sqlDelete = "DELETE FROM dbo.dist_RecargoZona WHERE Id_Recargo = @IdRecargoParam"; // Usar parámetro con alias
            const string sqlInsertHistorico = @"
                INSERT INTO dbo.dist_RecargoZona_H (Id_Recargo, Id_Publicacion, Id_Zona, VigenciaD, VigenciaH, Valor, Id_Usuario, FechaMod, TipoMod)
                VALUES (@IdRecargoParam, @IdPublicacionParam, @IdZonaParam, @VigenciaDParam, @VigenciaHParam, @ValorParam, @Id_UsuarioParam, @FechaModParam, @TipoModParam);";

            await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
            {
                IdRecargoParam = actual.IdRecargo,
                IdPublicacionParam = actual.IdPublicacion,
                IdZonaParam = actual.IdZona,
                VigenciaDParam = actual.VigenciaD,
                VigenciaHParam = actual.VigenciaH,
                ValorParam = actual.Valor,
                Id_UsuarioParam = idUsuario,
                FechaModParam = DateTime.Now,
                TipoModParam = "Eliminado"
            }, transaction);

            var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete, new { IdRecargoParam = idRecargo }, transaction);
            return rowsAffected == 1;
        }

        public async Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction)
        {
            const string selectSql = @"
                SELECT 
                    Id_Recargo AS IdRecargo, Id_Publicacion AS IdPublicacion, Id_Zona AS IdZona, 
                    VigenciaD, VigenciaH, Valor
                FROM dbo.dist_RecargoZona WHERE Id_Publicacion = @IdPublicacionParam";
            var itemsToDelete = await transaction.Connection!.QueryAsync<RecargoZona>(selectSql, new { IdPublicacionParam = idPublicacion }, transaction);

            if (itemsToDelete.Any())
            {
                const string insertHistoricoSql = @"
                    INSERT INTO dbo.dist_RecargoZona_H (Id_Recargo, Id_Publicacion, Id_Zona, VigenciaD, VigenciaH, Valor, Id_Usuario, FechaMod, TipoMod)
                    VALUES (@IdRecargoParam, @IdPublicacionParam, @IdZonaParam, @VigenciaDParam, @VigenciaHParam, @ValorParam, @Id_UsuarioParam, @FechaModParam, @TipoModParam);";
                foreach (var item in itemsToDelete)
                {
                    await transaction.Connection!.ExecuteAsync(insertHistoricoSql, new
                    {
                        IdRecargoParam = item.IdRecargo,
                        IdPublicacionParam = item.IdPublicacion,
                        IdZonaParam = item.IdZona,
                        VigenciaDParam = item.VigenciaD,
                        VigenciaHParam = item.VigenciaH,
                        ValorParam = item.Valor,
                        Id_UsuarioParam = idUsuarioAuditoria,
                        FechaModParam = DateTime.Now,
                        TipoModParam = "Eliminado (Cascada)"
                    }, transaction);
                }
            }
            const string deleteSql = "DELETE FROM dbo.dist_RecargoZona WHERE Id_Publicacion = @IdPublicacionParam";
            try
            {
                await transaction.Connection!.ExecuteAsync(deleteSql, new { IdPublicacionParam = idPublicacion }, transaction: transaction);
                return true;
            }
            catch (System.Exception ex)
            {
                _logger.LogError(ex, "Error al eliminar RecargosZona por IdPublicacion: {IdPublicacion}", idPublicacion);
                throw;
            }
        }

        public async Task<IEnumerable<(RecargoZonaHistorico Historial, string NombreUsuarioModifico)>> GetHistorialAsync(
        DateTime? fechaDesde, DateTime? fechaHasta,
        int? idUsuarioModifico, string? tipoModificacion,
        int? idRecargoOriginal, int? idPublicacionOriginal, int? idZonaOriginal)
        {
            using var connection = _connectionFactory.CreateConnection();
            var sqlBuilder = new StringBuilder(@"
            SELECT 
                h.Id_Recargo, h.Id_Publicacion, h.Id_Zona, h.VigenciaD, h.VigenciaH, h.Valor,
                h.Id_Usuario, h.FechaMod, h.TipoMod,
                u.Nombre + ' ' + u.Apellido AS NombreUsuarioModifico
            FROM dbo.dist_RecargoZona_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 (idRecargoOriginal.HasValue) { sqlBuilder.Append(" AND h.Id_Recargo = @IdRecargoOriginalParam"); parameters.Add("IdRecargoOriginalParam", idRecargoOriginal.Value); }
            if (idPublicacionOriginal.HasValue) { sqlBuilder.Append(" AND h.Id_Publicacion = @IdPublicacionOriginalParam"); parameters.Add("IdPublicacionOriginalParam", idPublicacionOriginal.Value); }
            if (idZonaOriginal.HasValue) { sqlBuilder.Append(" AND h.Id_Zona = @IdZonaOriginalParam"); parameters.Add("IdZonaOriginalParam", idZonaOriginal.Value); }

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

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