module jsonrpc

import io

pub struct ClientConfig {
pub mut:
	stream       io.ReaderWriter
	interceptors Interceptors
}

pub struct Client {
mut:
	stream       io.ReaderWriter
	interceptors Interceptors
}

// new_client creates new `jsonrpc.Client` with `stream` to read/write and `interceptors`
pub fn new_client(cfg ClientConfig) Client {
	return Client{
		stream:       cfg.stream
		interceptors: cfg.interceptors
	}
}

// notify sends JSON-RPC 2.0 Notification and returns without waiting for `jsonrpc.Response`
pub fn (mut c Client) notify[T](method string, params T) ! {
	mut req := new_request(method, params, '')
	intercept_request(c.interceptors.request, &req) or { return err }

	mut enc_req := req.encode().bytes()
	intercept_encoded_request(c.interceptors.encoded_request, enc_req) or { return err }

	c.stream.write(enc_req) or { return err }
}

// request new `jsonrpc.Request` and return `jsonrpc.Response`
pub fn (mut c Client) request[T](method string, params T, id string) !Response {
	mut req := new_request(method, params, id)
	intercept_request(c.interceptors.request, &req) or { return err }

	mut enc_req := req.encode().bytes()
	intercept_encoded_request(c.interceptors.encoded_request, enc_req) or { return err }

	c.stream.write(enc_req) or { return err }

	mut enc_resp := []u8{len: 4096}
	c.stream.read(mut enc_resp) or { return err }

	intercept_encoded_response(c.interceptors.encoded_response, enc_resp)

	resp := decode_response(enc_resp.bytestr()) or { return err }

	intercept_response(c.interceptors.response, resp)

	return resp
}

// batch sends batch of `jsonrpc.Request` and returns batch of`jsonrpc.Response`
pub fn (mut c Client) batch(reqs []Request) ![]Response {
	mut reqs_str := '['
	for req in reqs {
		intercept_request(c.interceptors.request, &req) or { return err }
		reqs_str = reqs_str + req.encode() + ', '
	}

	reqs_str = reqs_str.all_before_last(', ') + ']'
	enc_reqs := reqs_str.bytes()
	intercept_encoded_request(c.interceptors.encoded_request, enc_reqs) or { return err }

	c.stream.write(enc_reqs) or { return err }

	mut enc_resp := []u8{len: 4096}
	c.stream.read(mut enc_resp) or { return err }

	intercept_encoded_response(c.interceptors.encoded_response, enc_resp)

	mut resps := decode_batch_response(enc_resp.bytestr()) or { return err }

	for mut resp in resps {
		intercept_response(c.interceptors.response, &resp)
	}

	return resps
}