GestionIntegralWeb/Backend/GestionIntegral.Api/Services/Distribucion/EntradaSalidaDistService.cs

using GestionIntegral.Api.Data;
using GestionIntegral.Api.Data.Repositories.Contables;
using GestionIntegral.Api.Data.Repositories.Distribucion;
using GestionIntegral.Api.Dtos.Distribucion;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;

namespace GestionIntegral.Api.Services.Distribucion
{
    public class EntradaSalidaDistService : IEntradaSalidaDistService
    {
        private readonly IEntradaSalidaDistRepository _esRepository;
        private readonly IPublicacionRepository _publicacionRepository;
        private readonly IDistribuidorRepository _distribuidorRepository;
        private readonly IPrecioRepository _precioRepository;
        private readonly IRecargoZonaRepository _recargoZonaRepository;
        private readonly IPorcPagoRepository _porcPagoRepository;
        private readonly ISaldoRepository _saldoRepository;
        private readonly IEmpresaRepository _empresaRepository; // Para obtener IdEmpresa de la publicación
        private readonly DbConnectionFactory _connectionFactory;
        private readonly ILogger<EntradaSalidaDistService> _logger;

        public EntradaSalidaDistService(
            IEntradaSalidaDistRepository esRepository,
            IPublicacionRepository publicacionRepository,
            IDistribuidorRepository distribuidorRepository,
            IPrecioRepository precioRepository,
            IRecargoZonaRepository recargoZonaRepository,
            IPorcPagoRepository porcPagoRepository,
            ISaldoRepository saldoRepository,
            IEmpresaRepository empresaRepository,
            DbConnectionFactory connectionFactory,
            ILogger<EntradaSalidaDistService> logger)
        {
            _esRepository = esRepository;
            _publicacionRepository = publicacionRepository;
            _distribuidorRepository = distribuidorRepository;
            _precioRepository = precioRepository;
            _recargoZonaRepository = recargoZonaRepository;
            _porcPagoRepository = porcPagoRepository;
            _saldoRepository = saldoRepository;
            _empresaRepository = empresaRepository;
            _connectionFactory = connectionFactory;
            _logger = logger;
        }

        private async Task<EntradaSalidaDistDto> MapToDto(EntradaSalidaDist es)
        {
            if (es == null) return null!;

            var publicacionData = await _publicacionRepository.GetByIdAsync(es.IdPublicacion);
            var distribuidorData = await _distribuidorRepository.GetByIdAsync(es.IdDistribuidor);
            
            // Obtener el valor bruto del movimiento
            decimal valorBrutoMovimiento = await CalcularMontoMovimiento(
                es.IdPublicacion, es.IdDistribuidor, es.Fecha, es.Cantidad, 
                es.TipoMovimiento, // Pasamos el tipo de movimiento original aquí
                es.IdPrecio, es.IdRecargo, es.IdPorcentaje, distribuidorData.Distribuidor?.IdZona
            );

            // Ajustar para el DTO: si es "Entrada", el monto calculado es un crédito (negativo o positivo según convención)
            // Para consistencia con el ajuste de saldo, si es Entrada, el MontoCalculado para el DTO puede ser el valor
            // que se le "acredita" al distribuidor (o sea, el valor de la mercadería devuelta).
            // La lógica de +/- para el saldo ya está en Crear/Actualizar/Eliminar.
            // Aquí solo mostramos el valor del movimiento. Si es entrada, es el valor de lo devuelto.
            // Si es salida, es el valor de lo que se le factura.
            // El método CalcularMonto ya devuelve el monto que el distribuidor DEBE pagar por una SALIDA.
            // Para una ENTRADA (devolución), el valor de esa mercadería es el mismo, pero opera en sentido contrario al saldo.

            decimal montoCalculadoParaDto = valorBrutoMovimiento;
            // Si queremos que el DTO muestre las entradas como un valor que "reduce la deuda",
            // podría ser positivo. Si queremos que refleje el impacto directo en la factura (salidas suman, entradas restan),
            // podríamos hacerlo negativo.
            // Por ahora, dejaremos que CalcularMontoMovimiento devuelva el valor de una "Salida",
            // y si es "Entrada", este mismo valor es el que se acredita.
            // La columna `MontoCalculado` en el DTO representará el valor de la transacción.

            return new EntradaSalidaDistDto
            {
                IdParte = es.IdParte,
                IdPublicacion = es.IdPublicacion,
                NombrePublicacion = publicacionData.Publicacion?.Nombre ?? "N/A",
                IdEmpresaPublicacion = publicacionData.Publicacion?.IdEmpresa ?? 0,
                NombreEmpresaPublicacion = publicacionData.NombreEmpresa ?? "N/A",
                IdDistribuidor = es.IdDistribuidor,
                NombreDistribuidor = distribuidorData.Distribuidor?.Nombre ?? "N/A",
                Fecha = es.Fecha.ToString("yyyy-MM-dd"),
                TipoMovimiento = es.TipoMovimiento,
                Cantidad = es.Cantidad,
                Remito = es.Remito,
                Observacion = es.Observacion,
                MontoCalculado = montoCalculadoParaDto // Representa el valor de los N ejemplares
            };
        }
        
        private async Task<decimal> CalcularMontoMovimiento(int idPublicacion, int idDistribuidor, DateTime fecha, int cantidad, string tipoMovimiento,
                                                            int idPrecio, int idRecargo, int idPorcentaje, int? idZonaDistribuidor)
        {
            // YA NO SE DEVUELVE 0 PARA ENTRADA AQUÍ
            // if (tipoMovimiento == "Entrada") return 0; 

            var precioConfig = await _precioRepository.GetByIdAsync(idPrecio);
            // Es crucial que idPrecio sea válido y se haya determinado correctamente antes de llamar aquí.
            // Si precioConfig es null, se lanzará una excepción abajo, lo cual está bien si es un estado inesperado.
            if (precioConfig == null)
            {
                _logger.LogError("Configuración de precio ID {IdPrecio} no encontrada al calcular monto para Pub {IdPublicacion}, Dist {IdDistribuidor}, Fecha {Fecha}", idPrecio, idPublicacion, idDistribuidor, fecha);
                // Dependiendo de la regla de negocio, podrías devolver 0 o lanzar una excepción.
                // Si un precio es OBLIGATORIO para cualquier movimiento, lanzar excepción es más apropiado.
                // Si puede haber movimientos sin precio (ej. cortesía que no se factura), entonces 0.
                // En este contexto, un precio es fundamental para el cálculo.
                throw new InvalidOperationException($"Configuración de precio ID {idPrecio} no encontrada. No se puede calcular el monto.");
            }


            decimal precioDia = 0;
            DayOfWeek diaSemana = fecha.DayOfWeek;
            switch (diaSemana)
            {
                case DayOfWeek.Monday: precioDia = precioConfig.Lunes ?? 0; break;
                case DayOfWeek.Tuesday: precioDia = precioConfig.Martes ?? 0; break;
                case DayOfWeek.Wednesday: precioDia = precioConfig.Miercoles ?? 0; break;
                case DayOfWeek.Thursday: precioDia = precioConfig.Jueves ?? 0; break;
                case DayOfWeek.Friday: precioDia = precioConfig.Viernes ?? 0; break;
                case DayOfWeek.Saturday: precioDia = precioConfig.Sabado ?? 0; break;
                case DayOfWeek.Sunday: precioDia = precioConfig.Domingo ?? 0; break;
            }

            decimal valorRecargo = 0;
            if (idRecargo > 0 && idZonaDistribuidor.HasValue)
            {
                 var recargoConfig = await _recargoZonaRepository.GetActiveByPublicacionZonaAndDateAsync(idPublicacion, idZonaDistribuidor.Value, fecha);
                if (recargoConfig != null)
                {
                    valorRecargo = recargoConfig.Valor;
                }
            }
            
            decimal precioConRecargo = precioDia + valorRecargo;
            decimal montoBase = precioConRecargo * cantidad;

            if (idPorcentaje > 0)
            {
                var porcConfig = await _porcPagoRepository.GetByIdAsync(idPorcentaje);
                if (porcConfig != null)
                {
                    // El porcentaje de pago del distribuidor es lo que ÉL PAGA a la editorial.
                    // Entonces, el monto es (precio_tapa_con_recargo * cantidad) * (porcentaje_pago_dist / 100)
                    return (montoBase * porcConfig.Porcentaje) / 100;
                }
            }
            // Si no hay porcentaje de pago específico, se asume que el distribuidor paga el 100% del monto base.
            return montoBase;
        }


        public async Task<IEnumerable<EntradaSalidaDistDto>> ObtenerTodosAsync(DateTime? fechaDesde, DateTime? fechaHasta, int? idPublicacion, int? idDistribuidor, string? tipoMovimiento)
        {
            var movimientos = await _esRepository.GetAllAsync(fechaDesde, fechaHasta, idPublicacion, idDistribuidor, tipoMovimiento);
            var dtos = new List<EntradaSalidaDistDto>();
            foreach (var mov in movimientos)
            {
                dtos.Add(await MapToDto(mov));
            }
            return dtos;
        }

        public async Task<EntradaSalidaDistDto?> ObtenerPorIdAsync(int idParte)
        {
            var movimiento = await _esRepository.GetByIdAsync(idParte);
            return movimiento == null ? null : await MapToDto(movimiento);
        }

        public async Task<(EntradaSalidaDistDto? Movimiento, string? Error)> CrearMovimientoAsync(CreateEntradaSalidaDistDto createDto, int idUsuario)
        {
            var publicacion = await _publicacionRepository.GetByIdSimpleAsync(createDto.IdPublicacion);
            if (publicacion == null || publicacion.Habilitada != true) return (null, "Publicación no válida o no habilitada.");

            var distribuidor = await _distribuidorRepository.GetByIdSimpleAsync(createDto.IdDistribuidor);
            if (distribuidor == null) return (null, "Distribuidor no válido.");

            if (await _esRepository.ExistsByRemitoAndTipoForPublicacionAsync(createDto.Remito, createDto.TipoMovimiento, createDto.IdPublicacion))
            {
                return (null, $"Ya existe un movimiento de '{createDto.TipoMovimiento}' con el remito N°{createDto.Remito} para esta publicación.");
            }

            // Determinar IDs de Precio, Recargo y Porcentaje activos en la fecha del movimiento
            var precioActivo = await _precioRepository.GetActiveByPublicacionAndDateAsync(createDto.IdPublicacion, createDto.Fecha.Date);
            if (precioActivo == null) return (null, $"No hay un precio definido para la publicación '{publicacion.Nombre}' en la fecha {createDto.Fecha:dd/MM/yyyy}.");

            RecargoZona? recargoActivo = null;
            if (distribuidor.IdZona.HasValue)
            {
                 recargoActivo = await _recargoZonaRepository.GetActiveByPublicacionZonaAndDateAsync(createDto.IdPublicacion, distribuidor.IdZona.Value, createDto.Fecha.Date);
            }

            var porcPagoActivo = await _porcPagoRepository.GetActiveByPublicacionDistribuidorAndDateAsync(createDto.IdPublicacion, createDto.IdDistribuidor, createDto.Fecha.Date);

            var nuevoES = new EntradaSalidaDist
            {
                IdPublicacion = createDto.IdPublicacion,
                IdDistribuidor = createDto.IdDistribuidor,
                Fecha = createDto.Fecha.Date,
                TipoMovimiento = createDto.TipoMovimiento,
                Cantidad = createDto.Cantidad,
                Remito = createDto.Remito,
                Observacion = createDto.Observacion,
                IdPrecio = precioActivo.IdPrecio,
                IdRecargo = recargoActivo?.IdRecargo ?? 0, // 0 si no aplica
                IdPorcentaje = porcPagoActivo?.IdPorcentaje ?? 0 // 0 si no aplica
            };

            using var connection = _connectionFactory.CreateConnection();
            if (connection is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync(); else connection.Open();
            using var transaction = connection.BeginTransaction();
            try
            {
                var esCreada = await _esRepository.CreateAsync(nuevoES, idUsuario, transaction);
                if (esCreada == null) throw new DataException("Error al registrar el movimiento.");

                // Afectar Saldo
                decimal montoAfectacion = await CalcularMontoMovimiento(
                    esCreada.IdPublicacion, esCreada.IdDistribuidor, esCreada.Fecha, esCreada.Cantidad, esCreada.TipoMovimiento,
                    esCreada.IdPrecio, esCreada.IdRecargo, esCreada.IdPorcentaje, distribuidor.IdZona);
                
                // Si es Salida, montoAfectacion es positivo (aumenta deuda). Si es Entrada, es 0 por CalcularMontoMovimiento,
                // pero para el saldo, una Entrada (devolución) debería restar del saldo deudor.
                // Por lo tanto, el monto real a restar del saldo si es Entrada sería el valor de esos ejemplares devueltos.
                if(esCreada.TipoMovimiento == "Entrada")
                {
                     // Recalcular como si fuera salida para obtener el valor a acreditar/restar del saldo
                    montoAfectacion = await CalcularMontoMovimiento(
                        esCreada.IdPublicacion, esCreada.IdDistribuidor, esCreada.Fecha, esCreada.Cantidad, "Salida", // Forzar tipo Salida para cálculo de valor
                        esCreada.IdPrecio, esCreada.IdRecargo, esCreada.IdPorcentaje, distribuidor.IdZona);
                    montoAfectacion *= -1; // Hacerlo negativo para restar del saldo
                }


                bool saldoActualizado = await _saldoRepository.ModificarSaldoAsync("Distribuidores", esCreada.IdDistribuidor, publicacion.IdEmpresa, montoAfectacion, transaction);
                if (!saldoActualizado) throw new DataException("Error al actualizar el saldo del distribuidor.");

                transaction.Commit();
                _logger.LogInformation("Movimiento ID {Id} creado y saldo afectado por Usuario ID {UserId}.", esCreada.IdParte, idUsuario);
                return (await MapToDto(esCreada), null);
            }
            catch (Exception ex)
            {
                try { transaction.Rollback(); } catch { }
                _logger.LogError(ex, "Error CrearMovimientoAsync para Pub ID {IdPub}", createDto.IdPublicacion);
                return (null, $"Error interno: {ex.Message}");
            }
        }

        public async Task<(bool Exito, string? Error)> ActualizarMovimientoAsync(int idParte, UpdateEntradaSalidaDistDto updateDto, int idUsuario)
        {
             // La actualización de un movimiento que afecta saldos es compleja.
             // Si cambia la cantidad, el monto original y el nuevo deben calcularse,
             // y la diferencia debe aplicarse al saldo.
             // Por ahora, este DTO solo permite cambiar Cantidad y Observacion.
             // Cambiar otros campos como Fecha, Publicacion, Distribuidor implicaría recalcular todo
             // y posiblemente anular el movimiento original y crear uno nuevo.

            using var connection = _connectionFactory.CreateConnection();
            if (connection is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync(); else connection.Open();
            using var transaction = connection.BeginTransaction();
            try
            {
                var esExistente = await _esRepository.GetByIdAsync(idParte);
                if (esExistente == null) return (false, "Movimiento no encontrado.");

                var publicacion = await _publicacionRepository.GetByIdSimpleAsync(esExistente.IdPublicacion);
                 if (publicacion == null) return (false, "Publicación asociada no encontrada."); // Muy raro
                var distribuidor = await _distribuidorRepository.GetByIdSimpleAsync(esExistente.IdDistribuidor);
                 if (distribuidor == null) return (false, "Distribuidor asociado no encontrado.");


                // 1. Calcular monto del movimiento original (antes de la actualización)
                decimal montoOriginal = await CalcularMontoMovimiento(
                    esExistente.IdPublicacion, esExistente.IdDistribuidor, esExistente.Fecha, esExistente.Cantidad, esExistente.TipoMovimiento,
                    esExistente.IdPrecio, esExistente.IdRecargo, esExistente.IdPorcentaje, distribuidor.IdZona);
                if(esExistente.TipoMovimiento == "Entrada") montoOriginal *= -1; // Para revertir

                // 2. Actualizar la entidad en la BD (esto también guarda en historial)
                var esParaActualizar = new EntradaSalidaDist
                {
                    IdParte = esExistente.IdParte,
                    IdPublicacion = esExistente.IdPublicacion, // No cambia
                    IdDistribuidor = esExistente.IdDistribuidor, // No cambia
                    Fecha = esExistente.Fecha, // No cambia
                    TipoMovimiento = esExistente.TipoMovimiento, // No cambia
                    Cantidad = updateDto.Cantidad, // Nuevo valor
                    Remito = esExistente.Remito, // No cambia
                    Observacion = updateDto.Observacion, // Nuevo valor
                    IdPrecio = esExistente.IdPrecio, // No cambia
                    IdRecargo = esExistente.IdRecargo, // No cambia
                    IdPorcentaje = esExistente.IdPorcentaje // No cambia
                };
                var actualizado = await _esRepository.UpdateAsync(esParaActualizar, idUsuario, transaction);
                if (!actualizado) throw new DataException("Error al actualizar el movimiento.");

                // 3. Calcular monto del movimiento nuevo (después de la actualización)
                decimal montoNuevo = await CalcularMontoMovimiento(
                    esParaActualizar.IdPublicacion, esParaActualizar.IdDistribuidor, esParaActualizar.Fecha, esParaActualizar.Cantidad, esParaActualizar.TipoMovimiento,
                    esParaActualizar.IdPrecio, esParaActualizar.IdRecargo, esParaActualizar.IdPorcentaje, distribuidor.IdZona);
                if(esParaActualizar.TipoMovimiento == "Entrada") montoNuevo *= -1;


                // 4. Ajustar saldo con la diferencia
                decimal diferenciaAjusteSaldo = montoNuevo - montoOriginal;
                if (diferenciaAjusteSaldo != 0)
                {
                    bool saldoActualizado = await _saldoRepository.ModificarSaldoAsync("Distribuidores", esExistente.IdDistribuidor, publicacion.IdEmpresa, diferenciaAjusteSaldo, transaction);
                    if (!saldoActualizado) throw new DataException("Error al ajustar el saldo del distribuidor tras la actualización.");
                }

                transaction.Commit();
                _logger.LogInformation("Movimiento ID {Id} actualizado y saldo ajustado por Usuario ID {UserId}.", idParte, idUsuario);
                return (true, null);
            }
            catch (KeyNotFoundException) { try { transaction.Rollback(); } catch { } return (false, "Movimiento no encontrado."); }
            catch (Exception ex)
            {
                try { transaction.Rollback(); } catch { }
                _logger.LogError(ex, "Error ActualizarMovimientoAsync ID: {Id}", idParte);
                return (false, $"Error interno: {ex.Message}");
            }
        }

        public async Task<(bool Exito, string? Error)> EliminarMovimientoAsync(int idParte, int idUsuario)
        {
            using var connection = _connectionFactory.CreateConnection();
            if (connection is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync(); else connection.Open();
            using var transaction = connection.BeginTransaction();
            try
            {
                var esExistente = await _esRepository.GetByIdAsync(idParte);
                if (esExistente == null) return (false, "Movimiento no encontrado.");

                var publicacion = await _publicacionRepository.GetByIdSimpleAsync(esExistente.IdPublicacion);
                if (publicacion == null) return (false, "Publicación asociada no encontrada.");
                var distribuidor = await _distribuidorRepository.GetByIdSimpleAsync(esExistente.IdDistribuidor);
                if (distribuidor == null) return (false, "Distribuidor asociado no encontrado.");

                // 1. Calcular el monto del movimiento a eliminar para revertir el saldo
                decimal montoReversion = await CalcularMontoMovimiento(
                    esExistente.IdPublicacion, esExistente.IdDistribuidor, esExistente.Fecha, esExistente.Cantidad, esExistente.TipoMovimiento,
                    esExistente.IdPrecio, esExistente.IdRecargo, esExistente.IdPorcentaje, distribuidor.IdZona);
                
                // Si es Salida, el monto es positivo, al revertir restamos.
                // Si es Entrada, el monto es 0 (por Calcular...), pero su efecto en saldo fue negativo, al revertir sumamos el valor.
                if(esExistente.TipoMovimiento == "Salida") {
                    montoReversion *= -1; // Para restar del saldo lo que se sumó
                } else if (esExistente.TipoMovimiento == "Entrada") {
                    // Recalcular el valor como si fuera salida para saber cuánto se restó del saldo
                     montoReversion = await CalcularMontoMovimiento(
                        esExistente.IdPublicacion, esExistente.IdDistribuidor, esExistente.Fecha, esExistente.Cantidad, "Salida",
                        esExistente.IdPrecio, esExistente.IdRecargo, esExistente.IdPorcentaje, distribuidor.IdZona);
                    // No se multiplica por -1 aquí, porque el saldo ya lo tiene restado, al eliminar revertimos sumando.
                }


                // 2. Eliminar el registro (esto también guarda en historial)
                var eliminado = await _esRepository.DeleteAsync(idParte, idUsuario, transaction);
                if (!eliminado) throw new DataException("Error al eliminar el movimiento.");

                // 3. Ajustar Saldo
                bool saldoActualizado = await _saldoRepository.ModificarSaldoAsync("Distribuidores", esExistente.IdDistribuidor, publicacion.IdEmpresa, montoReversion, transaction);
                if (!saldoActualizado) throw new DataException("Error al revertir el saldo del distribuidor tras la eliminación.");

                transaction.Commit();
                _logger.LogInformation("Movimiento ID {Id} eliminado y saldo revertido por Usuario ID {UserId}.", idParte, idUsuario);
                return (true, null);
            }
            catch (KeyNotFoundException) { try { transaction.Rollback(); } catch { } return (false, "Movimiento no encontrado."); }
            catch (Exception ex)
            {
                try { transaction.Rollback(); } catch { }
                _logger.LogError(ex, "Error EliminarMovimientoAsync ID: {Id}", idParte);
                return (false, $"Error interno: {ex.Message}");
            }
        }
    }
}