{
  "id": 1,
  "descripcion": "PROMO_2X1_ARROZ",
  "metodocomputo": { "id": "CANTIDAD" },
  "tipobeneficio": { "id": "PORCENTAJE_DESCUENTO" },
  "valorbeneficio": 50.0,
  "codigodescarga": null,
  "conveniosclientes": [],
  "condiciones": {
    "acumulativa": false,
    "maximacantidadpromosxticket": 1,
    "montominimo": 0.0,
    "excluyelistaofertas": false,
    "excluyeventamayorista": false
  },
  "vigencia": {
    "fechadesde": "20260301",
    "fechahasta": "20260331",
    "diassemana": ["MIERCOLES"],
    "horadesde": "10",
    "horahasta": "11"
  },
  "sucursales": [],
  "mediosdepago": [],
  "listasitems": [
    {
      "listaindex": 1,
      "tipodeLista": { "id": "INCLUSION" },
      "nrolista":    { "id": "LISTA1" },
      "tipoelemento":{ "id": "EAN" },
      "valor": "7791234567890",
      "cantidad": 2.0,
      "monto": null
    }
  ]
}

// sucursales[]
{ "nrosucursal": 1, "descripcion": "CASA CENTRAL" }

// mediosdepago[]
{ "idmdep": 1, "subidmdep": 10, "cuotanumero": 0, "descripcion": "EFECTIVO" }
// Match: idmdep + subidmdep + cuotanumero  ↔  tiposdepago.id + idid + cuota

{
  "id": 1,
  "promocionid": 1,
  "descripcion": "PROMO_2X1_ARROZ",
  "tipoPromo": "ITEM",
  "promocionestado": { "id": "APLICADA" },
  "monto": -1310.0,
  "elementos": [
    { "movimientoid": 1, "articuloid": 1,
      "unidadesimpactadas": 1.0, "monto": -655.0 },
    { "movimientoid": 2, "articuloid": 1,
      "unidadesimpactadas": 1.0, "monto": -655.0 }
  ]
}

// Algoritmo principal
Repetir hasta que no haya más combos posibles:

  A) Para cada promo COMBO activa:
       — Identificar ítems disponibles (no consumidos) en sus listas
       — Generar TODAS las combinaciones posibles de (LISTA1 × LISTA2)
       — Calcular descuento = Σ(precios ítems) − precio_combo (LISTA3)
       — Registrar la combinación de máximo descuento para esta promo

  B) Comparar el máximo de cada promo entre sí
     → Seleccionar la promo con mayor descuento global
     → En caso de empate: selección indiferente

  C) Marcar como CONSUMIDAS las unidades de esa combinación ganadora
     (solo las unidades usadas, no el ítem completo si quedan más)

  D) Registrar PROMOCION en movimientos[] y en promociones[]
     Distribuir descuento proporcionalmente al precio de cada ítem

  E) Volver a A) con el pool de ítems restantes

// Ticket: ATUN-A×3, ATUN-B×1, MAYONESA×1, PASCUALINA×2, TAPAS×1
// Promos: 260000 (2×ATUN + 1×PASCUALINA = $3.79)
//         261000 (2×ATUN + 1×MAYONESA   = $3.79)
//         263000 (1×PASCUALINA + 1×TAPAS = $3.00)

// ITERACION 1: Evalúa los 3 combos simultáneamente
260000: mejor combinación → ATUN-A + ATUN-B + PASCUALINA = $12 − $3.79 = −$8.21
261000: mejor combinación → ATUN-A + ATUN-B + MAYONESA  = $13 − $3.79 = −$9.21  ← ganador
263000: mejor combinación → PASCUALINA + TAPAS          = $7  − $3.00 = −$4.00

// Consume: ATUN-A×1, ATUN-B×1, MAYONESA×1

// ITERACION 2: Remanente: ATUN-A×2, PASCUALINA×2, TAPAS×1
260000: ATUN-A×2 + PASCUALINA × 1 = $11 − $3.79 = −$7.21  ← ganador
261000: sin MAYONESA → no aplica
263000: PASCUALINA + TAPAS = −$4.00

// Consume: ATUN-A×2, PASCUALINA×1

// ITERACION 3: Remanente: PASCUALINA×1, TAPAS×1
263000: PASCUALINA + TAPAS = −$4.00  ← único disponible

// RESULTADO: −$9.21 + −$7.21 + −$4.00 = −$20.42
// TOTAL TICKET: $31 − $20.42 = $10.58

1. Recibir mediodepagoid (idmdep + subidmdep + cuotanumero)
2. Filtrar listapromociones donde mediosdepago[] contiene ese medio
3. Para cada promo encontrada verificar:
   — Vigencia activa (fecha, hora, día de semana)
   — Sucursal del ticket en sucursales[] (si no vacío)
   — cliente.convenio.id en conveniosclientes[] (si no vacío)
   — Condiciones de ítems (excluyelistaofertas, excluyeventamayorista)
   — Ítems del ticket presentes en listasitems[]
4. Calcular beneficio sobre precio resultante post-promos ITEM de cada ítem
5. Retornar: promocionesdisponibles[], saldoneto
6. NO modificar el ticket

com.tipre.ruleengine
├── model/
│   ├── Ticket.java
│   ├── Item.java
│   ├── Articulo.java
│   ├── Movimiento.java
│   ├── Pago.java
│   ├── Promocion.java
│   └── NucleoImpositivo.java
├── model/enums/
│   ├── TipoConcepto.java         // VENTA_ITEM, PROMOCION, PAGO
│   ├── NivelPrecio.java          // MINORISTA, MAYORISTA1..3, GRUPOMAY1..3, VTABULTO
│   ├── MetodoComputo.java        // MAYORISTA, VENTAXBULTO, GRUPOMAYORISTA, COMBO, CANTIDAD
│   ├── TipoBeneficio.java        // PORCENTAJE_DESCUENTO, MONTO_DESCUENTO, etc.
│   └── PromoEstado.java          // POSIBLE, APLICADA, NOAPLICA, ANULADA
├── model/catalog/
│   ├── ListaPromociones.java
│   ├── DefinicionPromocion.java
│   ├── TipoDePago.java
│   ├── Vigencia.java
│   ├── Condiciones.java
│   └── ListaItem.java
├── logic/
│   └── MotorPromociones.java
├── logic/item/
│   ├── ModoItemProcessor.java
│   ├── MayoristaEvaluator.java
│   ├── CantidadEvaluator.java
│   └── ComboEvaluator.java       // Greedy recursivo
├── logic/pago/
│   ├── ModoPagoConsulta.java
│   ├── ModoPagoAplicar.java
│   └── VueltoResolver.java       // Casos A/B/C
├── validation/
│   ├── ReconciliacionValidator.java
│   └── LedgerConsistencyChecker.java
└── example/
    └── TicketConPromocion2x1.java

// Clase de trabajo en memoria durante el cómputo ITEM
// NO persiste en el modelo — solo vive durante el pipeline
record ItemPricingView(
    int           itemId,
    int           articuloId,
    int           movimientoId,
    BigDecimal    precioBase,         // preciolista original
    BigDecimal    precioVigente,      // se actualiza en cada paso
    NivelPrecio   nivelVigente,       // comienza MINORISTA
    boolean       mayorista,
    boolean       vtaBulto,
    boolean       acumulativaAplicada
) {}

public class ComboEvaluator {

  public List<ComboResult> evaluar(
      List<ItemPricingView> items,
      List<DefinicionPromocion> combos,
      LocalDateTime ahora) {

    List<ComboResult> resultados = new ArrayList<>();
    // Multiset mutable de unidades disponibles
    Map<Integer, BigDecimal> pool = buildPool(items);

    boolean hayMas = true;
    while (hayMas) {
      Map<DefinicionPromocion, ComboCandidate> mejores = new LinkedHashMap<>();
      for (DefinicionPromocion promo : combos) {
        if (!promo.getVigencia().estaActiva(ahora)) continue;
        generarMejorCombinacion(promo, items, pool)
            .ifPresent(c -> mejores.put(promo, c));
      }

      Optional<ComboCandidate> ganador = mejores.values().stream()
          .max(Comparator.comparing(ComboCandidate::descuento));

      if (ganador.isEmpty()) {
        hayMas = false;
      } else {
        consumirPool(pool, ganador.get());
        resultados.add(new ComboResult(
            ganador.get(),
            distribuirDescuento(ganador.get())));
      }
    }
    return resultados;
  }
}

private List<BigDecimal> distribuirDescuento(ComboCandidate c) {
    BigDecimal total     = c.subtotalItems();
    BigDecimal descuento = total.subtract(c.precioCombo()); // positivo
    List<BigDecimal> partes = new ArrayList<>();
    BigDecimal acum = BigDecimal.ZERO;

    for (int i = 0; i < c.items().size(); i++) {
        BigDecimal parte;
        if (i == c.items().size() - 1) {
            parte = descuento.subtract(acum); // absorbe residuo
        } else {
            parte = descuento
                .multiply(c.items().get(i).precioVigente())
                .divide(total, 8, RoundingMode.HALF_UP);
            acum = acum.add(parte);
        }
        partes.add(parte.negate()); // negativo en ledger
    }
    return partes;
    // Garantía: Σ partes == descuentoTotal
}

record NucleoComponente(String impuestoId, BigDecimal monto) {
    NucleoComponente negate() {
        return new NucleoComponente(impuestoId, monto.negate());
    }
    NucleoComponente add(NucleoComponente other) {
        return new NucleoComponente(impuestoId, monto.add(other.monto));
    }
}

record Vigencia(
    LocalDate     fechaDesde,
    LocalDate     fechaHasta,
    Set<DayOfWeek> diasSemana,
    int           horaDesde,
    int           horaHasta
) {
    boolean estaActiva(LocalDateTime ahora) {
        return !ahora.toLocalDate().isBefore(fechaDesde)
            && !ahora.toLocalDate().isAfter(fechaHasta)
            && diasSemana.contains(ahora.getDayOfWeek())
            && ahora.getHour() >= horaDesde
            && ahora.getHour() <= horaHasta;
    }
}

public enum NivelPrecio {
    MINORISTA, MAYORISTA1, MAYORISTA2, MAYORISTA3,
    GRUPOMAY1, GRUPOMAY2, GRUPOMAY3, VTABULTO;

    public boolean esMayorista() {
        return this == MAYORISTA1 || this == MAYORISTA2 || this == MAYORISTA3;
    }
    public boolean esVtaBulto()        { return this == VTABULTO; }
    public boolean esGrupoMayorista()  {
        return this == GRUPOMAY1 || this == GRUPOMAY2 || this == GRUPOMAY3;
    }
}

public enum TipoConcepto     { VENTA_ITEM, PROMOCION, PAGO }
public enum MetodoComputo    { MAYORISTA, VENTAXBULTO, GRUPOMAYORISTA, COMBO, CANTIDAD }
public enum TipoBeneficio    {
    PORCENTAJE_DESCUENTO, PORCENTAJE_RECARGO,
    MONTO_DESCUENTO, MONTO_RECARGO,
    NUEVOPRECIOITEM, NO_PERMITIR_VENTA_ITEM, EAN_COMBO, CUPON
}
public enum PromoEstado      { POSIBLE, APLICADA, NOAPLICA, ANULADA }

@Component
public class ReconciliacionValidator {

    public ValidationResult validate(Ticket ticket) {
        Map<String, BigDecimal> sumas = new HashMap<>();

        ticket.getMovimientos().forEach(mov ->
            mov.getNucleoImpositivo().forEach(comp ->
                sumas.merge(comp.impuestoId(), comp.monto(), BigDecimal::add)
            )
        );

        List<String> errores = sumas.entrySet().stream()
            .filter(e -> e.getValue().compareTo(BigDecimal.ZERO) != 0)
            .map(e -> "Impuesto " + e.getKey()
                    + " no cierra: " + e.getValue())
            .toList();

        return errores.isEmpty()
            ? ValidationResult.ok()
            : ValidationResult.fail(errores);
    }
}

// Uso en test:
ReconciliacionValidator v = new ReconciliacionValidator();
ValidationResult r = v.validate(ticket);
assertThat(r.isOk()).isTrue(); // Σ movimientos[] == 0

public class VueltoResolver {

  public VueltoResult resolver(
      TipoDePago tipoPago,
      BigDecimal excedente,
      List<TipoDePago> catalogo) {

    if (tipoPago.isDaVuelto()) {
      return VueltoResult.mismoMedio(excedente);         // Caso A
    }

    if (tipoPago.getVueltoMedioDePago() == null) {
      return VueltoResult.denegado();                    // Caso B
    }

    TipoDePago alt = catalogo.stream()
        .filter(m -> m.getId() == tipoPago.getVueltoMedioDePago())
        .findFirst()
        .orElseThrow();

    return VueltoResult.medioAlternativo(alt, excedente); // Caso C
  }
}