module jsonrpc

// EventInterceptor called on `jsonrpc.dispatch_event`
pub type EventInterceptor = fn (name string, data string)

// EncodedRequestInterceptor called on `jsonrpc.intercept_encoded_request`
pub type EncodedRequestInterceptor = fn (req []u8) !

// RequestInterceptor called on `jsonrpc.intercept_request`
pub type RequestInterceptor = fn (req &Request) !

// ResponseInterceptor called on `jsonrpc.intercept_response`
pub type ResponseInterceptor = fn (resp &Response)

// EncodedResponseInterceptor called on `jsonrpc.intercept_encoded_response`
pub type EncodedResponseInterceptor = fn (resp []u8)

// Interceptors collection of all supported interceptors to be called on events
pub struct Interceptors {
pub mut:
    event            []EventInterceptor
    encoded_request  []EncodedRequestInterceptor
    request          []RequestInterceptor
    response         []ResponseInterceptor
    encoded_response []EncodedResponseInterceptor
}

// dispatch_event sends `event_name` and `data` to provided `jsonrpc.EventInterceptor`s
pub fn dispatch_event(ints []EventInterceptor, event_name string, data string) {
    for i in ints {
        i(event_name, data)
    }
}

// intercept_encoded_request sends raw request data before attempting
// to decode it into `jsonrpc.Request` to provided `jsonrpc.EncodedRequestInterceptor`s
pub fn intercept_encoded_request(ints []EncodedRequestInterceptor, req []u8) ! {
    for i in ints {
        i(req)!
    }
}

// intercept_request sends decoded `jsonrpc.Request` to provided `jsonrpc.RequestInterceptor`s
pub fn intercept_request(ints []RequestInterceptor, req &Request) ! {
    for i in ints {
        i(req)!
    }
}

// intercept_response sends decoded `jsonrpc.Response` to provided `jsonrpc.ResponseInterceptor`s
pub fn intercept_response(ints []ResponseInterceptor, resp &Response) {
    for i in ints {
        i(resp)
    }
}

// intercept_encoded_response sends raw encoded data representing
// `jsonrpc.Response` to provided `jsonrpc.EncodedResponseInterceptor`s
pub fn intercept_encoded_response(ints []EncodedResponseInterceptor, resp []u8) {
    for i in ints {
        i(resp)
    }
}

// is_interceptor_enabled checks if interceptor of provided type is enabled on `jsonrpc.Server`
pub fn (s &Server) is_interceptor_enabled[T]() bool {
    s.get_interceptor[T]() or { return false }
    return true
}

// get_interceptor tries to find and return interceptor of provided type from `jsonrpc.Interceptors`
pub fn (i Interceptors) get_interceptor[T]() ?&T {
    for inter in i.event {
        if inter is T {
            return inter
        }
    }
    for inter in i.encoded_request {
        if inter is T {
            return inter
        }
    }
    for inter in i.request {
        if inter is T {
            return inter
        }
    }
    for inter in i.response {
        if inter is T {
            return inter
        }
    }
    for inter in i.encoded_response {
        if inter is T {
            return inter
        }
    }

    return none
}