using Dapper;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System;
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 SalidaOtroDestinoRepository : ISalidaOtroDestinoRepository
    {
        private readonly DbConnectionFactory _cf;
        private readonly ILogger<SalidaOtroDestinoRepository> _log;

        public SalidaOtroDestinoRepository(DbConnectionFactory cf, ILogger<SalidaOtroDestinoRepository> log)
        {
            _cf = cf;
            _log = log;
        }

        public async Task<IEnumerable<SalidaOtroDestino>> GetAllAsync(DateTime? fechaDesde, DateTime? fechaHasta, int? idPublicacion, int? idDestino)
        {
            var sqlBuilder = new StringBuilder(@"
                SELECT 
                    Id_Parte AS IdParte, Id_Publicacion AS IdPublicacion, Id_Destino AS IdDestino,
                    Fecha, Cantidad, Observacion
                FROM dbo.dist_SalidasOtrosDestinos
                WHERE 1=1");
            var parameters = new DynamicParameters();

            if (fechaDesde.HasValue) { sqlBuilder.Append(" AND Fecha >= @FechaDesdeParam"); parameters.Add("FechaDesdeParam", fechaDesde.Value.Date); }
            if (fechaHasta.HasValue) { sqlBuilder.Append(" AND Fecha <= @FechaHastaParam"); parameters.Add("FechaHastaParam", fechaHasta.Value.Date); }
            if (idPublicacion.HasValue) { sqlBuilder.Append(" AND Id_Publicacion = @IdPublicacionParam"); parameters.Add("IdPublicacionParam", idPublicacion.Value); }
            if (idDestino.HasValue) { sqlBuilder.Append(" AND Id_Destino = @IdDestinoParam"); parameters.Add("IdDestinoParam", idDestino.Value); }
            sqlBuilder.Append(" ORDER BY Fecha DESC, Id_Publicacion;");

            try
            {
                using var connection = _cf.CreateConnection();
                return await connection.QueryAsync<SalidaOtroDestino>(sqlBuilder.ToString(), parameters);
            }
            catch (Exception ex)
            {
                _log.LogError(ex, "Error al obtener Salidas a Otros Destinos.");
                return Enumerable.Empty<SalidaOtroDestino>();
            }
        }

        public async Task<SalidaOtroDestino?> GetByIdAsync(int idParte)
        {
            const string sql = @"
                SELECT 
                    Id_Parte AS IdParte, Id_Publicacion AS IdPublicacion, Id_Destino AS IdDestino,
                    Fecha, Cantidad, Observacion
                FROM dbo.dist_SalidasOtrosDestinos 
                WHERE Id_Parte = @IdParteParam";
            try
            {
                using var connection = _cf.CreateConnection();
                return await connection.QuerySingleOrDefaultAsync<SalidaOtroDestino>(sql, new { IdParteParam = idParte });
            }
             catch (Exception ex)
            {
                _log.LogError(ex, "Error al obtener SalidaOtroDestino por ID: {IdParte}", idParte);
                return null;
            }
        }

        public async Task<SalidaOtroDestino?> CreateAsync(SalidaOtroDestino nuevaSalida, int idUsuario, IDbTransaction transaction)
        {
            const string sqlInsert = @"
                INSERT INTO dbo.dist_SalidasOtrosDestinos (Id_Publicacion, Id_Destino, Fecha, Cantidad, Observacion)
                OUTPUT INSERTED.Id_Parte AS IdParte, INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Id_Destino AS IdDestino, 
                       INSERTED.Fecha, INSERTED.Cantidad, INSERTED.Observacion
                VALUES (@IdPublicacion, @IdDestino, @Fecha, @Cantidad, @Observacion);";
            const string sqlHistorico = @"
                INSERT INTO dbo.dist_SalidasOtrosDestinos_H (Id_Parte, Id_Publicacion, Id_Destino, Fecha, Cantidad, Observacion, Id_Usuario, FechaMod, TipoMod)
                VALUES (@IdParteHist, @IdPublicacionHist, @IdDestinoHist, @FechaHist, @CantidadHist, @ObservacionHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";

            var inserted = await transaction.Connection!.QuerySingleAsync<SalidaOtroDestino>(sqlInsert, nuevaSalida, transaction);
            if (inserted == null || inserted.IdParte == 0) throw new DataException("Error al crear salida o ID no generado.");

            await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
                IdParteHist = inserted.IdParte, IdPublicacionHist = inserted.IdPublicacion, IdDestinoHist = inserted.IdDestino,
                FechaHist = inserted.Fecha, CantidadHist = inserted.Cantidad, ObservacionHist = inserted.Observacion,
                IdUsuarioHist = idUsuario, FechaModHist = DateTime.Now, TipoModHist = "Creada"
            }, transaction);
            return inserted;
        }

        public async Task<bool> UpdateAsync(SalidaOtroDestino salidaAActualizar, int idUsuario, IDbTransaction transaction)
        {
            var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<SalidaOtroDestino>(
                @"SELECT Id_Parte AS IdParte, Id_Publicacion AS IdPublicacion, Id_Destino AS IdDestino, Fecha, Cantidad, Observacion
                  FROM dbo.dist_SalidasOtrosDestinos WHERE Id_Parte = @IdParteParam",
                new { IdParteParam = salidaAActualizar.IdParte }, transaction);
            if (actual == null) throw new KeyNotFoundException("Salida no encontrada.");

            const string sqlUpdate = @"
                UPDATE dbo.dist_SalidasOtrosDestinos SET
                    Cantidad = @Cantidad, Observacion = @Observacion
                    -- No se permite cambiar Publicacion, Destino o Fecha de una salida ya registrada
                WHERE Id_Parte = @IdParte;";
            const string sqlHistorico = @"
                 INSERT INTO dbo.dist_SalidasOtrosDestinos_H (Id_Parte, Id_Publicacion, Id_Destino, Fecha, Cantidad, Observacion, Id_Usuario, FechaMod, TipoMod)
                VALUES (@IdParteHist, @IdPublicacionHist, @IdDestinoHist, @FechaHist, @CantidadHist, @ObservacionHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
            
            await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
                IdParteHist = actual.IdParte, IdPublicacionHist = actual.IdPublicacion, IdDestinoHist = actual.IdDestino,
                FechaHist = actual.Fecha, CantidadHist = actual.Cantidad, ObservacionHist = actual.Observacion, // Valores ANTERIORES
                IdUsuarioHist = idUsuario, FechaModHist = DateTime.Now, TipoModHist = "Actualizada"
            }, transaction);

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

        public async Task<bool> DeleteAsync(int idParte, int idUsuario, IDbTransaction transaction)
        {
            var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<SalidaOtroDestino>(
               @"SELECT Id_Parte AS IdParte, Id_Publicacion AS IdPublicacion, Id_Destino AS IdDestino, Fecha, Cantidad, Observacion
                 FROM dbo.dist_SalidasOtrosDestinos WHERE Id_Parte = @IdParteParam",
               new { IdParteParam = idParte }, transaction);
            if (actual == null) throw new KeyNotFoundException("Salida no encontrada para eliminar.");

            const string sqlDelete = "DELETE FROM dbo.dist_SalidasOtrosDestinos WHERE Id_Parte = @IdParteParam";
            const string sqlHistorico = @"
                 INSERT INTO dbo.dist_SalidasOtrosDestinos_H (Id_Parte, Id_Publicacion, Id_Destino, Fecha, Cantidad, Observacion, Id_Usuario, FechaMod, TipoMod)
                VALUES (@IdParteHist, @IdPublicacionHist, @IdDestinoHist, @FechaHist, @CantidadHist, @ObservacionHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";

            await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
                IdParteHist = actual.IdParte, IdPublicacionHist = actual.IdPublicacion, IdDestinoHist = actual.IdDestino,
                FechaHist = actual.Fecha, CantidadHist = actual.Cantidad, ObservacionHist = actual.Observacion,
                IdUsuarioHist = idUsuario, FechaModHist = DateTime.Now, TipoModHist = "Eliminada"
            }, transaction);

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