Atomic Time

// Assumes minutes always have exactly 60 seconds
function calculateDuration(startTime, endTime) {
  const diffMs = endTime.getTime() - startTime.getTime();
  const minutes = Math.floor(diffMs / (60 * 1000));
  const seconds = Math.floor((diffMs % (60 * 1000)) / 1000);
  
  // This breaks during leap seconds when a minute has 61 seconds
  return `${minutes}:${seconds.toString().padStart(2, '0')}`;
}

// Assumes timestamps are always increasing
function validateTimestamps(timestamps) {
  for (let i = 1; i < timestamps.length; i++) {
    if (timestamps[i] <= timestamps[i-1]) {
      throw new Error('Timestamps must be strictly increasing');
    }
  }
  // This fails during leap seconds when time can appear to go backward
}

// Ignores leap second announcements
function scheduleSystemMaintenance(date) {
  // Schedule maintenance for end of month
  const maintenanceTime = new Date(date.getFullYear(), date.getMonth() + 1, 0, 23, 59, 30);
  
  // This could schedule maintenance during a leap second event
  // when systems are most likely to fail
  return maintenanceTime;
}

// Assumes UTC and TAI are the same
function convertToAtomicTime(utcTime) {
  // Wrong! UTC and TAI differ by leap seconds (37 seconds as of 2023)
  return utcTime; // This is off by 37 seconds
}

// Handle variable minute lengths gracefully
function calculateDurationSafe(startTime, endTime) {
  const diffMs = endTime.getTime() - startTime.getTime();
  
  // Use total seconds instead of assuming 60 seconds per minute
  const totalSeconds = Math.floor(diffMs / 1000);
  const minutes = Math.floor(totalSeconds / 60);
  const seconds = totalSeconds % 60;
  
  return `${minutes}:${seconds.toString().padStart(2, '0')}`;
}

// Use monotonic timestamps for ordering
function validateTimestampsRobust(events) {
  // Use performance.now() or process.hrtime() for ordering
  // These are monotonic and not affected by leap seconds
  for (let i = 1; i < events.length; i++) {
    if (events[i].monotonicTime <= events[i-1].monotonicTime) {
      throw new Error('Event order violation');
    }
  }
}

// Check for leap second announcements
function isLeapSecondDate(date) {
  // Check if date is June 30 or December 31
  const month = date.getMonth();
  const day = date.getDate();
  
  return (month === 5 && day === 30) || (month === 11 && day === 31);
}

function scheduleMaintenanceSafely(date) {
  const maintenanceTime = new Date(date.getFullYear(), date.getMonth() + 1, 0, 23, 30, 0);
  
  // Avoid scheduling during potential leap second times
  if (isLeapSecondDate(maintenanceTime)) {
    console.warn('Potential leap second date - consider rescheduling');
    // Schedule for earlier in the day to avoid 23:59:60
    maintenanceTime.setHours(22, 0, 0, 0);
  }
  
  return maintenanceTime;
}

// Properly convert between UTC and TAI
function convertUTCtoTAI(utcTime) {
  // As of 2023, TAI is 37 seconds ahead of UTC
  // This offset changes when leap seconds are added
  const leapSecondOffset = 37; // Should be looked up from current tables
  
  return new Date(utcTime.getTime() + (leapSecondOffset * 1000));
}

// Handle leap second events gracefully
function handleTimeUpdate(newTime, previousTime) {
  const timeDiff = newTime.getTime() - previousTime.getTime();
  
  if (timeDiff < 0) {
    // Time went backward - possible leap second or clock adjustment
    console.warn('Time went backward, possible leap second event');
    return { time: newTime, leapSecondSuspected: true };
  }
  
  if (timeDiff > 2000) {
    // Large time jump - possible leap second or system issue
    console.warn('Large time jump detected');
    return { time: newTime, timeJumpDetected: true };
  }
  
  return { time: newTime, normal: true };
}

// Use NTP with leap second awareness
function syncTimeWithLeapSecondHandling() {
  // Configure NTP client to handle leap seconds appropriately
  // Options: step, slew, or ignore leap seconds based on system requirements
  const ntpConfig = {
    server: 'pool.ntp.org',
    leapSecondHandling: 'slew', // Gradually adjust instead of stepping
    maxOffset: 1000 // Maximum acceptable time offset in ms
  };
  
  return ntpConfig;
}