{-# LANGUAGE CPP #-}


module Test.Sandwich.Contexts.MinIO.Util where

import Data.Char
import qualified Data.List as L
import Data.Text as T
import Relude
import qualified System.Random as R

#if MIN_VERSION_aeson(2,0,0)
import qualified Data.Aeson.Key             as A
import qualified Data.Aeson.KeyMap          as HM
#else
import Data.Hashable
import qualified Data.HashMap.Strict        as HM
#endif


#if MIN_VERSION_aeson(2,0,0)
aesonLookup :: Text -> HM.KeyMap v -> Maybe v
aesonLookup :: forall v. Text -> KeyMap v -> Maybe v
aesonLookup = Key -> KeyMap v -> Maybe v
forall v. Key -> KeyMap v -> Maybe v
HM.lookup (Key -> KeyMap v -> Maybe v)
-> (Text -> Key) -> Text -> KeyMap v -> Maybe v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Key
A.fromText
#else
aesonLookup :: (Eq k, Hashable k) => k -> HM.HashMap k v -> Maybe v
aesonLookup = HM.lookup
#endif

makeUUID :: MonadIO m => m T.Text
makeUUID :: forall (m :: * -> *). MonadIO m => m Text
makeUUID = Int -> m Text
forall (m :: * -> *). MonadIO m => Int -> m Text
makeUUID' Int
8

makeUUID' :: MonadIO m => Int -> m T.Text
makeUUID' :: forall (m :: * -> *). MonadIO m => Int -> m Text
makeUUID' Int
n = [Char] -> Text
forall a. ToText a => a -> Text
toText ([Char] -> Text) -> m [Char] -> m Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> m Char -> m [Char]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
n (([Char]
uuidLetters [Char] -> Int -> Char
forall a. HasCallStack => [a] -> Int -> a
L.!!) (Int -> Char) -> m Int -> m Char
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int, Int) -> m Int
forall a (m :: * -> *). (Random a, MonadIO m) => (a, a) -> m a
R.randomRIO (Int
0, Int
numUUIDLetters Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)))
  where
    -- Note: for a UUID to appear in a Kubernetes name, it needs to match this regex
    -- [a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*'
    uuidLetters :: [Char]
    uuidLetters :: [Char]
uuidLetters = [Char
'a'..Char
'z'] [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char
'0'..Char
'9']

    numUUIDLetters :: Int
    numUUIDLetters :: Int
numUUIDLetters = [Char] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
L.length [Char]
uuidLetters