PureYAML/Sources/Tagged/Tagged.Timestamp.swift

public extension PureYAML.Tagged {
    /// A parsed YAML 1.1 `!!timestamp` value, held as calendar components
    /// plus a timezone offset, with `secondsSinceEpoch` for the callers that
    /// want an absolute instant (`Date(timeIntervalSince1970:)` bridges it
    /// in one line; the package itself stays Foundation-free).
    ///
    /// Accepted source forms are the YAML 1.1 timestamp grammar: the date
    /// alone (`2002-12-14`), or date and time separated by `T`/`t` or
    /// whitespace, with an optional fractional second and an optional
    /// timezone (`Z`, `+5`, `-05:30`). A missing timezone means UTC per the
    /// YAML 1.1 timestamp specification's treatment of unlabeled times.
    struct Timestamp: Equatable, Hashable, Sendable {
        public var year: Int
        public var month: Int
        public var day: Int
        public var hour: Int
        public var minute: Int
        public var second: Int
        /// Fraction of a second in the half-open range `0..<1`.
        public var fraction: Double
        /// Offset from UTC in seconds; `0` for `Z` or an absent timezone.
        public var offsetSeconds: Int

        public init(
            year: Int,
            month: Int,
            day: Int,
            hour: Int = 0,
            minute: Int = 0,
            second: Int = 0,
            fraction: Double = 0,
            offsetSeconds: Int = 0,
        ) {
            self.year = year
            self.month = month
            self.day = day
            self.hour = hour
            self.minute = minute
            self.second = second
            self.fraction = fraction
            self.offsetSeconds = offsetSeconds
        }

        /// Seconds since 1970-01-01T00:00:00Z, using the proleptic Gregorian
        /// calendar (the days-from-civil closed form), with the timezone
        /// offset applied.
        public var secondsSinceEpoch: Double {
            let shiftedYear = month <= 2 ? year - 1 : year
            let era = (shiftedYear >= 0 ? shiftedYear : shiftedYear - 399) / 400
            let yearOfEra = shiftedYear - era * 400
            let dayOfYear = (153 * (month + (month > 2 ? -3 : 9)) + 2) / 5 + day - 1
            let dayOfEra = yearOfEra * 365 + yearOfEra / 4 - yearOfEra / 100 + dayOfYear
            let days = era * 146_097 + dayOfEra - 719_468
            let seconds = days * 86400 + hour * 3600 + minute * 60 + second - offsetSeconds
            return Double(seconds) + fraction
        }
    }
}

extension PureYAML.Tagged.Timestamp {
    /// Parses the YAML 1.1 timestamp grammar. Returns `nil` for anything
    /// outside it, including calendar-invalid dates like February 30.
    init?(yaml raw: String) {
        var cursor = Substring(raw)
        guard let date = Self.takeDate(&cursor) else {
            return nil
        }
        if cursor.isEmpty {
            self.init(year: date.year, month: date.month, day: date.day)
            return
        }
        guard
            cursor.takeTimeSeparator(),
            let time = Self.takeTime(&cursor),
            let offsetSeconds = Self.takeOffset(&cursor),
            cursor.isEmpty
        else {
            return nil
        }
        self.init(
            year: date.year,
            month: date.month,
            day: date.day,
            hour: time.hour,
            minute: time.minute,
            second: time.second,
            fraction: time.fraction,
            offsetSeconds: offsetSeconds,
        )
    }

    struct DateParts {
        var year: Int
        var month: Int
        var day: Int
    }

    struct TimeParts {
        var hour: Int
        var minute: Int
        var second: Int
        var fraction: Double
    }

    static func takeDate(_ cursor: inout Substring) -> DateParts? {
        guard
            let year = cursor.takeDigits(exactly: 4),
            cursor.take("-"),
            let month = cursor.takeDigits(upTo: 2),
            cursor.take("-"),
            let day = cursor.takeDigits(upTo: 2),
            isValidDate(year: year, month: month, day: day)
        else {
            return nil
        }
        return DateParts(year: year, month: month, day: day)
    }

    static func takeTime(_ cursor: inout Substring) -> TimeParts? {
        guard
            let hour = cursor.takeDigits(upTo: 2), hour <= 23,
            cursor.take(":"),
            let minute = cursor.takeDigits(exactly: 2), minute <= 59,
            cursor.take(":"),
            let second = cursor.takeDigits(exactly: 2), second <= 59
        else {
            return nil
        }
        var fraction = 0.0
        if cursor.take(".") {
            var scale = 0.1
            while let digit = cursor.takeDigit() {
                fraction += Double(digit) * scale
                scale /= 10
            }
        }
        return TimeParts(hour: hour, minute: minute, second: second, fraction: fraction)
    }

    /// The timezone part: `Z`, a signed hour with optional `:minutes`, or
    /// nothing (UTC). Returns the offset in seconds, or `nil` on a
    /// malformed offset (which fails the whole parse; absence is `0`).
    static func takeOffset(_ cursor: inout Substring) -> Int? {
        cursor.takeWhitespace()
        if cursor.take("Z") {
            return 0
        }
        guard let sign = cursor.takeSign() else {
            return 0
        }
        guard let offsetHour = cursor.takeDigits(upTo: 2), offsetHour <= 23 else {
            return nil
        }
        var offsetMinute = 0
        if cursor.take(":") {
            guard let parsed = cursor.takeDigits(exactly: 2), parsed <= 59 else {
                return nil
            }
            offsetMinute = parsed
        }
        return sign * (offsetHour * 3600 + offsetMinute * 60)
    }

    static func isValidDate(year: Int, month: Int, day: Int) -> Bool {
        guard (1 ... 12).contains(month), day >= 1 else {
            return false
        }
        let leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
        let lengths = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
        return day <= lengths[month - 1]
    }
}

private extension Substring {
    mutating func take(_ character: Character) -> Bool {
        guard first == character else {
            return false
        }
        removeFirst()
        return true
    }

    mutating func takeDigit() -> Int? {
        guard let first, let digit = first.wholeNumberValue, first.isASCII, (0 ... 9).contains(digit) else {
            return nil
        }
        removeFirst()
        return digit
    }

    /// Between one and `upTo` digits.
    mutating func takeDigits(upTo limit: Int) -> Int? {
        var value: Int?
        for _ in 0 ..< limit {
            guard let digit = takeDigit() else {
                break
            }
            value = (value ?? 0) * 10 + digit
        }
        return value
    }

    mutating func takeDigits(exactly count: Int) -> Int? {
        var value = 0
        for _ in 0 ..< count {
            guard let digit = takeDigit() else {
                return nil
            }
            value = value * 10 + digit
        }
        return value
    }

    /// `T`, `t`, or one-or-more spaces/tabs between date and time.
    mutating func takeTimeSeparator() -> Bool {
        if take("T") || take("t") {
            return true
        }
        guard first == " " || first == "\t" else {
            return false
        }
        takeWhitespace()
        return true
    }

    mutating func takeWhitespace() {
        while first == " " || first == "\t" {
            removeFirst()
        }
    }

    mutating func takeSign() -> Int? {
        if take("+") {
            return 1
        }
        if take("-") {
            return -1
        }
        return nil
    }
}