function descriureCarrega(responsable, hores, limit) {
  console.log(`${responsable} · ${hores} h · límit ${limit}`);
}

descriureCarrega('Iván', 25, 40);        // Iván · 25 h · límit 40
descriureCarrega('Iván', 25);            // Iván · 25 h · límit undefined
descriureCarrega('Iván');                // Iván · undefined h · límit undefined
descriureCarrega('Iván', 25, 40, 'x');   // Iván · 25 h · límit 40   ← el quart s'ignora

function margeSetmanal(horesAssignades, limit) {
  return limit - horesAssignades;
}

console.log(margeSetmanal(25));   // NaN   ← undefined - 25

let horesIvan = 25;

function afegirHores(hores, extra) {
  hores = hores + extra;        // modifica la CÒPIA local
  return hores;
}

const nouTotal = afegirHores(horesIvan, 5);

console.log(horesIvan);   // 25  ← intacta
console.log(nouTotal);    // 30

const tasca = {
  id: 1,
  titol: 'Redissenyar la sala polivalent',
  estat: 'en-curs',
  horesEstimades: 12
};

function marcarComFeta(t) {
  t.estat = 'feta';             // ← modifica l'objecte COMPARTIT
}

marcarComFeta(tasca);
console.log(tasca.estat);       // 'feta'  ← ha canviat a fora!

function reemplacar(t) {
  t = { id: 99, titol: 'Una altra cosa' };   // la còpia local apunta a un altre objecte
}

reemplacar(tasca);
console.log(tasca.id);   // 1  ← intacta

// ✗ Sorpresa: el nom diu "calcular", però a més modifica
function calcularUrgencia(tasca, avui) {
  tasca.urgencia = pesDePrioritat(tasca.prioritat) * 10;   // efecte ocult
  return tasca.urgencia;
}

// ✓ 1. No mutar: només calcular i retornar
function calcularUrgencia(prioritat, diesRestants) {
  return pesDePrioritat(prioritat) * 10 - diesRestants;
}

// ✓ 2. Retornar una còpia modificada
function ambEstat(tasca, nouEstat) {
  const copia = Object.assign({}, tasca);   // còpia superficial
  copia.estat = nouEstat;
  return copia;
}

// ✓ 3. Mutar, però anunciant-ho al nom
function aplicarEstatEnTasca(tasca, nouEstat) {
  tasca.estat = nouEstat;
}

function crearResum(titol, responsable = 'sense assignar', hores = 0) {
  return `${titol} · ${responsable} · ${hores} h`;
}

console.log(crearResum('Cartelleria del taller de serigrafia'));
// Cartelleria del taller de serigrafia · sense assignar · 0 h

console.log(crearResum('Cartelleria del taller de serigrafia', 'Marta', 6));
// Cartelleria del taller de serigrafia · Marta · 6 h

console.log(crearResum('Inventari', undefined, 0));   // Inventari · sense assignar · 0 h
console.log(crearResum('Inventari', null, 0));        // Inventari · null · 0 h
console.log(crearResum('Inventari', '', 0));          // Inventari ·  · 0 h

function registrarCanvi(tascaId, data = new Date().toISOString().slice(0, 10)) {
  console.log(`[${data}] Canvi a la tasca ${tascaId}`);
}

function planificar(horesEstimades, horesPerDia = 8, dies = Math.ceil(horesEstimades / horesPerDia)) {
  return `${horesEstimades} h → ${dies} dia/es a ${horesPerDia} h/dia`;
}

console.log(planificar(14));           // 14 h → 2 dia/es a 8 h/dia
console.log(planificar(14, 4));        // 14 h → 4 dia/es a 4 h/dia
console.log(planificar(14, 4, 1));     // 14 h → 1 dia/es a 4 h/dia

function malament(dies = hores / 8, hores) { /* ... */ }
malament(undefined, 16);   // ✗ ReferenceError: Cannot access 'hores' before initialization

const obligatori = (nom) => {
  throw new Error(`Falta el paràmetre obligatori: ${nom}`);
};

function assignarTasca(tascaId = obligatori('tascaId'), responsable = obligatori('responsable')) {
  return `Tasca ${tascaId} assignada a ${responsable}`;
}

console.log(assignarTasca(3, 'Lucía'));   // Tasca 3 assignada a Lucía
assignarTasca(3);                         // ✗ Error: Falta el paràmetre obligatori: responsable

function sumarHores() {
  let total = 0;
  for (let i = 0; i < arguments.length; i++) {
    total += arguments[i];
  }
  return total;
}

console.log(sumarHores(12, 6, 14, 3, 8, 5));   // 48

function sumarHores(...hores) {
  let total = 0;
  for (const h of hores) {
    total += h;
  }
  return total;
}

console.log(sumarHores(12, 6, 14, 3, 8, 5));   // 48
console.log(sumarHores());                     // 0

function informeDeCarrega(responsable, ...hores) {
  let total = 0;
  for (const h of hores) total += h;
  return `${responsable}: ${hores.length} tasques, ${total} h`;
}

console.log(informeDeCarrega('Iván', 12, 8, 5));   // Iván: 3 tasques, 25 h
console.log(informeDeCarrega('Lucía', 14));        // Lucía: 1 tasques, 14 h
console.log(informeDeCarrega('Ningú'));            // Ningú: 0 tasques, 0 h

descriureTasca(1, 'Redissenyar la sala polivalent', 'Iván', 'alta', 'en-curs', 12, '2026-09-30', AVUI);

function descriureTasca(opcions) {
  const marca = opcions.estat === 'feta' ? '✓' : '○';
  const avis = opcions.dataLimit < opcions.avui && opcions.estat !== 'feta'
    ? ' ⚠ VENÇUDA'
    : '';
  return `${marca} [${opcions.id}] ${opcions.titol} · ${opcions.responsable} · ${opcions.horesEstimades} h${avis}`;
}

console.log(descriureTasca({
  id: 6,
  titol: 'Pressupost de la fusteria',
  responsable: 'Iván',
  prioritat: 'alta',
  estat: 'pendent',
  horesEstimades: 5,
  dataLimit: '2026-09-05',
  avui: '2026-09-20'
}));
// ○ [6] Pressupost de la fusteria · Iván · 5 h ⚠ VENÇUDA

function formatarBacklog(tasques, opcions = {}) {
  const separador = opcions.separador ?? '\n';
  const mostrarHores = opcions.mostrarHores ?? true;
  const ordre = opcions.ordre ?? 'data';
  // ...
}

formatarBacklog(backlog);                                  // tot per defecte
formatarBacklog(backlog, { ordre: 'prioritat' });          // només canvia el que interessa
formatarBacklog(backlog, { mostrarHores: false, ordre: 'responsable' });

// ✗ Imbricació en escala
function calcularMarge(responsable, horesAssignades, limit) {
  if (responsable !== null) {
    if (typeof horesAssignades === 'number') {
      if (horesAssignades <= limit) {
        return limit - horesAssignades;
      } else {
        return 0;
      }
    }
  }
}

// ✓ Guardes i sortida primerenca
function calcularMarge(responsable, horesAssignades, limit) {
  if (responsable === null) return limit;
  if (typeof horesAssignades !== 'number') return limit;
  if (horesAssignades >= limit) return 0;
  return limit - horesAssignades;
}

// ✗ Tres tipus diferents segons el cas
function cercarHores(responsable) {
  if (responsable === null) return 'sense responsable';
  if (responsable === 'Iván') return 25;
  return false;
}

const h = cercarHores('Marta');
console.log(h + 10);   // 10  ← false + 10, sense error i sense sentit

function cercarHores(responsable, responsables, hores) {
  if (responsable === null) return null;      // absència declarada
  let total = 0;
  let trobat = false;
  for (let i = 0; i < responsables.length; i++) {
    if (responsables[i] === responsable) {
      total += hores[i];
      trobat = true;
    }
  }
  return trobat ? total : null;
}

// Opció A: objecte (recomanat quan les dades tenen nom)
function resumirCarrega(hores, estats) {
  let total = 0;
  let obertes = 0;
  let fetes = 0;
  for (let i = 0; i < hores.length; i++) {
    total += hores[i];
    if (estats[i] === 'feta') fetes += hores[i];
    else obertes += hores[i];
  }
  return { total: total, obertes: obertes, fetes: fetes };
}

const r = resumirCarrega([12, 6, 14, 3, 8, 5],
                         ['en-curs', 'pendent', 'pendent', 'feta', 'en-curs', 'pendent']);
console.log(r.total, r.obertes, r.fetes);   // 48 45 3

// Opció B: array (només quan l'ordre és evident i són pocs)
function rangDeDates(dates) {
  let minima = dates[0];
  let maxima = dates[0];
  for (const d of dates) {
    if (d < minima) minima = d;
    if (d > maxima) maxima = d;
  }
  return [minima, maxima];
}

const rang = rangDeDates(['2026-09-30', '2026-10-15', '2026-09-05', '2026-11-05']);
console.log(rang[0], rang[1]);   // 2026-09-05 2026-11-05

// Avançament: així s'escriurà a partir del Mòdul 4
const { total, obertes, fetes } = resumirCarrega(hores, estats);
const [minima, maxima] = rangDeDates(dates);

// ✓ PURA: només depèn dels seus arguments i només retorna
function pesDePrioritat(prioritat) {
  if (prioritat === 'alta') return 3;
  if (prioritat === 'mitjana') return 2;
  if (prioritat === 'baixa') return 1;
  return 0;
}

// ✗ IMPURA: depèn d'una variable externa
let limitSetmanal = 40;
function margeDe(hores) {
  return limitSetmanal - hores;      // el resultat canvia si canvia limitSetmanal
}

// ✗ IMPURA: efecte secundari (escriu a la consola)
function informar(responsable, hores) {
  console.log(`${responsable}: ${hores} h`);
}

// ✗ IMPURA: depèn del rellotge
function diesFinsA(dataLimit) {
  const avui = new Date();           // resultat diferent cada dia
  return Math.ceil((new Date(dataLimit) - avui) / 86400000);
}

function margeDe(hores, limitSetmanal) {
  return limitSetmanal - hores;
}

function diesFinsA(dataLimit, avui) {
  return Math.ceil((new Date(dataLimit) - new Date(avui)) / 86400000);
}

console.log(diesFinsA('2026-09-30', '2026-09-20'));   // 10
console.log(diesFinsA('2026-09-05', '2026-09-20'));   // -15  (vençuda)

'use strict';

const AVUI = '2026-09-20';

const obligatori = (camp) => {
  throw new Error(`Falta el camp obligatori: ${camp}`);
};

let ultimId = 0;

/**
 * Crea una tasca vàlida a partir d'un objecte d'opcions.
 * Aplica R1 (id correlatiu), R5 (neix pendent), R8 (responsable null),
 * R9 (etiquetes en minúscules i sense duplicats).
 * Impura a propòsit: consumeix el comptador d'ids.
 */
function crearTasca(opcions = {}) {
  const titol = opcions.titol ?? obligatori('titol');
  const horesEstimades = opcions.horesEstimades ?? obligatori('horesEstimades');
  const dataLimit = opcions.dataLimit ?? obligatori('dataLimit');

  const responsable = opcions.responsable ?? null;      // R8
  const prioritat = opcions.prioritat ?? 'mitjana';
  const etiquetes = normalitzarEtiquetes(opcions.etiquetes ?? []);   // R9
  const revisor = opcions.revisor ?? null;

  if (titol.trim().length === 0) throw new Error('R2: el títol no pot estar buit.');
  if (horesEstimades <= 0 || horesEstimades > 40) throw new Error('R3: hores fora de rang (0-40).');

  ultimId = ultimId + 1;                                // R1

  return {
    id: ultimId,
    titol: titol.trim(),
    responsable: responsable,
    prioritat: prioritat,
    estat: 'pendent',                                   // R5
    etiquetes: etiquetes,
    horesEstimades: horesEstimades,
    dataLimit: dataLimit,
    revisor: revisor
  };
}

/** Pura: minúscules, sense espais sobrants i sense duplicats (R9). */
function normalitzarEtiquetes(etiquetes) {
  const netes = [];
  for (const etiqueta of etiquetes) {
    const normalitzada = String(etiqueta).trim().toLowerCase();
    if (normalitzada === '') continue;
    let repetida = false;
    for (let j = 0; j < netes.length; j++) {
      if (netes[j] === normalitzada) { repetida = true; break; }
    }
    if (!repetida) netes.push(normalitzada);
  }
  return netes;
}

const nova = crearTasca({
  titol: '  Renovar el torn de la fusteria  ',
  horesEstimades: 10,
  dataLimit: '2026-10-20',
  responsable: 'Lucía',
  prioritat: 'alta',
  etiquetes: ['Fusteria', 'fusteria', ' MANTENIMENT ']
});

console.log(nova);
// {
//   id: 1,
//   titol: 'Renovar el torn de la fusteria',
//   responsable: 'Lucía',
//   prioritat: 'alta',
//   estat: 'pendent',
//   etiquetes: [ 'fusteria', 'manteniment' ],
//   horesEstimades: 10,
//   dataLimit: '2026-10-20',
//   revisor: null
// }

/**
 * Retorna diversos totals d'un responsable en un sol objecte.
 * Pura: mateixos arrays i mateix responsable → mateix resultat.
 */
function resumirCarrega(responsables, hores, estats, datesLimit, responsable, avui = AVUI) {
  let totalHores = 0;
  let horesObertes = 0;
  let tasques = 0;
  let vencudes = 0;

  for (let i = 0; i < responsables.length; i++) {
    if (responsables[i] !== responsable) continue;

    tasques++;
    totalHores += hores[i];

    if (estats[i] !== 'feta') {
      horesObertes += hores[i];
      if (datesLimit[i] < avui) vencudes++;
    }
  }

  return {
    responsable: responsable,
    tasques: tasques,
    totalHores: totalHores,
    horesObertes: horesObertes,
    vencudes: vencudes,
    marge: 40 - horesObertes,            // R7
    sobrecarregat: horesObertes > 40     // R7
  };
}

const responsables = ['Iván', 'Marta', 'Lucía', 'Marta', 'Iván', 'Iván'];
const hores        = [12, 6, 14, 3, 8, 5];
const estats       = ['en-curs', 'pendent', 'pendent', 'feta', 'en-curs', 'pendent'];
const datesLimit   = ['2026-09-30', '2026-10-15', '2026-10-02',
                      '2026-09-12', '2026-11-05', '2026-09-05'];

const equip = ['Iván', 'Marta', 'Lucía'];
for (const persona of equip) {
  const r = resumirCarrega(responsables, hores, estats, datesLimit, persona);
  console.log(`${r.responsable}: ${r.tasques} tasques · ${r.horesObertes}/${r.totalHores} h obertes · ` +
              `marge ${r.marge} h · vençudes ${r.vencudes}`);
}
// Iván: 3 tasques · 25/25 h obertes · marge 15 h · vençudes 1
// Marta: 2 tasques · 6/9 h obertes · marge 34 h · vençudes 0
// Lucía: 1 tasques · 14/14 h obertes · marge 26 h · vençudes 0

function ambMarge(hores) {
  hores = hores || 8;      // ✗ un 0 legítim es converteix en 8
  return hores;
}
console.log(ambMarge(0));   // 8  ← malament

crearTasca({ titlo: 'Nova', horesEstimades: 4, dataLimit: '2026-10-01' });
// ✗ Error: Falta el camp obligatori: titol

// a)
const IVA = 0.21;
function ambImpostos(base) { return base * (1 + IVA); }

// b)
let comptadorCrides = 0;
function urgencia(prioritat, dies) {
  comptadorCrides++;
  return pesDePrioritat(prioritat) * 10 - dies;
}

// c)
function ordenarEtiquetes(etiquetes) {
  etiquetes.sort();
  return etiquetes;
}

// d)
function diesDeMarge(dataLimit) {
  const avui = new Date().toISOString().slice(0, 10);
  return dataLimit >= avui ? 'a temps' : 'vençuda';
}

function generarInforme(tasques, responsable, incloureFetes, ordenarPer, format, ample, mostrarVencudes) {
  // ...
}

// Crides que han de funcionar després del redisseny:
// 1) Només el backlog, tota la resta per defecte
// 2) El backlog de l'Iván, incloent-hi les fetes
// 3) El backlog ordenat per prioritat, en format compacte

// b) Sense efecte secundari. Si cal comptar, que ho faci qui la crida.
function urgencia(prioritat, dies) {
  return pesDePrioritat(prioritat) * 10 - dies;
}

// c) Copiar abans d'ordenar
function ordenarEtiquetes(etiquetes) {
  const copia = [];
  for (const e of etiquetes) copia.push(e);
  copia.sort();
  return copia;
}

const originals = ['serigrafia', 'disseny', 'fusteria'];
const ordenades = ordenarEtiquetes(originals);
console.log(originals);   // [ 'serigrafia', 'disseny', 'fusteria' ]  ← intacte
console.log(ordenades);   // [ 'disseny', 'fusteria', 'serigrafia' ]

// d) La data hi entra per paràmetre
function diesDeMarge(dataLimit, avui) {
  return dataLimit >= avui ? 'a temps' : 'vençuda';
}
console.log(diesDeMarge('2026-09-05', '2026-09-20'));   // vençuda

function generarInforme(tasques, opcions = {}) {
  const responsable     = opcions.responsable     ?? null;    // null = tot l'equip
  const incloureFetes   = opcions.incloureFetes   ?? false;
  const ordenarPer      = opcions.ordenarPer      ?? 'data';
  const format          = opcions.format          ?? 'detallat';
  const ample           = opcions.ample           ?? 80;
  const mostrarVencudes = opcions.mostrarVencudes ?? true;

  return `Informe [${responsable ?? 'equip'}] · ordre: ${ordenarPer} · format: ${format} · ` +
         `${incloureFetes ? 'amb' : 'sense'} fetes · ample ${ample}` +
         `${mostrarVencudes ? ' · marcant vençudes' : ''}`;
}

console.log(generarInforme(backlog));
// Informe [equip] · ordre: data · format: detallat · sense fetes · ample 80 · marcant vençudes

console.log(generarInforme(backlog, { responsable: 'Iván', incloureFetes: true }));
// Informe [Iván] · ordre: data · format: detallat · amb fetes · ample 80 · marcant vençudes

console.log(generarInforme(backlog, { ordenarPer: 'prioritat', format: 'compacte' }));
// Informe [equip] · ordre: prioritat · format: compacte · sense fetes · ample 80 · marcant vençudes

function resumirBacklog(estats, hores, ...responsablesFiltre) {
  const filtrar = responsablesFiltre.length > 0;

  let tasques = 0;
  let horesTotals = 0;
  let horesObertes = 0;
  let horesFetes = 0;

  for (let i = 0; i < estats.length; i++) {
    if (filtrar) {
      let coincideix = false;
      for (const nom of responsablesFiltre) {
        if (responsables[i] === nom) { coincideix = true; break; }
      }
      if (!coincideix) continue;
    }

    tasques++;
    horesTotals += hores[i];
    if (estats[i] === 'feta') horesFetes += hores[i];
    else horesObertes += hores[i];
  }

  const percentatge = horesTotals === 0
    ? 0
    : Math.round((horesFetes / horesTotals) * 1000) / 10;

  return {
    tasques: tasques,
    horesTotals: horesTotals,
    horesObertes: horesObertes,
    percentatgeCompletat: percentatge
  };
}

console.log(resumirBacklog(estats, hores));
// { tasques: 6, horesTotals: 48, horesObertes: 45, percentatgeCompletat: 6.3 }

console.log(resumirBacklog(estats, hores, 'Iván'));
// { tasques: 3, horesTotals: 25, horesObertes: 25, percentatgeCompletat: 0 }

console.log(resumirBacklog(estats, hores, 'Marta', 'Lucía'));
// { tasques: 3, horesTotals: 23, horesObertes: 20, percentatgeCompletat: 13 }