// src/domini/comanda.js — tot el que va marcat es COPIA, no es referencia
const crearLiniaComanda = ({ variant, producte, quantitat }) => ({
  variantId: variant.id, sku: variant.sku, quantitat,
  nomProducte: producte.nom,                          // congelat
  talla: variant.talla, color: variant.color,         // congelats
  preuUnitariCentims: variant.preuCentims,            // congelat: l'essencial
  importCentims: variant.preuCentims * quantitat,
});
module.exports = { crearLiniaComanda };

// src/serveis/cistelles.js
async function fusionarCistelles({ repositoriCistelles, tokenConvidat, usuariId }) {
  const convidada = await repositoriCistelles.cercarPerToken(tokenConvidat);
  if (!convidada) return repositoriCistelles.obtenirOCrearDUsuari(usuariId);
  const propia = await repositoriCistelles.obtenirOCrearDUsuari(usuariId);
  for (const linia of convidada.linies) {
    const existent = propia.linies.find((l) => l.variantId === linia.variantId);
    // Regla de negoci: sumar quantitats, mai reemplacar en silenci.
    // Reemplacar fa que l'usuari "perdi" el que acabava d'afegir.
    if (existent) existent.quantitat = Math.min(existent.quantitat + linia.quantitat, LIMIT_LINIA);
    else propia.linies.push(linia);
  }
  await repositoriCistelles.guardar(propia);
  await repositoriCistelles.eliminar(convidada.id);
  return propia;
}
module.exports = { fusionarCistelles };

// src/serveis/calcul-import.js
const TIPUS_IVA_PER_MIL = 210;   // 21 % en per mil, per no fer servir decimals
const LLINDAR_ENVIAMENT_GRATIS = 5000;
const ENVIAMENT_ESTANDARD = 495;
function calcularImport({ linies, enviamentCentims }) {
  const subtotalCentims = linies.reduce(
    (suma, l) => suma + l.preuUnitariCentims * l.quantitat, 0);
  // Arrodoniment al centim una sola vegada i sobre el subtotal complet.
  // Arrodonir linia a linia acumula desviacions de fins a N/2 centims.
  const impostosCentims = Math.round((subtotalCentims * TIPUS_IVA_PER_MIL) / 1000);
  return { subtotalCentims, impostosCentims, enviamentCentims,
           totalCentims: subtotalCentims + impostosCentims + enviamentCentims };
}
// Funcio pura del subtotal: provable sense base de dades.
const calcularEnviament = (subtotal) => subtotal === 0 ? 0
  : (subtotal >= LLINDAR_ENVIAMENT_GRATIS ? 0 : ENVIAMENT_ESTANDARD);
module.exports = { calcularImport, calcularEnviament, TIPUS_IVA_PER_MIL };

// src/repositoris/inventari-sql.js
async function reservarStock({ sequelize, linies, comandaId, minuts = 20 }) {
  return sequelize.transaction(async (t) => {
    for (const linia of linies) {
      // SELECT ... FOR UPDATE serialitza els compradors de la mateixa variant.
      const [variant] = await sequelize.query(
        'SELECT stock, stock_reservat FROM variants WHERE id = :id FOR UPDATE',
        { replacements: { id: linia.variantId }, type: SELECT, transaction: t });
      const disponible = variant.stock - variant.stock_reservat;
      // Error de domini del M6: el gestor central el tradueix a 409.
      if (disponible < linia.quantitat) throw new ConflicteDEstat('STOCK_INSUFICIENT',
        { sku: linia.sku, sollicitat: linia.quantitat, disponible });
      await sequelize.query(
        'UPDATE variants SET stock_reservat = stock_reservat + :n WHERE id = :id',
        { replacements: { n: linia.quantitat, id: linia.variantId }, transaction: t });
    }
    await repositoriInventari.crearReserva({ comandaId, minuts }, t);
  });
}

// src/serveis/pagaments.js
async function crearIntencioDePagament({ comanda, usuari }) {
  const intencio = await stripe.paymentIntents.create({
    amount: comanda.totalCentims,   // l'import el fixa el servidor (punt 5)
    currency: comanda.moneda,       // 'eur'
    // La metadata es el pont entre el mon de Stripe i el nostre.
    metadata: { comandaId: comanda.id, usuariId: usuari.id },
    receipt_email: usuari.correu,   // [email protected]
    automatic_payment_methods: { enabled: true },
  // Idempotencia cap a fora: si reintentem, Stripe no crea dues intencions.
  }, { idempotencyKey: `intencio-${comanda.id}` });
  return { referenciaExterna: intencio.id, clientSecret: intencio.client_secret };
}
module.exports = { crearIntencioDePagament, stripe };

// src/app.js — extracte de l'ordre de middleware
function crearAplicacio(dependencies = {}) {
  const aplicacio = express();
  aplicacio.use(helmet());
  aplicacio.use(idPeticio);
  // ORDRE CRITIC: el webhook necessita Buffer, no objecte.
  aplicacio.use('/api/v1/webhooks/pagaments',
    express.raw({ type: 'application/json', limit: '1mb' }),
    crearRutesWebhookPagaments(dependencies));
  aplicacio.use(express.json({ limit: '100kb' }));  // la resta si que fa servir JSON
  // ... enrutadors normals i gestor d'errors central (M6) ...
  return aplicacio;
}

// src/rutes/webhook-pagaments.js
rutes.post('/', async (peticio, resposta) => {
  let esdeveniment;
  try {
    // peticio.body es un Buffer gracies a express.raw.
    esdeveniment = stripe.webhooks.constructEvent(peticio.body,
      peticio.get('stripe-signature'), configuracio.stripe.secretWebhook);
  } catch (error) {
    return resposta.status(400).json({ error: { codi: 'SIGNATURA_INVALIDA',
      missatge: 'Signatura no verificable', estat: 400, detalls: null } });
  }
  // Idempotencia: Stripe reintenta durant dies si no respons 2xx.
  // esdeveniment.id fa d'Idempotency-Key (M10), persistit a base de dades.
  const esNou = await repositoriEsdevenimentsPagament.registrarSiEsNou(esdeveniment.id, esdeveniment.type);
  if (!esNou) return resposta.status(200).json({ rebut: true, repetit: true });
  try {
    const objecte = esdeveniment.data.object;
    if (esdeveniment.type === 'payment_intent.succeeded') {
      await serveiComandes.confirmarPagament({ comandaId: objecte.metadata.comandaId,
        referenciaExterna: objecte.id, importCentims: objecte.amount_received });
    } else if (esdeveniment.type === 'payment_intent.payment_failed') {
      await serveiComandes.marcarPagamentFallit({ comandaId: objecte.metadata.comandaId });
    }
    return resposta.status(200).json({ rebut: true });  // 200 rapid, cua a part
  } catch (error) {
    // Un 500 fa que Stripe reintenti: correcte davant d'una fallada transitoria.
    await repositoriEsdevenimentsPagament.marcarFallit(esdeveniment.id, error.message);
    return resposta.status(500).json({ error: { codi: 'ERROR_INTERN',
      missatge: 'Reintentar', estat: 500, detalls: null } });
  }
});

// src/domini/estats-comanda.js
const TRANSICIONS = {
  cistella: ['pendent_pagament'],
  pendent_pagament: ['pagat', 'cancellat'],
  pagat: ['preparant', 'retornat', 'cancellat'],
  preparant: ['enviat', 'retornat'],
  enviat: ['lliurat', 'retornat'],
  lliurat: ['retornat'],
  cancellat: [], retornat: [],   // estats terminals: no hi ha sortida
};

function transitar(comanda, estatNou) {
  const permesos = TRANSICIONS[comanda.estat] ?? [];
  if (!permesos.includes(estatNou)) throw new ConflicteDEstat('TRANSICIO_INVALIDA',
    { estatActual: comanda.estat, estatSollicitat: estatNou, permesos });
  return { ...comanda, estat: estatNou, actualitzatEl: new Date().toISOString() };
}
module.exports = { transitar, TRANSICIONS };

// src/serveis/comandes.js — extracte
async function confirmarPagament({ comandaId, referenciaExterna, importCentims }) {
  const comanda = await repositoriComandes.obtenir(comandaId);
  if (!comanda) throw new RecursNoTrobat('COMANDA_NO_TROBADA', { comandaId });
  // Defensa: l'import cobrat ha de coincidir amb el calculat.
  if (importCentims !== comanda.totalCentims) throw new ConflicteDEstat(
    'IMPORT_DESQUADRAT', { comandaId, importCentims });
  const confirmada = transitar(comanda, 'pagat');
  // Consumeix la reserva en transaccio: stock -= n, stockReservat -= n.
  await repositoriComandes.confirmarEnTransaccio({ comanda: confirmada, referenciaExterna });
  // jobId fix = idempotencia de franc: BullMQ rebutja un id ja existent,
  // aixi que encara que el webhook es processes dues vegades el correu surt una.
  await cuaCorreus.add('confirmacio-comanda', { comandaId }, { attempts: 5,
    backoff: { type: 'exponential', delay: 2000 }, jobId: `confirmacio-${comandaId}` });
  await cuaFactures.add('generar-factura', { comandaId }, { jobId: `factura-${comandaId}` });
  return confirmada;
}

// test/botiga/pagament.test.js
describe('pagament de la botiga', () => {
  it('rebutja un webhook amb signatura invalida', async () => {
    await peticio(crearAplicacio()).post('/api/v1/webhooks/pagaments')
      .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.codi).to.equal('SIGNATURA_INVALIDA'));
  });
  it("impedeix la sobrevenda amb dues compres simultanies de l'ultima unitat", async () => {
    await sembrarVariant({ sku: 'EV-VIN-003-UNI', stock: 1 });
    const resultats = await Promise.allSettled([
      iniciarPagament({ sku: 'EV-VIN-003-UNI', quantitat: 1, usuari: 'usr-lucia' }),
      iniciarPagament({ sku: 'EV-VIN-003-UNI', quantitat: 1, usuari: 'usr-marc' }),
    ]);
    expect(resultats.filter((r) => r.status === 'fulfilled')).to.have.lengthOf(1);
    expect(resultats.find((r) => r.status === 'rejected').reason.codi)
      .to.equal('STOCK_INSUFICIENT');
  });
  it('ignora un payment_failed posterior a la confirmacio', async () => {
    await enviarWebhookSignat(esdevenimentExit);
    await enviarWebhookSignat(esdevenimentFallidaTardana);
    expect((await repositoriComandes.obtenir('ped-8812')).estat).to.equal('pagat');
  });
});

// src/cues/manteniment.js
await cuaManteniment.add('alliberar-reserves', {},
  { repeat: { every: 60_000 }, jobId: 'alliberar-reserves-repetible' });
new Worker('manteniment', async () => {
  for (const reserva of await repositoriInventari.reservesCaducades()) {
    await sequelize.transaction(async (t) => {
      for (const linia of reserva.linies) {
        await sequelize.query(
          'UPDATE variants SET stock_reservat = stock_reservat - :n WHERE id = :id',
          { replacements: { n: linia.quantitat, id: linia.variantId }, transaction: t });
      }
      // La condicio d'estat es imprescindible: sense ella, una carrera
      // amb el webhook cancellaria una comanda que ja s'ha cobrat.
      await sequelize.query(
        `UPDATE comandes SET estat = 'cancellat' WHERE id = :id AND estat = 'pendent_pagament'`,
        { replacements: { id: reserva.comandaId }, transaction: t });
      await repositoriInventari.eliminarReserva(reserva.id, t);
    });
  }
}, { connection });

it('cobra enviament a 4999 i no a 5000', () => {
  expect(calcularEnviament(4999)).to.equal(495);
  expect(calcularEnviament(5000)).to.equal(0);
});
it("calcula l'IVA sobre el subtotal complet", () => {
  const linies = [{ preuUnitariCentims: 1999, quantitat: 3 }];
  const r = calcularImport({ linies, enviamentCentims: calcularEnviament(5997) });
  expect(r.subtotalCentims).to.equal(5997);
  expect(r.impostosCentims).to.equal(1259);  // round(5997 * 210 / 1000)
  expect(r.totalCentims).to.equal(7256);
});
it('retorna tot a zero amb la cistella buida', () => {
  expect(calcularImport({ linies: [], enviamentCentims: 0 }).totalCentims).to.equal(0);
});

async function registrarSiEsNou(esdevenimentId, tipus) {
  // ON CONFLICT DO NOTHING RETURNING fa comprovacio i insercio en una
  // sola sentencia atomica: no hi ha finestra de carrera entre dos processos.
  const [files] = await sequelize.query(
    `INSERT INTO esdeveniments_pagament (esdeveniment_id, tipus) VALUES (:esdevenimentId, :tipus)
     ON CONFLICT (esdeveniment_id) DO NOTHING RETURNING esdeveniment_id`,
    { replacements: { esdevenimentId, tipus } });
  return files.length > 0;   // false si ja existia: es un reenviament
}

it('processa una sola vegada amb lliuraments simultanis', async () => {
  const espia = sinon.spy(serveiComandes, 'confirmarPagament');
  await Promise.all([enviarWebhookSignat(esdevenimentExit), enviarWebhookSignat(esdevenimentExit)]);
  expect(espia.callCount).to.equal(1);
});