Negative Timestamp Panic

// Dangerous: Unsigned timestamp assumptions
class DateSystem {
  constructor() {
    // Assumes all timestamps are positive!
    this.minTimestamp = 0;
    this.maxTimestamp = 4294967295; // 32-bit unsigned max
  }
  
  parseDate(dateString) {
    const date = new Date(dateString);
    const timestamp = Math.floor(date.getTime() / 1000);
    
    // This will fail for dates before 1970!
    if (timestamp < 0) {
      throw new Error("Invalid date: before Unix epoch");
    }
    
    return timestamp;
  }
  
  formatTimestamp(timestamp) {
    // Assumes timestamp is always positive
    if (timestamp > this.maxTimestamp) {
      throw new Error("Timestamp too large");
    }
    
    // No check for negative values!
    return new Date(timestamp * 1000).toISOString();
  }
}

// Embedded system with unsigned timestamp storage
struct DeviceLog {
  uint32_t timestamp;  // Can't store negative values!
  uint16_t sensor_id;
  float value;
};

// This will overflow for pre-1970 dates
void log_sensor_data(time_t event_time, uint16_t sensor, float value) {
  struct DeviceLog log;
  
  // Dangerous cast - negative time_t becomes huge positive uint32_t
  log.timestamp = (uint32_t)event_time;
  log.sensor_id = sensor;
  log.value = value;
  
  write_to_flash(&log, sizeof(log));
}

// Database migration that loses historical data
function migrateHistoricalData(records) {
  const migratedRecords = [];
  
  for (const record of records) {
    const timestamp = new Date(record.date).getTime() / 1000;
    
    // Skip all historical data!
    if (timestamp < 0) {
      console.log(`Skipping historical record: ${record.date}`);
      continue;
    }
    
    migratedRecords.push({
      id: record.id,
      timestamp: timestamp,
      data: record.data
    });
  }
  
  return migratedRecords;
}

// GPS system with week number overflow
class GPSSystem {
  constructor() {
    // 10-bit week counter (0-1023)
    this.weekNumber = 0;
    this.maxWeeks = 1024;
  }
  
  updateWeekNumber(currentWeek) {
    // This will overflow every 19.7 years!
    this.weekNumber = currentWeek % this.maxWeeks;
    
    if (this.weekNumber === 0) {
      // System doesn't know if this is week 0 or week 1024!
      throw new Error("GPS week rollover - ambiguous date");
    }
  }
  
  calculateDate(weekNumber, secondsInWeek) {
    // Assumes GPS epoch (January 6, 1980)
    const gpsEpoch = new Date('1980-01-06T00:00:00Z');
    const millisecondsPerWeek = 7 * 24 * 60 * 60 * 1000;
    
    // This breaks when weekNumber wraps around
    const totalMilliseconds = weekNumber * millisecondsPerWeek + secondsInWeek * 1000;
    
    return new Date(gpsEpoch.getTime() + totalMilliseconds);
  }
}

// Safe: Signed timestamp handling with validation
class DateSystemSafe {
  constructor() {
    // Use signed integers to handle negative timestamps
    this.minTimestamp = -2147483648; // 32-bit signed min (1901)
    this.maxTimestamp = 2147483647;  // 32-bit signed max (2038)
    
    // For 64-bit systems, use much larger ranges
    this.minTimestamp64 = -9223372036854775808n; // Way before any historical date
    this.maxTimestamp64 = 9223372036854775807n;  // Far into the future
  }
  
  parseDate(dateString) {
    const date = new Date(dateString);
    
    if (isNaN(date.getTime())) {
      throw new Error(`Invalid date format: ${dateString}`);
    }
    
    const timestamp = Math.floor(date.getTime() / 1000);
    
    // Validate range but allow negative timestamps
    if (timestamp < this.minTimestamp || timestamp > this.maxTimestamp) {
      throw new Error(`Date out of supported range: ${dateString} (${timestamp})`);
    }
    
    return timestamp;
  }
  
  formatTimestamp(timestamp) {
    // Validate range for both positive and negative timestamps
    if (timestamp < this.minTimestamp || timestamp > this.maxTimestamp) {
      throw new Error(`Timestamp out of range: ${timestamp}`);
    }
    
    // Handle negative timestamps correctly
    const date = new Date(timestamp * 1000);
    
    if (isNaN(date.getTime())) {
      throw new Error(`Invalid timestamp: ${timestamp}`);
    }
    
    return date.toISOString();
  }
  
  isHistoricalDate(timestamp) {
    return timestamp < 0; // Before Unix epoch
  }
  
  getDateInfo(timestamp) {
    const date = new Date(timestamp * 1000);
    
    return {
      timestamp: timestamp,
      iso: date.toISOString(),
      isHistorical: this.isHistoricalDate(timestamp),
      era: timestamp < 0 ? 'Pre-Unix Epoch' : 'Post-Unix Epoch',
      year: date.getFullYear(),
      isValid: !isNaN(date.getTime())
    };
  }
}

// Safe embedded system with signed timestamp storage
struct DeviceLogSafe {
  int64_t timestamp;   // Signed 64-bit can handle negative values
  uint16_t sensor_id;
  float value;
  uint8_t flags;       // Include metadata flags
};

// Safe logging with proper validation
int log_sensor_data_safe(time_t event_time, uint16_t sensor, float value) {
  struct DeviceLogSafe log;
  
  // Validate timestamp range
  if (event_time < MIN_SUPPORTED_TIME || event_time > MAX_SUPPORTED_TIME) {
    return -1; // Error: timestamp out of range
  }
  
  log.timestamp = (int64_t)event_time;
  log.sensor_id = sensor;
  log.value = value;
  log.flags = (event_time < 0) ? FLAG_HISTORICAL : FLAG_NORMAL;
  
  return write_to_flash(&log, sizeof(log));
}

// Safe database migration preserving historical data
function migrateHistoricalDataSafe(records) {
  const migratedRecords = [];
  const errors = [];
  
  for (const record of records) {
    try {
      const date = new Date(record.date);
      
      if (isNaN(date.getTime())) {
        errors.push(`Invalid date format: ${record.date}`);
        continue;
      }
      
      const timestamp = Math.floor(date.getTime() / 1000);
      
      // Preserve ALL data, including historical
      migratedRecords.push({
        id: record.id,
        timestamp: timestamp,
        data: record.data,
        isHistorical: timestamp < 0,
        originalDate: record.date,
        migrationDate: new Date().toISOString()
      });
      
      if (timestamp < 0) {
        console.log(`Preserved historical record: ${record.date} (${timestamp})`);
      }
      
    } catch (error) {
      errors.push(`Error processing record ${record.id}: ${error.message}`);
    }
  }
  
  return {
    migratedRecords,
    errors,
    stats: {
      total: records.length,
      migrated: migratedRecords.length,
      historical: migratedRecords.filter(r => r.isHistorical).length,
      errors: errors.length
    }
  };
}

// Safe GPS system with proper epoch handling
class GPSSystemSafe {
  constructor() {
    this.gpsEpoch = new Date('1980-01-06T00:00:00Z');
    this.weekRollovers = 0; // Track how many times we've rolled over
    this.lastKnownWeek = 0;
  }
  
  updateWeekNumber(currentWeek) {
    // Detect rollover
    if (currentWeek < this.lastKnownWeek && (this.lastKnownWeek - currentWeek) > 500) {
      this.weekRollovers++;
      console.log(`GPS week rollover detected. Rollover count: ${this.weekRollovers}`);
    }
    
    this.lastKnownWeek = currentWeek;
  }
  
  calculateDate(weekNumber, secondsInWeek) {
    // Account for rollovers
    const actualWeekNumber = weekNumber + (this.weekRollovers * 1024);
    const millisecondsPerWeek = 7 * 24 * 60 * 60 * 1000;
    
    const totalMilliseconds = actualWeekNumber * millisecondsPerWeek + secondsInWeek * 1000;
    const calculatedDate = new Date(this.gpsEpoch.getTime() + totalMilliseconds);
    
    return {
      date: calculatedDate,
      weekNumber: actualWeekNumber,
      rollovers: this.weekRollovers,
      isValid: !isNaN(calculatedDate.getTime())
    };
  }
  
  // Validate GPS date against known constraints
  validateGPSDate(date) {
    const gpsEpochTime = this.gpsEpoch.getTime();
    const dateTime = date.getTime();
    
    if (dateTime < gpsEpochTime) {
      throw new Error(`Date ${date.toISOString()} is before GPS epoch`);
    }
    
    // GPS dates shouldn't be too far in the future
    const maxFutureDate = new Date();
    maxFutureDate.setFullYear(maxFutureDate.getFullYear() + 50);
    
    if (dateTime > maxFutureDate.getTime()) {
      throw new Error(`Date ${date.toISOString()} is too far in the future`);
    }
    
    return true;
  }
}

// Utility functions for safe timestamp handling
const TimestampUtils = {
  isValidTimestamp(timestamp) {
    if (typeof timestamp !== 'number' || isNaN(timestamp)) {
      return false;
    }
    
    // Check reasonable bounds (year 1900 to year 2100)
    const minTimestamp = -2208988800; // 1900-01-01
    const maxTimestamp = 4102444800;  // 2100-01-01
    
    return timestamp >= minTimestamp && timestamp <= maxTimestamp;
  },
  
  safeTimestampToDate(timestamp) {
    if (!this.isValidTimestamp(timestamp)) {
      throw new Error(`Invalid timestamp: ${timestamp}`);
    }
    
    const date = new Date(timestamp * 1000);
    
    if (isNaN(date.getTime())) {
      throw new Error(`Cannot convert timestamp to date: ${timestamp}`);
    }
    
    return date;
  },
  
  safeDateToTimestamp(date) {
    if (!(date instanceof Date) || isNaN(date.getTime())) {
      throw new Error(`Invalid date object: ${date}`);
    }
    
    const timestamp = Math.floor(date.getTime() / 1000);
    
    if (!this.isValidTimestamp(timestamp)) {
      throw new Error(`Date produces invalid timestamp: ${date.toISOString()}`);
    }
    
    return timestamp;
  }
};