import jsonx
import jsonx/streams

let out = toJson((hello: "world", answer: 42))

import jsonx

type Person = object
  name: string
  age: int

let p = fromJson("{\"name\":\"Ada\",\"age\":42}", Person)

import jsonx
import jsonx/streams

type Person = object
  name: string
  age: int

let s = streams.open("{\"name\":\"Ada\",\"age\":42}")
let p = fromJson(s, Person)

import jsonx
import jsonx/streams

type Person = object
  name: string
  age: int

let s = streams.open("")
let p = Person(name: "Ada", age: 42)
s.writeJson(p)

var parsed: Person
var parser: JsonParser
open(parser, streams.open(s.s), "inline")
discard getTok(parser)
readJson(parsed, parser)

import jsonx
import jsonx/[parsejson, streams]

type
  ChatCompletionInputContentKind = enum
    text, parts

  ChatCompletionContentPart = object
    text: string

  ChatCompletionMessageContent = object
    case kind: ChatCompletionInputContentKind
    of text:
      text: string
    of parts:
      parts: seq[ChatCompletionContentPart]

  ChatMessage = object
    role: string
    content: ChatCompletionMessageContent

# Accept either:
# - "content": "plain text"
# - "content": [{ "text": "part 1" }, ...]
proc readJson*(dst: var ChatCompletionMessageContent; p: var JsonParser) =
  if p.tok == tkString:
    dst = ChatCompletionMessageContent(kind: text)
    readJson(dst.text, p)
  elif p.tok == tkBracketLe:
    dst = ChatCompletionMessageContent(kind: parts)
    readJson(dst.parts, p)
  else:
    raiseParseErr(p, "string or array")

# Write back with the same shape.
proc writeJson*(s: Stream; x: ChatCompletionMessageContent) =
  case x.kind
  of text:
    writeJson(s, x.text)
  of parts:
    writeJson(s, x.parts)

import jsonx
import jsonx/streams

type
  PageErrorKind = enum
    NoError, NetworkError, HttpError, ParseError

  PageResultStatus = enum
    PagePending = "pending"
    PageOk = "ok"
    PageError = "error"

  PageResult = object
    page: int
    status: PageResultStatus
    text: string
    errorKind: PageErrorKind
    errorMessage: string
    httpStatus: int

template writeJsonField(s: Stream; name: string; value: untyped) =
  # Shared "key:value" writer with comma handling.
  if comma: s.write ","
  else: comma = true
  escapeJson(s, name)
  s.write ":"
  writeJson(s, value)

proc writeJson*(s: Stream; x: PageResult) =
  var comma = false
  s.write "{"
  writeJsonField(s, "page", x.page)
  writeJsonField(s, "status", x.status)
  case x.status
  of PageOk:
    writeJsonField(s, "text", x.text) # Success payload.
  of PageError:
    writeJsonField(s, "error_kind", x.errorKind)
    writeJsonField(s, "error_message", x.errorMessage)
    if x.httpStatus != 0:
      writeJsonField(s, "http_status", x.httpStatus) # Optional HTTP context.
  of PagePending:
    discard # Nothing extra to emit yet.
  s.write "}"

let ok = PageResult(page: 7, status: PageOk, text: "hello")
echo toJson(ok) # {"page":7,"status":"ok","text":"hello"}

# This data structure is like a Table[int, T],
# so we encode it as an array of [key, value] pairs.
proc writeJson*[T](s: Stream; a: SparseSet[T]) =
  s.write "["
  var comma = false
  for e, val in a.pairs:
    # Emit commas between pairs.
    if comma: s.write ","
    else: comma = true

    # Each entry is a 2-element JSON array: [entity, value].
    s.write "["
    writeJson(s, e)
    s.write ","
    writeJson(s, val)
    s.write "]"
  s.write "]"

proc readJson*[T](dst: var SparseSet[T]; p: var JsonParser) =
  eat(p, tkBracketLe)
  # Start from a clean container before filling parsed entries.
  dst = initSparseSet[T]()
  while p.tok != tkBracketRi:
    eat(p, tkBracketLe)
    var e: Entity
    readJson(e, p)
    eat(p, tkComma)
    var val: T
    readJson(val, p)
    dst[e] = val
    eat(p, tkBracketRi)
    # Accept either ',' + next item or closing ']'.
    expectArraySeparator(p)
  eat(p, tkBracketRi)

import jsonx
import jsonx/streams

let s = streams.open("[{\"name\":\"A\"},{\"name\":\"B\"}]")
for item in jsonItems(s, Person):
  discard