plum

module std
import std/Number
import std/Str
import std/Bool

# A raw, host-provided wall-clock reading: milliseconds since the Unix epoch.
extern fun rawNowMillis() -> Int

# A single point in time, stored as milliseconds since the Unix epoch.
enum Time(ToStr) =
  | Time(value: Int)

  fun toMillis(self) -> Int =
    return self.value

  fun toSeconds(self) -> Int =
    return floorDiv(self.value, 1000)

  fun add(self, d: Duration) -> Time =
    return Time(value: self.value + d.value)

  fun sub(self, d: Duration) -> Time =
    return Time(value: self.value - d.value)

  # The `Duration` elapsed between `other` and `self` (`self - other`) —
  # positive if `self` is later than `other`.
  fun since(self, other: Time) -> Duration =
    return Duration(value: self.value - other.value)

  fun isBefore(self, other: Time) -> Bool =
    return self.value < other.value

  fun isAfter(self, other: Time) -> Bool =
    return self.value > other.value

  fun equals(self, other: Time) -> Bool =
    return self.value == other.value

  # The proleptic-Gregorian calendar date this instant falls on, in UTC.
  fun date(self) -> Civil =
    return civilFromDays(floorDiv(self.value, MILLIS_PER_DAY))

  fun year(self) -> Int =
    return self.date().year

  fun month(self) -> Int =
    return self.date().month

  fun day(self) -> Int =
    return self.date().day

  fun hour(self) -> Int =
    return floorMod(floorDiv(self.value, 3600000), 24)

  fun minute(self) -> Int =
    return floorMod(floorDiv(self.value, 60000), 60)

  fun second(self) -> Int =
    return floorMod(floorDiv(self.value, 1000), 60)

  fun millisecond(self) -> Int =
    return floorMod(self.value, 1000)

  # Day of the week: 0 = Sunday, ..., 6 = Saturday (1970-01-01 was a
  # Thursday, hence the `+ 4` offset from the epoch day).
  fun weekday(self) -> Int =
    return floorMod(floorDiv(self.value, MILLIS_PER_DAY) + 4, 7)

  # ISO 8601 / RFC 3339, always in UTC (`Z`): `YYYY-MM-DDTHH:MM:SS.mmmZ`.
  fun toStr(self) -> Str =
    d := self.date()
    return d.year.toStr().padStart("0", 4) + "-" + d.month.toStr().padStart("0", 2)
      + "-" + d.day.toStr().padStart("0", 2) + "T" + self.hour().toStr().padStart("0", 2)
      + ":" + self.minute().toStr().padStart("0", 2) + ":" + self.second().toStr().padStart("0", 2)
      + "." + self.millisecond().toStr().padStart("0", 3) + "Z"

fun now() -> Time =
  return Time(value: rawNowMillis())

# A Gregorian calendar date, decomposed from a day count by `civilFromDays`.
enum Civil =
  | Civil(year: Int, month: Int, day: Int)

MILLIS_PER_DAY = 86400000

# Days-since-epoch to proleptic Gregorian year/month/day, via Howard
# Hinnant's `civil_from_days` (http://howardhinnant.github.io/date_algorithms.html) —
# pure integer math, valid for the whole range representable by `Int`, and
# exact (no floating-point rounding).
fun civilFromDays(z: Int) -> Civil =
  zz := z + 719468
  era := zz >= 0 ? zz / 146097 : { zz - 146096 } / 146097
  doe := zz - era * 146097
  yoe := { doe - doe / 1460 + doe / 36524 - doe / 146096 } / 365
  y := yoe + era * 400
  doy := doe - { 365 * yoe + yoe / 4 - yoe / 100 }
  mp := { 5 * doy + 2 } / 153
  d := doy - { 153 * mp + 2 } / 5 + 1
  m := mp < 10 ? mp + 3 : mp - 9
  return Civil(year: m <= 2 ? y + 1 : y, month: m, day: d)

# Integer division rounding toward negative infinity, unlike `/`'s
# round-toward-zero — needed so times before the epoch (negative `value`)
# still decompose into the correct calendar day/hour/etc rather than one
# past it.
fun floorDiv(a: Int, b: Int) -> Int =
  q := a / b
  r := a % b
  return { { r < 0 && b > 0 } || { r > 0 && b < 0 } } ? q - 1 : q

fun floorMod(a: Int, b: Int) -> Int =
  r := a % b
  return { { r < 0 && b > 0 } || { r > 0 && b < 0 } } ? r + b : r

# A span of time, stored as milliseconds. Negative values are meaningful
# (e.g. the result of `Time.since` when `self` is earlier than `other`).
enum Duration =
  | Duration(value: Int)

  fun millis(n: Int) -> Duration =
    return Duration(value: n)

  fun seconds(n: Int) -> Duration =
    return Duration(value: n * 1000)

  fun minutes(n: Int) -> Duration =
    return Duration(value: n * 60000)

  fun hours(n: Int) -> Duration =
    return Duration(value: n * 3600000)

  fun days(n: Int) -> Duration =
    return Duration(value: n * MILLIS_PER_DAY)

  fun toMillis(self) -> Int =
    return self.value

  fun toSeconds(self) -> Float =
    return Float(self.value) / 1000.0f

  fun add(self, other: Duration) -> Duration =
    return Duration(value: self.value + other.value)

  fun sub(self, other: Duration) -> Duration =
    return Duration(value: self.value - other.value)

  fun negate(self) -> Duration =
    return Duration(value: -self.value)

  fun abs(self) -> Duration =
    return Duration(value: self.value < 0 ? -self.value : self.value)

  fun isZero(self) -> Bool =
    return self.value == 0

  fun isBefore(self, other: Duration) -> Bool =
    return self.value < other.value

  fun isAfter(self, other: Duration) -> Bool =
    return self.value > other.value

  fun equals(self, other: Duration) -> Bool =
    return self.value == other.value

test "Time.toStr formats the epoch as ISO 8601 in UTC"
  assert Time(value: 0).toStr() == "1970-01-01T00:00:00.000Z"

test "Time calendar/clock accessors decompose a known instant correctly"
  t := Time(value: 1704067199000) # 2023-12-31T23:59:59.000Z
  assert t.year() == 2023
  assert t.month() == 12
  assert t.day() == 31
  assert t.hour() == 23
  assert t.minute() == 59
  assert t.second() == 59
  assert t.weekday() == 0 # Sunday
  assert t.toStr() == "2023-12-31T23:59:59.000Z"

test "Time accessors handle instants before the epoch correctly"
  t := Time(value: -1000) # one second before the epoch
  assert t.toStr() == "1969-12-31T23:59:59.000Z"

test "Duration arithmetic and unit constructors compute correctly"
  assert Duration.seconds(90).toMillis() == 90000
  assert Duration.minutes(2).toMillis() == 120000
  assert Duration.hours(1).toMillis() == 3600000
  assert Duration.days(1).toMillis() == 86400000
  assert Duration.seconds(90).negate().toMillis() == -90000
  assert Duration.seconds(90).negate().abs().toMillis() == 90000
  assert Duration(value: 0).isZero() == True
  assert Duration.seconds(1).isBefore(Duration.seconds(2)) == True
  assert Duration.seconds(2).isAfter(Duration.seconds(1)) == True