ffapi

type APIRequest struct {
	Req             *http.Request
	QP              map[string]string
	QAP             map[string][]string
	PP              map[string]string
	FP              map[string]string
	Filter          AndFilter
	Input           interface{}
	Part            *Multipart
	SuccessStatus   int
	ResponseHeaders http.Header
	AlwaysPaginate  bool
}

type APIServer interface {
	Serve(ctx context.Context) error
	Started() <-chan struct{}
	MuxRouter(ctx context.Context) (*mux.Router, error)
	APIPublicURL() string // valid to call after server is successfully started
}

type APIServerOptions[T any] struct {
	MetricsRegistry           metric.MetricsRegistry
	MetricsSubsystemName      string
	Routes                    []*Route // move to use VersionedAPIs for support of Tags and ExternalDocs
	VersionedAPIs             *VersionedAPIs
	MonitoringRoutes          []*Route
	EnrichRequest             func(r *APIRequest) (T, error)
	Description               string
	APIConfig                 config.Section
	MonitoringConfig          config.Section
	CORSConfig                config.Section
	FavIcon16                 []byte
	FavIcon32                 []byte
	PanicOnMissingDescription bool
	SupportFieldRedaction     bool
	HandleYAML                bool
}

type APIServerRouteExt[T any] struct {
	JSONHandler   func(*APIRequest, T) (output interface{}, err error)
	UploadHandler func(*APIRequest, T) (output interface{}, err error)
	StreamHandler func(*APIRequest, T) (output io.ReadCloser, err error)
}

type APIVersion struct {
	Routes       []*Route               // the routes
	Tags         openapi3.Tags          // (OPTIONAL) description and external documentation of tags used in the routes, all tags in this array will need to be used by at least one of routes
	ExternalDocs *openapi3.ExternalDocs // (OPTIONAL) external documentation of this API version
}

type AndFilter interface{ MultiConditionFilter }

type BaseURLVariable struct {
	Default     string
	Description string
}

type BigIntField struct{}

type BoolField struct{}

type Bytes32Field struct{}

type CtxFFRequestIDKey struct{}

type CtxHeadersKey struct{}

type FFStringArrayField struct{}

type Field interface {
	GetSerialization() FieldSerialization
	Description() string
	FilterAsString() bool
}

type FieldMod int

type FieldResolverFn func(ctx context.Context, fieldName string) (resolvedFieldName string, err error)

type FieldSerialization interface {
	driver.Valuer
	sql.Scanner // Implementations can assume the value is ALWAYS a string
}

type Filter interface {
	FilterModifiers[Filter]

	// Finalize completes the filter, and for the plugin to validated output structure to convert
	Finalize() (*FilterInfo, error)

	// Builder returns the builder that made it
	Builder() FilterBuilder

	// Assert that this is a value filter, not an and/or
	ValueFilter() ValueFilter
}

type FilterBuilder interface {
	FilterModifiers[FilterBuilder]

	// Fields is the list of available fields
	Fields() []string
	// And requires all sub-filters to match
	And(and ...Filter) AndFilter
	// Or requires any of the sub-filters to match
	Or(and ...Filter) OrFilter
	// Eq equal - case sensitive
	Eq(name string, value driver.Value) Filter
	// Neq not equal - case sensitive
	Neq(name string, value driver.Value) Filter
	// IEq equal - case insensitive
	IEq(name string, value driver.Value) Filter
	// INeq not equal - case insensitive
	NIeq(name string, value driver.Value) Filter
	// In one of an array of values
	In(name string, value []driver.Value) Filter
	// NotIn not one of an array of values
	NotIn(name string, value []driver.Value) Filter
	// Lt less than
	Lt(name string, value driver.Value) Filter
	// Gt greater than
	Gt(name string, value driver.Value) Filter
	// Gte greater than or equal
	Gte(name string, value driver.Value) Filter
	// Lte less than or equal
	Lte(name string, value driver.Value) Filter
	// Contains allows the string anywhere - case sensitive
	Contains(name string, value driver.Value) Filter
	// NotContains disallows the string anywhere - case sensitive
	NotContains(name string, value driver.Value) Filter
	// IContains allows the string anywhere - case insensitive
	IContains(name string, value driver.Value) Filter
	// INotContains disallows the string anywhere - case insensitive
	NotIContains(name string, value driver.Value) Filter
	// StartsWith allows the string at the start - case sensitive
	StartsWith(name string, value driver.Value) Filter
	// NotStartsWith disallows the string at the start - case sensitive
	NotStartsWith(name string, value driver.Value) Filter
	// IStartsWith allows the string at the start - case insensitive
	IStartsWith(name string, value driver.Value) Filter
	// NotIStartsWith disallows the string att the start - case insensitive
	NotIStartsWith(name string, value driver.Value) Filter
	// EndsWith allows the string at the end - case sensitive
	EndsWith(name string, value driver.Value) Filter
	// NotEndsWith disallows the string at the end - case sensitive
	NotEndsWith(name string, value driver.Value) Filter
	// IEndsWith allows the string at the end - case insensitive
	IEndsWith(name string, value driver.Value) Filter
	// NotIEndsWith disallows the string att the end - case insensitive
	NotIEndsWith(name string, value driver.Value) Filter
}

type FilterInfo struct {
	GroupBy        []string
	RequiredFields []string
	Sort           []*SortField
	Skip           uint64
	Limit          uint64
	Count          bool
	CountExpr      string
	Field          string
	FieldMods      []FieldMod
	Op             FilterOp
	Values         []FieldSerialization
	Value          FieldSerialization
	Children       []*FilterInfo
}

type FilterJSON struct {
	Or []*FilterJSON `ffstruct:"FilterJSON" json:"or,omitempty"`
	FilterJSONOps
}

type FilterJSONBase struct {
	Not             bool   `ffstruct:"FilterJSON" json:"not,omitempty"`
	CaseInsensitive bool   `ffstruct:"FilterJSON" json:"caseInsensitive,omitempty"`
	Field           string `ffstruct:"FilterJSON" json:"field,omitempty"`
}

type FilterJSONKeyValue struct {
	FilterJSONBase
	Value SimpleFilterValue `ffstruct:"FilterJSON" json:"value,omitempty"`
}

type FilterJSONKeyValues struct {
	FilterJSONBase
	Values []SimpleFilterValue `ffstruct:"FilterJSON" json:"values,omitempty"`
}

type FilterJSONOps struct {
	Equal              []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"equal,omitempty"`
	Eq                 []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"eq,omitempty"`  // short name
	NEq                []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"neq,omitempty"` // negated short name
	Contains           []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"contains,omitempty"`
	StartsWith         []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"startsWith,omitempty"`
	EndsWith           []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"endsWith,omitempty"`
	LessThan           []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"lessThan,omitempty"`
	LT                 []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"lt,omitempty"` // short name
	LessThanOrEqual    []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"lessThanOrEqual,omitempty"`
	LTE                []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"lte,omitempty"` // short name
	GreaterThan        []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"greaterThan,omitempty"`
	GT                 []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"gt,omitempty"` // short name
	GreaterThanOrEqual []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"greaterThanOrEqual,omitempty"`
	GTE                []*FilterJSONKeyValue  `ffstruct:"FilterJSON" json:"gte,omitempty"` // short name
	In                 []*FilterJSONKeyValues `ffstruct:"FilterJSON" json:"in,omitempty"`
	NIn                []*FilterJSONKeyValues `ffstruct:"FilterJSON" json:"nin,omitempty"` // negated short name
	Null               []*FilterJSONBase      `ffstruct:"FilterJSON" json:"null,omitempty"`
}

type FilterModifiers[T any] interface {
	// Sort adds a set of sort conditions (all in a single sort order)
	Sort(...string) T

	// GroupBy adds a set of fields to group rows that have the same values into summary rows. Not assured every persistence implementation will support this (doc DBs cannot)
	GroupBy(...string) T

	// Ascending sort order
	Ascending() T

	// Descending sort order
	Descending() T

	// Skip for pagination
	Skip(uint64) T

	// Limit for pagination
	Limit(uint64) T

	// Request a count to be returned on the total number that match the query
	Count(c bool) T

	// Which fields we require to be returned. Only supported when using CRUD layer on top of underlying DB.
	// Might allow optimization of the query (in the case of SQL DBs, where it can be combined with GroupBy), or request post-query redaction (in the case of document DBs).
	RequiredFields(...string) T
}

type FilterOp string

type FilterResult struct {
	TotalCount *int64
}

type FilterResultsWithCount struct {
	Count int64       `json:"count"`
	Total *int64      `json:"total,omitempty"` // omitted if a count was not calculated (AlwaysPaginate enabled, and count not specified)
	Items interface{} `json:"items"`
}

type FormParam struct {
	// Name is the name of the parameter, from the Gorilla path mux
	Name string
	// Description is a message key to a translatable description of the parameter
	Description i18n.MessageKey
}

type HandlerFactory struct {
	DefaultRequestTimeout time.Duration
	MaxTimeout            time.Duration
	DefaultFilterLimit    uint64
	MaxFilterSkip         uint64
	MaxFilterLimit        uint64
	HandleYAML            bool
	PassthroughHeaders    []string
	AlwaysPaginate        bool
	SupportFieldRedaction bool
	BasePath              string
	BasePathParams        []*PathParam
}

type HandlerFunction func(res http.ResponseWriter, req *http.Request) (status int, err error)

type HasFieldMods interface {
	FieldMods() []FieldMod
}

type Int64Field struct{}

type ItemsResultTyped[T any] struct {
	Count int    `ffstruct:"CollectionResults" json:"count"`
	Total *int64 `ffstruct:"CollectionResults" json:"total,omitempty"` // omitted if a count was not calculated (AlwaysPaginate enabled, and count not specified)
	Items []T    `ffstruct:"CollectionResults" json:"items"`
}

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

type JSONField struct{}

type MultiConditionFilter interface {
	Filter
	// Add adds filters to the condition
	Condition(...Filter) MultiConditionFilter
	GetConditions() []Filter
}

type Multipart struct {
	Filename string
	Mimetype string
	Data     io.Reader
}

type NullBehavior int

type OpenAPIFormat int

type OpenAPIHandlerFactory struct {
	BaseSwaggerGenOptions   SwaggerGenOptions
	StaticPublicURL         string
	DynamicPublicURLHeader  string
	DynamicPublicURLBuilder func(req *http.Request) string
}

type OrFilter interface{ MultiConditionFilter }

type PathParam struct {
	// Name is the name of the parameter, from the Gorilla path mux
	Name string
	// Default is the value that will be used in the case no value is supplied
	Default string
	// Example is a field to fill in, in the helper UI
	Example string
	// ExampleFromConf is a field to fill in, in the helper UI, from the runtime configuration
	ExampleFromConf config.RootKey
	// Description is a message key to a translatable description of the parameter
	Description i18n.MessageKey
}

type QueryBuilder interface {

	// Limit sets the limit of the query
	Limit(limit uint64) QueryBuilder

	// Sort adds a sort filter to the query
	Sort(fields ...string) QueryBuilder

	// Equal adds an equal filter to the query
	Equal(field string, value any, adds ...addOns) QueryBuilder

	// NotEqual adds a not equal filter to the query
	NotEqual(field string, value any, adds ...addOns) QueryBuilder

	// GreaterThan adds a greater than filter to the query
	GreaterThan(field string, value any) QueryBuilder

	// GreaterThanOrEqual adds a greater than or equal filter to the query
	GreaterThanOrEqual(field string, value any) QueryBuilder

	// LessThan adds a less than filter to the query
	LessThan(field string, value any) QueryBuilder

	// LessThanOrEqual adds a less than or equal filter to the query
	LessThanOrEqual(field string, value any) QueryBuilder

	// In adds an in filter to the query
	In(field string, values []any, adds ...addOns) QueryBuilder

	// NotIn adds a not in filter to the query
	NotIn(field string, values []any, adds ...addOns) QueryBuilder

	// Null adds an is null filter to the query
	Null(field string) QueryBuilder

	// NotNull adds an is not null filter to the query
	NotNull(field string) QueryBuilder

	// Or creates an OR condition between multiple queries
	Or(...QueryBuilder) QueryBuilder

	// Query returns the query
	Query() *QueryJSON
}

type QueryFactory interface {
	NewFilter(ctx context.Context) FilterBuilder
	NewFilterLimit(ctx context.Context, defLimit uint64) FilterBuilder
	NewUpdate(ctx context.Context) UpdateBuilder
}

type QueryFields map[string]Field

type QueryJSON struct {
	FilterJSON
	Skip   *uint64  `ffstruct:"FilterJSON" json:"skip,omitempty"`
	Limit  *uint64  `ffstruct:"FilterJSON" json:"limit,omitempty"`
	Sort   []string `ffstruct:"FilterJSON" json:"sort,omitempty"`
	Count  *bool    `ffstruct:"FilterJSON" json:"count,omitempty"`
	Fields []string `ffstruct:"FilterJSON" json:"fields,omitempty"`
}

type QueryParam struct {
	// Name is the name of the parameter, from the Gorilla path mux
	Name string
	// IsBool if this is a boolean query
	IsBool bool
	// IsArray if this is an array parameter (can be specified multiple times)
	IsArray bool
	// Default is the value that will be used in the case no value is supplied
	Default string
	// Example is a field to fill in, in the helper UI
	Example string
	// ExampleFromConf is a field to fill in, in the helper UI, from the runtime configuration
	ExampleFromConf config.RootKey
	// Description is a message key to a translatable description of the parameter
	Description i18n.MessageKey
	// Deprecated whether this param is deprecated
	Deprecated bool
}

type Route struct {
	// Name is the operation name that will go into the Swagger definition, and prefix input/output schema
	Name string
	// Path is a Gorilla mux path spec
	Path string
	// PathParams is a list of documented path parameters
	PathParams []*PathParam
	// QueryParams is a list of documented query parameters
	QueryParams []*QueryParam
	// FormParams is a list of documented multi-part form parameters - combine with FormUploadHandler
	FormParams []*FormParam
	// Method is the HTTP method
	Method string
	// Description is a message key to a translatable description of the operation
	Description i18n.MessageKey
	// PreTranslatedDescription is a string describing the operation - used for programmatically generated routes where a built-in string translation is not available
	PreTranslatedDescription string
	// FilterFactory models the filter fields that can be specified on the API, and will automatically be parsed
	FilterFactory QueryFactory
	// JSONInputDecoder is a function that does the decoding completely - needed (as this was written pre-generics) for handling arrays
	JSONInputDecoder func(req *http.Request, body io.Reader) (interface{}, error)
	// JSONInputValue is a function that returns a pointer to a structure to take JSON input
	JSONInputValue func() interface{}
	// JSONInputMask are fields that aren't available for users to supply on input
	JSONInputMask []string
	// JSONInputSchema is a custom schema definition, for the case where the auto-gen + mask isn't good enough
	JSONInputSchema func(ctx context.Context, schemaGen SchemaGenerator) (*openapi3.SchemaRef, error)
	// JSONOutputSchema is a custom schema definition, for the case where the auto-gen + mask isn't good enough
	JSONOutputSchema func(ctx context.Context, schemaGen SchemaGenerator) (*openapi3.SchemaRef, error)
	// JSONOutputValue is a function that returns a pointer to a structure to take JSON output
	JSONOutputValue func() interface{}
	// JSONOutputCodes is the success response codes that could be returned by the API. Error codes are explicitly not supported by the framework since they could be subject to change by the errors thrown or how errors are handled.
	JSONOutputCodes []int
	// JSONHandler is a function for handling JSON content type input. Input/Output objects are returned by JSONInputValue/JSONOutputValue funcs
	JSONHandler func(r *APIRequest) (output interface{}, err error)
	// FormUploadHandler takes a single file upload, and returns a JSON object
	FormUploadHandler func(r *APIRequest) (output interface{}, err error)
	// StreamHandler allows for custom request handling with explicit stream (io.ReadCloser) responses
	StreamHandler func(r *APIRequest) (output io.ReadCloser, err error)
	// CustomResponseRefs allows for specifying custom responses for a route
	CustomResponseRefs map[string]*openapi3.ResponseRef
	// Deprecated whether this route is deprecated
	Deprecated bool
	// Tag a category identifier for this route in the generated OpenAPI spec
	Tag string
	// Extensions allows extension of the route struct by individual microservices
	Extensions interface{}
}

type SchemaGenerator func(o interface{}) (*openapi3.SchemaRef, error)

type SetOperation struct {
	Field string
	Value FieldSerialization
}

type SimpleFilterValue string

type SortField struct {
	Field      string
	Descending bool
	Nulls      NullBehavior
}

type StringField struct{}

type StringFieldLower struct {
	StringField
}

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

type SwaggerGenOptions struct {

	// attributes of openapi3.Info
	Title       string
	Version     string
	Description string

	// descriptions for the route parameters are parsed from the ffstruct tags
	// when set this flag to true, if a description is not found, the generator will panic
	// this is useful to ensure that all fields are documented
	PanicOnMissingDescription bool

	SupportFieldRedaction bool
	DefaultRequestTimeout time.Duration

	// ----------- API version specific options ------------
	// options to generate the base URL
	BaseURL          string
	BaseURLVariables map[string]BaseURLVariable

	// options of controlling query parameters values
	APIMaxFilterSkip      uint
	APIDefaultFilterLimit string
	APIMaxFilterLimit     uint

	// a custom function to modify the generated OpenAPI spec
	RouteCustomizations func(ctx context.Context, sg *SwaggerGen, route *Route, op *openapi3.Operation)

	// OpenAPI 3.0.x specific options
	Tags         openapi3.Tags
	ExternalDocs *openapi3.ExternalDocs
}

type TimeField struct{}

type UUIDField struct{}

type Update interface {
	UpdateOps

	// IsEmpty
	IsEmpty() bool

	// Finalize completes the update, and for the plugin to validated output structure to convert
	Finalize() (*UpdateInfo, error)
}

type UpdateBuilder interface {
	UpdateOps

	// S starts an update that doesn't have any fields
	S() Update

	// Fields returns the available fields on the update
	Fields() []string
}

type UpdateFactory interface {
	New(ctx context.Context) UpdateBuilder
}

type UpdateInfo struct {
	SetOperations []*SetOperation
}

type UpdateOps interface {
	// Set adds a set condition to the update
	Set(field string, value interface{}) Update

	// Set adds a set condition to the update, to set the value to NULL
	SetNull(field string) Update
}

type ValueFilter interface {
	// The operation for this filter
	Op() FilterOp

	// The field name
	Field() string

	// The value
	Value() interface{}

	// Set the operation for this filter
	SetOp(op FilterOp)

	// Set the field name
	SetField(f string)

	// Set the value
	SetValue(v interface{})
}

type ValueResolverFn func(ctx context.Context, level *FilterJSON, fieldName, suppliedValue string) (driver.Value, error)

type VersionedAPIs struct {
	DefaultVersion string                 // must be set to a version string if there are more than 1 API versions provided
	APIVersions    map[string]*APIVersion // a list of APIVersions, with the key being the version string
}