const (
	// DefaultCacheName is the default name used for the default cache.
	DefaultCacheName string = "httpx"

	// DefaultCapacity is the default capacity of the memory cache when not
	// specified.
	DefaultCapacity uint64 = 128
)

const (
	// DefaultTTL is the default time-to-live for cached responses.
	DefaultTTL time.Duration = 60 * time.Minute

	// DefaultMaxBodySize is the default maximum size of a response body.
	DefaultMaxBodySize int64 = 5 * 1024 * 1024
)

const ErrInvalidResponse xerrors.Error = "invalid response"

var (
	// ErrCacheMiss is returned when a cache entry is not found for the given key.
	ErrCacheMiss = NewCacheError(ErrNotFound, xerrors.Error("cache miss"))

	// ErrCacheExpired is returned when a cache entry is found but has expired.
	ErrCacheExpired = NewCacheError(ErrNotFound, xerrors.Error("cache entry expired"))

	// ErrKeyNotFound is returned when a cache entry is not found for the given key.
	ErrKeyNotFound = NewCacheError(ErrNotFound, xerrors.Error("key not found"))

	// ErrCacheStoreFailed is returned when storing an item in the cache fails.
	ErrCacheStoreFailed = NewCacheError(ErrOperationFailed, xerrors.Error("failed to set cache entry"))

	// ErrCacheDeleteFailed is returned when deleting an item from the cache fails.
	ErrCacheDeleteFailed = NewCacheError(ErrOperationFailed, xerrors.Error("failed to delete cache entry"))

	// ErrCachePurgeFailed is returned when purging the entire cache fails.
	ErrCachePurgeFailed = NewCacheError(ErrOperationFailed, xerrors.Error("failed to purge cache"))
)

type Behavior int

const (
	// BehaviorInclude means to include the URL in caching, even if it would be
	// excluded by default.
	BehaviorInclude Behavior = iota

	// BehaviorExclude means to exclude the URL from caching.
	BehaviorExclude
)

type Cache interface {
	// Get retrieves an *http.Response from the cache associated with the given
	// key.
	Get(ctx context.Context, key string) (*http.Response, error)

	// Set stores an *http.Response in the cache, associated with the given
	// key, and sets the expiration duration.
	Set(ctx context.Context, key string, resp *http.Response, duration time.Duration) error

	// Delete removes the cache entry associated with the given key.
	Delete(ctx context.Context, key string) error

	// Policy returns the cache policy.
	Policy() *Policy

	// Purge clears the entire cache.
	Purge(ctx context.Context) error
}

type Entry interface {
	// Load loads the HTTP response from the cache entry.
	Load(key string) (*http.Response, error)

	// Access updates the last access time of the entry.
	Access()

	// SetTTL sets the time-to-live of the entry.
	SetTTL(ttl time.Duration)

	// SetSize sets the size of the entry.
	SetSize(size uint64)

	// IsExpired checks if the entry is expired.
	IsExpired() bool
}

type Error struct {
	// contains filtered or unexported fields
}

type ErrorType int

const (
	// ErrNotFound indicates that the requested key was not found in the cache.
	ErrNotFound ErrorType = iota

	// ErrOperationFailed indicates that a cache operation, such as set or delete, has failed.
	ErrOperationFailed
)

type Policy struct {
	// AllowedStatusCodes is a list of HTTP status codes that should be cached.
	AllowedStatusCodes map[int]struct{} //nolint:revive // using int as key for performance

	// AllowedMethods is a list of HTTP methods that should be cached.
	AllowedMethods map[string]struct{} //nolint:revive // using string as key for performance

	// ExcludedHeaders is a list of HTTP headers to exclude from caching.
	ExcludedHeaders map[string]struct{} //nolint:revive // see above

	// ExcludedCookies is a list of HTTP cookies to exclude from caching.
	ExcludedCookies map[string]struct{} //nolint:revive // see above

	// Rules is a list of rules to apply to a request in order to determine if it should be cached.
	Rules []*Rule

	// MaxBodySize is the maximum size of the response body allowed to be
	// cached, in bytes. Zero or a negative value indicates no limit.
	MaxBodySize int64

	// UseCacheControl controls whether the cache takes the Cache-Control header
	// into account when deciding whether to cache a response.
	UseCacheControl bool

	// DefaultTTL is the default time-to-live of a cached response. Zero or a
	// negative value is interpreted as no expiration.
	//
	// If UseCacheControl is true, the cache will use the header's value to
	// determine the TTL instead.
	DefaultTTL time.Duration
}

type Rule struct {
	// URL is a URL to match against URLs.
	URL string

	// Pattern is a regular expression pattern to match against URLs.
	//
	// This field is ignored if URL is set.
	Pattern string

	// PatternFlag is a control flag for the regular expression pattern.
	//
	// URL is a slice of URLs to match against URLs.
	PatternFlag recache.Flag

	// Behavior is the caching behavior to apply for the matched URLs.
	Behavior Behavior
}