open Types

let encode_exn jsont v = Jsont_bytesrw.encode_string jsont v |> Result.get_ok
let encode jsont v = Jsont_bytesrw.encode_string jsont v
let decode jsont v = Jsont_bytesrw.decode_string jsont v

module Error_detail = struct
  open Error_detail

  let jsont =
    let make code hint = { code; hint } in
    let enc_code v = v.code in
    let enc_hint v = v.hint in
    Jsont.Object.map ~kind:"ErrorDetail" make
    |> Jsont.Object.mem "code" Jsont.int ~enc:enc_code
    |> Jsont.Object.opt_mem "hint" Jsont.(string) ~enc:enc_hint
    |> Jsont.Object.finish
end

module Timestamp = struct
  open Timestamp

  let number_or_never_jsont =
    let never =
      let dec s =
        match s with
        | "never" -> Never
        | _ -> Jsont.Error.msg Jsont.Meta.none "unexpected string value"
      in
      let enc = function Never -> "never" | _ -> assert false in
      Jsont.map ~dec ~enc Jsont.string
    in
    let number =
      let dec n = Seconds n in
      let enc = function Seconds n -> n | _ -> assert false in
      Jsont.map ~dec ~enc Jsont.number
    in
    let enc = function Never -> never | Seconds _ -> number in
    Jsont.any ~dec_string:never ~dec_number:number ~enc ()

  let jsont =
    let make t_s = t_s in
    Jsont.Object.map ~kind:"Timestamp" make
    |> Jsont.Object.mem "t_s" number_or_never_jsont ~enc:Fun.id
    |> Jsont.Object.finish
end

module Relative_time = struct
  open Relative_time

  let number_or_forever_jsont =
    let forever =
      let dec s =
        match s with
        | "forever" -> Forever
        | _ -> Jsont.Error.msg Jsont.Meta.none "unexpected string value"
      in
      let enc = function Forever -> "forever" | _ -> assert false in
      Jsont.map ~dec ~enc Jsont.string
    in
    let number =
      let dec n = Microseconds n in
      let enc = function Microseconds n -> n | _ -> assert false in
      Jsont.map ~dec ~enc Jsont.number
    in
    let enc = function Forever -> forever | Microseconds _ -> number in
    Jsont.any ~dec_string:forever ~dec_number:number ~enc ()

  let jsont =
    let make t_s = t_s in
    Jsont.Object.map ~kind:"RelativeTime" make
    |> Jsont.Object.mem "t_s" number_or_forever_jsont ~enc:Fun.id
    |> Jsont.Object.finish
end

let amount_jsont =
  Jsont.of_of_string ~kind:"Amount" Amount.of_string ~enc:Amount.to_string

module Eddsa = struct
  open Eddsa

  let pub_jsont =
    let dec = Jsont.Base.dec_result pub_of_string in
    let enc = Jsont.Base.enc pub_to_string in
    Jsont.Base.string (Jsont.Base.map ~kind:"EddsaPublicKey" ~dec ~enc ())
end

module Rsa_denomination_key = struct
  open Rsa_denomination_key

  let jsont =
    let make age_mask rsa_pub = { age_mask; rsa_pub } in
    let age_mask v = v.age_mask in
    let rsa_pub v = v.rsa_pub in
    Jsont.Object.map ~kind:"RsaDenominationKey" make
    |> Jsont.Object.mem "age_mask" Jsont.int ~enc:age_mask
    |> Jsont.Object.mem "rsa_pub" Jsont.string ~enc:rsa_pub
    |> Jsont.Object.finish
end

module CS_denomination_key = struct
  open CS_denomination_key

  let jsont =
    let make age_mask cs_pub = { age_mask; cs_pub } in
    let age_mask v = v.age_mask in
    let cs_pub v = v.cs_pub in
    Jsont.Object.map ~kind:"CSDenominationKey" make
    |> Jsont.Object.mem "age_mask" Jsont.int ~enc:age_mask
    |> Jsont.Object.mem "cs_pub" Jsont.string ~enc:cs_pub
    |> Jsont.Object.finish
end

module Denomination_key = struct
  open Denomination_key

  let rsa v = Rsa v
  let cs v = CS v

  let jsont =
    let open Jsont.Object in
    let rsa = Case.map "RSA" Rsa_denomination_key.jsont ~dec:rsa in
    let cs = Case.map "CS" CS_denomination_key.jsont ~dec:cs in
    let enc_case = function
      | Rsa v -> Case.value rsa v
      | CS v -> Case.value cs v
    in
    let cases = Case.[ make rsa; make cs ] in
    map ~kind:"DenominationKey" Fun.id
    |> case_mem "cipher" Jsont.string ~enc:Fun.id ~enc_case cases
    |> finish
end