{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TupleSections #-}

-- |
-- Module      : Network.Reddit.Types.Award
-- Copyright   : (c) 2021 Rory Tyler Hayford
-- License     : BSD-3-Clause
-- Maintainer  : rory.hayford@protonmail.com
-- Stability   : experimental
-- Portability : GHC
--
module Network.Reddit.Types.Award
    ( Awarding
    , AwardID(AwardID, Silver, Gold, Platinum, Argentium, Ternion)
    , AwardType(..)
    , Award(..)
    , mkAward
    , Trophy
    , TrophyID
    , TrophyList
    , AwardingsSummary(..)
    ) where

import           Control.Monad                  ( (<=<) )

import           Data.Aeson
                 ( (.:)
                 , (.:?)
                 , FromJSON(parseJSON)
                 , FromJSONKey
                 , Options(..)
                 , defaultOptions
                 , genericParseJSON
                 , withArray
                 , withText
                 )
import           Data.Aeson.Casing              ( snakeCase )
import           Data.Char                      ( toLower )
import           Data.HashMap.Strict            ( HashMap )
import           Data.Hashable                  ( Hashable )
import           Data.Sequence                  ( Seq )
import           Data.Text                      ( Text )
import           Data.Time                      ( UTCTime )

import           GHC.Exts                       ( IsList(fromList, toList) )
import           GHC.Generics                   ( Generic )

import           Network.Reddit.Types.Internal
import           Network.Reddit.Types.Subreddit

import           Web.FormUrlEncoded             ( ToForm(toForm) )
import           Web.HttpApiData                ( ToHttpApiData(..) )

-- | Information about a Reddit award that has been granted. This can be a
-- \"global\" award that may be granted site-wide, or a \"community\" award
-- that is limited to a single subreddit
data Awarding = Awarding
    { Awarding -> AwardID
awardID       :: AwardID
    , Awarding -> Name
name          :: Name
      -- | This will only be present for 'Community' awards
    , Awarding -> Name
description   :: Body
    , Awarding -> Maybe SubredditID
subredditID   :: Maybe SubredditID
    , Awarding -> AwardType
awardType     :: AwardType
    , Awarding -> Int
count         :: Int
      -- | The number of \"creddits\" required to grant the award
    , Awarding -> Int
coinPrice     :: Int
      -- | The number of \"creddits\" given to the recipient
    , Awarding -> Int
coinReward    :: Int
      -- | How many days of premium Reddit the awardee is granted
    , Awarding -> Int
daysOfPremium :: Int
      -- | URL of Reddit-hosted icon image
    , Awarding -> Name
iconURL       :: URL
      -- | Width of the icon in pixels
    , Awarding -> Int
iconHeight    :: Int
      -- | Width of the icon in pixels
    , Awarding -> Int
iconWidth     :: Int
    }
    deriving stock ( Int -> Awarding -> ShowS
[Awarding] -> ShowS
Awarding -> String
(Int -> Awarding -> ShowS)
-> (Awarding -> String) -> ([Awarding] -> ShowS) -> Show Awarding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Awarding] -> ShowS
$cshowList :: [Awarding] -> ShowS
show :: Awarding -> String
$cshow :: Awarding -> String
showsPrec :: Int -> Awarding -> ShowS
$cshowsPrec :: Int -> Awarding -> ShowS
Show, Awarding -> Awarding -> Bool
(Awarding -> Awarding -> Bool)
-> (Awarding -> Awarding -> Bool) -> Eq Awarding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Awarding -> Awarding -> Bool
$c/= :: Awarding -> Awarding -> Bool
== :: Awarding -> Awarding -> Bool
$c== :: Awarding -> Awarding -> Bool
Eq, (forall x. Awarding -> Rep Awarding x)
-> (forall x. Rep Awarding x -> Awarding) -> Generic Awarding
forall x. Rep Awarding x -> Awarding
forall x. Awarding -> Rep Awarding x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Awarding x -> Awarding
$cfrom :: forall x. Awarding -> Rep Awarding x
Generic )

instance FromJSON Awarding where
    parseJSON :: Value -> Parser Awarding
parseJSON = Options -> Value -> Parser Awarding
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON Options
defaultOptions { ShowS
fieldLabelModifier :: ShowS
fieldLabelModifier :: ShowS
fieldLabelModifier }
      where
        fieldLabelModifier :: ShowS
fieldLabelModifier = \case
            String
"awardID"     -> String
"id"
            String
"subredditID" -> String
"subreddit_id"
            String
"iconURL"     -> String
"icon_url"
            String
s             -> ShowS
snakeCase String
s

-- | The ID for an award, which users can grant each other. If you want to create
-- a new 'AwardID', see the bundled pattern synonyms for this type, which include
-- various common awards. Also see \"doc/awards.org\" in this repository for a list
-- of awards and their IDs.
--
-- __Note__: Most newer awards are composed of a UUID identifier and an \"award_\"
-- prefix. If you construct this type directly, you should omit the prefix, which
-- will be added for you when making API requests
newtype AwardID = AwardID Text
    deriving stock ( Int -> AwardID -> ShowS
[AwardID] -> ShowS
AwardID -> String
(Int -> AwardID -> ShowS)
-> (AwardID -> String) -> ([AwardID] -> ShowS) -> Show AwardID
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AwardID] -> ShowS
$cshowList :: [AwardID] -> ShowS
show :: AwardID -> String
$cshow :: AwardID -> String
showsPrec :: Int -> AwardID -> ShowS
$cshowsPrec :: Int -> AwardID -> ShowS
Show, (forall x. AwardID -> Rep AwardID x)
-> (forall x. Rep AwardID x -> AwardID) -> Generic AwardID
forall x. Rep AwardID x -> AwardID
forall x. AwardID -> Rep AwardID x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AwardID x -> AwardID
$cfrom :: forall x. AwardID -> Rep AwardID x
Generic )
    deriving newtype ( AwardID -> AwardID -> Bool
(AwardID -> AwardID -> Bool)
-> (AwardID -> AwardID -> Bool) -> Eq AwardID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AwardID -> AwardID -> Bool
$c/= :: AwardID -> AwardID -> Bool
== :: AwardID -> AwardID -> Bool
$c== :: AwardID -> AwardID -> Bool
Eq, FromJSONKeyFunction [AwardID]
FromJSONKeyFunction AwardID
FromJSONKeyFunction AwardID
-> FromJSONKeyFunction [AwardID] -> FromJSONKey AwardID
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [AwardID]
$cfromJSONKeyList :: FromJSONKeyFunction [AwardID]
fromJSONKey :: FromJSONKeyFunction AwardID
$cfromJSONKey :: FromJSONKeyFunction AwardID
FromJSONKey, Int -> AwardID -> Int
AwardID -> Int
(Int -> AwardID -> Int) -> (AwardID -> Int) -> Hashable AwardID
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: AwardID -> Int
$chash :: AwardID -> Int
hashWithSalt :: Int -> AwardID -> Int
$chashWithSalt :: Int -> AwardID -> Int
Hashable )

instance FromJSON AwardID where
    parseJSON :: Value -> Parser AwardID
parseJSON = String -> (Name -> Parser AwardID) -> Value -> Parser AwardID
forall a. String -> (Name -> Parser a) -> Value -> Parser a
withText String
"AwardID" ((Name -> Parser AwardID) -> Value -> Parser AwardID)
-> (Name -> Parser AwardID) -> Value -> Parser AwardID
forall a b. (a -> b) -> a -> b
$ Name -> Name -> Parser AwardID
forall a. Coercible a Name => Name -> Name -> Parser a
breakOnTypeLenient Name
"award"

instance ToHttpApiData AwardID where
    toQueryParam :: AwardID -> Name
toQueryParam aw :: AwardID
aw@(AwardID Name
a)
        | AwardID
aw AwardID -> [AwardID] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ AwardID
Silver, AwardID
Gold, AwardID
Platinum ] = Name
a
        | Bool
otherwise = Name
"award_" Name -> Name -> Name
forall a. Semigroup a => a -> a -> a
<> Name
a

-- | The type of the 'Awarding', either site-wide (\"global\") or limited to a
-- \"community\"
data AwardType
    = Global
    | Community
    deriving stock ( Int -> AwardType -> ShowS
[AwardType] -> ShowS
AwardType -> String
(Int -> AwardType -> ShowS)
-> (AwardType -> String)
-> ([AwardType] -> ShowS)
-> Show AwardType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AwardType] -> ShowS
$cshowList :: [AwardType] -> ShowS
show :: AwardType -> String
$cshow :: AwardType -> String
showsPrec :: Int -> AwardType -> ShowS
$cshowsPrec :: Int -> AwardType -> ShowS
Show, AwardType -> AwardType -> Bool
(AwardType -> AwardType -> Bool)
-> (AwardType -> AwardType -> Bool) -> Eq AwardType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AwardType -> AwardType -> Bool
$c/= :: AwardType -> AwardType -> Bool
== :: AwardType -> AwardType -> Bool
$c== :: AwardType -> AwardType -> Bool
Eq, (forall x. AwardType -> Rep AwardType x)
-> (forall x. Rep AwardType x -> AwardType) -> Generic AwardType
forall x. Rep AwardType x -> AwardType
forall x. AwardType -> Rep AwardType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AwardType x -> AwardType
$cfrom :: forall x. AwardType -> Rep AwardType x
Generic )

instance FromJSON AwardType where
    parseJSON :: Value -> Parser AwardType
parseJSON = Options -> Value -> Parser AwardType
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON --
        Options
defaultOptions { constructorTagModifier :: ShowS
constructorTagModifier = (Char -> Char) -> ShowS
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Char -> Char
toLower }

-- | Options for awarding an item
data Award = Award
    { -- | The ID of the award you wish to grant. See 'AwardID' and
      -- its bundled pattern synonyms for common awards (e.g. gold)
      Award -> AwardID
awardID     :: AwardID
      -- | If the award is issued anonymously
    , Award -> Bool
isAnonymous :: Bool
      -- | Optional message sent to the recipient
    , Award -> Maybe Name
message     :: Maybe Body
    }
    deriving stock ( Int -> Award -> ShowS
[Award] -> ShowS
Award -> String
(Int -> Award -> ShowS)
-> (Award -> String) -> ([Award] -> ShowS) -> Show Award
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Award] -> ShowS
$cshowList :: [Award] -> ShowS
show :: Award -> String
$cshow :: Award -> String
showsPrec :: Int -> Award -> ShowS
$cshowsPrec :: Int -> Award -> ShowS
Show, Award -> Award -> Bool
(Award -> Award -> Bool) -> (Award -> Award -> Bool) -> Eq Award
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Award -> Award -> Bool
$c/= :: Award -> Award -> Bool
== :: Award -> Award -> Bool
$c== :: Award -> Award -> Bool
Eq, (forall x. Award -> Rep Award x)
-> (forall x. Rep Award x -> Award) -> Generic Award
forall x. Rep Award x -> Award
forall x. Award -> Rep Award x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Award x -> Award
$cfrom :: forall x. Award -> Rep Award x
Generic )

instance ToForm Award where
    toForm :: Award -> Form
toForm Award { Bool
Maybe Name
AwardID
message :: Maybe Name
isAnonymous :: Bool
awardID :: AwardID
$sel:message:Award :: Award -> Maybe Name
$sel:isAnonymous:Award :: Award -> Bool
$sel:awardID:Award :: Award -> AwardID
.. } = [Item Form] -> Form
forall l. IsList l => [Item l] -> l
fromList
        ([Item Form] -> Form) -> [Item Form] -> Form
forall a b. (a -> b) -> a -> b
$ [ (Name
"gild_type", AwardID -> Name
forall a. ToHttpApiData a => a -> Name
toQueryParam AwardID
awardID)
          , (Name
"is_anonymous", Bool -> Name
forall a. ToHttpApiData a => a -> Name
toQueryParam Bool
isAnonymous)
          , (Name
"api_type", Name
"json")
          ]
        [(Name, Name)] -> [(Name, Name)] -> [(Name, Name)]
forall a. Semigroup a => a -> a -> a
<> ((Name, Name) -> [(Name, Name)])
-> Maybe (Name, Name) -> [(Name, Name)]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Name, Name) -> [(Name, Name)]
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Name
"award", ) (Name -> (Name, Name)) -> Maybe Name -> Maybe (Name, Name)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Name
message)

-- | Create a new anonymous 'Awarding' without a message, given an 'AwardID'
mkAward :: AwardID -> Award
mkAward :: AwardID -> Award
mkAward AwardID
awardID = Award :: AwardID -> Bool -> Maybe Name -> Award
Award { $sel:isAnonymous:Award :: Bool
isAnonymous = Bool
True, $sel:message:Award :: Maybe Name
message = Maybe Name
forall a. Maybe a
Nothing, AwardID
awardID :: AwardID
$sel:awardID:Award :: AwardID
.. }

-- | A summary of your 'Awardings', returned after you have awarded an item
data AwardingsSummary = AwardingsSummary
    { -- | All of the awardings issued by the current user
      AwardingsSummary -> Seq Awarding
allAwardings :: Seq Awarding
      -- | A mapping of award IDs to the number of times the
      -- authenticated user has granted each one
    , AwardingsSummary -> HashMap AwardID Integer
gildings     :: HashMap AwardID Integer
      -- | Coin balance for the authenticated user
    , AwardingsSummary -> Integer
coins        :: Integer
    }
    deriving stock ( Int -> AwardingsSummary -> ShowS
[AwardingsSummary] -> ShowS
AwardingsSummary -> String
(Int -> AwardingsSummary -> ShowS)
-> (AwardingsSummary -> String)
-> ([AwardingsSummary] -> ShowS)
-> Show AwardingsSummary
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AwardingsSummary] -> ShowS
$cshowList :: [AwardingsSummary] -> ShowS
show :: AwardingsSummary -> String
$cshow :: AwardingsSummary -> String
showsPrec :: Int -> AwardingsSummary -> ShowS
$cshowsPrec :: Int -> AwardingsSummary -> ShowS
Show, AwardingsSummary -> AwardingsSummary -> Bool
(AwardingsSummary -> AwardingsSummary -> Bool)
-> (AwardingsSummary -> AwardingsSummary -> Bool)
-> Eq AwardingsSummary
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AwardingsSummary -> AwardingsSummary -> Bool
$c/= :: AwardingsSummary -> AwardingsSummary -> Bool
== :: AwardingsSummary -> AwardingsSummary -> Bool
$c== :: AwardingsSummary -> AwardingsSummary -> Bool
Eq, (forall x. AwardingsSummary -> Rep AwardingsSummary x)
-> (forall x. Rep AwardingsSummary x -> AwardingsSummary)
-> Generic AwardingsSummary
forall x. Rep AwardingsSummary x -> AwardingsSummary
forall x. AwardingsSummary -> Rep AwardingsSummary x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AwardingsSummary x -> AwardingsSummary
$cfrom :: forall x. AwardingsSummary -> Rep AwardingsSummary x
Generic )

instance FromJSON AwardingsSummary where
    parseJSON :: Value -> Parser AwardingsSummary
parseJSON =
        Options -> Value -> Parser AwardingsSummary
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON Options
defaultOptions { fieldLabelModifier :: ShowS
fieldLabelModifier = ShowS
snakeCase }

-- | A Reddit trophy, such as the \"one-year club\", that the Reddit grants
-- users. Redditors cannot gift each other these trophies
data Trophy = Trophy
    { Trophy -> Name
name        :: Name
    , Trophy -> Maybe Name
trophyID    :: Maybe TrophyID
      -- | It is not clear what this field is referring to, as 'Trophy's and
      -- 'Award's are supposed to be entirely distinct, according to Reddit
    , Trophy -> Maybe Name
awardID     :: Maybe Text
    , Trophy -> Maybe Name
description :: Maybe Body
    , Trophy -> Maybe UTCTime
grantedAt   :: Maybe UTCTime
    , Trophy -> Maybe Name
url         :: Maybe URL
      -- | URL for a 41x41 px icon
    , Trophy -> Name
icon40      :: URL
      -- | URL for a 71x71 px icon
    , Trophy -> Name
icon70      :: URL
    }
    deriving stock ( Int -> Trophy -> ShowS
[Trophy] -> ShowS
Trophy -> String
(Int -> Trophy -> ShowS)
-> (Trophy -> String) -> ([Trophy] -> ShowS) -> Show Trophy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Trophy] -> ShowS
$cshowList :: [Trophy] -> ShowS
show :: Trophy -> String
$cshow :: Trophy -> String
showsPrec :: Int -> Trophy -> ShowS
$cshowsPrec :: Int -> Trophy -> ShowS
Show, Trophy -> Trophy -> Bool
(Trophy -> Trophy -> Bool)
-> (Trophy -> Trophy -> Bool) -> Eq Trophy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Trophy -> Trophy -> Bool
$c/= :: Trophy -> Trophy -> Bool
== :: Trophy -> Trophy -> Bool
$c== :: Trophy -> Trophy -> Bool
Eq, (forall x. Trophy -> Rep Trophy x)
-> (forall x. Rep Trophy x -> Trophy) -> Generic Trophy
forall x. Rep Trophy x -> Trophy
forall x. Trophy -> Rep Trophy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Trophy x -> Trophy
$cfrom :: forall x. Trophy -> Rep Trophy x
Generic )

instance FromJSON Trophy where
    parseJSON :: Value -> Parser Trophy
parseJSON = RedditKind
-> String -> (Object -> Parser Trophy) -> Value -> Parser Trophy
forall b a.
FromJSON b =>
RedditKind -> String -> (b -> Parser a) -> Value -> Parser a
withKind RedditKind
AwardKind String
"Trophy" ((Object -> Parser Trophy) -> Value -> Parser Trophy)
-> (Object -> Parser Trophy) -> Value -> Parser Trophy
forall a b. (a -> b) -> a -> b
$ \Object
o -> Name
-> Maybe Name
-> Maybe Name
-> Maybe Name
-> Maybe UTCTime
-> Maybe Name
-> Name
-> Name
-> Trophy
Trophy (Name
 -> Maybe Name
 -> Maybe Name
 -> Maybe Name
 -> Maybe UTCTime
 -> Maybe Name
 -> Name
 -> Name
 -> Trophy)
-> Parser Name
-> Parser
     (Maybe Name
      -> Maybe Name
      -> Maybe Name
      -> Maybe UTCTime
      -> Maybe Name
      -> Name
      -> Name
      -> Trophy)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Name -> Parser Name
forall a. FromJSON a => Object -> Name -> Parser a
.: Name
"name"
        Parser
  (Maybe Name
   -> Maybe Name
   -> Maybe Name
   -> Maybe UTCTime
   -> Maybe Name
   -> Name
   -> Name
   -> Trophy)
-> Parser (Maybe Name)
-> Parser
     (Maybe Name
      -> Maybe Name
      -> Maybe UTCTime
      -> Maybe Name
      -> Name
      -> Name
      -> Trophy)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Name -> Parser (Maybe Name)
forall a. FromJSON a => Object -> Name -> Parser (Maybe a)
.:? Name
"id"
        Parser
  (Maybe Name
   -> Maybe Name
   -> Maybe UTCTime
   -> Maybe Name
   -> Name
   -> Name
   -> Trophy)
-> Parser (Maybe Name)
-> Parser
     (Maybe Name
      -> Maybe UTCTime -> Maybe Name -> Name -> Name -> Trophy)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Name -> Parser (Maybe Name)
forall a. FromJSON a => Object -> Name -> Parser (Maybe a)
.:? Name
"award_id"
        Parser
  (Maybe Name
   -> Maybe UTCTime -> Maybe Name -> Name -> Name -> Trophy)
-> Parser (Maybe Name)
-> Parser (Maybe UTCTime -> Maybe Name -> Name -> Name -> Trophy)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Name -> Parser (Maybe Name)
forall a. FromJSON a => Object -> Name -> Parser (Maybe a)
.:? Name
"description"
        Parser (Maybe UTCTime -> Maybe Name -> Name -> Name -> Trophy)
-> Parser (Maybe UTCTime)
-> Parser (Maybe Name -> Name -> Name -> Trophy)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((Integer -> UTCTime) -> Maybe Integer -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Integer -> UTCTime
integerToUTC (Maybe Integer -> Maybe UTCTime)
-> Parser (Maybe Integer) -> Parser (Maybe UTCTime)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Name -> Parser (Maybe Integer)
forall a. FromJSON a => Object -> Name -> Parser (Maybe a)
.:? Name
"granted_at")
        Parser (Maybe Name -> Name -> Name -> Trophy)
-> Parser (Maybe Name) -> Parser (Name -> Name -> Trophy)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Name -> Parser (Maybe Name)
forall a. FromJSON a => Object -> Name -> Parser (Maybe a)
.:? Name
"url"
        Parser (Name -> Name -> Trophy)
-> Parser Name -> Parser (Name -> Trophy)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Name -> Parser Name
forall a. FromJSON a => Object -> Name -> Parser a
.: Name
"icon_40"
        Parser (Name -> Trophy) -> Parser Name -> Parser Trophy
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Name -> Parser Name
forall a. FromJSON a => Object -> Name -> Parser a
.: Name
"icon_70"

-- | The ID of a 'Trophy'
type TrophyID = Text

-- | Wrapper for parsing JSON objects listing 'Trophy's
newtype TrophyList = TrophyList (Seq Trophy)
    deriving stock ( Int -> TrophyList -> ShowS
[TrophyList] -> ShowS
TrophyList -> String
(Int -> TrophyList -> ShowS)
-> (TrophyList -> String)
-> ([TrophyList] -> ShowS)
-> Show TrophyList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TrophyList] -> ShowS
$cshowList :: [TrophyList] -> ShowS
show :: TrophyList -> String
$cshow :: TrophyList -> String
showsPrec :: Int -> TrophyList -> ShowS
$cshowsPrec :: Int -> TrophyList -> ShowS
Show, (forall x. TrophyList -> Rep TrophyList x)
-> (forall x. Rep TrophyList x -> TrophyList) -> Generic TrophyList
forall x. Rep TrophyList x -> TrophyList
forall x. TrophyList -> Rep TrophyList x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TrophyList x -> TrophyList
$cfrom :: forall x. TrophyList -> Rep TrophyList x
Generic )

instance FromJSON TrophyList where
    parseJSON :: Value -> Parser TrophyList
parseJSON = RedditKind
-> String
-> (Object -> Parser TrophyList)
-> Value
-> Parser TrophyList
forall b a.
FromJSON b =>
RedditKind -> String -> (b -> Parser a) -> Value -> Parser a
withKind RedditKind
TrophyListKind String
"TrophyList"
        ((Object -> Parser TrophyList) -> Value -> Parser TrophyList)
-> (Object -> Parser TrophyList) -> Value -> Parser TrophyList
forall a b. (a -> b) -> a -> b
$ ([Trophy] -> TrophyList) -> Parser [Trophy] -> Parser TrophyList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Seq Trophy -> TrophyList
TrophyList (Seq Trophy -> TrophyList)
-> ([Trophy] -> Seq Trophy) -> [Trophy] -> TrophyList
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Trophy] -> Seq Trophy
forall l. IsList l => [Item l] -> l
fromList) (Parser [Trophy] -> Parser TrophyList)
-> (Object -> Parser [Trophy]) -> Object -> Parser TrophyList
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value -> Parser [Trophy]
trophiesP (Value -> Parser [Trophy])
-> (Object -> Parser Value) -> Object -> Parser [Trophy]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< (Object -> Name -> Parser Value
forall a. FromJSON a => Object -> Name -> Parser a
.: Name
"trophies"))
      where
        trophiesP :: Value -> Parser [Trophy]
trophiesP = String -> (Array -> Parser [Trophy]) -> Value -> Parser [Trophy]
forall a. String -> (Array -> Parser a) -> Value -> Parser a
withArray String
"[Trophy]" ((Value -> Parser Trophy) -> [Value] -> Parser [Trophy]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Value -> Parser Trophy
forall a. FromJSON a => Value -> Parser a
parseJSON ([Value] -> Parser [Trophy])
-> (Array -> [Value]) -> Array -> Parser [Trophy]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array -> [Value]
forall l. IsList l => l -> [Item l]
toList)

pattern Silver :: AwardID
pattern $bSilver :: AwardID
$mSilver :: forall r. AwardID -> (Void# -> r) -> (Void# -> r) -> r
Silver = AwardID "gid_1"

pattern Gold :: AwardID
pattern $bGold :: AwardID
$mGold :: forall r. AwardID -> (Void# -> r) -> (Void# -> r) -> r
Gold = AwardID "gid_2"

pattern Platinum :: AwardID
pattern $bPlatinum :: AwardID
$mPlatinum :: forall r. AwardID -> (Void# -> r) -> (Void# -> r) -> r
Platinum = AwardID "gid_3"

pattern Argentium :: AwardID
pattern $bArgentium :: AwardID
$mArgentium :: forall r. AwardID -> (Void# -> r) -> (Void# -> r) -> r
Argentium = AwardID "4ca5a4e6-8873-4ac5-99b9-71b1d5161a91"

pattern Ternion :: AwardID
pattern $bTernion :: AwardID
$mTernion :: forall r. AwardID -> (Void# -> r) -> (Void# -> r) -> r
Ternion = AwardID "2385c499-a1fb-44ec-b9b7-d260f3dc55de"