Holiday Calculation Failures

// Dangerous: Hardcoded holiday dates
class TradingSystem {
  constructor() {
    // This will be wrong every year!
    this.holidays2024 = [
      new Date(2024, 0, 1),   // New Year's Day
      new Date(2024, 3, 31),  // Easter - WRONG! Easter 2024 is March 31
      new Date(2024, 6, 4),   // July 4th
      new Date(2024, 11, 25), // Christmas
    ];
    
    // What about 2025? 2026? This system will break!
  }
  
  isHoliday(date) {
    // Only works for 2024, fails for any other year
    return this.holidays2024.some(holiday => 
      holiday.getTime() === date.getTime()
    );
  }
  
  isMarketOpen(date) {
    // Naive weekend + holiday check
    const dayOfWeek = date.getDay();
    
    if (dayOfWeek === 0 || dayOfWeek === 6) {
      return false; // Weekend
    }
    
    if (this.isHoliday(date)) {
      return false; // Holiday
    }
    
    return true;
  }
}

// Broken Easter calculation
function calculateEasterWrong(year) {
  // This is completely wrong!
  // Easter is NOT always the last Sunday in March
  const march = new Date(year, 2, 31); // March 31
  const dayOfWeek = march.getDay();
  const lastSunday = 31 - dayOfWeek;
  
  return new Date(year, 2, lastSunday);
}

// Financial settlement with broken holiday logic
function calculateSettlementDate(tradeDate, settlementDays) {
  const settlement = new Date(tradeDate);
  let daysAdded = 0;
  
  while (daysAdded < settlementDays) {
    settlement.setDate(settlement.getDate() + 1);
    
    // This will fail on holidays!
    const dayOfWeek = settlement.getDay();
    if (dayOfWeek !== 0 && dayOfWeek !== 6) {
      daysAdded++;
    }
  }
  
  return settlement;
}

// Banking payment system with hardcoded dates
const BANK_HOLIDAYS_2024 = {
  "2024-01-01": "New Year's Day",
  "2024-03-31": "Easter Sunday", // WRONG DATE!
  "2024-07-04": "Independence Day",
  "2024-12-25": "Christmas Day"
};

function processPayment(amount, targetDate) {
  const dateKey = targetDate.toISOString().split('T')[0];
  
  if (BANK_HOLIDAYS_2024[dateKey]) {
    // This only works for 2024!
    throw new Error("Cannot process payment on holiday");
  }
  
  // Process payment...
}

// Safe: Proper holiday calculation system
class TradingSystemSafe {
  constructor() {
    this.holidayCache = new Map();
  }
  
  // Correct Easter calculation using Gregorian algorithm
  calculateEaster(year) {
    const a = year % 19;
    const b = Math.floor(year / 100);
    const c = year % 100;
    const d = Math.floor(b / 4);
    const e = b % 4;
    const f = Math.floor((b + 8) / 25);
    const g = Math.floor((b - f + 1) / 3);
    const h = (19 * a + b - d - g + 15) % 30;
    const i = Math.floor(c / 4);
    const k = c % 4;
    const l = (32 + 2 * e + 2 * i - h - k) % 7;
    const m = Math.floor((a + 11 * h + 22 * l) / 451);
    const month = Math.floor((h + l - 7 * m + 114) / 31);
    const day = ((h + l - 7 * m + 114) % 31) + 1;
    
    return new Date(year, month - 1, day);
  }
  
  // Calculate Good Friday (2 days before Easter)
  calculateGoodFriday(year) {
    const easter = this.calculateEaster(year);
    const goodFriday = new Date(easter);
    goodFriday.setDate(easter.getDate() - 2);
    return goodFriday;
  }
  
  // Calculate all holidays for a given year
  calculateHolidays(year, country = 'US') {
    const cacheKey = `${year}-${country}`;
    
    if (this.holidayCache.has(cacheKey)) {
      return this.holidayCache.get(cacheKey);
    }
    
    const holidays = new Set();
    
    // Fixed holidays
    holidays.add(new Date(year, 0, 1).getTime());   // New Year's Day
    holidays.add(new Date(year, 6, 4).getTime());   // Independence Day (US)
    holidays.add(new Date(year, 11, 25).getTime()); // Christmas Day
    
    // Floating holidays
    const easter = this.calculateEaster(year);
    holidays.add(easter.getTime()); // Easter Sunday
    
    const goodFriday = this.calculateGoodFriday(year);
    holidays.add(goodFriday.getTime()); // Good Friday
    
    // Memorial Day (last Monday in May)
    const memorialDay = this.getLastMondayOfMonth(year, 4); // May = month 4
    holidays.add(memorialDay.getTime());
    
    // Labor Day (first Monday in September)
    const laborDay = this.getFirstMondayOfMonth(year, 8); // September = month 8
    holidays.add(laborDay.getTime());
    
    // Thanksgiving (fourth Thursday in November)
    const thanksgiving = this.getFourthThursdayOfMonth(year, 10); // November = month 10
    holidays.add(thanksgiving.getTime());
    
    this.holidayCache.set(cacheKey, holidays);
    return holidays;
  }
  
  getLastMondayOfMonth(year, month) {
    const lastDay = new Date(year, month + 1, 0); // Last day of month
    const dayOfWeek = lastDay.getDay();
    const daysToSubtract = dayOfWeek === 1 ? 0 : (dayOfWeek === 0 ? 6 : dayOfWeek - 1);
    lastDay.setDate(lastDay.getDate() - daysToSubtract);
    return lastDay;
  }
  
  getFirstMondayOfMonth(year, month) {
    const firstDay = new Date(year, month, 1);
    const dayOfWeek = firstDay.getDay();
    const daysToAdd = dayOfWeek === 1 ? 0 : (dayOfWeek === 0 ? 1 : 8 - dayOfWeek);
    firstDay.setDate(firstDay.getDate() + daysToAdd);
    return firstDay;
  }
  
  getFourthThursdayOfMonth(year, month) {
    const firstThursday = new Date(year, month, 1);
    const dayOfWeek = firstThursday.getDay();
    const daysToAdd = dayOfWeek <= 4 ? 4 - dayOfWeek : 11 - dayOfWeek;
    firstThursday.setDate(firstThursday.getDate() + daysToAdd);
    
    // Add 3 weeks to get the fourth Thursday
    firstThursday.setDate(firstThursday.getDate() + 21);
    return firstThursday;
  }
  
  isHoliday(date, country = 'US') {
    const year = date.getFullYear();
    const holidays = this.calculateHolidays(year, country);
    return holidays.has(date.getTime());
  }
  
  isBusinessDay(date, country = 'US') {
    const dayOfWeek = date.getDay();
    
    // Weekend check
    if (dayOfWeek === 0 || dayOfWeek === 6) {
      return false;
    }
    
    // Holiday check
    if (this.isHoliday(date, country)) {
      return false;
    }
    
    return true;
  }
  
  addBusinessDays(startDate, businessDays, country = 'US') {
    const result = new Date(startDate);
    let daysAdded = 0;
    
    while (daysAdded < businessDays) {
      result.setDate(result.getDate() + 1);
      
      if (this.isBusinessDay(result, country)) {
        daysAdded++;
      }
    }
    
    return result;
  }
}

// Safe financial settlement calculation
function calculateSettlementDateSafe(tradeDate, settlementDays, country = 'US') {
  const tradingSystem = new TradingSystemSafe();
  return tradingSystem.addBusinessDays(tradeDate, settlementDays, country);
}

// Multi-country holiday support
class GlobalHolidaySystem extends TradingSystemSafe {
  calculateHolidays(year, country = 'US') {
    switch (country) {
      case 'US':
        return super.calculateHolidays(year, country);
      
      case 'UK':
        return this.calculateUKHolidays(year);
      
      case 'CN':
        return this.calculateChineseHolidays(year);
      
      default:
        throw new Error(`Unsupported country: ${country}`);
    }
  }
  
  calculateUKHolidays(year) {
    const holidays = new Set();
    
    // UK specific holidays
    holidays.add(new Date(year, 0, 1).getTime());   // New Year's Day
    holidays.add(new Date(year, 11, 25).getTime()); // Christmas Day
    holidays.add(new Date(year, 11, 26).getTime()); // Boxing Day
    
    // Easter-based holidays
    const easter = this.calculateEaster(year);
    const goodFriday = new Date(easter);
    goodFriday.setDate(easter.getDate() - 2);
    holidays.add(goodFriday.getTime());
    
    const easterMonday = new Date(easter);
    easterMonday.setDate(easter.getDate() + 1);
    holidays.add(easterMonday.getTime());
    
    // Bank holidays (first and last Monday in May)
    const firstMayMonday = this.getFirstMondayOfMonth(year, 4);
    holidays.add(firstMayMonday.getTime());
    
    const lastMayMonday = this.getLastMondayOfMonth(year, 4);
    holidays.add(lastMayMonday.getTime());
    
    return holidays;
  }
  
  calculateChineseHolidays(year) {
    // This would require lunar calendar calculations
    // In practice, use a specialized library like moment-lunar
    const holidays = new Set();
    
    // Simplified - in reality, use proper lunar calendar library
    holidays.add(new Date(year, 0, 1).getTime()); // New Year's Day
    
    // Chinese New Year calculation would go here
    // This is extremely complex and should use a specialized library
    
    return holidays;
  }
}