function describeWorkload(assignee, hours, limit) {
  console.log(`${assignee} · ${hours} h · limit ${limit}`);
}

describeWorkload('Iván', 25, 40);        // Iván · 25 h · limit 40
describeWorkload('Iván', 25);            // Iván · 25 h · limit undefined
describeWorkload('Iván');                // Iván · undefined h · limit undefined
describeWorkload('Iván', 25, 40, 'x');   // Iván · 25 h · limit 40   ← the fourth is ignored

function weeklyHeadroom(assignedHours, limit) {
  return limit - assignedHours;
}

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

let ivanHours = 25;

function addHours(hours, extra) {
  hours = hours + extra;        // modifies the local COPY
  return hours;
}

const newTotal = addHours(ivanHours, 5);

console.log(ivanHours);   // 25  ← untouched
console.log(newTotal);    // 30

const task = {
  id: 1,
  title: 'Redesign the multipurpose room',
  status: 'in-progress',
  estimatedHours: 12
};

function markAsDone(t) {
  t.status = 'done';            // ← modifies the SHARED object
}

markAsDone(task);
console.log(task.status);       // 'done'  ← it changed on the outside!

function replace(t) {
  t = { id: 99, title: 'Something else' };   // the local copy points at another object
}

replace(task);
console.log(task.id);   // 1  ← untouched

// ✗ Surprise: the name says "calculate", but it also modifies
function calculateUrgency(task, today) {
  task.urgency = priorityWeight(task.priority) * 10;   // hidden effect
  return task.urgency;
}

// ✓ 1. Do not mutate: just calculate and return
function calculateUrgency(priority, daysLeft) {
  return priorityWeight(priority) * 10 - daysLeft;
}

// ✓ 2. Return a modified copy
function withStatus(task, newStatus) {
  const copy = Object.assign({}, task);   // shallow copy
  copy.status = newStatus;
  return copy;
}

// ✓ 3. Mutate, but announce it in the name
function applyStatusToTask(task, newStatus) {
  task.status = newStatus;
}

function createSummary(title, assignee = 'unassigned', hours = 0) {
  return `${title} · ${assignee} · ${hours} h`;
}

console.log(createSummary('Signage for the screen-printing workshop'));
// Signage for the screen-printing workshop · unassigned · 0 h

console.log(createSummary('Signage for the screen-printing workshop', 'Marta', 6));
// Signage for the screen-printing workshop · Marta · 6 h

console.log(createSummary('Inventory', undefined, 0));   // Inventory · unassigned · 0 h
console.log(createSummary('Inventory', null, 0));        // Inventory · null · 0 h
console.log(createSummary('Inventory', '', 0));          // Inventory ·  · 0 h

function logChange(taskId, date = new Date().toISOString().slice(0, 10)) {
  console.log(`[${date}] Change on task ${taskId}`);
}

function plan(estimatedHours, hoursPerDay = 8, days = Math.ceil(estimatedHours / hoursPerDay)) {
  return `${estimatedHours} h → ${days} day(s) at ${hoursPerDay} h/day`;
}

console.log(plan(14));           // 14 h → 2 day(s) at 8 h/day
console.log(plan(14, 4));        // 14 h → 4 day(s) at 4 h/day
console.log(plan(14, 4, 1));     // 14 h → 1 day(s) at 4 h/day

function bad(days = hours / 8, hours) { /* ... */ }
bad(undefined, 16);   // ✗ ReferenceError: Cannot access 'hours' before initialization

const required = (name) => {
  throw new Error(`Missing required parameter: ${name}`);
};

function assignTask(taskId = required('taskId'), assignee = required('assignee')) {
  return `Task ${taskId} assigned to ${assignee}`;
}

console.log(assignTask(3, 'Lucía'));   // Task 3 assigned to Lucía
assignTask(3);                         // ✗ Error: Missing required parameter: assignee

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

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

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

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

function workloadReport(assignee, ...hours) {
  let total = 0;
  for (const h of hours) total += h;
  return `${assignee}: ${hours.length} tasks, ${total} h`;
}

console.log(workloadReport('Iván', 12, 8, 5));   // Iván: 3 tasks, 25 h
console.log(workloadReport('Lucía', 14));        // Lucía: 1 tasks, 14 h
console.log(workloadReport('Nobody'));           // Nobody: 0 tasks, 0 h

describeTask(1, 'Redesign the multipurpose room', 'Iván', 'high', 'in-progress', 12, '2026-09-30', TODAY);

function describeTask(options) {
  const badge = options.status === 'done' ? '✓' : '○';
  const warning = options.dueDate < options.today && options.status !== 'done'
    ? ' ⚠ OVERDUE'
    : '';
  return `${badge} [${options.id}] ${options.title} · ${options.assignee} · ${options.estimatedHours} h${warning}`;
}

console.log(describeTask({
  id: 6,
  title: 'Carpentry workshop quote',
  assignee: 'Iván',
  priority: 'high',
  status: 'pending',
  estimatedHours: 5,
  dueDate: '2026-09-05',
  today: '2026-09-20'
}));
// ○ [6] Carpentry workshop quote · Iván · 5 h ⚠ OVERDUE

function formatBacklog(tasks, options = {}) {
  const separator = options.separator ?? '\n';
  const showHours = options.showHours ?? true;
  const sortBy = options.sortBy ?? 'date';
  // ...
}

formatBacklog(backlog);                                  // everything by default
formatBacklog(backlog, { sortBy: 'priority' });          // change only what matters
formatBacklog(backlog, { showHours: false, sortBy: 'assignee' });

// ✗ Staircase nesting
function calculateHeadroom(assignee, assignedHours, limit) {
  if (assignee !== null) {
    if (typeof assignedHours === 'number') {
      if (assignedHours <= limit) {
        return limit - assignedHours;
      } else {
        return 0;
      }
    }
  }
}

// ✓ Guards and early exit
function calculateHeadroom(assignee, assignedHours, limit) {
  if (assignee === null) return limit;
  if (typeof assignedHours !== 'number') return limit;
  if (assignedHours >= limit) return 0;
  return limit - assignedHours;
}

// ✗ Three different types depending on the case
function findHours(assignee) {
  if (assignee === null) return 'no assignee';
  if (assignee === 'Iván') return 25;
  return false;
}

const h = findHours('Marta');
console.log(h + 10);   // 10  ← false + 10, no error and no meaning

function findHours(assignee, assignees, hours) {
  if (assignee === null) return null;      // declared absence
  let total = 0;
  let found = false;
  for (let i = 0; i < assignees.length; i++) {
    if (assignees[i] === assignee) {
      total += hours[i];
      found = true;
    }
  }
  return found ? total : null;
}

// Option A: an object (recommended when the data has names)
function summarizeWorkload(hours, statuses) {
  let total = 0;
  let open = 0;
  let done = 0;
  for (let i = 0; i < hours.length; i++) {
    total += hours[i];
    if (statuses[i] === 'done') done += hours[i];
    else open += hours[i];
  }
  return { total: total, open: open, done: done };
}

const r = summarizeWorkload([12, 6, 14, 3, 8, 5],
                            ['in-progress', 'pending', 'pending', 'done', 'in-progress', 'pending']);
console.log(r.total, r.open, r.done);   // 48 45 3

// Option B: an array (only when the order is obvious and there are few values)
function dateRange(dates) {
  let earliest = dates[0];
  let latest = dates[0];
  for (const d of dates) {
    if (d < earliest) earliest = d;
    if (d > latest) latest = d;
  }
  return [earliest, latest];
}

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

// A preview: this is how it will be written from Module 4 onward
const { total, open, done } = summarizeWorkload(hours, statuses);
const [earliest, latest] = dateRange(dates);

// ✓ PURE: it depends only on its arguments and it only returns
function priorityWeight(priority) {
  if (priority === 'high') return 3;
  if (priority === 'medium') return 2;
  if (priority === 'low') return 1;
  return 0;
}

// ✗ IMPURE: it depends on an external variable
let weeklyLimit = 40;
function headroomFor(hours) {
  return weeklyLimit - hours;        // the result changes if weeklyLimit changes
}

// ✗ IMPURE: side effect (it writes to the console)
function report(assignee, hours) {
  console.log(`${assignee}: ${hours} h`);
}

// ✗ IMPURE: it depends on the clock
function daysUntil(dueDate) {
  const today = new Date();          // a different result every day
  return Math.ceil((new Date(dueDate) - today) / 86400000);
}

function headroomFor(hours, weeklyLimit) {
  return weeklyLimit - hours;
}

function daysUntil(dueDate, today) {
  return Math.ceil((new Date(dueDate) - new Date(today)) / 86400000);
}

console.log(daysUntil('2026-09-30', '2026-09-20'));   // 10
console.log(daysUntil('2026-09-05', '2026-09-20'));   // -15  (overdue)

'use strict';

const TODAY = '2026-09-20';

const required = (field) => {
  throw new Error(`Missing required field: ${field}`);
};

let lastId = 0;

/**
 * Creates a valid task from an options object.
 * Applies R1 (sequential id), R5 (born pending), R8 (assignee null),
 * R9 (tags lowercased and deduplicated).
 * Deliberately impure: it consumes the id counter.
 */
function createTask(options = {}) {
  const title = options.title ?? required('title');
  const estimatedHours = options.estimatedHours ?? required('estimatedHours');
  const dueDate = options.dueDate ?? required('dueDate');

  const assignee = options.assignee ?? null;             // R8
  const priority = options.priority ?? 'medium';
  const tags = normalizeTags(options.tags ?? []);        // R9
  const reviewer = options.reviewer ?? null;

  if (title.trim().length === 0) throw new Error('R2: the title cannot be empty.');
  if (estimatedHours <= 0 || estimatedHours > 40) throw new Error('R3: hours out of range (0-40).');

  lastId = lastId + 1;                                   // R1

  return {
    id: lastId,
    title: title.trim(),
    assignee: assignee,
    priority: priority,
    status: 'pending',                                   // R5
    tags: tags,
    estimatedHours: estimatedHours,
    dueDate: dueDate,
    reviewer: reviewer
  };
}

/** Pure: lowercase, no stray spaces and no duplicates (R9). */
function normalizeTags(tags) {
  const clean = [];
  for (const tag of tags) {
    const normalized = String(tag).trim().toLowerCase();
    if (normalized === '') continue;
    let duplicate = false;
    for (let j = 0; j < clean.length; j++) {
      if (clean[j] === normalized) { duplicate = true; break; }
    }
    if (!duplicate) clean.push(normalized);
  }
  return clean;
}

const created = createTask({
  title: '  Refurbish the lathe  ',
  estimatedHours: 10,
  dueDate: '2026-10-20',
  assignee: 'Lucía',
  priority: 'high',
  tags: ['Carpentry', 'carpentry', ' MAINTENANCE ']
});

console.log(created);
// {
//   id: 1,
//   title: 'Refurbish the lathe',
//   assignee: 'Lucía',
//   priority: 'high',
//   status: 'pending',
//   tags: [ 'carpentry', 'maintenance' ],
//   estimatedHours: 10,
//   dueDate: '2026-10-20',
//   reviewer: null
// }

/**
 * Returns several totals for one assignee in a single object.
 * Pure: same arrays and same assignee → same result.
 */
function summarizeWorkload(assignees, hours, statuses, dueDates, assignee, today = TODAY) {
  let totalHours = 0;
  let openHours = 0;
  let tasks = 0;
  let overdue = 0;

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

    tasks++;
    totalHours += hours[i];

    if (statuses[i] !== 'done') {
      openHours += hours[i];
      if (dueDates[i] < today) overdue++;
    }
  }

  return {
    assignee: assignee,
    tasks: tasks,
    totalHours: totalHours,
    openHours: openHours,
    overdue: overdue,
    headroom: 40 - openHours,          // R7
    overloaded: openHours > 40         // R7
  };
}

const assignees = ['Iván', 'Marta', 'Lucía', 'Marta', 'Iván', 'Iván'];
const hours     = [12, 6, 14, 3, 8, 5];
const statuses  = ['in-progress', 'pending', 'pending', 'done', 'in-progress', 'pending'];
const dueDates  = ['2026-09-30', '2026-10-15', '2026-10-02',
                   '2026-09-12', '2026-11-05', '2026-09-05'];

const team = ['Iván', 'Marta', 'Lucía'];
for (const person of team) {
  const r = summarizeWorkload(assignees, hours, statuses, dueDates, person);
  console.log(`${r.assignee}: ${r.tasks} tasks · ${r.openHours}/${r.totalHours} h open · ` +
              `headroom ${r.headroom} h · overdue ${r.overdue}`);
}
// Iván: 3 tasks · 25/25 h open · headroom 15 h · overdue 1
// Marta: 2 tasks · 6/9 h open · headroom 34 h · overdue 0
// Lucía: 1 tasks · 14/14 h open · headroom 26 h · overdue 0

function withHeadroom(hours) {
  hours = hours || 8;      // ✗ a legitimate 0 turns into 8
  return hours;
}
console.log(withHeadroom(0));   // 8  ← wrong

createTask({ ttile: 'New one', estimatedHours: 4, dueDate: '2026-10-01' });
// ✗ Error: Missing required field: title

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

// b)
let callCount = 0;
function urgency(priority, days) {
  callCount++;
  return priorityWeight(priority) * 10 - days;
}

// c)
function sortTags(tags) {
  tags.sort();
  return tags;
}

// d)
function marginStatus(dueDate) {
  const today = new Date().toISOString().slice(0, 10);
  return dueDate >= today ? 'on time' : 'overdue';
}

function generateReport(tasks, assignee, includeDone, sortBy, format, width, showOverdue) {
  // ...
}

// Calls that must work after the redesign:
// 1) Just the backlog, everything else by default
// 2) Iván's backlog, including the done tasks
// 3) The backlog sorted by priority, in compact format

// b) No side effect. If counting is needed, let the caller do it.
function urgency(priority, days) {
  return priorityWeight(priority) * 10 - days;
}

// c) Copy before sorting
function sortTags(tags) {
  const copy = [];
  for (const t of tags) copy.push(t);
  copy.sort();
  return copy;
}

const originals = ['screen-printing', 'design', 'carpentry'];
const sorted = sortTags(originals);
console.log(originals);   // [ 'screen-printing', 'design', 'carpentry' ]  ← untouched
console.log(sorted);      // [ 'carpentry', 'design', 'screen-printing' ]

// d) The date comes in as a parameter
function marginStatus(dueDate, today) {
  return dueDate >= today ? 'on time' : 'overdue';
}
console.log(marginStatus('2026-09-05', '2026-09-20'));   // overdue

function generateReport(tasks, options = {}) {
  const assignee     = options.assignee     ?? null;    // null = the whole team
  const includeDone  = options.includeDone  ?? false;
  const sortBy       = options.sortBy       ?? 'date';
  const format       = options.format       ?? 'detailed';
  const width        = options.width        ?? 80;
  const showOverdue  = options.showOverdue  ?? true;

  return `Report [${assignee ?? 'team'}] · sort: ${sortBy} · format: ${format} · ` +
         `${includeDone ? 'with' : 'without'} done · width ${width}` +
         `${showOverdue ? ' · marking overdue' : ''}`;
}

console.log(generateReport(backlog));
// Report [team] · sort: date · format: detailed · without done · width 80 · marking overdue

console.log(generateReport(backlog, { assignee: 'Iván', includeDone: true }));
// Report [Iván] · sort: date · format: detailed · with done · width 80 · marking overdue

console.log(generateReport(backlog, { sortBy: 'priority', format: 'compact' }));
// Report [team] · sort: priority · format: compact · without done · width 80 · marking overdue

function summarizeBacklog(statuses, hours, ...assigneeFilter) {
  const filtering = assigneeFilter.length > 0;

  let tasks = 0;
  let totalHours = 0;
  let openHours = 0;
  let doneHours = 0;

  for (let i = 0; i < statuses.length; i++) {
    if (filtering) {
      let matches = false;
      for (const name of assigneeFilter) {
        if (assignees[i] === name) { matches = true; break; }
      }
      if (!matches) continue;
    }

    tasks++;
    totalHours += hours[i];
    if (statuses[i] === 'done') doneHours += hours[i];
    else openHours += hours[i];
  }

  const percentage = totalHours === 0
    ? 0
    : Math.round((doneHours / totalHours) * 1000) / 10;

  return {
    tasks: tasks,
    totalHours: totalHours,
    openHours: openHours,
    completedPercentage: percentage
  };
}

console.log(summarizeBacklog(statuses, hours));
// { tasks: 6, totalHours: 48, openHours: 45, completedPercentage: 6.3 }

console.log(summarizeBacklog(statuses, hours, 'Iván'));
// { tasks: 3, totalHours: 25, openHours: 25, completedPercentage: 0 }

console.log(summarizeBacklog(statuses, hours, 'Marta', 'Lucía'));
// { tasks: 3, totalHours: 23, openHours: 20, completedPercentage: 13 }