fn pub static from_timestamp[T: ToFloat](
  time: ref T,
  utc_offset: Int,
) -> DateTime {
  # This implementation is based on the algorithms as described on
  # http://howardhinnant.github.io/date_algorithms.html, specifically the
  # `civil_from_days()` algorithm.
  #
  # To be truly honest, at the time of writing I didn't fully understand the
  # algorithm, and reading through the linked article made my head spin. But
  # it works, so ship it!
  #
  # Important note: this algorithm works because Inko implements integer
  # divisions as floored divisions (like e.g. Python and Ruby), instead of
  # rounding towards zero (like Rust and C).
  let time = time.to_float
  let epoch_secs = time.to_int + utc_offset
  let epoch_days = (epoch_secs / SECS_PER_DAY) + 719_468
  let era = if epoch_days >= 0 { epoch_days } else { epoch_days - 146_096 }
    / 146_097
  let doe = epoch_days - (era * 146_097)
  let yoe = (doe - (doe / 1460) + (doe / 36_524) - (doe / 146_096)) / 365
  let doy = doe - ((365 * yoe) + (yoe / 4) - (yoe / 100))
  let mp = ((5 * doy) + 2) / 153
  let day = doy - ((153 * mp) + 2 / 5) + 1
  let month = if mp < 10 { mp + 3 } else { mp - 9 }
  let mut year = yoe + (era * 400)

  if month <= 2 { year += 1 }

  # The number of seconds since the start of the day.
  let mut day_secs = epoch_secs - ((epoch_secs / SECS_PER_DAY) * SECS_PER_DAY)
  let second = day_secs % 60
  let minute = (day_secs % SECS_PER_HOUR) / 60
  let hour = day_secs / SECS_PER_HOUR

  DateTime(
    year: year,
    month: month,
    day: day,
    hour: hour,
    minute: minute,
    second: second,
    sub_second: time.fractional,
    utc_offset: utc_offset,
  )
}

fn pub static new -> DateTime {
  from_timestamp(inko_time_system, inko_time_system_offset as Int)
}

fn pub static utc -> DateTime {
  from_timestamp(time: inko_time_system, utc_offset: 0)
}

fn pub !=(other: T) -> Bool {
  (self == other).false?
}

fn pub +(other: ref Duration) -> DateTime {
  let timestamp = to_float + other.to_secs

  DateTime.from_timestamp(timestamp, utc_offset: @utc_offset)
}

fn pub -(other: ref Duration) -> DateTime {
  let timestamp = to_float - other.to_secs

  DateTime.from_timestamp(timestamp, utc_offset: @utc_offset)
}

fn pub <(other: ref T) -> Bool {
  match cmp(other) {
    case Less -> true
    case _ -> false
  }
}

fn pub <=(other: ref T) -> Bool {
  match cmp(other) {
    case Less or Equal -> true
    case _ -> false
  }
}

fn pub ==(other: ref DateTime) -> Bool {
  @year == other.year
    and @month == other.month
    and @day == other.day
    and @hour == other.hour
    and @minute == other.minute
    and @second == other.second
    and @sub_second == other.sub_second
    and @utc_offset == other.utc_offset
}

fn pub >(other: ref T) -> Bool {
  match cmp(other) {
    case Greater -> true
    case _ -> false
  }
}

fn pub >=(other: ref T) -> Bool {
  match cmp(other) {
    case Greater or Equal -> true
    case _ -> false
  }
}

fn pub clone -> DateTime {
  DateTime(
    year: @year,
    month: @month,
    day: @day,
    hour: @hour,
    minute: @minute,
    second: @second,
    sub_second: @sub_second,
    utc_offset: @utc_offset,
  )
}

fn pub cmp(other: ref DateTime) -> Ordering {
  to_float.cmp(other.to_float)
}

fn pub day_of_week -> Int {
  # January 1st, 1970 (our anchor date) was on a Thursday. We add 3 so that
  # Monday (3 days before Thursday) becomes the anchor date.
  #
  # We later on add 1 since the % operator will return 0 for Monday (since its
  # the first value in the range), but week days range from 1 to 7; not 0 to
  # 6.
  #
  # The following table should help illustrate this:
  #
  # | Date       | Day of week | days_since_unix_epoch
  # |:-----------|:------------|:----------------------
  # | 1969-12-29 | Monday      | -3
  # | 1969-12-30 | Tuesday     | -2
  # | 1969-12-31 | Wednesday   | -1
  # | 1970-01-01 | Thursday    | 0
  # | 1970-01-02 | Friday      | 1
  # | 1970-01-03 | Saturday    | 2
  # | 1970-01-04 | Sunday      | 3
  #
  # For these dates, the calculations would be as follows:
  #
  # | Date       | Calculation        | Simplified  | Return value
  # |:-----------|:-------------------|:------------|:------------
  # | 1969-12-29 | ((-3 + 3) % 7) + 1 | (0 % 7) + 1 | 1
  # | 1969-12-30 | ((-2 + 3) % 7) + 1 | (1 % 7) + 1 | 2
  # | 1969-12-31 | ((-1 + 3) % 7) + 1 | (2 % 7) + 1 | 3
  # | 1970-01-01 | ((0 + 3) % 7) + 1  | (3 % 7) + 1 | 4
  # | 1970-01-02 | ((1 + 3) % 7) + 1  | (4 % 7) + 1 | 5
  # | 1970-01-03 | ((2 + 3) % 7) + 1  | (5 % 7) + 1 | 6
  # | 1970-01-04 | ((3 + 3) % 7) + 1  | (6 % 7) + 1 | 7
  days_since_unix_epoch + 3 % DAYS_PER_WEEK + 1
}

fn pub day_of_year -> Int {
  let days = if leap_year? { LEAP_DAYS } else { NORMAL_DAYS }

  days.get(@month - 1) + @day
}

fn pub days_since_unix_epoch -> Int {
  let year = if @month <= 2 { @year - 1 } else { @year }
  let month = @month
  let era = if year >= 0 { year } else { year - 399 } / 400
  let yoe = year - (era * 400)
  let doy = (((153 * if month > 2 { month - 3 } else { month + 9 }) + 2) / 5)
    + @day
    - 1
  let doe = (yoe * 365) + (yoe / 4) - (yoe / 100) + doy

  (era * 146_097) + doe - 719_468
}

fn pub fmt(formatter: mut Formatter) {
  let sign = if @utc_offset > 0 { '+' } else { '-' }
  let offset = if @utc_offset == 0 {
    ' UTC'
  } else {
    let hh = (@utc_offset / SECS_PER_HOUR).to_string.pad_start(
      with: '0',
      chars: 2,
    )
    let mm = (@utc_offset % SECS_PER_HOUR / 60).to_string.pad_start(
      with: '0',
      chars: 2,
    )

    ' ${sign}${hh}${mm}'
  }

  let year = @year.to_string.pad_start(with: '0', chars: 4)
  let month = @month.to_string.pad_start(with: '0', chars: 2)
  let day = @day.to_string.pad_start(with: '0', chars: 2)
  let hour = @hour.to_string.pad_start(with: '0', chars: 2)
  let min = @minute.to_string.pad_start(with: '0', chars: 2)
  let secs = @second.to_string.pad_start(with: '0', chars: 2)

  formatter.write('${year}-${month}-${day} ${hour}:${min}:${secs}${offset}')
}

fn pub leap_year? -> Bool {
  let year = @year

  (year % 4) == 0 and ((year % 100) > 0 or (year % 400) == 0)
}

fn pub to_float -> Float {
  to_int.to_float + @sub_second
}

fn pub to_int -> Int {
  let days = days_since_unix_epoch
  let days_sec = days.absolute * SECS_PER_DAY
  let time_sec = (@hour * SECS_PER_HOUR) + (@minute * SECS_PER_MIN) + @second
  let timestamp = if days < 0 {
    0 - (days_sec - time_sec)
  } else {
    days_sec + time_sec
  }

  # Timestamps are always in UTC, not in the local time.
  timestamp - @utc_offset
}

fn pub to_utc -> DateTime {
  DateTime.from_timestamp(time: to_float, utc_offset: 0)
}

fn pub utc? -> Bool {
  @utc_offset == 0
}