module Rattletrap.Type.Attribute.FlaggedInt where

import qualified Rattletrap.BitGet as BitGet
import qualified Rattletrap.BitPut as BitPut
import qualified Rattletrap.Schema as Schema
import qualified Rattletrap.Type.I32 as I32
import qualified Rattletrap.Utility.Json as Json

data FlaggedInt = FlaggedInt
  { FlaggedInt -> Bool
flag :: Bool
  , FlaggedInt -> I32
int :: I32.I32
  }
  deriving (FlaggedInt -> FlaggedInt -> Bool
(FlaggedInt -> FlaggedInt -> Bool)
-> (FlaggedInt -> FlaggedInt -> Bool) -> Eq FlaggedInt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FlaggedInt -> FlaggedInt -> Bool
$c/= :: FlaggedInt -> FlaggedInt -> Bool
== :: FlaggedInt -> FlaggedInt -> Bool
$c== :: FlaggedInt -> FlaggedInt -> Bool
Eq, Int -> FlaggedInt -> ShowS
[FlaggedInt] -> ShowS
FlaggedInt -> String
(Int -> FlaggedInt -> ShowS)
-> (FlaggedInt -> String)
-> ([FlaggedInt] -> ShowS)
-> Show FlaggedInt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FlaggedInt] -> ShowS
$cshowList :: [FlaggedInt] -> ShowS
show :: FlaggedInt -> String
$cshow :: FlaggedInt -> String
showsPrec :: Int -> FlaggedInt -> ShowS
$cshowsPrec :: Int -> FlaggedInt -> ShowS
Show)

instance Json.FromJSON FlaggedInt where
  parseJSON :: Value -> Parser FlaggedInt
parseJSON = String
-> (Object -> Parser FlaggedInt) -> Value -> Parser FlaggedInt
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Json.withObject String
"FlaggedInt" ((Object -> Parser FlaggedInt) -> Value -> Parser FlaggedInt)
-> (Object -> Parser FlaggedInt) -> Value -> Parser FlaggedInt
forall a b. (a -> b) -> a -> b
$ \Object
object -> do
    Bool
flag <- Object -> String -> Parser Bool
forall value. FromJSON value => Object -> String -> Parser value
Json.required Object
object String
"flag"
    I32
int <- Object -> String -> Parser I32
forall value. FromJSON value => Object -> String -> Parser value
Json.required Object
object String
"int"
    FlaggedInt -> Parser FlaggedInt
forall (f :: * -> *) a. Applicative f => a -> f a
pure FlaggedInt :: Bool -> I32 -> FlaggedInt
FlaggedInt { Bool
flag :: Bool
flag :: Bool
flag, I32
int :: I32
int :: I32
int }

instance Json.ToJSON FlaggedInt where
  toJSON :: FlaggedInt -> Value
toJSON FlaggedInt
x = [Pair] -> Value
Json.object [String -> Bool -> Pair
forall value pair.
(ToJSON value, KeyValue pair) =>
String -> value -> pair
Json.pair String
"flag" (Bool -> Pair) -> Bool -> Pair
forall a b. (a -> b) -> a -> b
$ FlaggedInt -> Bool
flag FlaggedInt
x, String -> I32 -> Pair
forall value pair.
(ToJSON value, KeyValue pair) =>
String -> value -> pair
Json.pair String
"int" (I32 -> Pair) -> I32 -> Pair
forall a b. (a -> b) -> a -> b
$ FlaggedInt -> I32
int FlaggedInt
x]

schema :: Schema.Schema
schema :: Schema
schema = String -> Value -> Schema
Schema.named String
"attribute-flagged-int" (Value -> Schema) -> Value -> Schema
forall a b. (a -> b) -> a -> b
$ [(Pair, Bool)] -> Value
Schema.object
  [ (String -> Value -> Pair
forall value pair.
(ToJSON value, KeyValue pair) =>
String -> value -> pair
Json.pair String
"flag" (Value -> Pair) -> Value -> Pair
forall a b. (a -> b) -> a -> b
$ Schema -> Value
Schema.ref Schema
Schema.boolean, Bool
True)
  , (String -> Value -> Pair
forall value pair.
(ToJSON value, KeyValue pair) =>
String -> value -> pair
Json.pair String
"int" (Value -> Pair) -> Value -> Pair
forall a b. (a -> b) -> a -> b
$ Schema -> Value
Schema.ref Schema
I32.schema, Bool
True)
  ]

bitPut :: FlaggedInt -> BitPut.BitPut
bitPut :: FlaggedInt -> BitPut
bitPut FlaggedInt
flaggedIntAttribute = Bool -> BitPut
BitPut.bool (FlaggedInt -> Bool
flag FlaggedInt
flaggedIntAttribute)
  BitPut -> BitPut -> BitPut
forall a. Semigroup a => a -> a -> a
<> I32 -> BitPut
I32.bitPut (FlaggedInt -> I32
int FlaggedInt
flaggedIntAttribute)

bitGet :: BitGet.BitGet FlaggedInt
bitGet :: BitGet FlaggedInt
bitGet = String -> BitGet FlaggedInt -> BitGet FlaggedInt
forall a. String -> BitGet a -> BitGet a
BitGet.label String
"FlaggedInt" (BitGet FlaggedInt -> BitGet FlaggedInt)
-> BitGet FlaggedInt -> BitGet FlaggedInt
forall a b. (a -> b) -> a -> b
$ do
  Bool
flag <- String -> BitGet Bool -> BitGet Bool
forall a. String -> BitGet a -> BitGet a
BitGet.label String
"flag" BitGet Bool
BitGet.bool
  I32
int <- String -> BitGet I32 -> BitGet I32
forall a. String -> BitGet a -> BitGet a
BitGet.label String
"int" BitGet I32
I32.bitGet
  FlaggedInt -> BitGet FlaggedInt
forall (f :: * -> *) a. Applicative f => a -> f a
pure FlaggedInt :: Bool -> I32 -> FlaggedInt
FlaggedInt { Bool
flag :: Bool
flag :: Bool
flag, I32
int :: I32
int :: I32
int }