encoding/json

import encoding.json
import encoding.encerr

struct Database:
    pub host: str = "localhost"
    pub port: int = 5432
    pub pool: int = 4
end

struct Config:
    pub name: str = "app"
    pub debug: bool = false
    pub db: Database = Database {}
    pub admins: Vector<str> = Vector {}
end

func main:
    text := `{
  "name": "shop",
  "db": {"host": "db.internal", "port": 6432},
  "admins": ["sara", "reza"]
}`
    mut cfg := Config {}
    mut e := encerr.NoError()
    if not json.UnmarshalLenient(text, cfg, e):
        println "bad config:", e.message
        ret 1
    end
    println "name:", cfg.name
    println "debug:", cfg.debug
    println "database:", cfg.db.host, cfg.db.port, "pool", cfg.db.pool
    println "admins:", cfg.admins.len(), cfg.admins.get(0), cfg.admins.get(1)
end

import encoding.json

struct Item:
    pub sku: str = ""
    pub title: str = ""
    @json "price_cents"
    pub price: int = 0
    pub in_stock: bool = true
end

struct Page:
    pub page: int = 1
    pub total: int = 0
    pub items: Vector<Item> = Vector {}
    @json "-"
    pub cache_key: str = ""
end

func main:
    mut p := Page { page = 2, total = 14, cache_key = "products:2" }
    p.items.push(Item { sku = "BK-01", title = "Notebook", price = 1250 })
    p.items.push(Item { sku = "PN-07", title = "Pen \"fine\"", price = 300, in_stock = false })

    println json.Marshal(p)
    println json.MarshalIndent(p, "  ")
end

import encoding.json
import encoding.value
import encoding.encerr
import str

func describe(v: value.Value): str:
    if value.IsString(v): ret "string " + value.AsString(v) end
    if value.IsInt(v): ret "int " + str.FromInt(value.AsInt(v)) end
    if value.IsFloat(v): ret "float " + str.FromFloat(value.AsFloat(v)) end
    if value.IsBool(v):
        if value.AsBool(v): ret "bool true" end
        ret "bool false"
    end
    if value.IsArray(v): ret "array of " + str.FromInt(value.ArrayLen(v)) end
    if value.IsObject(v): ret "object with " + str.FromInt(value.ObjectLen(v)) + " keys" end
    ret "null"
end

func main:
    mut e := encerr.NoError()
    doc := json.Decode(`{"id": 7, "name": "Lamp", "price": 19.5, "sale": true, "tags": ["home", "light"], "size": {"w": 20, "h": 45}, "note": null}`, e)
    if encerr.IsError(e):
        println "parse error:", e.message
        ret 1
    end
    println "keys:", value.ObjectLen(doc)
    keys := ["id", "name", "price", "sale", "tags", "size", "note", "color"]
    each k in keys:
        if not value.ObjectHas(doc, k):
            println k, "is missing"
            continue
        end
        println k, "=", describe(value.ObjectGet(doc, k))
    end
    size := value.ObjectGet(doc, "size")
    println "area:", value.AsInt(value.ObjectGet(size, "w")) * value.AsInt(value.ObjectGet(size, "h"))
end

import encoding.json
import encoding.encerr

struct Signup:
    pub email: str = ""
    pub age: int = 0
end

func load(text: str):
    mut s := Signup {}
    mut e := encerr.NoError()
    if json.Unmarshal(text, s, e):
        println "ok:", s.email, s.age
    else:
        println "error at", e.position, "->", e.message
    end
end

func load_lenient(text: str):
    mut s := Signup {}
    mut e := encerr.NoError()
    if json.UnmarshalLenient(text, s, e):
        println "lenient ok:", s.email, s.age
    end
end

func main:
    load(`{"email": "a@example.com", "age": 31}`)
    load(`{"email": "a@example.com", "age": "31"}`)
    load(`{"email": "a@example.com", "age": 31`)
    load(`{"email": "a@example.com", "age": 31, "plan": "pro"}`)
    load_lenient(`{"email": "a@example.com", "age": 31, "plan": "pro"}`)

    println "valid:", json.Valid(`[1, 2, 3]`), json.Valid(`[1, 2,]`)
    println "missing key gives [" + json.Get(`{"a": 1}`, "b") + "]"
end

import encoding.json
import encoding.value

func main:
    logs := `{"level": "info", "msg": "started", "ms": 3}
{"level": "warn", "msg": "slow query", "ms": 820}
{"level": "info", "msg": "request", "ms": 41}
{"level": "error", "msg": "timeout", "ms": 5000}
{"level": "info", "msg": "request", "ms": 37}
`
    mut counts := HashMap {} as HashMap<str, int>
    mut slow := 0
    mut d := json.NewBufDecoder(logs)
    until d.More():
        line := d.Decode()
        level := value.AsString(value.ObjectGet(line, "level"))
        counts.put(level, counts.get_or(level, 0) + 1)
        if value.AsInt(value.ObjectGet(line, "ms")) > 500:
            slow += 1
        end
    end
    println "info:", counts.get_or("info", 0), "warn:", counts.get_or("warn", 0), "error:", counts.get_or("error", 0)
    println "slower than 500 ms:", slow

    mut out := json.NewBufEncoder()
    out.Encode(value.ValueString("summary"))
    out.Encode(value.ValueInt(slow))
    println out.String()
    out.Close()
end