-- SPDX-FileCopyrightText: 2026 Alexandra de Wit
--
-- SPDX-License-Identifier: MIT

{- | ISO 8601 UTC time stamps, read and rendered without the library's parser or a text builder.
A registry document holds one for each release or file, and an npm listing renders one for each release.
The read takes one layout and declines every other, and the render leaves what it does not write to 'iso8601Show'.
-}
module Ecluse.Core.Text.Iso8601 (
    readIso8601Utc,
    renderIso8601Utc,
) where

import Control.Monad.ST (ST)
import Data.Char (isDigit)
import Data.Primitive.ByteArray (MutableByteArray, createByteArray, setByteArray, writeByteArray)
import Data.Text qualified as T
import Data.Text.Internal qualified as TI
import Data.Time (Day (ModifiedJulianDay), UTCTime (UTCTime), diffTimeToPicoseconds, fromGregorian, picosecondsToDiffTime, toModifiedJulianDay)
import Data.Time.Format.ISO8601 (iso8601Show)

import Ecluse.Core.Text (writeDigits)

{- | The instant of a stamp written @YYYY-MM-DDTHH:MM:SS@, an optional fraction of 1 to 12 digits, then @Z@.
'Nothing' for every other text, which includes stamps that a wider parser reads.
-}
readIso8601Utc :: Text -> Maybe UTCTime
readIso8601Utc :: Text -> Maybe UTCTime
readIso8601Utc raw :: Text
raw@(TI.Text Array
_ Int
_ Int
bytes)
    | Int
bytes Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
longestStamp = Maybe UTCTime
forall a. Maybe a
Nothing
    | Bool
otherwise = case (Scan -> Char -> Scan) -> Scan -> Text -> Scan
forall a. (a -> Char -> a) -> a -> Text -> a
T.foldl' Scan -> Char -> Scan
scanStamp (Int -> Int -> Int -> Int -> Scan
Scan Int
0 Int
0 Int
0 Int
100_000_000_000) Text
raw of
        Scan Int
at Int
digits Int
fraction Int
_ | Int
at Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
scanFinished -> Int -> Int -> Maybe UTCTime
stampInstant Int
digits Int
fraction
        Scan
_ -> Maybe UTCTime
forall a. Maybe a
Nothing

-- The bytes of a stamp with a fraction of twelve digits. A longer text is refused unread.
longestStamp :: Int
longestStamp :: Int
longestStamp = Int
33

{- A scan's place in a stamp: the offset of the next character, the date and time digits read so far as
one number, the fraction in picoseconds, and the picoseconds one unit of the next fraction digit is worth. -}
data Scan = Scan Int Int Int Int

-- Offsets no character sits at: the zone has ended the stamp, and a character has broken the layout.
scanFinished, scanRefused :: Int
scanFinished :: Int
scanFinished = -Int
1
scanRefused :: Int
scanRefused = -Int
2

-- Inlined into the fold, so the scan passes between characters without a heap object.
scanStamp :: Scan -> Char -> Scan
scanStamp :: Scan -> Char -> Scan
scanStamp (Scan Int
at Int
digits Int
fraction Int
worth) Char
c
    | Int
at Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = Scan
refused
    | Int
at Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
4 Bool -> Bool -> Bool
|| Int
at Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
7 = Char -> Scan
punctuation Char
'-'
    | Int
at Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
10 = Char -> Scan
punctuation Char
'T'
    | Int
at Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
13 Bool -> Bool -> Bool
|| Int
at Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
16 = Char -> Scan
punctuation Char
':'
    | Int
at Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
19 = if Char -> Bool
isDigit Char
c then Int -> Int -> Int -> Int -> Scan
Scan (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (Int
digits Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
10 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
digitValue) Int
fraction Int
worth else Scan
refused
    | Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'Z' Bool -> Bool -> Bool
&& Int
at Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
20 = Int -> Int -> Int -> Int -> Scan
Scan Int
scanFinished Int
digits Int
fraction Int
worth
    | Int
at Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
19 = Char -> Scan
punctuation Char
'.'
    | Char -> Bool
isDigit Char
c Bool -> Bool -> Bool
&& Int
worth Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0 = Int -> Int -> Int -> Int -> Scan
Scan (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
digits (Int
fraction Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
worth Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
digitValue) (Int
worth Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
10)
    | Bool
otherwise = Scan
refused
  where
    refused :: Scan
refused = Int -> Int -> Int -> Int -> Scan
Scan Int
scanRefused Int
0 Int
0 Int
0
    punctuation :: Char -> Scan
punctuation Char
expected = if Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
expected then Int -> Int -> Int -> Int -> Scan
Scan (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
digits Int
fraction Int
worth else Scan
refused
    digitValue :: Int
digitValue = Char -> Int
ord Char
c Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
ord Char
'0'
{-# INLINE scanStamp #-}

-- The instant of fourteen date and time digits and a fraction, when they name a date and a time of day below 24 h.
stampInstant :: Int -> Int -> Maybe UTCTime
stampInstant :: Int -> Int -> Maybe UTCTime
stampInstant Int
digits Int
fraction
    | Int
hour Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
23 Bool -> Bool -> Bool
|| Int
minute Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
59 Bool -> Bool -> Bool
|| Int
secondOfMinute Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
59 = Maybe UTCTime
forall a. Maybe a
Nothing
    | Bool
otherwise = do
        day <- Int -> Int -> Int -> Maybe Day
gregorianDay Int
year Int
month Int
dayOfMonth
        let !time = Integer -> DiffTime
picosecondsToDiffTime (Int -> Integer
forall a. Integral a => a -> Integer
toInteger (((Int
hour Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
60 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
minute) Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
60 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
secondOfMinute) Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
1_000_000_000_000 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
fraction))
        pure (UTCTime day time)
  where
    (Int
date, Int
clock) = Int
digits Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
1_000_000
    (Int
yearMonth, Int
dayOfMonth) = Int
date Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
100
    (Int
year, Int
month) = Int
yearMonth Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
100
    (Int
hourMinute, Int
secondOfMinute) = Int
clock Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
100
    (Int
hour, Int
minute) = Int
hourMinute Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
100

{- The day of a date in years 0 to 9999, by the arithmetic of the time library's 'Data.Time.fromGregorianValid',
or 'Nothing' for a month or a day that the calendar lacks. -}
gregorianDay :: Int -> Int -> Int -> Maybe Day
gregorianDay :: Int -> Int -> Int -> Maybe Day
gregorianDay !Int
year !Int
month !Int
dayOfMonth
    | Int
month Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1 Bool -> Bool -> Bool
|| Int
month Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
12 Bool -> Bool -> Bool
|| Int
dayOfMonth Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1 Bool -> Bool -> Bool
|| Int
dayOfMonth Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
monthLength = Maybe Day
forall a. Maybe a
Nothing
    | Bool
otherwise = Day -> Maybe Day
forall a. a -> Maybe a
Just (Day -> Maybe Day) -> Day -> Maybe Day
forall a b. (a -> b) -> a -> b
$! Integer -> Day
ModifiedJulianDay (Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Int
dayOfYear Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
365 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
before Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
before Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
before Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
100 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
before Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
400 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
678_576))
  where
    leap :: Bool
leap = Int
year Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
4 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
&& (Int
year Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
100 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0 Bool -> Bool -> Bool
|| Int
year Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
400 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0)
    monthLength :: Int
monthLength
        | Int
month Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
2 = if Bool
leap then Int
29 else Int
28
        | Int
month Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
4 Bool -> Bool -> Bool
|| Int
month Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
6 Bool -> Bool -> Bool
|| Int
month Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
9 Bool -> Bool -> Bool
|| Int
month Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
11 = Int
30
        | Bool
otherwise = Int
31
    before :: Int
before = Int
year Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
    dayOfYear :: Int
dayOfYear = (Int
367 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
month Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
362) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
12 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
dayOfMonth Int -> Int -> Int
forall a. Num a => a -> a -> a
- (if Int
month Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
2 then Int
0 else if Bool
leap then Int
1 else Int
2)

{- | The text of 'iso8601Show', written to one buffer for years 0 to 9999 and a time of day below 86 400 s.
In those years a negative time of day keeps a signed hour, where 'iso8601Show' borrows from the day.
-}
renderIso8601Utc :: UTCTime -> Text
renderIso8601Utc :: UTCTime -> Text
renderIso8601Utc t :: UTCTime
t@(UTCTime Day
day DiffTime
dt)
    | Integer
mjd Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
firstDayOfYear0 Bool -> Bool -> Bool
|| Integer
mjd Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
lastDayOfYear9999 Bool -> Bool -> Bool
|| Integer
picos Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Integer
picosPerDay = String -> Text
forall a. ToText a => a -> Text
toText (UTCTime -> String
forall t. ISO8601 t => t -> String
iso8601Show UTCTime
t)
    | Integer
picos Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0 = Int -> Text -> Text
T.take Int
11 Text
pastHourStamp Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Integer -> Text
forall b a. (Show a, IsString b) => a -> b
show Integer
hour Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text -> Text
T.drop Int
13 Text
pastHourStamp
    | Bool
otherwise = Int -> Int -> Text
stampText (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
mjd) (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
picos)
  where
    mjd :: Integer
mjd = Day -> Integer
toModifiedJulianDay Day
day
    picos :: Integer
picos = DiffTime -> Integer
diffTimeToPicoseconds DiffTime
dt
    (Integer
hour, Integer
pastHour) = Integer
picos Integer -> Integer -> (Integer, Integer)
forall a. Integral a => a -> a -> (a, a)
`divMod` Integer
picosPerHour
    -- The stamp of the time past the hour: every field of the result but the hour.
    pastHourStamp :: Text
pastHourStamp = Int -> Int -> Text
stampText (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
mjd) (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
pastHour)

firstDayOfYear0, lastDayOfYear9999 :: Integer
firstDayOfYear0 :: Integer
firstDayOfYear0 = Day -> Integer
toModifiedJulianDay (Integer -> Int -> Int -> Day
fromGregorian Integer
0 Int
1 Int
1)
lastDayOfYear9999 :: Integer
lastDayOfYear9999 = Day -> Integer
toModifiedJulianDay (Integer -> Int -> Int -> Day
fromGregorian Integer
9999 Int
12 Int
31)

picosPerDay, picosPerHour :: Integer
picosPerDay :: Integer
picosPerDay = Integer
24 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
picosPerHour
picosPerHour :: Integer
picosPerHour = Integer
3_600_000_000_000_000

{- The stamp of a day number in years 0 to 9999 and the picoseconds of a time of day from zero
below 86 400 s. The date is Howard Hinnant's @civil_from_days@, over days since 0000-03-01. -}
stampText :: Int -> Int -> Text
stampText :: Int -> Int -> Text
stampText !Int
mjd !Int
picos = Array -> Int -> Int -> Text
TI.text (Int -> (forall s. MutableByteArray s -> ST s ()) -> Array
createByteArray Int
len MutableByteArray s -> ST s ()
forall s. MutableByteArray s -> ST s ()
fill) Int
0 Int
len
  where
    sinceMarch :: Int
sinceMarch = Int
mjd Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
678_881
    era :: Int
era = Int
sinceMarch Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
146_097
    dayOfEra :: Int
dayOfEra = Int
sinceMarch Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
146_097
    yearOfEra :: Int
yearOfEra = (Int
dayOfEra Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
dayOfEra Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
1460 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
dayOfEra Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
36_524 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
dayOfEra Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
146_096) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
365
    dayOfYear :: Int
dayOfYear = Int
dayOfEra Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Int
365 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
yearOfEra Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
yearOfEra Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
yearOfEra Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
100)
    marchMonth :: Int
marchMonth = (Int
5 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
dayOfYear Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
153
    dayOfMonth :: Int
dayOfMonth = Int
dayOfYear Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Int
153 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
marchMonth Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
5 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
    month :: Int
month = if Int
marchMonth Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
10 then Int
marchMonth Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3 else Int
marchMonth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
9
    year :: Int
year = Int
yearOfEra Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
era Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
400 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (if Int
month Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
2 then Int
1 else Int
0)

    (Int
secondOfDay, Int
fraction) = Int
picos Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
1_000_000_000_000
    (Int
minuteOfDay, Int
secondOfMinute) = Int
secondOfDay Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
60
    (Int
hourOfDay, Int
minuteOfHour) = Int
minuteOfDay Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
60
    !(Int
fractionDigits, Int
significant) = Int -> Int -> (Int, Int)
withoutTrailingZeros Int
12 Int
fraction
    len :: Int
len = if Int
fraction Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 then Int
20 else Int
21 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
fractionDigits

    -- Every digit starts as a zero, so a field written from its last digit backwards is padded.
    fill :: MutableByteArray st -> ST st ()
    fill :: forall s. MutableByteArray s -> ST s ()
fill MutableByteArray st
target = do
        MutableByteArray (PrimState (ST st))
-> Int -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> Int -> a -> m ()
setByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target Int
0 Int
len (Char -> Word8
ascii Char
'0')
        MutableByteArray st -> Int -> Word -> ST st ()
forall st. MutableByteArray st -> Int -> Word -> ST st ()
writeDigits MutableByteArray st
target Int
3 (Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
year)
        MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target Int
4 (Char -> Word8
ascii Char
'-')
        MutableByteArray st -> Int -> Word -> ST st ()
forall st. MutableByteArray st -> Int -> Word -> ST st ()
writeDigits MutableByteArray st
target Int
6 (Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
month)
        MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target Int
7 (Char -> Word8
ascii Char
'-')
        MutableByteArray st -> Int -> Word -> ST st ()
forall st. MutableByteArray st -> Int -> Word -> ST st ()
writeDigits MutableByteArray st
target Int
9 (Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
dayOfMonth)
        MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target Int
10 (Char -> Word8
ascii Char
'T')
        MutableByteArray st -> Int -> Word -> ST st ()
forall st. MutableByteArray st -> Int -> Word -> ST st ()
writeDigits MutableByteArray st
target Int
12 (Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
hourOfDay)
        MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target Int
13 (Char -> Word8
ascii Char
':')
        MutableByteArray st -> Int -> Word -> ST st ()
forall st. MutableByteArray st -> Int -> Word -> ST st ()
writeDigits MutableByteArray st
target Int
15 (Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minuteOfHour)
        MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target Int
16 (Char -> Word8
ascii Char
':')
        MutableByteArray st -> Int -> Word -> ST st ()
forall st. MutableByteArray st -> Int -> Word -> ST st ()
writeDigits MutableByteArray st
target Int
18 (Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
secondOfMinute)
        Bool -> ST st () -> ST st ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
fraction Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0) (ST st () -> ST st ()) -> ST st () -> ST st ()
forall a b. (a -> b) -> a -> b
$ do
            MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target Int
19 (Char -> Word8
ascii Char
'.')
            MutableByteArray st -> Int -> Word -> ST st ()
forall st. MutableByteArray st -> Int -> Word -> ST st ()
writeDigits MutableByteArray st
target (Int
19 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
fractionDigits) (Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
significant)
        MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target (Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (Char -> Word8
ascii Char
'Z')

ascii :: Char -> Word8
ascii :: Char -> Word8
ascii = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word8) -> (Char -> Int) -> Char -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord

-- A count of digits and the value they spell, less every trailing zero of the value.
withoutTrailingZeros :: Int -> Int -> (Int, Int)
withoutTrailingZeros :: Int -> Int -> (Int, Int)
withoutTrailingZeros !Int
count !Int
value
    | Int
value Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0 Bool -> Bool -> Bool
&& Int
value Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
10 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = Int -> Int -> (Int, Int)
withoutTrailingZeros (Int
count Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (Int
value Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
10)
    | Bool
otherwise = (Int
count, Int
value)