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

-- | Bounded retry hints from an upstream response, without a default delay policy.
module Ecluse.Core.Fault.RetryAfter (
    parseRetryAfter,
    upstreamRetryCap,
    responseRetryAfter,
) where

import Data.ByteString qualified as BS
import Data.Char (isDigit)
import Data.List (lookup)
import Data.Text qualified as T
import Data.Time (UTCTime, diffUTCTime, getCurrentTime)
import Network.HTTP.Types (ResponseHeaders)

import Ecluse.Core.Fault (RetryAfter (RetryAfter))
import Ecluse.Core.Text (readDecimalText)
import Ecluse.Core.Text.HttpDate (parseHttpDateAt)

-- | Return a positive delay capped by the caller, rounding dates up to whole seconds. Unusable hints yield 'Nothing'.
parseRetryAfter :: UTCTime -> RetryAfter -> Maybe ByteString -> Maybe RetryAfter
parseRetryAfter :: UTCTime -> RetryAfter -> Maybe ByteString -> Maybe RetryAfter
parseRetryAfter UTCTime
now (RetryAfter Int
cap) Maybe ByteString
header = do
    Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Int
cap Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0)
    raw <- (Char -> Bool) -> Text -> Text
T.dropAround (\Char
c -> Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
' ' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\t') (Text -> Text) -> (ByteString -> Text) -> ByteString -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Text
forall a b. ConvertUtf8 a b => b -> a
decodeUtf8 (ByteString -> Text) -> Maybe ByteString -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ByteString
header
    seconds <- cappedDecimal cap raw <|> (ceiling . (`diffUTCTime` now) <$> parseHttpDateAt now raw)
    guard (seconds > (0 :: Integer))
    pure (RetryAfter (fromInteger (min (toInteger cap) seconds)))

-- | The longest delay an upstream hint may set: ten minutes.
upstreamRetryCap :: RetryAfter
upstreamRetryCap :: RetryAfter
upstreamRetryCap = Int -> RetryAfter
RetryAfter Int
600

-- | A response's @Retry-After@ under 'upstreamRetryCap', read at the current time.
responseRetryAfter :: ResponseHeaders -> IO (Maybe RetryAfter)
responseRetryAfter :: ResponseHeaders -> IO (Maybe RetryAfter)
responseRetryAfter ResponseHeaders
headers = do
    now <- IO UTCTime
getCurrentTime
    pure (parseRetryAfter now upstreamRetryCap (lookup "Retry-After" headers))

-- Strip leading zeroes before the length check, so numeric conversion never grows with the header.
cappedDecimal :: Int -> Text -> Maybe Integer
cappedDecimal :: Int -> Text -> Maybe Integer
cappedDecimal Int
cap Text
raw = do
    Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Bool
not (Text -> Bool
T.null Text
raw) Bool -> Bool -> Bool
&& (Char -> Bool) -> Text -> Bool
T.all Char -> Bool
isDigit Text
raw)
    let digits :: Text
digits = (Char -> Bool) -> Text -> Text
T.dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'0') Text
raw
    if Text -> Bool
T.null Text
digits
        then Integer -> Maybe Integer
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Integer
0
        else
            if Text -> Int -> Ordering
T.compareLength Text
digits (ByteString -> Int
BS.length (Int -> ByteString
forall b a. (Show a, IsString b) => a -> b
show Int
cap)) Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
GT
                then Integer -> Maybe Integer
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
cap)
                else Integer -> Integer -> Integer
forall a. Ord a => a -> a -> a
min (Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
cap) (Integer -> Integer) -> Maybe Integer -> Maybe Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe Integer
forall a. Integral a => Text -> Maybe a
readDecimalText Text
digits