// src/dominio/pedido.js — todo lo marcado se COPIA, no se referencia
const crearLineaPedido = ({ variante, producto, cantidad }) => ({
  varianteId: variante.id, sku: variante.sku, cantidad,
  nombreProducto: producto.nombre,                       // congelado
  talla: variante.talla, color: variante.color,          // congelados
  precioUnitarioCentimos: variante.precioCentimos,       // congelado: lo esencial
  importeCentimos: variante.precioCentimos * cantidad,
});
module.exports = { crearLineaPedido };

// src/servicios/carritos.js
async function fusionarCarritos({ repositorioCarritos, tokenInvitado, usuarioId }) {
  const invitado = await repositorioCarritos.buscarPorToken(tokenInvitado);
  if (!invitado) return repositorioCarritos.obtenerOCrearDeUsuario(usuarioId);
  const propio = await repositorioCarritos.obtenerOCrearDeUsuario(usuarioId);
  for (const linea of invitado.lineas) {
    const existente = propio.lineas.find((l) => l.varianteId === linea.varianteId);
    // Regla de negocio: sumar cantidades, nunca reemplazar en silencio.
    // Reemplazar hace que el usuario "pierda" lo que acababa de añadir.
    if (existente) existente.cantidad = Math.min(existente.cantidad + linea.cantidad, LIMITE_LINEA);
    else propio.lineas.push(linea);
  }
  await repositorioCarritos.guardar(propio);
  await repositorioCarritos.eliminar(invitado.id);
  return propio;
}
module.exports = { fusionarCarritos };

// src/servicios/calculo-importe.js
const TIPO_IVA_POR_MIL = 210;   // 21 % en por mil, para no usar decimales
const UMBRAL_ENVIO_GRATIS = 5000;
const ENVIO_ESTANDAR = 495;
function calcularImporte({ lineas, envioCentimos }) {
  const subtotalCentimos = lineas.reduce(
    (suma, l) => suma + l.precioUnitarioCentimos * l.cantidad, 0);
  // Redondeo al céntimo una sola vez y sobre el subtotal completo.
  // Redondear línea a línea acumula desviaciones de hasta N/2 céntimos.
  const impuestosCentimos = Math.round((subtotalCentimos * TIPO_IVA_POR_MIL) / 1000);
  return { subtotalCentimos, impuestosCentimos, envioCentimos,
           totalCentimos: subtotalCentimos + impuestosCentimos + envioCentimos };
}
// Función pura del subtotal: probable sin base de datos.
const calcularEnvio = (subtotal) => subtotal === 0 ? 0
  : (subtotal >= UMBRAL_ENVIO_GRATIS ? 0 : ENVIO_ESTANDAR);
module.exports = { calcularImporte, calcularEnvio, TIPO_IVA_POR_MIL };

// src/repositorios/inventario-sql.js
async function reservarStock({ sequelize, lineas, pedidoId, minutos = 20 }) {
  return sequelize.transaction(async (t) => {
    for (const linea of lineas) {
      // SELECT ... FOR UPDATE serializa a los compradores de la misma variante.
      const [variante] = await sequelize.query(
        'SELECT stock, stock_reservado FROM variantes WHERE id = :id FOR UPDATE',
        { replacements: { id: linea.varianteId }, type: SELECT, transaction: t });
      const disponible = variante.stock - variante.stock_reservado;
      // Error de dominio del M6: el manejador central lo traduce a 409.
      if (disponible < linea.cantidad) throw new ConflictoDeEstado('STOCK_INSUFICIENTE',
        { sku: linea.sku, solicitado: linea.cantidad, disponible });
      await sequelize.query(
        'UPDATE variantes SET stock_reservado = stock_reservado + :n WHERE id = :id',
        { replacements: { n: linea.cantidad, id: linea.varianteId }, transaction: t });
    }
    await repositorioInventario.crearReserva({ pedidoId, minutos }, t);
  });
}

// src/servicios/pagos.js
async function crearIntencionDePago({ pedido, usuario }) {
  const intencion = await stripe.paymentIntents.create({
    amount: pedido.totalCentimos,   // el importe lo fija el servidor (punto 5)
    currency: pedido.moneda,        // 'eur'
    // La metadata es el puente entre el mundo de Stripe y el nuestro.
    metadata: { pedidoId: pedido.id, usuarioId: usuario.id },
    receipt_email: usuario.correo,  // [email protected]
    automatic_payment_methods: { enabled: true },
  // Idempotencia hacia fuera: si reintentamos, Stripe no crea dos intenciones.
  }, { idempotencyKey: `intencion-${pedido.id}` });
  return { referenciaExterna: intencion.id, clientSecret: intencion.client_secret };
}
module.exports = { crearIntencionDePago, stripe };

// src/app.js — extracto del orden de middleware
function crearAplicacion(dependencias = {}) {
  const aplicacion = express();
  aplicacion.use(helmet());
  aplicacion.use(idPeticion);
  // ORDEN CRÍTICO: el webhook necesita Buffer, no objeto.
  aplicacion.use('/api/v1/webhooks/pagos',
    express.raw({ type: 'application/json', limit: '1mb' }),
    crearRutasWebhookPagos(dependencias));
  aplicacion.use(express.json({ limit: '100kb' }));  // el resto sí usa JSON
  // ... routers normales y manejador de errores central (M6) ...
  return aplicacion;
}

// src/rutas/webhook-pagos.js
rutas.post('/', async (peticion, respuesta) => {
  let evento;
  try {
    // peticion.body es un Buffer gracias a express.raw.
    evento = stripe.webhooks.constructEvent(peticion.body,
      peticion.get('stripe-signature'), configuracion.stripe.secretoWebhook);
  } catch (error) {
    return respuesta.status(400).json({ error: { codigo: 'FIRMA_INVALIDA',
      mensaje: 'Firma no verificable', estado: 400, detalles: null } });
  }
  // Idempotencia: Stripe reintenta durante días si no respondes 2xx.
  // evento.id hace de Idempotency-Key (M10), persistido en base de datos.
  const esNuevo = await repositorioEventosPago.registrarSiEsNuevo(evento.id, evento.type);
  if (!esNuevo) return respuesta.status(200).json({ recibido: true, repetido: true });
  try {
    const objeto = evento.data.object;
    if (evento.type === 'payment_intent.succeeded') {
      await servicioPedidos.confirmarPago({ pedidoId: objeto.metadata.pedidoId,
        referenciaExterna: objeto.id, importeCentimos: objeto.amount_received });
    } else if (evento.type === 'payment_intent.payment_failed') {
      await servicioPedidos.marcarPagoFallido({ pedidoId: objeto.metadata.pedidoId });
    }
    return respuesta.status(200).json({ recibido: true });  // 200 rápido, cola aparte
  } catch (error) {
    // Un 500 hace que Stripe reintente: correcto ante fallo transitorio.
    await repositorioEventosPago.marcarFallido(evento.id, error.message);
    return respuesta.status(500).json({ error: { codigo: 'ERROR_INTERNO',
      mensaje: 'Reintentar', estado: 500, detalles: null } });
  }
});

// src/dominio/estados-pedido.js
const TRANSICIONES = {
  carrito: ['pendiente_pago'],
  pendiente_pago: ['pagado', 'cancelado'],
  pagado: ['preparando', 'reembolsado', 'cancelado'],
  preparando: ['enviado', 'reembolsado'],
  enviado: ['entregado', 'reembolsado'],
  entregado: ['reembolsado'],
  cancelado: [], reembolsado: [],   // estados terminales: no hay salida
};

function transitar(pedido, estadoNuevo) {
  const permitidos = TRANSICIONES[pedido.estado] ?? [];
  if (!permitidos.includes(estadoNuevo)) throw new ConflictoDeEstado('TRANSICION_INVALIDA',
    { estadoActual: pedido.estado, estadoSolicitado: estadoNuevo, permitidos });
  return { ...pedido, estado: estadoNuevo, actualizadoEn: new Date().toISOString() };
}
module.exports = { transitar, TRANSICIONES };

// src/servicios/pedidos.js — extracto
async function confirmarPago({ pedidoId, referenciaExterna, importeCentimos }) {
  const pedido = await repositorioPedidos.obtener(pedidoId);
  if (!pedido) throw new RecursoNoEncontrado('PEDIDO_NO_ENCONTRADO', { pedidoId });
  // Defensa: el importe cobrado debe coincidir con el calculado.
  if (importeCentimos !== pedido.totalCentimos) throw new ConflictoDeEstado(
    'IMPORTE_DESCUADRADO', { pedidoId, importeCentimos });
  const confirmado = transitar(pedido, 'pagado');
  // Consume la reserva en transacción: stock -= n, stockReservado -= n.
  await repositorioPedidos.confirmarEnTransaccion({ pedido: confirmado, referenciaExterna });
  // jobId fijo = idempotencia gratis: BullMQ rechaza un id ya existente,
  // así que aunque el webhook se procesara dos veces el correo sale una.
  await colaCorreos.add('confirmacion-pedido', { pedidoId }, { attempts: 5,
    backoff: { type: 'exponential', delay: 2000 }, jobId: `confirmacion-${pedidoId}` });
  await colaFacturas.add('generar-factura', { pedidoId }, { jobId: `factura-${pedidoId}` });
  return confirmado;
}

// test/tienda/checkout.test.js
describe('checkout de la tienda', () => {
  it('rechaza un webhook con firma invalida', async () => {
    await peticion(crearAplicacion()).post('/api/v1/webhooks/pagos')
      .set('stripe-signature', 't=1,v1=falsa').set('Content-Type', 'application/json')
      .send(Buffer.from(JSON.stringify({ type: 'payment_intent.succeeded' })))
      .expect(400)
      .expect((r) => expect(r.body.error.codigo).to.equal('FIRMA_INVALIDA'));
  });
  it('impide la sobreventa con dos compras simultaneas de la ultima unidad', async () => {
    await sembrarVariante({ sku: 'EV-VIN-003-UNI', stock: 1 });
    const resultados = await Promise.allSettled([
      iniciarPago({ sku: 'EV-VIN-003-UNI', cantidad: 1, usuario: 'usr-lucia' }),
      iniciarPago({ sku: 'EV-VIN-003-UNI', cantidad: 1, usuario: 'usr-marc' }),
    ]);
    expect(resultados.filter((r) => r.status === 'fulfilled')).to.have.lengthOf(1);
    expect(resultados.find((r) => r.status === 'rejected').reason.codigo)
      .to.equal('STOCK_INSUFICIENTE');
  });
  it('ignora un payment_failed posterior a la confirmacion', async () => {
    await enviarWebhookFirmado(eventoExito);
    await enviarWebhookFirmado(eventoFalloTardio);
    expect((await repositorioPedidos.obtener('ped-8812')).estado).to.equal('pagado');
  });
});

// src/colas/mantenimiento.js
await colaMantenimiento.add('liberar-reservas', {},
  { repeat: { every: 60_000 }, jobId: 'liberar-reservas-repetible' });
new Worker('mantenimiento', async () => {
  for (const reserva of await repositorioInventario.reservasCaducadas()) {
    await sequelize.transaction(async (t) => {
      for (const linea of reserva.lineas) {
        await sequelize.query(
          'UPDATE variantes SET stock_reservado = stock_reservado - :n WHERE id = :id',
          { replacements: { n: linea.cantidad, id: linea.varianteId }, transaction: t });
      }
      // La condición de estado es imprescindible: sin ella, una carrera
      // con el webhook cancelaría un pedido que ya se ha cobrado.
      await sequelize.query(
        `UPDATE pedidos SET estado = 'cancelado' WHERE id = :id AND estado = 'pendiente_pago'`,
        { replacements: { id: reserva.pedidoId }, transaction: t });
      await repositorioInventario.eliminarReserva(reserva.id, t);
    });
  }
}, { connection });

it('cobra envio en 4999 y no en 5000', () => {
  expect(calcularEnvio(4999)).to.equal(495);
  expect(calcularEnvio(5000)).to.equal(0);
});
it('calcula el IVA sobre el subtotal completo', () => {
  const lineas = [{ precioUnitarioCentimos: 1999, cantidad: 3 }];
  const r = calcularImporte({ lineas, envioCentimos: calcularEnvio(5997) });
  expect(r.subtotalCentimos).to.equal(5997);
  expect(r.impuestosCentimos).to.equal(1259);  // round(5997 * 210 / 1000)
  expect(r.totalCentimos).to.equal(7256);
});
it('devuelve todo a cero con el carrito vacio', () => {
  expect(calcularImporte({ lineas: [], envioCentimos: 0 }).totalCentimos).to.equal(0);
});

async function registrarSiEsNuevo(eventoId, tipo) {
  // ON CONFLICT DO NOTHING RETURNING hace comprobación e inserción en una
  // sola sentencia atómica: no hay ventana de carrera entre dos procesos.
  const [filas] = await sequelize.query(
    `INSERT INTO eventos_pago (evento_id, tipo) VALUES (:eventoId, :tipo)
     ON CONFLICT (evento_id) DO NOTHING RETURNING evento_id`,
    { replacements: { eventoId, tipo } });
  return filas.length > 0;   // false si ya existía: es un reenvío
}

it('procesa una sola vez con entregas simultaneas', async () => {
  const espia = sinon.spy(servicioPedidos, 'confirmarPago');
  await Promise.all([enviarWebhookFirmado(eventoExito), enviarWebhookFirmado(eventoExito)]);
  expect(espia.callCount).to.equal(1);
});