<!-- El problema de l'ambit global compartit -->
<script src="cataleg.js"></script>    <!-- defineix: var cataleg = [...] -->
<script src="informes.js"></script>   <!-- tambe defineix: var cataleg = {} -->
<!-- El segon trepitja el primer. Ningu no avisa. Tot es trenca. -->

// src/utils/format.js
// PRIVAT: ningu de fora d'aquest fitxer pot veure aquesta constant.
const SIMBOL_MONEDA = 'EUR';

// PRIVAT: funcio auxiliar interna.
function partirCentims(centims) {
  return { euros: Math.floor(centims / 100), resta: centims % 100 };
}

// PUBLIC: nomes aixo surt del modul.
function formatarPreu(centims) {
  const { euros, resta } = partirCentims(centims);
  return `${euros},${String(resta).padStart(2, '0')} ${SIMBOL_MONEDA}`;
}

module.exports = { formatarPreu };

// Un altre fitxer
const { formatarPreu } = require('./utils/format.js');

console.log(formatarPreu(2500));    // 25,00 EUR
console.log(SIMBOL_MONEDA);         // ReferenceError: no existeix aqui
console.log(partirCentims);         // ReferenceError: no existeix aqui

// Un objecte amb diverses coses (el mes habitual)
module.exports = { formatarPreu, formatarData };

// Una sola funcio
module.exports = function calcularOcupacio(sessio) { /* ... */ };

// Una sola classe
module.exports = class Esdeveniment { /* ... */ };

// Un array de dades
module.exports = [ { id: 'evt-001' }, { id: 'evt-002' } ];

// Un valor primitiu (rar, pero legal)
module.exports = 3000;

// Importar l'objecte complet
const format = require('./utils/format.js');
console.log(format.formatarPreu(2500));

// Desestructurar nomes el que necessites (preferit: es veu d'un cop d'ull
// que fa servir aquest fitxer)
const { formatarPreu } = require('./utils/format.js');

// Reanomenar en desestructurar, per evitar collisions
const { formatarPreu: preu } = require('./utils/format.js');

// El que Node fa, conceptualment, abans d'executar el teu codi:
const module = { exports: {} };
let exports = module.exports;   // <-- Totes dues apunten al MATEIX objecte

// src/utils/format.js
exports.formatarPreu = formatarPreu;   // Funciona
exports.formatarData = formatarData;   // Funciona

// Equivalent:
module.exports.formatarPreu = formatarPreu;

// MALAMENT: aixo NO exporta res.
exports = { formatarPreu, formatarData };

// src/laboratori/exports-trencat.js
exports = { hola: () => 'hola' };
console.log('Dins del modul, exports:', exports);              // { hola: [Function] }
console.log('Dins del modul, module.exports:', module.exports); // {}

// src/laboratori/provar-exports.js
const modul = require('./exports-trencat.js');
console.log(modul);          // {}   <- buit
console.log(modul.hola);     // undefined

const cataleg = [];
module.exports = { cataleg };

(function (exports, require, module, __filename, __dirname) {
  // ---- El teu codi va aqui, intacte ----
  const cataleg = [];
  module.exports = { cataleg };
  // --------------------------------------
});

// src/laboratori/embolcall.js
console.log(require('node:module').wrapper);

[
  '(function (exports, require, module, __filename, __dirname) { ',
  '\n});'
]

// src/laboratori/variables-modul.js
console.log('__filename:', __filename);
console.log('__dirname :', __dirname);
console.log('module.id :', module.id);        // '.' si es el punt d'entrada
console.log('this === module.exports:', this === module.exports);   // true
console.log("Es el punt d'entrada:", require.main === module);

const path = require('node:path');

// MALAMENT: depen de des d'on executis node.
const rutaDades = './dades/esdeveniments.json';

// BE: sempre correcta, executis des d'on executis.
const rutaDades = path.join(__dirname, '..', 'dades', 'esdeveniments.json');

// src/informes/ocupacio.js

function generarInformeOcupacio(cataleg) {
  // ... logica de l'informe ...
}

// Nomes si s'executa directament amb "node src/informes/ocupacio.js"
if (require.main === module) {
  const { cataleg } = require('../cataleg-dades.js');
  console.log(generarInformeOcupacio(cataleg));
}

module.exports = { generarInformeOcupacio };

require('./domini/esdeveniment')
// 1. ./domini/esdeveniment          (tal qual)
// 2. ./domini/esdeveniment.js       <-- normalment aqui
// 3. ./domini/esdeveniment.json
// 4. ./domini/esdeveniment.node     (complement binari en C++)

require('./domini')
// 1-4. L'anterior amb "domini"...
// 5. ./domini/package.json    -> llegeix el seu camp "main"
// 6. ./domini/index.js        <-- el patro habitual
// 7. ./domini/index.json

Des de /home/joan/escena-viva/src/servidor/rutes.js, require('express') cerca a:

/home/joan/escena-viva/src/servidor/node_modules/express
/home/joan/escena-viva/src/node_modules/express
/home/joan/escena-viva/node_modules/express          <-- normalment aqui
/home/joan/node_modules/express
/home/node_modules/express
/node_modules/express

console.log(module.paths);

// Torna directament l'array, sense JSON.parse.
const cataleg = require('./dades/esdeveniments.json');
console.log(cataleg.length);   // 3

// src/laboratori/comptador.js
console.log(">> El modul comptador.js s'esta AVALUANT");

let compte = 0;

function incrementar() {
  compte++;
  return compte;
}

function valor() {
  return compte;
}

module.exports = { incrementar, valor };

// src/laboratori/usar-comptador.js
console.log('--- Primer require ---');
const primer = require('./comptador.js');

console.log('--- Segon require ---');
const segon = require('./comptador.js');

console.log('--- Tercer require ---');
const tercer = require('./comptador.js');

console.log('');
console.log('Son el mateix objecte?', primer === segon, segon === tercer);

primer.incrementar();
primer.incrementar();
segon.incrementar();

console.log('Valor vist des de "primer":', primer.valor());
console.log('Valor vist des de "tercer":', tercer.valor());

--- Primer require ---
>> El modul comptador.js s'esta AVALUANT
--- Segon require ---
--- Tercer require ---

Son el mateix objecte? true true
Valor vist des de "primer": 3
Valor vist des de "tercer": 3

// src/dades/connexio.js
// El grup de connexions a la base de dades: un de sol a tot el proces.

const grup = crearGrupDeConnexions({ maxim: 20 });

module.exports = { grup };

// PERILL: la configuracio es mutable i global.
// src/config.js
module.exports = { limitEntradesPerComanda: 10 };

// En un altre fitxer, algu fa:
const config = require('./config.js');
config.limitEntradesPerComanda = 999;   // Ho canvia per a TOTA l'aplicacio

module.exports = Object.freeze({ limitEntradesPerComanda: 10 });

// En lloc d'exportar una instancia (singleton forcos)...
module.exports = { gestor: new GestorDeVendes(cataleg) };

// ...exporta la classe i deixa que cadascu creï la seva.
module.exports = { GestorDeVendes };

// Rutes de tots els moduls carregats
console.log(Object.keys(require.cache));

// Forcar que un modul es torni a avaluar al seguent require
delete require.cache[require.resolve('./comptador.js')];

const nou = require('./comptador.js');   // Es torna a avaluar: compte = 0

// src/laboratori/circular-a.js
console.log('A: comenca a avaluar-se');

const b = require('./circular-b.js');
console.log('A: b val', b);

module.exports = { nom: 'modul A' };
console.log("A: acaba d'avaluar-se");

// src/laboratori/circular-b.js
console.log('B: comenca a avaluar-se');

const a = require('./circular-a.js');
console.log('B: a val', a);          // <-- Aqui hi ha la sorpresa

module.exports = { nom: 'modul B' };
console.log("B: acaba d'avaluar-se");

node src/laboratori/circular-a.js

A: comenca a avaluar-se
B: comenca a avaluar-se
B: a val {}          <-- Objecte BUIT, no pas { nom: 'modul A' }
B: acaba d'avaluar-se
A: b val { nom: 'modul B' }
A: acaba d'avaluar-se

// A circular-b.js
const { crearEsdeveniment } = require('./circular-a.js');
crearEsdeveniment();   // TypeError: crearEsdeveniment is not a function

ABANS                                DESPRES
escena-viva/                         escena-viva/
├── dades/                           ├── dades/
│   └── esdeveniments.json           │   └── esdeveniments.json
└── src/                             └── src/
    ├── cataleg.js   <- dades            ├── cataleg.js       <- nomes presentacio
    │                   incrustades      ├── cataleg-dades.js <- nomes dades
    └── cataleg-dades.js  <- sense       ├── domini/
                       module.exports    │   ├── sessio.js
                                         │   ├── esdeveniment.js
                                         │   ├── gestor-vendes.js
                                         │   └── index.js
                                         └── utils/
                                             └── format.js

// src/utils/format.js
// Utilitats de presentacio d'Escena Viva.
// Sense dependencies: es el modul mes basic del projecte.

// Converteix 2500 (centims) en la cadena '25,00 EUR'.
function formatarPreu(centims) {
  const euros = Math.floor(centims / 100);
  const resta = String(centims % 100).padStart(2, '0');
  return `${euros},${resta} EUR`;
}

// Converteix '2026-10-03T20:00:00' en '03/10/2026 20:00'.
function formatarData(dataISO) {
  const data = new Date(dataISO);
  const dia = String(data.getDate()).padStart(2, '0');
  const mes = String(data.getMonth() + 1).padStart(2, '0');
  const any = data.getFullYear();
  const hora = String(data.getHours()).padStart(2, '0');
  const minut = String(data.getMinutes()).padStart(2, '0');
  return `${dia}/${mes}/${any} ${hora}:${minut}`;
}

// Genera un codi d'entrada: EV-2026-000123
function generarCodiEntrada(any, sequencia) {
  return `EV-${any}-${String(sequencia).padStart(6, '0')}`;
}

module.exports = { formatarPreu, formatarData, generarCodiEntrada };

// src/domini/sessio.js
// Una sessio es un passi concret d'un esdeveniment, amb data, aforament i preu.

const { formatarPreu, formatarData } = require('../utils/format.js');

class Sessio {
  // Camp privat: l'unica manera de modificar-lo es a traves de vendre().
  #venudes = 0;

  constructor({ id, dataHora, aforament, venudes = 0, preuCentims }) {
    this.id = id;
    this.dataHora = dataHora;
    this.aforament = aforament;
    this.preuCentims = preuCentims;
    this.#venudes = venudes;
  }

  get venudes() {
    return this.#venudes;
  }

  get lliures() {
    return this.aforament - this.#venudes;
  }

  get ocupacio() {
    return Math.round((this.#venudes / this.aforament) * 100);
  }

  get exhaurida() {
    return this.lliures === 0;
  }

  get preuEuros() {
    return (this.preuCentims / 100).toFixed(2);
  }

  // Recaptacio en centims, enter.
  get recaptacioCentims() {
    return this.#venudes * this.preuCentims;
  }

  vendre(quantitat = 1) {
    if (!Number.isInteger(quantitat) || quantitat < 1) {
      const error = new Error('La quantitat ha de ser un enter positiu');
      error.codi = 'QUANTITAT_INVALIDA';
      throw error;
    }
    if (quantitat > this.lliures) {
      const error = new Error(`Aforament insuficient a ${this.id}: en queden ${this.lliures}`);
      error.codi = 'AFORAMENT_INSUFICIENT';
      throw error;
    }

    this.#venudes += quantitat;
    return this.#venudes;
  }

  // Linia d'una sola fila per al llistat per consola.
  descriure() {
    return (
      `${formatarData(this.dataHora)}  ${formatarPreu(this.preuCentims)}  ` +
      `${this.lliures}/${this.aforament} lliures  (${this.ocupacio}% ocupat)` +
      (this.exhaurida ? '  [EXHAURIDA]' : '')
    );
  }

  // JSON.stringify crida automaticament a toJSON si existeix.
  // Sense aixo, el camp privat #venudes no apareixeria a la serialitzacio.
  toJSON() {
    return {
      id: this.id,
      dataHora: this.dataHora,
      aforament: this.aforament,
      venudes: this.#venudes,
      preuCentims: this.preuCentims
    };
  }
}

module.exports = { Sessio };

// src/domini/esdeveniment.js
// Un esdeveniment es un espectacle programat, amb una o diverses sessions.

const { Sessio } = require('./sessio.js');

class Esdeveniment {
  #sessions = [];

  constructor({ id, titol, sala, organitzador, categoria, duracioMinuts, estat = 'publicat', sessions = [] }) {
    this.id = id;
    this.titol = titol;
    this.sala = sala;
    this.organitzador = organitzador;
    this.categoria = categoria;
    this.duracioMinuts = duracioMinuts;
    this.estat = estat;

    // Convertim els objectes plans en instancies de Sessio.
    // Si ja ho son, els deixem tal com estan.
    this.#sessions = sessions.map((s) => (s instanceof Sessio ? s : new Sessio(s)));
  }

  get sessions() {
    // Copia defensiva: ningu de fora no pot afegir ni treure sessions.
    return [...this.#sessions];
  }

  get nombreSessions() {
    return this.#sessions.length;
  }

  get aforamentTotal() {
    return this.#sessions.reduce((total, s) => total + s.aforament, 0);
  }

  get entradesVenudes() {
    return this.#sessions.reduce((total, s) => total + s.venudes, 0);
  }

  get entradesLliuresTotals() {
    return this.aforamentTotal - this.entradesVenudes;
  }

  get ocupacio() {
    if (this.aforamentTotal === 0) return 0;
    return Math.round((this.entradesVenudes / this.aforamentTotal) * 100);
  }

  get recaptacioCentims() {
    return this.#sessions.reduce((total, s) => total + s.recaptacioCentims, 0);
  }

  get exhaurit() {
    return this.#sessions.every((s) => s.exhaurida);
  }

  cercarSessio(idSessio) {
    return this.#sessions.find((s) => s.id === idSessio);
  }

  entradesLliures(idSessio) {
    const sessio = this.cercarSessio(idSessio);
    return sessio ? sessio.lliures : 0;
  }

  reservar(idSessio, quantitat = 1) {
    const sessio = this.cercarSessio(idSessio);

    if (!sessio) {
      const error = new Error(`La sessio ${idSessio} no existeix a ${this.id}`);
      error.codi = 'SESSIO_NO_TROBADA';
      throw error;
    }

    // Deleguem en Sessio: es ella qui sap validar el seu propi aforament.
    return sessio.vendre(quantitat);
  }

  toString() {
    return `${this.titol} (${this.sala}) - ${this.ocupacio}% ocupat`;
  }

  toJSON() {
    return {
      id: this.id,
      titol: this.titol,
      sala: this.sala,
      organitzador: this.organitzador,
      categoria: this.categoria,
      duracioMinuts: this.duracioMinuts,
      estat: this.estat,
      sessions: this.#sessions.map((s) => s.toJSON())
    };
  }

  static desDeJSON(objecte) {
    return new Esdeveniment(objecte);
  }
}

module.exports = { Esdeveniment };

// src/domini/index.js
// Facana del domini: un unic punt d'entrada per a tot el model.
// Permet escriure require('./domini') en lloc de tres require diferents.

const { Sessio } = require('./sessio.js');
const { Esdeveniment } = require('./esdeveniment.js');
const { GestorDeVendes, LLINDAR_AFORAMENT_BAIX } = require('./gestor-vendes.js');

module.exports = { Sessio, Esdeveniment, GestorDeVendes, LLINDAR_AFORAMENT_BAIX };

// Sense facana: tres linies, i qui importa ha de coneixer l'estructura interna.
const { Sessio } = require('./domini/sessio.js');
const { Esdeveniment } = require('./domini/esdeveniment.js');
const { GestorDeVendes } = require('./domini/gestor-vendes.js');

// Amb facana: una linia, i l'estructura interna pot canviar sense trencar res.
const { Sessio, Esdeveniment, GestorDeVendes } = require('./domini');

// src/cataleg-dades.js
// Font de dades del cataleg d'Escena Viva.
// Fins al modul 3 les dades son aqui incrustades; despres es llegiran
// de dades/esdeveniments.json amb fs, i aquest fitxer sera l'unic que canvii.

const cataleg = [
  {
    id: 'evt-001',
    titol: 'Concierto de Otono',
    sala: 'Teatro Almendra',
    organitzador: 'org-almendra',
    categoria: 'concert',
    duracioMinuts: 95,
    estat: 'publicat',
    sessions: [
      { id: 'ses-001-1', dataHora: '2026-10-03T20:00:00', aforament: 420, venudes: 180, preuCentims: 2500 },
      { id: 'ses-001-2', dataHora: '2026-10-04T19:00:00', aforament: 420, venudes: 96,  preuCentims: 2200 }
    ]
  },
  {
    id: 'evt-002',
    titol: 'Noche de Monologos',
    sala: 'Sala Boveda',
    organitzador: 'org-boveda',
    categoria: 'humor',
    duracioMinuts: 80,
    estat: 'publicat',
    sessions: [
      { id: 'ses-002-1', dataHora: '2026-10-10T21:30:00', aforament: 120, venudes: 118, preuCentims: 1800 },
      { id: 'ses-002-2', dataHora: '2026-10-11T21:30:00', aforament: 120, venudes: 45,  preuCentims: 1800 },
      { id: 'ses-002-3', dataHora: '2026-10-17T21:30:00', aforament: 120, venudes: 12,  preuCentims: 1500 }
    ]
  },
  {
    id: 'evt-003',
    titol: 'Festival de Jazz de Primavera',
    sala: 'Auditorio Ribera',
    organitzador: 'org-ribera',
    categoria: 'festival',
    duracioMinuts: 240,
    estat: 'publicat',
    sessions: [
      { id: 'ses-003-1', dataHora: '2027-04-17T19:00:00', aforament: 900, venudes: 640, preuCentims: 3800 },
      { id: 'ses-003-2', dataHora: '2027-04-18T19:00:00', aforament: 900, venudes: 720, preuCentims: 4200 }
    ]
  }
];

// Torna una copia profunda perque ningu no modifiqui la font per accident.
// structuredClone es natiu a Node des de la versio 17.
function obtenirCataleg() {
  return structuredClone(cataleg);
}

function obtenirEsdevenimentPerId(id) {
  const esdeveniment = cataleg.find((e) => e.id === id);
  return esdeveniment ? structuredClone(esdeveniment) : undefined;
}

module.exports = { obtenirCataleg, obtenirEsdevenimentPerId };

// src/cataleg.js
// Punt d'entrada del cataleg per consola d'Escena Viva.
// Us:
//   node src/cataleg.js
//   node src/cataleg.js --sala="Teatro Almendra"
//   node src/cataleg.js --taula
//   node src/cataleg.js --max=2000

const { obtenirCataleg } = require('./cataleg-dades.js');
const { Esdeveniment } = require('./domini');
const { formatarPreu } = require('./utils/format.js');

// --- Lectura d'arguments ---

function llegirOpcions(parametres) {
  const opcions = { sala: null, taula: false, preuMaximCentims: Infinity };

  for (const parametre of parametres) {
    if (parametre === '--taula') {
      opcions.taula = true;
    } else if (parametre.startsWith('--sala=')) {
      opcions.sala = parametre.slice('--sala='.length);
    } else if (parametre.startsWith('--max=')) {
      opcions.preuMaximCentims = Number(parametre.slice('--max='.length));
    }
  }

  return opcions;
}

// --- Presentacio ---

function mostrarDetall(esdeveniments) {
  console.log('');
  console.log('==============================================');
  console.log("   ESCENA VIVA - CATALEG D'ESDEVENIMENTS");
  console.log('==============================================');

  for (const esdeveniment of esdeveniments) {
    console.log('');
    console.log(`${esdeveniment.titol}  [${esdeveniment.id}]`);
    console.log(`  Sala      : ${esdeveniment.sala}`);
    console.log(`  Categoria : ${esdeveniment.categoria}`);
    console.log(`  Durada    : ${esdeveniment.duracioMinuts} min`);
    console.log(`  Sessions  : ${esdeveniment.nombreSessions}`);
    console.log(`  Lliures   : ${esdeveniment.entradesLliuresTotals} entrades`);
    console.log(`  Ocupacio  : ${esdeveniment.ocupacio}%`);

    for (const sessio of esdeveniment.sessions) {
      // La sessio sap descriure's a si mateixa: cataleg.js no calcula res.
      console.log(`    - ${sessio.descriure()}`);
    }
  }

  console.log('');
}

function mostrarTaula(esdeveniments) {
  const files = esdeveniments.flatMap((esdeveniment) =>
    esdeveniment.sessions.map((sessio) => ({
      esdeveniment: esdeveniment.id,
      titol: esdeveniment.titol,
      sala: esdeveniment.sala,
      sessio: sessio.id,
      preu: formatarPreu(sessio.preuCentims),
      lliures: sessio.lliures,
      ocupacio: `${sessio.ocupacio}%`
    }))
  );

  console.table(files);
}

// --- Programa principal ---

function principal() {
  const opcions = llegirOpcions(process.argv.slice(2));

  // Les dades planes es converteixen en objectes de domini.
  let esdeveniments = obtenirCataleg().map((dades) => Esdeveniment.desDeJSON(dades));

  if (opcions.sala) {
    esdeveniments = esdeveniments.filter((esdeveniment) => esdeveniment.sala === opcions.sala);
  }

  if (opcions.preuMaximCentims < Infinity) {
    esdeveniments = esdeveniments.filter((esdeveniment) =>
      esdeveniment.sessions.some((s) => s.preuCentims <= opcions.preuMaximCentims)
    );
  }

  if (esdeveniments.length === 0) {
    // Diagnostic per stderr, segons la convencio del projecte.
    console.error('No hi ha esdeveniments que compleixin els criteris indicats.');
    process.exitCode = 1;
    return;
  }

  if (opcions.taula) {
    mostrarTaula(esdeveniments);
  } else {
    mostrarDetall(esdeveniments);
  }

  const aforamentTotal = esdeveniments.reduce((t, e) => t + e.aforamentTotal, 0);
  const venudes = esdeveniments.reduce((t, e) => t + e.entradesVenudes, 0);
  const recaptacio = esdeveniments.reduce((t, e) => t + e.recaptacioCentims, 0);

  console.error(
    `${esdeveniments.length} esdeveniments | aforament ${aforamentTotal} | venudes ${venudes} | ` +
    `lliures ${aforamentTotal - venudes} | recaptacio ${formatarPreu(recaptacio)}`
  );
}

// Nomes s'executa si aquest fitxer es el programa principal.
if (require.main === module) {
  principal();
}

module.exports = { llegirOpcions, principal };

node src/cataleg.js --taula

┌─────────┬──────────────┬─────────────────────────────────┬────────────────────┬─────────────┬─────────────┬─────────┬──────────┐
│ (index) │ esdeveniment │ titol                           │ sala               │ sessio      │ preu        │ lliures │ ocupacio │
├─────────┼──────────────┼─────────────────────────────────┼────────────────────┼─────────────┼─────────────┼─────────┼──────────┤
│ 0       │ 'evt-001'    │ 'Concierto de Otono'            │ 'Teatro Almendra'  │ 'ses-001-1' │ '25,00 EUR' │ 240     │ '43%'    │
│ 1       │ 'evt-001'    │ 'Concierto de Otono'            │ 'Teatro Almendra'  │ 'ses-001-2' │ '22,00 EUR' │ 324     │ '23%'    │
│ 2       │ 'evt-002'    │ 'Noche de Monologos'            │ 'Sala Boveda'      │ 'ses-002-1' │ '18,00 EUR' │ 2       │ '98%'    │
│ 3       │ 'evt-002'    │ 'Noche de Monologos'            │ 'Sala Boveda'      │ 'ses-002-2' │ '18,00 EUR' │ 75      │ '38%'    │
│ 4       │ 'evt-002'    │ 'Noche de Monologos'            │ 'Sala Boveda'      │ 'ses-002-3' │ '15,00 EUR' │ 108     │ '10%'    │
│ 5       │ 'evt-003'    │ 'Festival de Jazz de Primavera' │ 'Auditorio Ribera' │ 'ses-003-1' │ '38,00 EUR' │ 260     │ '71%'    │
│ 6       │ 'evt-003'    │ 'Festival de Jazz de Primavera' │ 'Auditorio Ribera' │ 'ses-003-2' │ '42,00 EUR' │ 180     │ '80%'    │
└─────────┴──────────────┴─────────────────────────────────┴────────────────────┴─────────────┴─────────────┴─────────┴──────────┘
3 esdeveniments | aforament 3000 | venudes 1811 | lliures 1189 | recaptacio 62298,00 EUR

// MALAMENT: exposa detalls interns que ningu de fora necessita.
module.exports = {
  formatarPreu,
  partirCentims,        // Auxiliar intern
  SIMBOL_MONEDA,        // Constant interna
  cacheDeFormats        // Estat intern
};

// BE: nomes el que forma part del contracte.
module.exports = { formatarPreu };

// MALAMENT: en requerir aquest modul s'obre una connexio, es llegeix un fitxer
// i s'imprimeix per consola. Sense que ningu ho hagi demanat.
const connexio = connectarABaseDeDades();
const dades = fs.readFileSync('dades/esdeveniments.json');
console.log('Modul de cataleg carregat');

module.exports = { connexio, dades };

// BE: el modul defineix capacitats. Qui les vulgui, les invoca.
function connectar(opcions) { /* ... */ }
function carregarDades(ruta) { /* ... */ }

module.exports = { connectar, carregarDades };

// Al principi del fitxer, agrupats i ordenats:
const path = require('node:path');            // 1. Nucli de Node
const express = require('express');           // 2. Paquets externs
const { Esdeveniment } = require('./domini'); // 3. Moduls propis

// MALAMENT: la dependencia nomes es descobreix en temps d'execucio.
if (process.env.MODE === 'produccio') {
  registrador = require('./registrador-produccio.js');
}

// Menys flexible: forca un singleton i complica les proves.
module.exports = { gestor: new GestorDeVendes(cataleg) };

// Mes flexible: cadascu crea el seu quan i com vulgui.
module.exports = { GestorDeVendes };

// src/utils/ajudes.js
const fs = require('fs');

console.log('Carregant ajudes...');

const cataleg = JSON.parse(fs.readFileSync('./dades/esdeveniments.json', 'utf8'));

var CONFIG = { limit: 10 };

function formatarPreu(c) {
  return (c / 100).toFixed(2) + ' EUR';
}

function _arrodonir(n) {
  return Math.round(n);
}

exports = { formatarPreu, _arrodonir, CONFIG, cataleg };

// src/utils/format.js
// Nomes formatatge. Sense dependencies, sense efectes secundaris.

function formatarPreu(centims) {
  const euros = Math.floor(centims / 100);
  const resta = String(centims % 100).padStart(2, '0');
  return `${euros},${resta} EUR`;
}

module.exports = { formatarPreu };

// src/config.js
// Configuracio de l'aplicacio. Congelada perque ningu no la modifiqui.

module.exports = Object.freeze({
  limitEntradesPerComanda: 10,
  llindarAforamentBaix: 0.10
});

// src/cataleg-dades.js
// Acces a les dades. La lectura passa quan es DEMANA, no en carregar.

const fs = require('node:fs');
const path = require('node:path');

// Ruta relativa AL FITXER, no al directori de treball.
const RUTA_DADES = path.join(__dirname, '..', 'dades', 'esdeveniments.json');

function obtenirCataleg() {
  const contingut = fs.readFileSync(RUTA_DADES, 'utf8');
  return JSON.parse(contingut);
}

module.exports = { obtenirCataleg };

// src/informes/ocupacio.js
// Informes d'ocupacio d'Escena Viva.
// Rep els esdeveniments com a argument: no en coneix l'origen.

const { formatarPreu } = require('../utils/format.js');

// Resum agregat per sala.
function resumirPerSala(esdeveniments) {
  const perSala = new Map();

  for (const esdeveniment of esdeveniments) {
    const acumulat = perSala.get(esdeveniment.sala) ?? {
      sala: esdeveniment.sala, esdeveniments: 0, sessions: 0,
      aforament: 0, venudes: 0, recaptacioCentims: 0
    };

    acumulat.esdeveniments += 1;
    acumulat.sessions += esdeveniment.nombreSessions;
    acumulat.aforament += esdeveniment.aforamentTotal;
    acumulat.venudes += esdeveniment.entradesVenudes;
    acumulat.recaptacioCentims += esdeveniment.recaptacioCentims;

    perSala.set(esdeveniment.sala, acumulat);
  }

  return [...perSala.values()].map((a) => ({
    sala: a.sala,
    esdeveniments: a.esdeveniments,
    sessions: a.sessions,
    aforament: a.aforament,
    venudes: a.venudes,
    lliures: a.aforament - a.venudes,
    ocupacio: `${Math.round((a.venudes / a.aforament) * 100)}%`,
    recaptacioEuros: formatarPreu(a.recaptacioCentims)
  }));
}

// Sessions per sota del llindar d'ocupacio.
function sessionsEnRisc(esdeveniments, llindarPercentatge = 20) {
  return esdeveniments.flatMap((esdeveniment) =>
    esdeveniment.sessions
      .filter((sessio) => sessio.ocupacio < llindarPercentatge)
      .map((sessio) => ({
        esdeveniment: esdeveniment.id,
        titol: esdeveniment.titol,
        sessio: sessio.id,
        lliures: sessio.lliures,
        ocupacio: `${sessio.ocupacio}%`
      }))
  );
}

// Sessions sense entrades disponibles.
function sessionsExhaurides(esdeveniments) {
  return esdeveniments.flatMap((esdeveniment) =>
    esdeveniment.sessions
      .filter((sessio) => sessio.exhaurida)
      .map((sessio) => ({
        esdeveniment: esdeveniment.id,
        titol: esdeveniment.titol,
        sessio: sessio.id,
        aforament: sessio.aforament,
        recaptacioEuros: formatarPreu(sessio.recaptacioCentims)
      }))
  );
}

// --- Execucio directa: nomes si aquest fitxer ES el programa principal ---
if (require.main === module) {
  const { obtenirCataleg } = require('../cataleg-dades.js');
  const { Esdeveniment } = require('../domini');

  const esdeveniments = obtenirCataleg().map((dades) => Esdeveniment.desDeJSON(dades));
  const llindar = Number(process.argv[2]) || 20;

  console.log('OCUPACIO PER SALA');
  console.table(resumirPerSala(esdeveniments));

  console.log('');
  console.log(`SESSIONS EN RISC (menys del ${llindar}%)`);
  const risc = sessionsEnRisc(esdeveniments, llindar);
  if (risc.length === 0) {
    console.log('  Cap.');
  } else {
    console.table(risc);
    process.exitCode = 1;
  }

  console.log('');
  console.log('SESSIONS EXHAURIDES');
  const exhaurides = sessionsExhaurides(esdeveniments);
  if (exhaurides.length === 0) {
    console.log('  Cap.');
  } else {
    console.table(exhaurides);
  }
}

module.exports = { resumirPerSala, sessionsEnRisc, sessionsExhaurides };

node src/informes/ocupacio.js

OCUPACIO PER SALA
┌─────────┬────────────────────┬───────────────┬──────────┬───────────┬─────────┬─────────┬──────────┬─────────────────┐
│ (index) │ sala               │ esdeveniments │ sessions │ aforament │ venudes │ lliures │ ocupacio │ recaptacioEuros │
├─────────┼────────────────────┼───────────────┼──────────┼───────────┼─────────┼─────────┼──────────┼─────────────────┤
│ 0       │ 'Teatro Almendra'  │ 1             │ 2        │ 840       │ 276     │ 564     │ '33%'    │ '6612,00 EUR'   │
│ 1       │ 'Sala Boveda'      │ 1             │ 3        │ 360       │ 175     │ 185     │ '49%'    │ '3114,00 EUR'   │
│ 2       │ 'Auditorio Ribera' │ 1             │ 2        │ 1800      │ 1360    │ 440     │ '76%'    │ '52572,00 EUR'  │
└─────────┴────────────────────┴───────────────┴──────────┴───────────┴─────────┴─────────┴──────────┴─────────────────┘

SESSIONS EN RISC (menys del 20%)
┌─────────┬──────────────┬──────────────────────┬─────────────┬─────────┬──────────┐
│ (index) │ esdeveniment │ titol                │ sessio      │ lliures │ ocupacio │
├─────────┼──────────────┼──────────────────────┼─────────────┼─────────┼──────────┤
│ 0       │ 'evt-002'    │ 'Noche de Monologos' │ 'ses-002-3' │ 108     │ '10%'    │
└─────────┴──────────────┴──────────────────────┴─────────────┴─────────┴──────────┘

SESSIONS EXHAURIDES
  Cap.

// src/laboratori/provar-informes.js
const { sessionsExhaurides } = require('../informes/ocupacio.js');
const { obtenirCataleg } = require('../cataleg-dades.js');
const { Esdeveniment } = require('../domini');

const esdeveniments = obtenirCataleg().map((d) => Esdeveniment.desDeJSON(d));
console.log(`Exhaurides: ${sessionsExhaurides(esdeveniments).length}`);

node src/laboratori/provar-informes.js
# Exhaurides: 0

// src/laboratori/registre-vendes.js
console.error(">> registre-vendes.js AVALUANT (aixo nomes ha de veure's un cop)");

const vendes = [];

function anotar(venda) {
  vendes.push({ ...venda, anotadaEl: new Date().toISOString() });
  return vendes.length;
}

function total() {
  return vendes.reduce((t, v) => t + v.importCentims, 0);
}

function llistar() {
  return [...vendes];
}

module.exports = { anotar, total, llistar };

// src/laboratori/taquilla-a.js
const registre = require('./registre-vendes.js');

function vendreDesDeTaquillaA() {
  registre.anotar({ sessioId: 'ses-001-1', quantitat: 2, importCentims: 5000 });
}

module.exports = { vendreDesDeTaquillaA };

// src/laboratori/taquilla-b.js
const registre = require('./registre-vendes.js');

function vendreDesDeTaquillaB() {
  registre.anotar({ sessioId: 'ses-002-2', quantitat: 3, importCentims: 5400 });
}

module.exports = { vendreDesDeTaquillaB };

// src/laboratori/demostrar-cache.js
console.error(`Moduls a la cache en comencar: ${Object.keys(require.cache).length}`);

const registre = require('./registre-vendes.js');
const { vendreDesDeTaquillaA } = require('./taquilla-a.js');
const { vendreDesDeTaquillaB } = require('./taquilla-b.js');

console.error(`Moduls a la cache despres dels require: ${Object.keys(require.cache).length}`);
console.error('');

// Vendes des de tres punts diferents del programa.
registre.anotar({ sessioId: 'ses-003-1', quantitat: 1, importCentims: 3800 });
vendreDesDeTaquillaA();
vendreDesDeTaquillaB();

console.log('--- Estat compartit ---');
console.log(`Vendes anotades: ${registre.llistar().length}`);
console.log(`Total: ${(registre.total() / 100).toFixed(2)} EUR`);

// Comprovacio d'identitat.
const altraReferencia = require('./registre-vendes.js');
console.log(`Mateix objecte? ${registre === altraReferencia}`);
console.log(`Total vist des de l'altra referencia: ${(altraReferencia.total() / 100).toFixed(2)} EUR`);

// --- Buidatge de la cache ---
console.log('');
console.log('--- Despres de buidar la cache ---');

const ruta = require.resolve('./registre-vendes.js');
delete require.cache[ruta];

const registreNou = require('./registre-vendes.js');   // Es torna a avaluar
console.log(`Mateix objecte que abans? ${registre === registreNou}`);
console.log(`Vendes a la instancia nova: ${registreNou.llistar().length}`);
console.log(`Vendes a la instancia antiga: ${registre.llistar().length}`);

console.error('');
console.error(`Moduls a la cache en acabar: ${Object.keys(require.cache).length}`);

Moduls a la cache en comencar: 1
>> registre-vendes.js AVALUANT (aixo nomes ha de veure's un cop)
Moduls a la cache despres dels require: 4

--- Estat compartit ---
Vendes anotades: 3
Total: 142.00 EUR
Mateix objecte? true
Total vist des de l'altra referencia: 142.00 EUR

--- Despres de buidar la cache ---
>> registre-vendes.js AVALUANT (aixo nomes ha de veure's un cop)
Mateix objecte que abans? false
Vendes a la instancia nova: 0
Vendes a la instancia antiga: 3

Moduls a la cache en acabar: 4

// src/laboratori/circular-comanda.js
console.error('comanda.js: comenca');

const { Entrada } = require('./circular-entrada.js');
console.error('comanda.js: Entrada val', typeof Entrada);

class Comanda {
  constructor(id, sessioId, quantitat) {
    this.id = id;
    this.entrades = [];
    for (let i = 0; i < quantitat; i++) {
      this.entrades.push(new Entrada(`EV-2026-00000${i + 1}`, sessioId, this));
    }
  }
}

module.exports = { Comanda };
console.error('comanda.js: acaba');

// src/laboratori/circular-entrada.js
console.error('entrada.js: comenca');

const { Comanda } = require('./circular-comanda.js');
console.error('entrada.js: Comanda val', typeof Comanda);   // <-- undefined

class Entrada {
  constructor(codi, sessioId, comanda) {
    this.codi = codi;
    this.sessioId = sessioId;
    this.comanda = comanda;
    this.estat = 'valida';
  }

  // Fa servir Comanda per validar: fallara si Comanda es undefined.
  pertanyAComandaValida() {
    return this.comanda instanceof Comanda;
  }
}

module.exports = { Entrada };
console.error('entrada.js: acaba');

node src/laboratori/circular-comanda.js

comanda.js: comenca
entrada.js: comenca
entrada.js: Comanda val undefined     <-- el simptoma
entrada.js: acaba
comanda.js: Entrada val function
comanda.js: acaba

// src/domini/entrada.js
// Entrada NO necessita coneixer la classe Comanda: en te prou amb el seu identificador.

class Entrada {
  constructor({ codi, sessioId, comandaId, estat = 'valida' }) {
    this.codi = codi;
    this.sessioId = sessioId;
    this.comandaId = comandaId;    // Nomes l'id, no pas l'objecte
    this.estat = estat;
  }

  usar() {
    if (this.estat !== 'valida') {
      const error = new Error(`L'entrada ${this.codi} esta ${this.estat}`);
      error.codi = 'ENTRADA_NO_VALIDA';
      throw error;
    }
    this.estat = 'usada';
    return this;
  }

  anullar() {
    this.estat = 'anullada';
    return this;
  }
}

module.exports = { Entrada };

// src/domini/comanda.js
// Comanda coneix Entrada. Entrada no coneix Comanda. Sense cicle.

const { Entrada } = require('./entrada.js');
const { generarCodiEntrada } = require('../utils/format.js');

class Comanda {
  #entrades = [];

  constructor({ id, usuariId, sessioId, quantitat, preuCentims, estat = 'pendent' }) {
    this.id = id;
    this.usuariId = usuariId;
    this.sessioId = sessioId;
    this.quantitat = quantitat;
    this.totalCentims = quantitat * preuCentims;
    this.estat = estat;
  }

  get entrades() {
    return [...this.#entrades];
  }

  emetre(any, sequenciaInicial) {
    if (this.estat !== 'pagat') {
      const error = new Error(`No es poden emetre entrades d'una comanda ${this.estat}`);
      error.codi = 'ESTAT_INVALID';
      throw error;
    }

    for (let i = 0; i < this.quantitat; i++) {
      this.#entrades.push(new Entrada({
        codi: generarCodiEntrada(any, sequenciaInicial + i),
        sessioId: this.sessioId,
        comandaId: this.id
      }));
    }

    this.estat = 'emes';
    return this.entrades;
  }
}

module.exports = { Comanda };