httpclient

type AfterHook interface {
	// After is invoked after HTTP response is returned and before the response is decoded.
	After(context.Context, *http.Response) context.Context
}

type AfterHookFunc func(context.Context, *http.Response) context.Context

type BeforeHook interface {
	// Before is invoked after the HTTP request is encoded and before the request is sent.
	Before(context.Context, *http.Request) context.Context
}

type BeforeHookFunc func(context.Context, *http.Request) context.Context

type Client interface {
	// Execute send the provided request and parse the response using provided ResponseOptions
	// When using default decoding function:
	// 		- it returns non-nil Response only if the response has 2XX status code
	// 		- it returns non-nil error for 4XX, 5XX status code or any other type of errors
	// 		- the returned error can be casted to *Error
	Execute(ctx context.Context, request *Request, opts ...ResponseOptions) (*Response, error)

	// WithService create a client with specific service with given instance selectors.
	// The returned client is responsible to track service instance changes with help of discovery package,
	// and to perform load-balancing and retrying.
	// The returned client is goroutine-safe and can be reused
	WithService(service string, opts ...SDOptions) (Client, error)

	// WithBaseUrl create a client with specific base URL.
	// The returned client is responsible to perform retrying.
	// The returned client is goroutine-safe and can be reused
	WithBaseUrl(baseUrl string) (Client, error)

	// WithConfig create a shallow copy of the client with specified config.
	// Service (with LB) or BaseURL cannot be changed with this method.
	// If any field of provided config is zero value, this value is not applied.
	// The returned client is goroutine-safe and can be reused
	WithConfig(config *ClientConfig) Client
}

type ClientConfig struct {
	// HTTPClient underlying http.Client to use
	HTTPClient *http.Client
	// BeforeHooks hooks to use before sending HTTP request
	BeforeHooks []BeforeHook
	// AfterHooks hooks to use before sending HTTP request
	AfterHooks []AfterHook
	// MaxRetries number of retries in case of error. Negative value means no retry.
	// Note: by default, non-2XX response status code error is not retried
	MaxRetries int
	// RetryBackoff time to wait between retries. Negative means retry immediately
	RetryBackoff time.Duration
	// RetryCallback allows fine control when and how to retry.
	// If set, this override MaxRetries and RetryBackoff
	RetryCallback RetryCallback
	// Timeout how long to wait for each execution.
	// Note: this is total duration including RetryBackoff between each attempt, not per-retry timeout.
	Timeout time.Duration
	// Logger used for logging request/response
	Logger log.ContextualLogger
	// Logging configuration of request/response logging
	Logging LoggingConfig
}

type ClientCustomizer interface {
	Customize(opt *ClientOption)
}

type ClientCustomizerFunc func(opt *ClientOption)

type ClientOption struct {
	ClientConfig
	SDClient           discovery.Client
	DefaultSelector    discovery.InstanceMatcher
	DefaultBeforeHooks []BeforeHook
	DefaultAfterHooks  []AfterHook
}

type ClientOptions func(opt *ClientOption)

type ConfigurableAfterHook interface {
	WithConfig(cfg *ClientConfig) AfterHook
}

type ConfigurableBeforeHook interface {
	WithConfig(cfg *ClientConfig) BeforeHook
}

type CreateRequestFunc func(ctx context.Context, method string, target *url.URL) (*http.Request, error)

type DecodeResponseFunc func(context.Context, *http.Response) (response interface{}, err error)

type EncodeRequestFunc func(ctx context.Context, req *http.Request, val interface{}) error

type Error struct {
	CodedError
	Response *ErrorResponse
}

type ErrorResponse struct {
	http.Response
	RawBody []byte
	Body    ErrorResponseBody
}

type ErrorResponseBody interface {
	Error() string
	Message() string
	Details() map[string]string
}

type Hook interface {
	// Before is invoked after the HTTP request is encoded and before the request is sent.
	// The implementing class could also implement order.Ordered interface. Highest order is invoked first
	Before(context.Context, *http.Request) context.Context
	// After is invoked after HTTP response is returned and before the response is decoded.
	// The implementing class could also implement order.Ordered interface. Highest order is invoked first
	After(context.Context, *http.Response) context.Context
}

type HttpClientProperties struct {
	MaxRetries int              `json:"max-retries"` // negative value means no retry
	Timeout    utils.Duration   `json:"timeout"`
	Logger     LoggerProperties `json:"logger"`
}

type LogDetailsLevel int

type LoggerProperties struct {
	Level           log.LoggingLevel          `json:"level"`
	DetailsLevel    LogDetailsLevel           `json:"details-level"`
	SanitizeHeaders utils.CommaSeparatedSlice `json:"sanitize-headers"`
	ExcludeHeaders  utils.CommaSeparatedSlice `json:"exclude-headers"`
}

type LoggingConfig struct {
	Level           log.LoggingLevel
	DetailsLevel    LogDetailsLevel
	SanitizeHeaders utils.StringSet
	ExcludeHeaders  utils.StringSet
}

type Request struct {
	Path           string
	Method         string
	Params         map[string]string
	Headers        http.Header
	Body           interface{}
	BodyEncodeFunc EncodeRequestFunc
	CreateFunc     CreateRequestFunc
}

type RequestOptions func(r *Request)

type Response struct {
	StatusCode int
	Headers    http.Header
	Body       interface{}
	RawBody    []byte `json:"-"`
}

type ResponseOptions func(opt *responseOption)

type RetryCallback func(n int, rs interface{}, err error) (shouldContinue bool, backoff time.Duration)

type Retryable func(ctx context.Context) (interface{}, error)

type SDOption struct {
	// Selector Used to filter targets during service discovery.
	// Default: discovery.InstanceIsHealthy()
	Selector discovery.InstanceMatcher
	// InvalidateOnError Whether to return previously known targets in case service discovery is temporarily unavailable
	// Default: true
	InvalidateOnError bool
	// InvalidateTimeout How long to keep previously known targets in case service discovery is temporarily unavailable.
	// < 0:  Always use previously known targets, equivalent to InvalidateOnError = false
	// == 0: Never use previously known targets.
	// > 0:  Use previously known targets for the specified duration since the first error received from SD client
	// Default: -1 if InvalidateOnError = false, 0 if InvalidateOnError = true
	InvalidateTimeout time.Duration
	// Scheme HTTP scheme to use.
	// If not set, the actual scheme is resolved from target instance's Meta/Tags.
	// Possible values: "http", "https", "" (empty string).
	// Default: ""
	Scheme string
	// ContextPath Path prefix for any given Request.
	// If not set, the context path is resolved from target instance's Meta/Tags.
	// e.g. "/auth/api"
	// Default: ""
	ContextPath string
}

type SDOptions func(opt *SDOption)

type SDTargetResolver struct {
	SDOption
	// contains filtered or unexported fields
}

type TargetResolver interface {
	Resolve(ctx context.Context, req *Request) (*url.URL, error)
}

type TargetResolverFunc func(ctx context.Context, req *Request) (*url.URL, error)