Y2K Leap Year Oversight

// COBOL - Many mainframe systems had this RIGHT
LEAP-YEAR-CHECK.
    IF YEAR-VAR IS DIVISIBLE BY 400
        MOVE 'Y' TO LEAP-FLAG
    ELSE
        IF YEAR-VAR IS DIVISIBLE BY 100
            MOVE 'N' TO LEAP-FLAG
        ELSE
            IF YEAR-VAR IS DIVISIBLE BY 4
                MOVE 'Y' TO LEAP-FLAG
            ELSE
                MOVE 'N' TO LEAP-FLAG.

// This was often CORRECT but got "fixed" for Y2K!

// C - Quick Y2K fix that breaks general logic
int isLeapYear(int year) {
    // Y2K fix: hardcode year 2000
    if (year == 2000) {
        return 1;  // 2000 is leap year
    }
    
    // Simple rule for other years (WRONG!)
    return (year % 4 == 0);
}

// This will incorrectly say 1900 and 2100 are leap years!
// Works for 2000, 2004, 2008... but fails for century years

// Java - Assumes post-2000 years are "modern"
public boolean isLeapYear(int year) {
    if (year >= 2000) {
        // "Modern" leap year logic (incomplete!)
        return (year % 4 == 0) && (year % 100 != 0);
    } else {
        // Legacy logic for pre-2000
        return legacyLeapYearCheck(year);
    }
}

// This breaks in 2400! (divisible by 400, should be leap year)
// Also assumes pre-2000 logic was wrong (often it wasn't!)

// VB6 - Missing the 400-year exception
Function IsLeapYear(year As Integer) As Boolean
    ' Y2K remediation: fixed leap year calculation
    ' Handles century years correctly... or does it?
    
    If year Mod 4 = 0 And year Mod 100 <> 0 Then
        IsLeapYear = True
    Else
        IsLeapYear = False
    End If
End Function

' This correctly handles 1900 (not leap) and 2004 (leap)
' But INCORRECTLY handles 2000 and 2400 (should be leap years!)
' The Y2K team "fixed" a bug that wasn't there

// C# - The correct, complete leap year algorithm
public static bool IsLeapYear(int year)
{
    // Rule 3: Years divisible by 400 are leap years
    if (year % 400 == 0) return true;
    
    // Rule 2: Years divisible by 100 are NOT leap years
    if (year % 100 == 0) return false;
    
    // Rule 1: Years divisible by 4 are leap years
    if (year % 4 == 0) return true;
    
    // All other years are not leap years
    return false;
}

// Test cases that Y2K fixes often broke:
// IsLeapYear(1900) → false ✓ (divisible by 100, not by 400)
// IsLeapYear(2000) → true  ✓ (divisible by 400)
// IsLeapYear(2004) → true  ✓ (divisible by 4, not by 100)
// IsLeapYear(2100) → false ✓ (divisible by 100, not by 400)

// Python - Let the standard library handle it
import calendar
from datetime import datetime

def is_leap_year_safe(year):
    """Use Python's built-in leap year logic"""
    return calendar.isleap(year)

def validate_date_safe(year, month, day):
    """Use datetime for validation - handles all edge cases"""
    try:
        datetime(year, month, day)
        return True
    except ValueError:
        return False

# JavaScript - Use Date object
function isLeapYearSafe(year) {
    // February 29th exists in leap years
    return new Date(year, 1, 29).getDate() === 29;
}

// Java 8+ - Use built-in Year class
import java.time.Year;

public boolean isLeapYearSafe(int year) {
    return Year.of(year).isLeap();
}

// Strategy for fixing Y2K-era leap year bugs
public class LeapYearMigration {
    
    // Step 1: Identify the current (possibly broken) logic
    private boolean legacyIsLeapYear(int year) {
        // Document what the current system does
        // This might be a Y2K-era "fix" that's actually broken
        return currentSystemLogic(year);
    }
    
    // Step 2: Implement correct logic
    private boolean correctIsLeapYear(int year) {
        if (year % 400 == 0) return true;
        if (year % 100 == 0) return false;
        if (year % 4 == 0) return true;
        return false;
    }
    
    // Step 3: Migration with validation
    public boolean isLeapYear(int year) {
        boolean legacyResult = legacyIsLeapYear(year);
        boolean correctResult = correctIsLeapYear(year);
        
        if (legacyResult != correctResult) {
            // Log discrepancy for analysis
            logLeapYearDiscrepancy(year, legacyResult, correctResult);
            
            // For now, use correct logic but flag for review
            auditLeapYearCalculation(year);
        }
        
        return correctResult;
    }
    
    // Step 4: Test against known cases
    public void validateLeapYearLogic() {
        // Test cases that Y2K fixes often broke
        assert !isLeapYear(1900) : "1900 should not be leap year";
        assert isLeapYear(2000) : "2000 should be leap year";
        assert isLeapYear(2004) : "2004 should be leap year";
        assert !isLeapYear(2100) : "2100 should not be leap year";
        assert isLeapYear(2400) : "2400 should be leap year";
    }
}