import
    system,
    std/[json,sequtils]
import
    stew/[byteutils,results]
import
    ../../waku/common/base64,
    ../../waku/waku_core/message,
    ../../waku/waku_core/message/message,
    ./json_base_event

type
  JsonMessage* = ref object
    # https://rfc.vac.dev/spec/36/#jsonmessage-type
    payload*: Base64String
    contentTopic*: string
    version*: uint
    timestamp*: int64
    ephemeral*: bool
    meta*: Base64String
    proof*: Base64String

func fromJsonNode*(T: type JsonMessage, jsonContent: JsonNode): JsonMessage =
  # Visit https://rfc.vac.dev/spec/14/ for further details
  JsonMessage(
    payload: Base64String(jsonContent["payload"].getStr()),
    contentTopic: jsonContent["contentTopic"].getStr(),
    version: uint32(jsonContent{"version"}.getInt()),
    timestamp: int64(jsonContent{"timestamp"}.getBiggestInt()),
    ephemeral: jsonContent{"ephemeral"}.getBool(),
    meta: Base64String(jsonContent{"meta"}.getStr()),
    proof: Base64String(jsonContent{"proof"}.getStr())
  )

proc toWakuMessage*(self: JsonMessage): Result[WakuMessage, string] =
  let payload = base64.decode(self.payload).valueOr:
    return err("invalid payload format: " & error)

  let meta = base64.decode(self.meta).valueOr:
    return err("invalid meta format: " & error)

  let proof = base64.decode(self.proof).valueOr:
    return err("invalid proof format: " & error)

  ok(WakuMessage(
    payload: payload,
    meta: meta,
    contentTopic: self.contentTopic,
    version: uint32(self.version),
    timestamp: self.timestamp,
    ephemeral: self.ephemeral,
    proof: proof,
  ))

proc `%`*(value: Base64String): JsonNode =
  %(value.string)

proc `%`*(value: WakuMessageHash): JsonNode =
  %(to0xHex(value))

type JsonMessageEvent* = ref object of JsonEvent
    pubsubTopic*: string
    messageHash*: WakuMessageHash
    wakuMessage*: JsonMessage

proc new*(T: type JsonMessageEvent,
          pubSubTopic: string,
          msg: WakuMessage): T =
  # Returns a WakuMessage event as indicated in
  # https://rfc.vac.dev/spec/36/#jsonmessageevent-type

  var payload = newSeq[byte](len(msg.payload))
  if len(msg.payload) != 0:
    copyMem(addr payload[0], unsafeAddr msg.payload[0], len(msg.payload))

  var meta = newSeq[byte](len(msg.meta))
  if len(msg.meta) != 0:
    copyMem(addr meta[0], unsafeAddr msg.meta[0], len(msg.meta))

  var proof = newSeq[byte](len(msg.proof))
  if len(msg.proof) != 0:
    copyMem(addr proof[0], unsafeAddr msg.proof[0], len(msg.proof))

  let msgHash = computeMessageHash(pubSubTopic, msg)

  return JsonMessageEvent(
    eventType: "message",
    pubSubTopic: pubSubTopic,
    messageHash: msgHash,
    wakuMessage: JsonMessage(
        payload: base64.encode(payload),
        contentTopic: msg.contentTopic,
        version: msg.version,
        timestamp: int64(msg.timestamp),
        ephemeral: msg.ephemeral,
        meta: base64.encode(meta),
        proof: base64.encode(proof),
    )
  )

method `$`*(jsonMessage: JsonMessageEvent): string =
  $( %* jsonMessage )