dnsdb

type Client interface {
	// LookupRRSet performs the rrset lookup query
	LookupRRSet(name string) Query
	// LookupRDataName performs the rdata name lookup query
	LookupRDataName(name string) Query
	// LookupRDataIP performs the rdata ip lookup query with a cidr. Use net.IPNet{IP: ip} for a
	// single IP.
	LookupRDataIP(ip net.IPNet) Query
	// LookupRDataIPRange performs the rdata ip lookup query with an ip range
	LookupRDataIPRange(lower, upper net.IP) Query
	// LookupRDataRaw performs the rdata raw lookup query
	LookupRDataRaw(raw []byte) Query
}

type HttpResultFunc func(ctx context.Context, req *http.Request) Result

type PingClient interface {
	Ping() PingRequest
}

type PingRequest interface {
	Do(context.Context) error
}

type PingResponse struct {
	Ping string `json:"ping"`
}

type Query interface {
	// WithRRType sets the rrtype for the query. The default value is ANY.
	WithRRType(rrtype string) Query

	// WithBailiwick sets the bailiwick for the query. This is only applicable to
	// RRSet-type queries.
	WithBailiwick(bailiwick string) Query

	// WithLimit sets the limit for the number of results returned.
	WithLimit(n int) Query
	// WithAggregation enables or disables grouping of identical rrsets across all time periods
	WithAggregation(aggr bool) Query

	// WithOffset sets how many rows to skip in the results. This is only applicable to Lookup queries
	// and the API server may return an error if it is set for a Summarize query.
	WithOffset(n int) Query

	// WithMaxCount is an option for Summarize query that instructs the api server to stop counting
	// and return an answer immediately once it has reached this value.
	WithMaxCount(n int) Query

	// WithTimeFirstBefore selects records with time_first that is before `when`.
	WithTimeFirstBefore(when time.Time) Query
	// WithTimeFirstAfter selects records with time_first that is after `when`.
	WithTimeFirstAfter(when time.Time) Query
	// WithTimeLastBefore selects records with time_last that is before `when`.
	WithTimeLastBefore(when time.Time) Query
	// WithTimeLastAfter selects records with time_last that is after `when`.
	WithTimeLastAfter(when time.Time) Query

	// WithRelativeTimeFirstBefore selects records with time_first that is before now - `since`. This will panic
	// if passed a negative Duration.
	WithRelativeTimeFirstBefore(since time.Duration) Query
	// WithRelativeTimeFirstAfter selects records with time_first that is after now - `since`. This will panic
	// if passed a negative Duration.
	WithRelativeTimeFirstAfter(since time.Duration) Query
	// WithRelativeTimeLastBefore selects records with time_last that is before now - `since`. This will panic
	// if passed a negative Duration.
	WithRelativeTimeLastBefore(since time.Duration) Query
	// WithRelativeTimeLastAfter selects records with time_last that is after now - `since`. This will panic
	// if passed a negative Duration.
	WithRelativeTimeLastAfter(since time.Duration) Query

	// Do executes the Query and returns a Result. Do is non-blocking. The caller must call `Result.Close()`.
	Do(ctx context.Context) Result
}

type RRSet struct {
	// RRName is the owner name of the RRset in DNS presentation format.
	RRName string
	// RRType is esource record type of the RRset, either using the standard DNS type mnemonic, or an RFC 3597 generic
	// type, i.e. the string TYPE immediately followed by the decimal RRtype number.
	RRType string
	// RData is an array of one or more Rdata values. The Rdata values are converted to the standard presentation
	// format based on the rrtype value. If the encoder lacks a type-specific presentation format for the RRset's
	// rrtype, then the RFC 3597 generic Rdata encoding will be used.
	RData []string
	// RawRData is a byte array returned for rdata rows in flex search.
	RawRData  []byte
	Bailiwick string
	// Count is the number of times the RRset was observed via passive DNS replication.
	Count int
	// NumResults is the number of results (RRsets) that would be returned from a Lookup.
	NumResults int
	// TimeFirst is the first time that the record was observed via passive DNS replication.
	TimeFirst time.Time
	// TimeLast is the last time that the record was observed via passive DNS replication.
	TimeLast time.Time
	// ZoneTimeFirst is the first time that the record was observed via zone file import.
	ZoneTimeFirst time.Time
	// ZoneTimeLast is the last time that the record was observed via zone file import.
	ZoneTimeLast time.Time
}

type Rate struct {
	Reset       *time.Time `json:"reset"`
	Limit       *int       `json:"limit"`
	Remaining   *int       `json:"remaining"`
	Expires     *time.Time `json:"expires"`
	ResultsMax  int        `json:"results_max"`
	OffsetMax   int        `json:"offset_max"`
	BurstSize   int        `json:"burst_size"`
	BurstWindow int        `json:"burst_window"`
}

type RateLimit struct {
	Rate Rate `json:"rate"`
}

type RateLimitClient interface {
	RateLimit() RateLimitQuery
}

type RateLimitQuery interface {
	Do(ctx context.Context) (RateLimit, error)
}

type RateLimitResult interface {
	// Rate is non-blocking and should not be called until Ch() has been closed.
	Rate() *RateLimit
}

type Result interface {
	// Close terminates the query and closes the channel returned by `Ch()`
	Close()
	// Ch returns a channel with the results of the query.
	Ch() <-chan RRSet
	// Err should be called after the channel has been closed to check if any errors have occurred.
	Err() error
}

type SummarizeClient interface {
	// SummarizeRRSet performs the rrset summarize query
	SummarizeRRSet(name string) Query
	// SummarizeRDataName performs the rdata name summarize query
	SummarizeRDataName(name string) Query
	// SummarizeRDataIP performs the rdata ip summarize query with a cidr. Use net.IPNet{IP: ip} for a
	// single IP.
	SummarizeRDataIP(ip net.IPNet) Query
	// SummarizeRDataIPRange performs the rdata ip summarize query with an ip range
	SummarizeRDataIPRange(lower, upper net.IP) Query
	// SummarizeRDataRaw performs the rdata raw summarize query
	SummarizeRDataRaw(raw []byte) Query
}