common

type APIError struct {
	Code    string      `json:"code"`
	Message string      `json:"message"`
	Details interface{} `json:"details,omitempty"`
	Detail  string      `json:"detail,omitempty"`
}

type CRUDRequestProvider interface {
	GetRequest() string
}

type Column struct {
	Name       string `json:"name"`
	Type       string `json:"type"`
	IsNullable bool   `json:"is_nullable"`
	IsPrimary  bool   `json:"is_primary"`
	IsUnique   bool   `json:"is_unique"`
	HasIndex   bool   `json:"has_index"`
}

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

type ComputedColumn struct {
	Name       string `json:"name"`
	Expression string `json:"expression"`
}

type CustomOperator struct {
	Name string `json:"name"`
	SQL  string `json:"sql"`
}

type Database interface {
	// Core query operations
	NewSelect() SelectQuery
	NewInsert() InsertQuery
	NewUpdate() UpdateQuery
	NewDelete() DeleteQuery

	// Raw SQL execution
	Exec(ctx context.Context, query string, args ...interface{}) (Result, error)
	Query(ctx context.Context, dest interface{}, query string, args ...interface{}) error

	// Transaction support
	BeginTx(ctx context.Context) (Database, error)
	CommitTx(ctx context.Context) error
	RollbackTx(ctx context.Context) error
	RunInTransaction(ctx context.Context, fn func(Database) error) error
}

type DeleteQuery interface {
	Model(model interface{}) DeleteQuery
	Table(table string) DeleteQuery
	Where(query string, args ...interface{}) DeleteQuery

	// Execution
	Exec(ctx context.Context) (Result, error)
}

type FilterOption struct {
	Column        string      `json:"column"`
	Operator      string      `json:"operator"`
	Value         interface{} `json:"value"`
	LogicOperator string      `json:"logic_operator"` // "AND" or "OR" - how this filter combines with previous filters
}

type HTTPHandlerFunc func(ResponseWriter, Request)

type InsertQuery interface {
	Model(model interface{}) InsertQuery
	Table(table string) InsertQuery
	Value(column string, value interface{}) InsertQuery
	OnConflict(action string) InsertQuery
	Returning(columns ...string) InsertQuery

	// Execution
	Exec(ctx context.Context) (Result, error)
}

type Metadata struct {
	Total     int64  `json:"total"`
	Count     int64  `json:"count"`
	Filtered  int64  `json:"filtered"`
	Limit     int    `json:"limit"`
	Offset    int    `json:"offset"`
	RowNumber *int64 `json:"row_number,omitempty"`
}

type ModelRegistry interface {
	RegisterModel(name string, model interface{}) error
	GetModel(name string) (interface{}, error)
	GetAllModels() map[string]interface{}
	GetModelByEntity(schema, entity string) (interface{}, error)
}

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

type Parameter struct {
	Name     string `json:"name"`
	Value    string `json:"value"`
	Sequence *int   `json:"sequence"`
}

type PreloadOption struct {
	Relation    string         `json:"relation"`
	Columns     []string       `json:"columns"`
	OmitColumns []string       `json:"omit_columns"`
	Sort        []SortOption   `json:"sort"`
	Filters     []FilterOption `json:"filters"`
	Where       string         `json:"where"`
	Limit       *int           `json:"limit"`
	Offset      *int           `json:"offset"`
	Updatable   *bool          `json:"updateable"` // if true, the relation can be updated
}

type PrimaryKeyNameProvider interface {
	GetIDName() string
}

type ProcessResult struct {
	ID           interface{}            // The ID of the processed record
	AffectedRows int64                  // Number of rows affected
	Data         map[string]interface{} // The processed data
	RelationData map[string]interface{} // Data from processed relations
}

type RelationshipInfo struct {
	FieldName    string
	JSONName     string
	RelationType string // "belongsTo", "hasMany", "hasOne", "many2many"
	ForeignKey   string
	References   string
	JoinTable    string
	RelatedModel interface{}
}

type RelationshipInfoProvider interface {
	GetRelationshipInfo(modelType reflect.Type, relationName string) *RelationshipInfo
}

type Request interface {
	Method() string
	URL() string
	Header(key string) string
	AllHeaders() map[string]string // Get all headers as a map
	Body() ([]byte, error)
	PathParam(key string) string
	QueryParam(key string) string
}

type RequestBody struct {
	Operation string         `json:"operation"`
	Data      interface{}    `json:"data"`
	ID        *int64         `json:"id"`
	Options   RequestOptions `json:"options"`
}

type RequestOptions struct {
	Preload         []PreloadOption  `json:"preload"`
	Columns         []string         `json:"columns"`
	OmitColumns     []string         `json:"omit_columns"`
	Filters         []FilterOption   `json:"filters"`
	Sort            []SortOption     `json:"sort"`
	Limit           *int             `json:"limit"`
	Offset          *int             `json:"offset"`
	CustomOperators []CustomOperator `json:"customOperators"`
	ComputedColumns []ComputedColumn `json:"computedColumns"`
	Parameters      []Parameter      `json:"parameters"`

	// Cursor pagination
	CursorForward  string  `json:"cursor_forward"`
	CursorBackward string  `json:"cursor_backward"`
	FetchRowNumber *string `json:"fetch_row_number"`
}

type Response struct {
	Success  bool        `json:"success"`
	Data     interface{} `json:"data"`
	Metadata *Metadata   `json:"metadata,omitempty"`
	Error    *APIError   `json:"error,omitempty"`
}

type ResponseWriter interface {
	SetHeader(key, value string)
	WriteHeader(statusCode int)
	Write(data []byte) (int, error)
	WriteJSON(data interface{}) error
}

type Result interface {
	RowsAffected() int64
	LastInsertId() (int64, error)
}

type RouteRegistration interface {
	Methods(methods ...string) RouteRegistration
	PathPrefix(prefix string) RouteRegistration
}

type Router interface {
	HandleFunc(pattern string, handler HTTPHandlerFunc) RouteRegistration
	ServeHTTP(w ResponseWriter, r Request)
}

type SchemaProvider interface {
	SchemaName() string
}

type SelectQuery interface {
	Model(model interface{}) SelectQuery
	Table(table string) SelectQuery
	Column(columns ...string) SelectQuery
	ColumnExpr(query string, args ...interface{}) SelectQuery
	Where(query string, args ...interface{}) SelectQuery
	WhereOr(query string, args ...interface{}) SelectQuery
	Join(query string, args ...interface{}) SelectQuery
	LeftJoin(query string, args ...interface{}) SelectQuery
	Preload(relation string, conditions ...interface{}) SelectQuery
	PreloadRelation(relation string, apply ...func(SelectQuery) SelectQuery) SelectQuery
	Order(order string) SelectQuery
	Limit(n int) SelectQuery
	Offset(n int) SelectQuery
	Group(group string) SelectQuery
	Having(having string, args ...interface{}) SelectQuery

	// Execution methods
	Scan(ctx context.Context, dest interface{}) error
	ScanModel(ctx context.Context) error
	Count(ctx context.Context) (int, error)
	Exists(ctx context.Context) (bool, error)
}

type SortOption struct {
	Column    string `json:"column"`
	Direction string `json:"direction"`
}

type TableAliasProvider interface {
	TableAlias() string
}

type TableMetadata struct {
	Schema    string   `json:"schema"`
	Table     string   `json:"table"`
	Columns   []Column `json:"columns"`
	Relations []string `json:"relations"`
}

type TableNameProvider interface {
	TableName() string
}

type UpdateQuery interface {
	Model(model interface{}) UpdateQuery
	Table(table string) UpdateQuery
	Set(column string, value interface{}) UpdateQuery
	SetMap(values map[string]interface{}) UpdateQuery
	Where(query string, args ...interface{}) UpdateQuery
	Returning(columns ...string) UpdateQuery

	// Execution
	Exec(ctx context.Context) (Result, error)
}