ISO Week 53 Surprise

// Dangerous: Fixed 52-week assumption
class PayrollSystem {
  constructor() {
    // This will crash on Week 53!
    this.weeklyData = new Array(52);
    this.weeklyBudgets = new Array(52);
    this.overtimeRates = new Array(52);
  }
  
  calculateAnnualSalary(weeklySalary) {
    // Always assumes 52 weeks - WRONG!
    return weeklySalary * 52;
  }
  
  getWeekData(weekNumber) {
    // Array bounds error on Week 53
    if (weekNumber > 52) {
      throw new Error("Invalid week number");
    }
    return this.weeklyData[weekNumber - 1];
  }
  
  processTimesheet(year, weekNumber, hours) {
    // Crashes when weekNumber = 53
    const weekIndex = weekNumber - 1;
    
    if (weekIndex >= this.weeklyData.length) {
      // System crash - Week 53 doesn't exist in our array!
      throw new Error("Week number out of bounds");
    }
    
    this.weeklyData[weekIndex] = hours;
  }
}

// Database schema that fails
const createPayrollTable = `
  CREATE TABLE weekly_payroll (
    employee_id INT,
    year INT,
    week_number INT CHECK (week_number BETWEEN 1 AND 52), -- FAILS on Week 53!
    hours_worked DECIMAL(5,2),
    overtime_hours DECIMAL(5,2),
    PRIMARY KEY (employee_id, year, week_number)
  )
`;

// Report generation that breaks
function generateAnnualReport(year) {
  const weeks = [];
  
  // Only generates 52 weeks - misses Week 53 data!
  for (let week = 1; week <= 52; week++) {
    weeks.push(getWeekData(year, week));
  }
  
  return {
    year: year,
    totalWeeks: 52, // Wrong for 53-week years!
    weeklyData: weeks,
    annualTotal: weeks.reduce((sum, week) => sum + week.total, 0)
  };
}

// Safe: Dynamic week handling
class PayrollSystemSafe {
  constructor() {
    // Use Maps instead of fixed arrays
    this.weeklyData = new Map();
    this.weeklyBudgets = new Map();
    this.overtimeRates = new Map();
  }
  
  getWeeksInYear(year) {
    // Properly calculate weeks in year
    const jan1 = new Date(year, 0, 1);
    const dec31 = new Date(year, 11, 31);
    
    // Check if year has 53 weeks
    const jan1Day = jan1.getDay();
    const isLeapYear = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
    
    // Week 53 occurs when Jan 1 is Thursday, or Wednesday in leap years
    return (jan1Day === 4 || (jan1Day === 3 && isLeapYear)) ? 53 : 52;
  }
  
  calculateAnnualSalary(weeklySalary, year) {
    // Use actual weeks in year
    const weeksInYear = this.getWeeksInYear(year);
    return weeklySalary * weeksInYear;
  }
  
  getWeekData(year, weekNumber) {
    const maxWeeks = this.getWeeksInYear(year);
    
    if (weekNumber < 1 || weekNumber > maxWeeks) {
      throw new Error(`Invalid week number ${weekNumber} for year ${year}. Valid range: 1-${maxWeeks}`);
    }
    
    const key = `${year}-${weekNumber}`;
    return this.weeklyData.get(key) || null;
  }
  
  processTimesheet(year, weekNumber, hours) {
    const maxWeeks = this.getWeeksInYear(year);
    
    if (weekNumber < 1 || weekNumber > maxWeeks) {
      throw new Error(`Week ${weekNumber} is invalid for year ${year}. Year has ${maxWeeks} weeks.`);
    }
    
    const key = `${year}-${weekNumber}`;
    this.weeklyData.set(key, hours);
    
    // Log for audit trail
    console.log(`Processed timesheet for ${year}-W${weekNumber} (${maxWeeks}-week year)`);
  }
}

// Safe database schema
const createPayrollTableSafe = `
  CREATE TABLE weekly_payroll (
    employee_id INT,
    year INT,
    week_number INT CHECK (week_number BETWEEN 1 AND 53), -- Allows Week 53
    hours_worked DECIMAL(5,2),
    overtime_hours DECIMAL(5,2),
    is_week_53 BOOLEAN DEFAULT FALSE, -- Flag for Week 53 records
    PRIMARY KEY (employee_id, year, week_number),
    -- Additional constraint to ensure Week 53 only in valid years
    CONSTRAINT valid_week_53 CHECK (
      week_number <= 52 OR 
      (week_number = 53 AND is_week_53 = TRUE)
    )
  )
`;

// Safe report generation
function generateAnnualReportSafe(year) {
  const payrollSystem = new PayrollSystemSafe();
  const maxWeeks = payrollSystem.getWeeksInYear(year);
  const weeks = [];
  
  // Generate report for actual number of weeks
  for (let week = 1; week <= maxWeeks; week++) {
    const weekData = payrollSystem.getWeekData(year, week);
    if (weekData) {
      weeks.push({
        ...weekData,
        weekNumber: week,
        isWeek53: week === 53
      });
    }
  }
  
  return {
    year: year,
    totalWeeks: maxWeeks,
    hasWeek53: maxWeeks === 53,
    weeklyData: weeks,
    annualTotal: weeks.reduce((sum, week) => sum + (week.total || 0), 0),
    generatedAt: new Date().toISOString()
  };
}

// ISO week calculation utility
function getISOWeek(date) {
  const target = new Date(date.valueOf());
  const dayNumber = (date.getDay() + 6) % 7;
  target.setDate(target.getDate() - dayNumber + 3);
  const firstThursday = target.valueOf();
  target.setMonth(0, 1);
  if (target.getDay() !== 4) {
    target.setMonth(0, 1 + ((4 - target.getDay()) + 7) % 7);
  }
  return 1 + Math.ceil((firstThursday - target) / 604800000);
}