fn pub static from_timestamp[T: ToFloat](
  time: ref T,
  utc_offset: Int,
) -> Option[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
  let nsec = (time.fractional * NANOS_PER_SEC).to_int

  Option.Some(
    DateTime(
      date: try Date.new(year, month, day),
      time: try Time.new(hour, minute, second, nsec),
      utc_offset: utc_offset,
    ),
  )
}

fn pub static local -> DateTime {
  let raw = sys.local_time

  DateTime(
    date: Date.new_unchecked(raw.year, raw.month, raw.day),
    time: Time.new_unchecked(raw.hour, raw.minute, raw.second, raw.nanos),
    utc_offset: raw.offset,
  )
}

fn pub inline static new(
  date: Date,
  time: Time,
  utc_offset: Int,
) -> DateTime {
  DateTime(date: date, time: time, utc_offset: utc_offset)
}

fn pub static parse[T: Bytes, L: Locale](
  input: ref T,
  format: String,
  locale: ref L,
) -> Option[DateTime] {
  if input.size == 0 or format.size == 0 { return Option.None }

  let mut inp_idx = 0
  let mut fmt_idx = 0
  let mut year = 0
  let mut mon = 1
  let mut day = 1
  let mut hour = 0
  let mut min = 0
  let mut sec = 0
  let mut nsec = 0
  let mut off = 0

  loop {
    match format.opt(fmt_idx) {
      case Some(PERCENT) -> {
        fmt_idx += 1

        match format.opt(fmt_idx) {
          case Some(PERCENT) if input.opt(inp_idx).or(-1) == PERCENT -> {
            fmt_idx += 1
            inp_idx += 1
          }
          case Some(PERCENT) -> return Option.None
          case Some(what) -> {
            fmt_idx += 1
            inp_idx += match what {
              case UPPER_Y -> {
                let neg = match input.opt(inp_idx) {
                  case Some(MINUS) -> {
                    inp_idx += 1
                    true
                  }
                  case _ -> false
                }

                match try four_digits(input, inp_idx) {
                  case v if neg -> year = v.opposite
                  case v -> year = v
                }

                4
              }
              case LOWER_M -> {
                mon = try two_digits(input, inp_idx)
                2
              }
              case LOWER_D -> {
                day = try two_digits(input, inp_idx)
                2
              }
              case UPPER_H -> {
                hour = try two_digits(input, inp_idx)
                2
              }
              case UPPER_M -> {
                min = try two_digits(input, inp_idx)
                2
              }
              case UPPER_S -> {
                sec = try two_digits(input, inp_idx)
                2
              }
              case LOWER_B -> {
                let idx_len = try locale.parse_short_month(input, inp_idx)

                mon = idx_len.0 + 1
                idx_len.1
              }
              case UPPER_B -> {
                let idx_len = try locale.parse_full_month(input, inp_idx)

                mon = idx_len.0 + 1
                idx_len.1
              }
              case LOWER_A -> {
                match try locale.parse_short_day_of_week(input, inp_idx) {
                  case (_, len) -> len
                }
              }
              case UPPER_A -> {
                match try locale.parse_full_day_of_week(input, inp_idx) {
                  case (_, len) -> len
                }
              }
              case LOWER_F -> {
                match input.opt(inp_idx := inp_idx + 1) {
                  case Some(DOT) -> {}
                  case _ -> return Option.None
                }

                match try digits(input, start: inp_idx, limit: 3) {
                  case (num, len) -> {
                    nsec = num * MICROS_PER_SEC
                    len
                  }
                }
              }
              case LOWER_Z -> {
                match input.opt(inp_idx) {
                  case Some(UPPER_Z) -> {
                    inp_idx += 1
                    next
                  }
                  case _ -> {}
                }

                let off_idx = try parse_offset(input, inp_idx)

                off = off_idx.0
                inp_idx = off_idx.1
                2
              }
              case UPPER_Z -> {
                match name_index_at(input, inp_idx, RFC_2822_ZONES) {
                  case Some((_, len)) -> {
                    inp_idx += len
                    next
                  }
                  case _ -> {}
                }

                let off_idx = try parse_offset(input, inp_idx)

                off = off_idx.0
                inp_idx = off_idx.1
                2
              }
              case _ -> return Option.None
            }
          }
          case _ -> return Option.None
        }
      }
      case Some(f) -> {
        match input.opt(inp_idx) {
          case Some(i) if f == i -> {
            fmt_idx += 1
            inp_idx += 1
          }
          case _ -> return Option.None
        }
      }
      case _ -> break
    }
  }

  Option.Some(
    DateTime.new(
      date: try Date.new(year, mon, day),
      time: try Time.new(hour, min, sec, nsec),
      utc_offset: off,
    ),
  )
}

fn pub static utc -> DateTime {
  let raw = sys.utc_time

  DateTime(
    date: Date.new_unchecked(raw.year, raw.month, raw.day),
    time: Time.new_unchecked(raw.hour, raw.minute, raw.second, raw.nanos),
    utc_offset: 0,
  )
}

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

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

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

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

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

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 inline ==(other: ref DateTime) -> Bool {
  @date == other.date
    and @time == other.time
    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 inline clone -> DateTime {
  DateTime(date: @date, time: @time, utc_offset: @utc_offset)
}

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

fn pub inline date -> Date {
  @date
}

fn pub inline day -> Int {
  @date.day
}

fn pub day_of_week -> Int {
  @date.day_of_week
}

fn pub day_of_year -> Int {
  @date.day_of_year
}

fn pub days_since_unix_epoch -> Int {
  @date.days_since_unix_epoch
}

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

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

  @date.fmt(formatter)
  formatter.write(' ')
  @time.fmt(formatter)
  formatter.write(offset)
}

fn pub format[L: Locale](how: String, locale: ref L) -> String {
  let buf = ByteArray.new
  let mut i = 0
  let max = how.size

  while i < max {
    match how.byte(i := i + 1) {
      case PERCENT -> {
        match how.opt(i := i + 1) {
          case Some(PERCENT) -> buf.push(PERCENT)
          case Some(UPPER_Y) -> format_digits(buf, year, amount: 4)
          case Some(LOWER_M) -> format_digits(buf, month, amount: 2)
          case Some(LOWER_D) -> format_digits(buf, day, amount: 2)
          case Some(UPPER_H) -> format_digits(buf, hour, amount: 2)
          case Some(UPPER_M) -> format_digits(buf, minute, amount: 2)
          case Some(UPPER_S) -> format_digits(buf, second, amount: 2)
          case Some(LOWER_B) -> buf.append(locale.short_month(month - 1))
          case Some(UPPER_B) -> buf.append(locale.full_month(month - 1))
          case Some(LOWER_A) -> {
            buf.append(locale.short_day_of_week(day_of_week - 1))
          }
          case Some(UPPER_A) -> {
            buf.append(locale.full_day_of_week(day_of_week - 1))
          }
          case Some(LOWER_F) -> {
            buf.push(DOT)
            format_digits(buf, nanosecond / MICROS_PER_SEC, amount: 1)
          }
          case Some(LOWER_Z) -> {
            if utc_offset == 0 {
              buf.push(UPPER_Z)
            } else {
              format_offset(buf, utc_offset)
            }
          }
          case Some(UPPER_Z) -> {
            if utc_offset == 0 {
              buf.append('GMT')
            } else {
              format_offset(buf, utc_offset)
            }
          }
          case Some(byte) -> {
            buf.push(PERCENT)
            buf.push(byte)
          }
          case _ -> buf.push(PERCENT)
        }
      }
      case byte -> buf.push(byte)
    }
  }

  buf.into_string
}

fn pub inline hour -> Int {
  @time.hour
}

fn pub leap_year? -> Bool {
  @date.leap_year?
}

fn pub inline minute -> Int {
  @time.minute
}

fn pub inline month -> Int {
  @date.month
}

fn pub inline nanosecond -> Int {
  @time.nanosecond
}

fn pub inline second -> Int {
  @time.second
}

fn pub inline time -> Time {
  @time
}

fn pub to_float -> Float {
  to_int.to_float + (nanosecond.to_float / NANOS_PER_SEC)
}

fn pub to_int -> Int {
  let days = days_since_unix_epoch
  let days_sec = days.absolute * SECS_PER_DAY
  let time_sec = (@time.hour * SECS_PER_HOUR)
    + (@time.minute * SECS_PER_MIN)
    + @time.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_iso8601 -> String {
  format('%Y-%m-%dT%H:%M:%S%f%z', English.new)
}

fn pub to_rfc2822 -> String {
  format('%a, %d %b %Y %H:%M:%S %Z', English.new)
}

fn pub to_utc -> DateTime {
  # Since our input is already valid at this point, this can never fail.
  DateTime.from_timestamp(time: to_float, utc_offset: 0).get
}

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

fn pub inline utc_offset -> Int {
  @utc_offset
}

fn pub inline year -> Int {
  @date.year
}