module jsonrpc

import json

fn test_try_decode_encode() {
    obj_data := {
        'key': 'value'
    }
    mut enc_data := try_encode[map[string]string](obj_data)
    assert enc_data == json.encode(obj_data)
    assert try_decode[map[string]string](enc_data)! == obj_data

    str_data := 'string'
    enc_data = try_encode[string](str_data)
    assert enc_data == '"${str_data}"'
    assert try_decode[string](enc_data)! == str_data

    bool_data := true
    enc_data = try_encode[bool](bool_data)
    assert enc_data == bool_data.str()
    assert try_decode[bool](enc_data)! == bool_data

    int_data := 123
    enc_data = try_encode[int](int_data)
    assert enc_data == int_data.str()
    assert try_decode[int](enc_data)! == int_data

    null_data := null
    enc_data = try_encode[Null](null_data)
    assert enc_data == null_data.str()
    assert try_decode[Null](enc_data)! == null_data

    empty_data := empty
    enc_data = try_encode[Empty](empty)
    assert enc_data == empty_data.str()
    assert try_decode[Empty](enc_data)! == empty_data
}

fn test_request_obj_params() {
    id := 'obj'
    method := 'params.' + id
    params := {
        'key': 'value'
    }
    mut req := new_request(method, params, id)
    assert req.jsonrpc == version
    assert req.method == method
    assert req.params == json.encode(params)
    assert req.id == id

    enc_req := req.encode()
    assert enc_req == '{"jsonrpc":"${version}","method":"${method}","params":${json.encode(params)},"id":"${id}"}'

    assert req.decode_params[map[string]string]()! == params

    dec_req := decode_request(enc_req)!
    assert req.jsonrpc == dec_req.jsonrpc
    assert req.method == dec_req.method
    assert req.params == dec_req.params
    assert req.id == dec_req.id
}

fn test_request_notification() {
    id := ''
    method := 'req.notif'
    params := 'notif'
    mut req := new_request(method, params, id)
    assert req.jsonrpc == version
    assert req.method == method
    assert req.params == '"${params}"'
    assert req.id == id

    assert req.encode() == '{"jsonrpc":"${version}","method":"${method}","params":"${params}"}'
    assert req.decode_params[string]()! == params
}

fn test_request_empty_params() {
    id := ''
    method := 'req.empty'
    params := empty
    mut req := new_request(method, params, id)
    assert req.jsonrpc == version
    assert req.method == method
    assert req.params == params.str()
    assert req.id == id

    assert req.encode() == '{"jsonrpc":"${version}","method":"${method}"}'
    assert req.decode_params[Empty]()! == params
}

fn test_request_batch() {
    n_id := ''
    n_method := 'req.notif'
    n_params := 'notif'
    mut notif := new_request(n_method, n_params, n_id)

    r_id := 'obj'
    r_method := 'params.obj'
    r_params := {
        'key': 'value'
    }
    mut req := new_request(r_method, r_params, r_id)

    batch := [notif, req]
    enc_batch := batch.encode_batch()
    assert enc_batch == '[{"jsonrpc":"${version}","method":"${n_method}","params":"${n_params}"},{"jsonrpc":"${version}","method":"${r_method}","params":${json.encode(r_params)},"id":"${r_id}"}]'

    assert decode_batch_request(enc_batch)! == batch
}

fn test_response_obj_result() {
    id := 'obj'
    result := {
        'key': 'value'
    }
    mut resp := new_response(result, ResponseError{}, id)
    assert resp.jsonrpc == version
    assert resp.result == json.encode(result)
    assert resp.error == ResponseError{}
    assert resp.id == id

    enc_resp := resp.encode()
    assert enc_resp == '{"jsonrpc":"${version}","result":${json.encode(result)},"id":"${id}"}'

    assert resp.decode_result[map[string]string]()! == result

    dec_resp := decode_response(enc_resp)!
    assert resp.jsonrpc == dec_resp.jsonrpc
    assert resp.result == dec_resp.result
    assert resp.error == dec_resp.error
    assert resp.id == dec_resp.id
}

fn test_response_error() {
    id := 'error'
    result := 'should be null'
    err := parse_error
    mut resp := new_response(result, err, id)
    assert resp.jsonrpc == version
    assert resp.result == ''
    assert resp.error == parse_error
    assert resp.id == id

    enc_resp := resp.encode()
    assert enc_resp == '{"jsonrpc":"${version}","error":${json.encode(err)},"id":"${id}"}'

    assert resp.decode_result[Empty]()! == empty

    dec_resp := decode_response(enc_resp)!
    assert resp.jsonrpc == dec_resp.jsonrpc
    assert resp.result == dec_resp.result
    assert resp.error == dec_resp.error
    assert resp.id == dec_resp.id
}

fn test_response_null_id() {
    id := ''
    result := 'should be null'
    err := parse_error
    mut resp := new_response(result, err, id)
    assert resp.jsonrpc == version
    assert resp.result == ''
    assert resp.error == parse_error
    assert resp.id == id

    enc_resp := resp.encode()
    assert enc_resp == '{"jsonrpc":"${version}","error":${json.encode(err)},"id":${null.str()}}'

    assert resp.decode_result[Empty]()! == empty

    dec_resp := decode_response(enc_resp)!
    assert resp.jsonrpc == dec_resp.jsonrpc
    assert resp.result == dec_resp.result
    assert resp.error == dec_resp.error
    assert resp.id == dec_resp.id
}

fn test_response_batch() {
    r_id := 'obj'
    r_err := ResponseError{}
    r_result := {
        'key': 'value'
    }
    mut r_resp := new_response(r_result, r_err, r_id)

    e_id := ''
    e_result := 'should be null'
    e_err := parse_error
    mut e_resp := new_response(e_result, e_err, e_id)

    batch := [r_resp, e_resp]
    enc_batch := batch.encode_batch()
    assert enc_batch == '[{"jsonrpc":"${version}","result":${json.encode(r_result)},"id":"${r_id}"},{"jsonrpc":"${version}","error":${json.encode(e_err)},"id":${null.str()}}]'

    assert decode_batch_response(enc_batch)! == batch
}