module TD.Data.SuggestedPostInfo
  (SuggestedPostInfo(..)) where

import qualified Data.Aeson as A
import qualified Data.Aeson.Types as AT
import qualified TD.Lib.Internal as I
import qualified TD.Data.SuggestedPostPrice as SuggestedPostPrice
import qualified TD.Data.SuggestedPostState as SuggestedPostState

data SuggestedPostInfo
  = SuggestedPostInfo -- ^ Contains information about a suggested post. If the post can be approved or declined, then changes to the post can be also suggested. Use sendMessage with reply to the message and suggested post information to suggest message changes. Use addOffer to suggest price or time changes
    { SuggestedPostInfo -> Maybe SuggestedPostPrice
price           :: Maybe SuggestedPostPrice.SuggestedPostPrice -- ^ Price of the suggested post; may be null if the post is non-paid
    , SuggestedPostInfo -> Maybe Int
send_date       :: Maybe Int                                   -- ^ Point in time (Unix timestamp) when the post is expected to be published; 0 if the specific date isn't set yet
    , SuggestedPostInfo -> Maybe SuggestedPostState
state           :: Maybe SuggestedPostState.SuggestedPostState -- ^ State of the post
    , SuggestedPostInfo -> Maybe Bool
can_be_approved :: Maybe Bool                                  -- ^ True, if the suggested post can be approved by the current user using approveSuggestedPost; updates aren't sent when value of this field changes
    , SuggestedPostInfo -> Maybe Bool
can_be_declined :: Maybe Bool                                  -- ^ True, if the suggested post can be declined by the current user using declineSuggestedPost; updates aren't sent when value of this field changes
    }
  deriving (SuggestedPostInfo -> SuggestedPostInfo -> Bool
(SuggestedPostInfo -> SuggestedPostInfo -> Bool)
-> (SuggestedPostInfo -> SuggestedPostInfo -> Bool)
-> Eq SuggestedPostInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SuggestedPostInfo -> SuggestedPostInfo -> Bool
== :: SuggestedPostInfo -> SuggestedPostInfo -> Bool
$c/= :: SuggestedPostInfo -> SuggestedPostInfo -> Bool
/= :: SuggestedPostInfo -> SuggestedPostInfo -> Bool
Eq, Int -> SuggestedPostInfo -> ShowS
[SuggestedPostInfo] -> ShowS
SuggestedPostInfo -> String
(Int -> SuggestedPostInfo -> ShowS)
-> (SuggestedPostInfo -> String)
-> ([SuggestedPostInfo] -> ShowS)
-> Show SuggestedPostInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SuggestedPostInfo -> ShowS
showsPrec :: Int -> SuggestedPostInfo -> ShowS
$cshow :: SuggestedPostInfo -> String
show :: SuggestedPostInfo -> String
$cshowList :: [SuggestedPostInfo] -> ShowS
showList :: [SuggestedPostInfo] -> ShowS
Show)

instance I.ShortShow SuggestedPostInfo where
  shortShow :: SuggestedPostInfo -> String
shortShow SuggestedPostInfo
    { price :: SuggestedPostInfo -> Maybe SuggestedPostPrice
price           = Maybe SuggestedPostPrice
price_
    , send_date :: SuggestedPostInfo -> Maybe Int
send_date       = Maybe Int
send_date_
    , state :: SuggestedPostInfo -> Maybe SuggestedPostState
state           = Maybe SuggestedPostState
state_
    , can_be_approved :: SuggestedPostInfo -> Maybe Bool
can_be_approved = Maybe Bool
can_be_approved_
    , can_be_declined :: SuggestedPostInfo -> Maybe Bool
can_be_declined = Maybe Bool
can_be_declined_
    }
      = String
"SuggestedPostInfo"
        String -> ShowS
forall a. [a] -> [a] -> [a]
++ [String] -> String
I.cc
        [ String
"price"           String -> Maybe SuggestedPostPrice -> String
forall a. ShortShow a => String -> Maybe a -> String
`I.p` Maybe SuggestedPostPrice
price_
        , String
"send_date"       String -> Maybe Int -> String
forall a. ShortShow a => String -> Maybe a -> String
`I.p` Maybe Int
send_date_
        , String
"state"           String -> Maybe SuggestedPostState -> String
forall a. ShortShow a => String -> Maybe a -> String
`I.p` Maybe SuggestedPostState
state_
        , String
"can_be_approved" String -> Maybe Bool -> String
forall a. ShortShow a => String -> Maybe a -> String
`I.p` Maybe Bool
can_be_approved_
        , String
"can_be_declined" String -> Maybe Bool -> String
forall a. ShortShow a => String -> Maybe a -> String
`I.p` Maybe Bool
can_be_declined_
        ]

instance AT.FromJSON SuggestedPostInfo where
  parseJSON :: Value -> Parser SuggestedPostInfo
parseJSON v :: Value
v@(AT.Object Object
obj) = do
    String
t <- Object
obj Object -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
A..: Key
"@type" :: AT.Parser String

    case String
t of
      String
"suggestedPostInfo" -> Value -> Parser SuggestedPostInfo
parseSuggestedPostInfo Value
v
      String
_                   -> Parser SuggestedPostInfo
forall a. Monoid a => a
mempty
    
    where
      parseSuggestedPostInfo :: A.Value -> AT.Parser SuggestedPostInfo
      parseSuggestedPostInfo :: Value -> Parser SuggestedPostInfo
parseSuggestedPostInfo = String
-> (Object -> Parser SuggestedPostInfo)
-> Value
-> Parser SuggestedPostInfo
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"SuggestedPostInfo" ((Object -> Parser SuggestedPostInfo)
 -> Value -> Parser SuggestedPostInfo)
-> (Object -> Parser SuggestedPostInfo)
-> Value
-> Parser SuggestedPostInfo
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
        Maybe SuggestedPostPrice
price_           <- Object
o Object -> Key -> Parser (Maybe SuggestedPostPrice)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
A..:?  Key
"price"
        Maybe Int
send_date_       <- Object
o Object -> Key -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
A..:?  Key
"send_date"
        Maybe SuggestedPostState
state_           <- Object
o Object -> Key -> Parser (Maybe SuggestedPostState)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
A..:?  Key
"state"
        Maybe Bool
can_be_approved_ <- Object
o Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
A..:?  Key
"can_be_approved"
        Maybe Bool
can_be_declined_ <- Object
o Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
A..:?  Key
"can_be_declined"
        SuggestedPostInfo -> Parser SuggestedPostInfo
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SuggestedPostInfo -> Parser SuggestedPostInfo)
-> SuggestedPostInfo -> Parser SuggestedPostInfo
forall a b. (a -> b) -> a -> b
$ SuggestedPostInfo
          { price :: Maybe SuggestedPostPrice
price           = Maybe SuggestedPostPrice
price_
          , send_date :: Maybe Int
send_date       = Maybe Int
send_date_
          , state :: Maybe SuggestedPostState
state           = Maybe SuggestedPostState
state_
          , can_be_approved :: Maybe Bool
can_be_approved = Maybe Bool
can_be_approved_
          , can_be_declined :: Maybe Bool
can_be_declined = Maybe Bool
can_be_declined_
          }
  parseJSON Value
_ = Parser SuggestedPostInfo
forall a. Monoid a => a
mempty