expr

type AliasField interface {
	attrs.Field
	Alias() string
}

type BaseLookup struct {
	AllowedDrivers []driver.Driver
	Identifier     LookupFilter
	ArgMin         int
	ArgMax         int
	Normalize      func(any) any
	ResolveFunc    func(inf *ExpressionInfo, lhsResolved ResolvedExpression, values []any) LookupExpression
}

type BaseTransform struct {
	AllowedDrivers []driver.Driver
	//	Transforms     []string
	//	Lookups        []string
	Identifier string
	Transform  func(inf *ExpressionInfo, lhsResolved ResolvedExpression) (ResolvedExpression, error)
}

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

type CastFuncEntry struct {
	Arity int
	SQL   string
}

type CastType uint

type ClauseExpression interface {
	Expression
	IsNot() bool
	Not(b bool) ClauseExpression
	And(...Expression) ClauseExpression
	Or(...Expression) ClauseExpression
}

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

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

type ExprOp string

type Expression interface {
	ResolvedExpression
	Clone() Expression
	Resolve(inf *ExpressionInfo) Expression
}

type ExpressionBuilder interface {
	BuildExpression() Expression
}

type ExpressionInfo struct {
	// Driver is the driver used to execute the query.
	Driver driver.Driver

	// Model is the base model of the queryset.
	Model attrs.Definer

	// Resolver is the field resolver used to resolve fields in the queryset.
	Resolver FieldResolver

	// Placeholder is the placeholder to use in the query.
	//
	// It is used to format the placeholders in the query.
	Placeholder string

	// FormatField is a function that formats the field for the SQL query.
	//
	// It takes a TableColumn and returns the formatted field as a string
	// and a slice of possible args that can be used in the query.
	FormatField func(*alias.Generator, *TableColumn) (string, []any)

	// Quote is a function that quotes the given string for use in a SQL query.
	Quote func(string) string

	// QuoteIdentifier is a function that quotes the given identifier for use in a SQL query.
	//
	// It should be used to quote table names, column names, and other identifiers such as aliases.
	//
	// It should only be used for advanced use cases, such as when creating custom expressions
	// or when there is no other way to format an identifier (see [ExpressionStatement.Resolve] for example).
	QuoteIdentifier func(string) string

	// Lookups provides information about how to format the lookups
	// used in the query.
	Lookups ExpressionLookupInfo

	// ForUpdate specifies if the expression is used in an UPDATE statement
	// or UPDATE- like statement.
	//
	// This will automatically append "= ?" to the SQL TableColumn statement
	ForUpdate bool

	// SupportsWhereExpressionAlias indicates if the database supports WHERE expressions with aliases.
	SupportsWhereAlias bool

	// SupportsAsExpr indicates if the current method of building expressions support aliasing the expression.
	SupportsAsExpr bool

	// Annotations is a map of queryset annotations (fields).
	Annotations *orderedmap.OrderedMap[string, attrs.Field]
}

type ExpressionLookupInfo struct {
	// PrepForLikeQuery is a function that prepares the value for a LIKE query.
	//
	// It takes any value and returns a string that is properly formatted and
	// escaped for use in a LIKE query.
	PrepForLikeQuery func(any) string

	// FormatLookupCol is a function that formats the left-hand side and right-hand side of
	// a lookup operation in the query.
	//
	// It takes the operator and the left-hand side value and returns a formatted string.
	// This is used to format the left-hand side of an operator in the query for iexact, icontains, etc.
	//
	// The default compiler has a format function for the following operators:
	//
	// - iexact
	// - icontains
	// - istartswith
	// - iendswith
	FormatLookupCol func(string, string) string

	// LogicalOpRHS is a map of logical operators to functions that format the right-hand side of the operator.
	//
	// It takes the logical operator and the right-hand side value and returns a formatted string.
	//
	// The defualt compiler has logical operators for:
	//
	// - EQ
	// - NE
	// - GT
	// - LT
	// - GTE
	// - LTE
	// - ADD
	// - SUB
	// - MUL
	// - DIV
	// - MOD
	// - BITAND
	// - BITOR
	// - BITXOR
	// - BITLSH
	// - BITRSH
	// - BITNOT
	LogicalOpRHS map[LogicalOp]func(rhs string, value []any) (string, []any)

	// Operators is a map of lookup operations to format strings.
	//
	// It is used to format the operators in the query.
	//
	// Use ExpressionInfo.FormatOp(...) to format the operator.
	//
	// The default compiler has operators for:
	//
	// - iexact
	// - contains
	// - icontains
	// - regex
	// - iregex
	// - startswith
	// - endswith
	// - istartswith
	// - iendswith
	OperatorsRHS map[string]string

	// PatternOps is a map of pattern operators to format strings.
	//
	// It is used to format operators when the operator is used as
	// an expression in a pattern match, such as 'contains' or 'icontains'.
	//
	// Use ExpressionInfo.PatternOp(...) to format the pattern operator.
	//
	// The default compiler supports pattern operators for:
	//
	// - contains
	// - icontains
	// - startswith
	// - endswith
	// - istartswith
	// - iendswith
	PatternOpsRHS map[string]string
}

type ExpressionStatement struct {
	Statement string
	Values    []any
	// contains filtered or unexported fields
}

type FieldResolver interface {
	Alias() *alias.Generator
	Peek() QueryInformation
	Context() context.Context
	Resolve(fieldName string, inf *ExpressionInfo) (model attrs.Definer, field attrs.FieldDefinition, col *TableColumn, err error)
}

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

type InLookup struct {
	BaseLookup
}

type IsNullLookup struct {
	BaseLookup
}

type Join interface {
	TableName() string
	TableAlias() string
	Type() JoinType
	Condition() JoinCondition
}

type JoinCondition interface {
	// LHS returns the left-hand side of the join condition.
	LHS() TableColumn

	// RHS returns the right-hand side of the join condition.
	RHS() TableColumn

	// Op returns the operator used in the join condition.
	Op() LogicalOp

	// NextCondition returns the next join condition, if any.
	NextCondition() JoinCondition
}

type JoinType string

type LogicalExpression interface {
	Expression
	Scope(LogicalOp, Expression) LogicalExpression
	EQ(key interface{}, vals ...interface{}) LogicalExpression
	NE(key interface{}, vals ...interface{}) LogicalExpression
	GT(key interface{}, vals ...interface{}) LogicalExpression
	LT(key interface{}, vals ...interface{}) LogicalExpression
	GTE(key interface{}, vals ...interface{}) LogicalExpression
	LTE(key interface{}, vals ...interface{}) LogicalExpression
	ADD(key interface{}, vals ...interface{}) LogicalExpression
	SUB(key interface{}, vals ...interface{}) LogicalExpression
	MUL(key interface{}, vals ...interface{}) LogicalExpression
	DIV(key interface{}, vals ...interface{}) LogicalExpression
	MOD(key interface{}, vals ...interface{}) LogicalExpression
	BITAND(key interface{}, vals ...interface{}) LogicalExpression
	BITOR(key interface{}, vals ...interface{}) LogicalExpression
	BITXOR(key interface{}, vals ...interface{}) LogicalExpression
	BITLSH(key interface{}, vals ...interface{}) LogicalExpression
	BITRSH(key interface{}, vals ...interface{}) LogicalExpression
	BITNOT(key interface{}, vals ...interface{}) LogicalExpression
}

type LogicalLookup struct {
	BaseLookup
	Operator LogicalOp
}

type LogicalNamedExpressionFunc interface {
	NamedExpression
	LogicalExpression
}

type LogicalOp string

type Lookup interface {
	// returns the drivers that support this lookup
	// if empty, the lookup is supported by all drivers
	Drivers() []driver.Driver

	// name of the lookup
	Name() string

	// number of arguments the lookup expects, or -1 for variable arguments
	Arity() (min, max int)

	// normalize the arguments for the lookup
	NormalizeArgs(inf *ExpressionInfo, value []any) ([]any, error)

	// Resolve resolves the lookup for the given field and value
	// and generates an expression for the lookup.
	Resolve(inf *ExpressionInfo, lhsResolved ResolvedExpression, args []any) LookupExpression
}

type LookupExpression = func(sb *strings.Builder) []any

type LookupField interface {
	attrs.FieldDefinition
	AllowedTransforms() []string
	AllowedLookups() []string
}

type LookupFilter = string

type LookupTransform interface {
	// returns the drivers that support this transform
	// if empty, the transform is supported by all drivers
	Drivers() []driver.Driver

	// name of the transform
	Name() string

	// Resolves the expression and generates a new expressionq
	Resolve(inf *ExpressionInfo, lhsResolved ResolvedExpression) (ResolvedExpression, error)
}

type ModelMeta interface {
	Model() attrs.Definer
	TableName() string
	PrimaryKey() attrs.FieldDefinition
	OrderBy() []string
}

type NamedExpression interface {
	Expression
	FieldName() string
}

type OrderBy struct {
	Column TableColumn // The field to order by
	Desc   bool
}

type PatternLookup struct {
	BaseLookup
	Pattern string
}

type QueryInformation struct {
	Meta      ModelMeta
	Select    []attrs.FieldDefinition
	GroupBy   []attrs.FieldDefinition
	Joins     []Join
	Where     []ClauseExpression
	Having    []ClauseExpression
	Unions    []FieldResolver
	OrderBy   []OrderBy
	Limit     int
	Offset    int
	ForUpdate bool
	Distinct  bool
}

type RangeLookup struct {
	BaseLookup
}

type RawExpr = RawNamedExpression

type RawNamedExpression struct {
	Statement *ExpressionStatement // The statement to be executed, containing placeholders for fields and values.
	Field     string
	// contains filtered or unexported fields
}

type ResolvedExpression interface {
	SQL(sb *strings.Builder) []any
}

type ResolvedField struct {
	FieldPath         string
	Field             string
	SQLText           string
	SQLArgs           []any
	AllowedTransforms []string
	AllowedLookups    []string
}

type StatementParser interface {
	// return the type / identifier of the statement parser, e.g. "field", "table", "value", "expr"
	Type() string

	// should return a value created by StatementParserArg of type parserArg
	Data(v any) any

	// Compiled returns the compiled regex for the statement parser
	Compiled() *regexp.Regexp

	// CompiledAbs returns the compiled regex for the statement parser with anchors
	CompiledAbs() *regexp.Regexp

	// RawText returns the raw text of the statement parser, given the matched input, I.E. ![FieldName] -> FieldName
	RawText(in []string) string

	// Resolve resolves the statement parser, given the matched input, the expression info, the arguments and any additional data
	Resolve(nodesIndex int, typIndex int, in []string, info *ExpressionInfo, args []any, data any) (string, []any, error)
}

type String string

type TableColumn struct {
	// The table or alias to use in the join condition
	// If this is set, the FieldColumn must be specified
	TableOrAlias string

	// The alias for the field in the join condition.
	FieldAlias string

	// RawSQL is the raw SQL to use in the join condition
	RawSQL string

	// The field or column to use in the join condition
	FieldColumn attrs.FieldDefinition

	// ForUpdate specifies if the field should be used in an UPDATE statement
	// This will automatically append "= ?" to the SQL statement
	ForUpdate bool

	// The value to use for the placeholder if the field column is not specified
	Values []any
}

type VirtualField interface {
	attrs.FieldDefinition
	SQL(inf *ExpressionInfo) (string, []any)
}

type WhenExpression = *when