module Rattletrap.Type.Attribute.Product where

import qualified Data.Map as Map
import qualified Rattletrap.BitGet as BitGet
import qualified Rattletrap.BitPut as BitPut
import qualified Rattletrap.Schema as Schema
import qualified Rattletrap.Type.Attribute.ProductValue as ProductValue
import qualified Rattletrap.Type.List as RList
import qualified Rattletrap.Type.Str as Str
import qualified Rattletrap.Type.U32 as U32
import qualified Rattletrap.Type.U8 as U8
import qualified Rattletrap.Type.Version as Version
import qualified Rattletrap.Utility.Json as Json

data Product = Product
  { Product -> Bool
unknown :: Bool,
    Product -> U32
objectId :: U32.U32,
    -- | read-only
    Product -> Maybe Str
objectName :: Maybe Str.Str,
    Product -> ProductValue
value :: ProductValue.ProductValue
  }
  deriving (Product -> Product -> Bool
(Product -> Product -> Bool)
-> (Product -> Product -> Bool) -> Eq Product
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Product -> Product -> Bool
== :: Product -> Product -> Bool
$c/= :: Product -> Product -> Bool
/= :: Product -> Product -> Bool
Eq, Int -> Product -> ShowS
[Product] -> ShowS
Product -> String
(Int -> Product -> ShowS)
-> (Product -> String) -> ([Product] -> ShowS) -> Show Product
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Product -> ShowS
showsPrec :: Int -> Product -> ShowS
$cshow :: Product -> String
show :: Product -> String
$cshowList :: [Product] -> ShowS
showList :: [Product] -> ShowS
Show)

instance Json.FromJSON Product where
  parseJSON :: Value -> Parser Product
parseJSON = String -> (Object -> Parser Product) -> Value -> Parser Product
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Json.withObject String
"Product" ((Object -> Parser Product) -> Value -> Parser Product)
-> (Object -> Parser Product) -> Value -> Parser Product
forall a b. (a -> b) -> a -> b
$ \Object
object -> do
    unknown <- Object -> String -> Parser Bool
forall value. FromJSON value => Object -> String -> Parser value
Json.required Object
object String
"unknown"
    objectId <- Json.required object "object_id"
    objectName <- Json.optional object "object_name"
    value <- Json.required object "value"
    pure Product {unknown, objectId, objectName, value}

instance Json.ToJSON Product where
  toJSON :: Product -> Value
toJSON Product
x =
    [(Key, Value)] -> Value
Json.object
      [ String -> Bool -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"unknown" (Bool -> (Key, Value)) -> Bool -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Product -> Bool
unknown Product
x,
        String -> U32 -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"object_id" (U32 -> (Key, Value)) -> U32 -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Product -> U32
objectId Product
x,
        String -> Maybe Str -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"object_name" (Maybe Str -> (Key, Value)) -> Maybe Str -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Product -> Maybe Str
objectName Product
x,
        String -> ProductValue -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"value" (ProductValue -> (Key, Value)) -> ProductValue -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Product -> ProductValue
value Product
x
      ]

schema :: Schema.Schema
schema :: Schema
schema =
  String -> Value -> Schema
Schema.named String
"attribute-product" (Value -> Schema) -> Value -> Schema
forall a b. (a -> b) -> a -> b
$
    [((Key, Value), Bool)] -> Value
Schema.object
      [ (String -> Value -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"unknown" (Value -> (Key, Value)) -> Value -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Schema -> Value
Schema.ref Schema
Schema.boolean, Bool
True),
        (String -> Value -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"object_id" (Value -> (Key, Value)) -> Value -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Schema -> Value
Schema.ref Schema
U32.schema, Bool
True),
        (String -> Value -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"object_name" (Value -> (Key, Value))
-> (Schema -> Value) -> Schema -> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Schema -> Value
Schema.json (Schema -> (Key, Value)) -> Schema -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Schema -> Schema
Schema.maybe Schema
Str.schema, Bool
False),
        (String -> Value -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"value" (Value -> (Key, Value)) -> Value -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Schema -> Value
Schema.ref Schema
ProductValue.schema, Bool
True)
      ]

putProductAttributes :: RList.List Product -> BitPut.BitPut
putProductAttributes :: List Product -> BitPut
putProductAttributes List Product
attributes =
  let v :: [Product]
v = List Product -> [Product]
forall a. List a -> [a]
RList.toList List Product
attributes
   in (U8 -> BitPut
U8.bitPut (U8 -> BitPut) -> (Int -> U8) -> Int -> BitPut
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> U8
U8.fromWord8 (Word8 -> U8) -> (Int -> Word8) -> Int -> U8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> BitPut) -> Int -> BitPut
forall a b. (a -> b) -> a -> b
$ [Product] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Product]
v) BitPut -> BitPut -> BitPut
forall a. Semigroup a => a -> a -> a
<> (Product -> BitPut) -> [Product] -> BitPut
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Product -> BitPut
bitPut [Product]
v

bitPut :: Product -> BitPut.BitPut
bitPut :: Product -> BitPut
bitPut Product
attribute =
  Bool -> BitPut
BitPut.bool (Product -> Bool
unknown Product
attribute)
    BitPut -> BitPut -> BitPut
forall a. Semigroup a => a -> a -> a
<> U32 -> BitPut
U32.bitPut (Product -> U32
objectId Product
attribute)
    BitPut -> BitPut -> BitPut
forall a. Semigroup a => a -> a -> a
<> ProductValue -> BitPut
ProductValue.bitPut (Product -> ProductValue
value Product
attribute)

decodeProductAttributesBits ::
  Version.Version ->
  Map.Map U32.U32 Str.Str ->
  BitGet.BitGet (RList.List Product)
decodeProductAttributesBits :: Version -> Map U32 Str -> BitGet (List Product)
decodeProductAttributesBits Version
version Map U32 Str
objectMap = do
  size <- BitGet U8
U8.bitGet
  RList.replicateM (fromIntegral $ U8.toWord8 size) $ bitGet version objectMap

bitGet :: Version.Version -> Map.Map U32.U32 Str.Str -> BitGet.BitGet Product
bitGet :: Version -> Map U32 Str -> Get BitString Identity Product
bitGet Version
version Map U32 Str
objectMap = String
-> Get BitString Identity Product -> Get BitString Identity Product
forall a. String -> BitGet a -> BitGet a
BitGet.label String
"Product" (Get BitString Identity Product -> Get BitString Identity Product)
-> Get BitString Identity Product -> Get BitString Identity Product
forall a b. (a -> b) -> a -> b
$ do
  unknown <- String -> BitGet Bool -> BitGet Bool
forall a. String -> BitGet a -> BitGet a
BitGet.label String
"unknown" BitGet Bool
BitGet.bool
  objectId <- BitGet.label "objectId" U32.bitGet
  let objectName = U32 -> Map U32 Str -> Maybe Str
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup U32
objectId Map U32 Str
objectMap
  value <-
    BitGet.label "value" $
      ProductValue.bitGet version objectId objectName
  pure Product {unknown, objectId, objectName, value}