module jsonrpc

import json

pub const version = '2.0'

// ---- error helpers ----

pub struct ResponseError {
pub mut:
    code    int
    message string
    data    string
}

// code returns `jsonrpc.ResponseError.code` field value
pub fn (err ResponseError) code() int {
    return err.code
}

// msg returns `jsonrpc.ResponseError.message` field value
pub fn (err ResponseError) msg() string {
    return err.message
}

// err returns `jsonrpc.ResponseError` casted to `IError`
pub fn (e ResponseError) err() IError {
    return IError(e)
}

// ResponseErrorGeneratorParams & response_error are used by server.v :contentReference[oaicite:2]{index=2}
@[params]
pub struct ResponseErrorGeneratorParams {
    error IError @[required]
    data  string
}

// response_error returns `jsonrpc.ResponseError` created from passed error and data
@[inline]
pub fn response_error(params ResponseErrorGeneratorParams) ResponseError {
    return ResponseError{
        code:    params.error.code()
        message: params.error.msg()
        data:    params.data
    }
}

// error_with_code returns `jsonrpc.ResponseError` with empty data field
pub fn error_with_code(message string, code int) ResponseError {
    return ResponseError{
        code:    code
        message: message
        data:    ''
    }
}

// JSON-RPC standard-ish errors :contentReference[oaicite:3]{index=3}

pub const parse_error = error_with_code('Invalid JSON.', -32700)
pub const invalid_request = error_with_code('Invalid request.', -32600)
pub const method_not_found = error_with_code('Method not found.', -32601)
pub const invalid_params = error_with_code('Invalid params', -32602)
pub const internal_error = error_with_code('Internal error.', -32693)
pub const server_error_start = error_with_code('Error occurred when starting server.', -32099)
pub const server_not_initialized = error_with_code('Server not initialized.', -32002)
pub const unknown_error = error_with_code('Unknown error.', -32001)
pub const server_error_end = error_with_code('Error occurred when stopping the server.', -32000)
pub const error_codes = [
    parse_error.code(),
    invalid_request.code(),
    method_not_found.code(),
    invalid_params.code(),
    internal_error.code(),
    server_error_start.code(),
    server_not_initialized.code(),
    server_error_end.code(),
    unknown_error.code(),
]

// Null represents the null value in JSON.
pub struct Null {}

// str returns string representation of json null: 'null' (can be used for
// `jsonrpc.Request` id and params as well as `jsonrpc.Response` result and id)
pub fn (n Null) str() string {
    return 'null'
}

pub const null = Null{}

pub struct Empty {}

// str returns empty string: '' (can be passed to jsonrpc.new_request as id or params to omit fields on encoding)
pub fn (e Empty) str() string {
    return ''
}

pub const empty = Empty{}

// ---- request/response ----

// Request uses raw JSON strings for id and params in the old VLS code. :contentReference[oaicite:4]{index=4}
pub struct Request {
pub:
    jsonrpc string = version
    method  string
    params  string @[omitempty; raw] // raw JSON object/array/null
    id      string @[omitempty]      // raw JSON (e.g. 1 or "abc") if empty => notification (no id field)
}

// new_request is the constructor for Request. ALWAYS use this to initialize new Request.
// if id is empty string ('') then the Request will be notification (no id field on encode).
// Pass jsonrpc.Empty{} as params to not generate params field on encode.
// jsonrpc.null can be used as params to set params field to json null on encode.
// Limitations: id is always string.
pub fn new_request[T](method string, params T, id string) Request {
    return Request{
        method: method
        params: try_encode(params)
        id:     id
    }
}

// (req Request) encode() returns json string representing Request.
// In returning string params field can be omited if in new_request was passed jsonrpc.Empty{} as params.
// In returning string id field can be omited if in new_request was passed empty string ('') as id.
pub fn (req Request) encode() string {
    params_payload := if req.params.len == 0 {
        ''
    } else {
        ',"params":${req.params}'
    }
    id_payload := if req.id.len != 0 { ',"id":"${req.id}"' } else { '' }
    return '{"jsonrpc":"${version}","method":"${req.method}"${params_payload}${id_payload}}'
}

// encode_batch loops through every `jsonrpc.Request` in array, calls encode() for each of them
// and writes into json list [] splitting with ','
pub fn (reqs []Request) encode_batch() string {
    if reqs.len == 0 {
        return '[]'
    }
    mut s := '[' + reqs[0].encode()
    for req in reqs[1..] {
        s = s + ',' + req.encode()
    }
    return s + ']'
}

// decode_params tries to decode Request.params into provided type
pub fn (req Request) decode_params[T]() !T {
    return try_decode[T](req.params)
}

// decode_request decodes raw request into JSONRPC Request by reading after \r\n\r\n.
pub fn decode_request(raw string) !Request {
    json_payload := raw.all_after('\r\n\r\n')
    return json.decode(Request, json_payload) or { return err }
}

// decode_batch_request decodes raw batch request into []jsonrpc.Request by reading after \r\n\r\n.
pub fn decode_batch_request(raw string) ![]Request {
    json_payload := raw.all_after('\r\n\r\n')
    return json.decode([]Request, json_payload) or { return err }
}

pub struct Response {
pub:
    jsonrpc string = version
    result  string @[raw]
    error   ResponseError
    id      string
}

// new_response is the constructor for Response. ALWAYS use this to initialize new Response.
// if id is empty string ('') then the Result id will be a json null.
// Pass jsonrpc.ResponseError{} as error to not generate error field on encode.
// jsonrpc.null can be used as result to set field to json null on encode.
// Limitations: id is always string.
pub fn new_response[T](result T, error ResponseError, id string) Response {
    return Response{
        result: if error.code != 0 { '' } else { try_encode(result) }
        error:  error
        id:     id
    }
}

// encode() returns json string representing Response.
// In returning string result field only generates if in new_response was passed `jsonrpc.ResponseError{}` as error value.
// In returning string id field will be json null if in new_request was passed empty string ('') as id.
pub fn (resp Response) encode() string {
    mut s := '{"jsonrpc":"${version}"'
    if resp.error.code != 0 {
        s = s + ',"error":' + json.encode(resp.error)
    } else {
        s = s + ',"result":' + resp.result
    }
    s = s + ',"id":'
    if resp.id.len == 0 {
        s = s + null.str()
    } else {
        s = s + '"${resp.id}"'
    }
    return s + '}'
}

// encode_batch loops through every `jsonrpc.Response` in array, calls encode() for each of them
// and writes into json list [] splitting with ','
pub fn (resps []Response) encode_batch() string {
    if resps.len == 0 {
        return '[]'
    }
    mut s := '[' + resps[0].encode()
    for resp in resps[1..] {
        s = s + ',' + resp.encode()
    }
    return s + ']'
}

// decode_params tries to decode Response.result into provided type
pub fn (resp Response) decode_result[T]() !T {
    return try_decode[T](resp.result)
}

// decode_response decodes raw response into JSONRPC Response by reading after \r\n\r\n.
pub fn decode_response(raw string) !Response {
    json_payload := raw.all_after('\r\n\r\n')
    return json.decode(Response, json_payload) or { return err }
}

// decode_batch_response decodes raw batch request into []jsonrpc.Request by reading after \r\n\r\n.
pub fn decode_batch_response(raw string) ![]Response {
    json_payload := raw.all_after('\r\n\r\n')
    return json.decode([]Response, json_payload) or { return err }
}

// try_encode tries to encode passed value to json object, array or primitive
// currently only for internal use
fn try_encode[T](data T) string {
    return $if data is string {
        '"${data}"'
    } $else $if data is bool {
        data.str()
    } $else $if data is int {
        data.str()
    } $else $if data is Null {
        data.str()
    } $else $if data is Empty {
        data.str()
    } $else {
        json.encode(data)
    }
}

fn try_decode[T](s string) !T {
    $if T is string {
        if s[0] == `"` && s[s.len - 1] == `"` {
            return s.find_between('"', '"\0')
        }
        return error('Could not decode data=${s} into type string')
    } $else $if T is bool {
        if s == 'true' {
            return true
        }
        if s == 'false' {
            return false
        }
        return error('Could not decode data=${s} into type bool')
    } $else $if T is int {
        res := s.int()
        if res == 0 && s != '0' {
            return error('Could not decode data=${s} into type int')
        }
        return res
    } $else $if T is Null {
        if s != null.str() {
            return error('Could not decode data=${s} into type bool')
        }
        return null
    } $else $if T is Empty {
        if s.len == 0 {
            return Empty{}
        }
        return error('Params not empty: data=${s}')
    } $else {
        return json.decode(T, s) or { return err }
    }
}