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

-- | HTTP timestamps for provenance and response retry hints.
module Ecluse.Core.Text.HttpDate (
    parseHttpDate,
    parseHttpDateAt,
) where

import Data.Text qualified as T
import Data.Time (UTCTime (..), addGregorianYearsClip, defaultTimeLocale, formatTime, parseTimeM, toGregorian)

import Ecluse.Core.Text (readDecimalText)

-- | Read the provenance date format, retaining its timezone and whitespace acceptance.
parseHttpDate :: Text -> Maybe UTCTime
parseHttpDate :: Text -> Maybe UTCTime
parseHttpDate Text
raw = Bool -> TimeLocale -> String -> String -> Maybe UTCTime
forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> String -> String -> m t
parseTimeM Bool
True TimeLocale
defaultTimeLocale String
"%a, %d %b %Y %H:%M:%S %Z" (Text -> String
forall a. ToString a => a -> String
toString (Text -> Text
T.strip Text
raw))

-- | Read all RFC 9110 HTTP-date forms, resolving two-digit years against the supplied current time.
parseHttpDateAt :: UTCTime -> Text -> Maybe UTCTime
parseHttpDateAt :: UTCTime -> Text -> Maybe UTCTime
parseHttpDateAt UTCTime
now Text
raw = do
    Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Text -> Int -> Ordering
T.compareLength Text
raw Int
33 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
GT)
    Maybe UTCTime
modern Maybe UTCTime -> Maybe UTCTime -> Maybe UTCTime
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe UTCTime
obsolete Maybe UTCTime -> Maybe UTCTime -> Maybe UTCTime
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe UTCTime
asctime
  where
    modern :: Maybe UTCTime
modern = do
        Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Text -> Int -> Ordering
T.compareLength Text
raw Int
29 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
EQ)
        Text -> Maybe UTCTime
parseHttpDate Text
raw Maybe UTCTime -> (UTCTime -> Maybe UTCTime) -> Maybe UTCTime
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Text -> UTCTime -> Maybe UTCTime
exact String
"%a, %d %b %Y %H:%M:%S GMT" Text
raw
    asctime :: Maybe UTCTime
asctime = do
        Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Text -> Int -> Ordering
T.compareLength Text
raw Int
24 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
EQ)
        stamp <- String -> Text -> Maybe UTCTime
parseDate String
"%a %b %e %H:%M:%S %Y" Text
raw
        exact "%a %b %e %H:%M:%S %Y" raw stamp <|> exact "%a %b %d %H:%M:%S %Y" raw stamp
    obsolete :: Maybe UTCTime
obsolete = do
        [weekday, date, clock, "GMT"] <- [Text] -> Maybe [Text]
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> [Text]
T.words Text
raw)
        [day, month, shortYear] <- pure (T.splitOn "-" date)
        guard (T.compareLength shortYear 2 == EQ)
        year <- readDecimalText shortYear
        let latestYear = Year
limitYear Year -> Year -> Year
forall a. Num a => a -> a -> a
- (Year
limitYear Year -> Year -> Year
forall a. Num a => a -> a -> a
- Year
year) Year -> Year -> Year
forall a. Integral a => a -> a -> a
`mod` Year
100
            dated a
fullYear = [Text] -> Text
T.unwords [Text
weekday, Text
day Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"-" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
month Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"-" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> a -> Text
forall b a. (Show a, IsString b) => a -> b
show a
fullYear, Text
clock, Text
"GMT"]
            candidates = (Year -> Maybe UTCTime) -> [Year] -> [UTCTime]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (String -> Text -> Maybe UTCTime
parseDate String
"%A, %d-%b-%Y %H:%M:%S GMT" (Text -> Maybe UTCTime) -> (Year -> Text) -> Year -> Maybe UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Year -> Text
forall {a}. Show a => a -> Text
dated) [Year
latestYear, Year
latestYear Year -> Year -> Year
forall a. Num a => a -> a -> a
- Year
100]
        stamp <- find (<= futureLimit) candidates
        exact "%A, %d-%b-%y %H:%M:%S GMT" raw stamp
    futureLimit :: UTCTime
futureLimit = UTCTime
now{utctDay = addGregorianYearsClip 50 (utctDay now)}
    (Year
limitYear, Int
_, Int
_) = Day -> (Year, Int, Int)
toGregorian (UTCTime -> Day
utctDay UTCTime
futureLimit)

parseDate :: String -> Text -> Maybe UTCTime
parseDate :: String -> Text -> Maybe UTCTime
parseDate String
format = Bool -> TimeLocale -> String -> String -> Maybe UTCTime
forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> String -> String -> m t
parseTimeM Bool
False TimeLocale
defaultTimeLocale String
format (String -> Maybe UTCTime)
-> (Text -> String) -> Text -> Maybe UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
forall a. ToString a => a -> String
toString

exact :: String -> Text -> UTCTime -> Maybe UTCTime
exact :: String -> Text -> UTCTime -> Maybe UTCTime
exact String
format Text
raw UTCTime
stamp = UTCTime
stamp UTCTime -> Maybe () -> Maybe UTCTime
forall a b. a -> Maybe b -> Maybe a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (String -> Text
forall a. ToText a => a -> Text
toText (TimeLocale -> String -> UTCTime -> String
forall t. FormatTime t => TimeLocale -> String -> t -> String
formatTime TimeLocale
defaultTimeLocale String
format UTCTime
stamp) Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
raw)