core

type AcceptedValuesConfig struct {
	Column string
	Values []string
}

type Adapter interface {
	// Connect establishes a connection to the database.
	Connect(ctx context.Context, cfg AdapterConfig) error

	// Close closes the database connection.
	Close() error

	// Exec executes a SQL statement that doesn't return rows.
	Exec(ctx context.Context, sql string) error

	// Query executes a SQL statement that returns rows.
	Query(ctx context.Context, sql string) (*Rows, error)

	// GetTableMetadata retrieves metadata for a table.
	GetTableMetadata(ctx context.Context, table string) (*TableMetadata, error)

	// LoadCSV loads data from a CSV file into a table.
	LoadCSV(ctx context.Context, tableName, filePath string) error

	// DialectConfig returns the static dialect configuration.
	DialectConfig() *DialectConfig
}

type AdapterConfig struct {
	Type     string
	Path     string
	Host     string
	Port     int
	Database string
	Username string
	Password string
	Schema   string
	Options  map[string]string
	Params   map[string]any
}

type BetweenExpr struct {
	Expr Expr
	Not  bool
	Low  Expr
	High Expr
}

type BinaryExpr struct {
	Left  Expr
	Op    token.TokenType
	Right Expr
}

type CTE struct {
	NodeInfo
	Name   string
	Select *SelectStmt
}

type CaseExpr struct {
	Operand Expr // CASE operand WHEN... (optional)
	Whens   []WhenClause
	Else    Expr
}

type CastExpr struct {
	Expr     Expr
	TypeName string
}

type ClauseDef struct {
	Token    token.TokenType
	Handler  any // spi.ClauseHandler - cast at call site
	Slot     ClauseSlot
	Keywords []string
	Inline   bool
}

type ClauseSlot int

type Column struct {
	Name       string
	Type       string
	Nullable   bool
	PrimaryKey bool
	Position   int
}

type ColumnInfo struct {
	Name          string
	Index         int
	TransformType TransformType // "" (direct) or "EXPR"
	Function      string        // "sum", "count", etc.
	Sources       []SourceRef   // where this column comes from
}

type ColumnRef struct {
	Table  string // optional table/alias qualifier
	Column string
}

type Conditional struct {
	Condition string
	Content   string
}

type Dependency struct {
	ModelID  string
	ParentID string
}

type DerivedTable struct {
	NodeInfo
	Select *SelectStmt
	Alias  string
}

type Dialect struct {
	Name        string
	Identifiers IdentifierConfig

	// Database-specific settings
	DefaultSchema string
	Placeholder   PlaceholderStyle

	// Function classifications (normalized names)
	Aggregates     map[string]struct{}
	Generators     map[string]struct{}
	Windows        map[string]struct{}
	TableFunctions map[string]struct{}

	// Documentation for LSP
	Docs map[string]FunctionDoc

	// Keywords and types for autocomplete
	Keywords      map[string]struct{}
	ReservedWords map[string]struct{}
	DataTypes     []string

	// Parsing behavior - handlers stored as 'any'
	ClauseSeq      []token.TokenType
	ClauseDefs     map[token.TokenType]ClauseDef
	Symbols        map[string]token.TokenType
	DynamicKw      map[string]token.TokenType
	Precedences    map[token.TokenType]int
	InfixHandlers  map[token.TokenType]any // spi.InfixHandler
	PrefixHandlers map[token.TokenType]any // spi.PrefixHandler
	JoinTypes      map[token.TokenType]JoinTypeDef
	StarModifiers  map[token.TokenType]any // core.StarModifierHandler
	FromItems      map[token.TokenType]any // spi.FromItemHandler
}

type DialectConfig struct {
	// Name is the dialect identifier (e.g., "duckdb", "postgres")
	Name string

	// Identifiers defines quoting and normalization rules
	Identifiers IdentifierConfig

	// DefaultSchema is the default schema name ("main" for DuckDB, "public" for Postgres)
	DefaultSchema string

	// Placeholder defines how query parameters are formatted
	Placeholder PlaceholderStyle

	// Function classifications (normalized names)
	Aggregates     []string // SUM, COUNT, AVG, etc.
	Generators     []string // NOW, UUID, RANDOM, etc.
	Windows        []string // ROW_NUMBER, LAG, LEAD, etc.
	TableFunctions []string // read_csv, generate_series, etc.

	// Keywords for autocomplete/highlighting
	Keywords  []string
	DataTypes []string

	// Feature Flags - Builder auto-wires based on these
	//
	// Clause extensions
	SupportsQualify    bool // QUALIFY clause for window filtering
	SupportsReturning  bool // RETURNING clause for DML
	SupportsGroupByAll bool // GROUP BY ALL
	SupportsOrderByAll bool // ORDER BY ALL

	// Operator extensions
	SupportsIlike        bool // ILIKE case-insensitive LIKE
	SupportsCastOperator bool // :: cast operator

	// Join extensions
	SupportsSemiAntiJoins bool // SEMI/ANTI join types
}

type Environment struct {
	Name      string
	CommitRef string
	CreatedAt time.Time
	UpdatedAt time.Time
}

type ExcludeModifier struct {
	Columns []string // Column names to exclude
}

type ExistsExpr struct {
	Not    bool
	Select *SelectStmt
}

type Expr interface {
	Node
	// contains filtered or unexported methods
}

type FetchClause struct {
	First    bool // true = FIRST, false = NEXT (semantically identical)
	Count    Expr // Number of rows (nil = 1 row implied)
	Percent  bool // FETCH FIRST n PERCENT ROWS
	WithTies bool // true = WITH TIES, false = ONLY
}

type FrameBound struct {
	Type   FrameBoundType
	Offset Expr // for N PRECEDING/FOLLOWING
}

type FrameBoundType string

type FrameSpec struct {
	Type  FrameType
	Start *FrameBound
	End   *FrameBound
}

type FrameType string

type FromClause struct {
	NodeInfo
	Source TableRef
	Joins  []*Join
}

type FuncCall struct {
	Name     string
	Distinct bool
	Args     []Expr
	Star     bool        // COUNT(*)
	Window   *WindowSpec // OVER clause
	Filter   Expr        // FILTER (WHERE ...) clause
}

type FunctionDoc struct {
	Description string
	Signatures  []string
	ReturnType  string
	Example     string
}

type FunctionLineageType int

type IdentifierConfig struct {
	Quote         string                // Quote character: ", `, [
	QuoteEnd      string                // End quote character (usually same as Quote, ] for [)
	Escape        string                // Escape sequence: "", “, ]]
	Normalization NormalizationStrategy // How to normalize unquoted identifiers
}

type InExpr struct {
	Expr   Expr
	Not    bool
	Values []Expr      // IN (1, 2, 3)
	Query  *SelectStmt // IN (SELECT ...)
}

type IndexExpr struct {
	NodeInfo
	Expr  Expr // The expression being indexed
	Index Expr // Simple index (non-nil if not a slice)
	// For slicing (arr[start:stop])
	IsSlice bool
	Start   Expr // nil means from beginning
	Stop    Expr // nil means to end (named Stop to avoid shadowing End() method)
}

type IsBoolExpr struct {
	Expr  Expr
	Not   bool
	Value bool // true for IS TRUE, false for IS FALSE
}

type IsNullExpr struct {
	Expr Expr
	Not  bool
}

type Join struct {
	NodeInfo
	Type      JoinType
	Natural   bool // NATURAL JOIN modifier
	Right     TableRef
	Condition Expr     // ON clause (mutually exclusive with Using)
	Using     []string // USING (col1, col2) columns
}

type JoinType string

type JoinTypeDef struct {
	Token         token.TokenType // The trigger token for this join type
	Type          string          // JoinType value (e.g., "LEFT", "SEMI")
	OptionalToken token.TokenType // Optional modifier token (OUTER) - 0 means none
	RequiresOn    bool            // true if ON clause is required
	AllowsUsing   bool            // true if USING clause is allowed
}

type LambdaExpr struct {
	NodeInfo
	Params []string // Parameter names
	Body   Expr     // Lambda body expression
}

type LateralTable struct {
	NodeInfo
	Select *SelectStmt
	Alias  string
}

type LikeExpr struct {
	Expr    Expr
	Not     bool
	Pattern Expr
	Op      token.TokenType // token.LIKE or dialect-registered ILIKE
}

type LintConfig struct {
	// Disabled contains rule IDs to disable
	Disabled []string `koanf:"disabled"`

	// Severity maps rule ID to severity override (error, warning, info, hint)
	Severity map[string]string `koanf:"severity"`

	// Rules contains rule-specific options
	Rules map[string]RuleOptions `koanf:"rules"`

	// ProjectHealth holds project-level linting configuration
	ProjectHealth *ProjectHealthConfig `koanf:"project_health"`
}

type ListLiteral struct {
	NodeInfo
	Elements []Expr // Expression elements
}

type Literal struct {
	Type  LiteralType
	Value string
}

type LiteralType int

type MacroExpr struct {
	NodeInfo
	Content string // raw {{ ... }} content including delimiters
}

type MacroFunction struct {
	Namespace string
	Name      string
	Args      []string
	Docstring string
	Line      int
}

type MacroNamespace struct {
	Name      string
	FilePath  string
	Package   string
	UpdatedAt string
}

type MacroTable struct {
	NodeInfo
	Content string // raw {{ ... }} content including delimiters
	Alias   string
}

type Model struct {
	// Path is the model path (e.g., "staging.customers")
	Path string
	// Name is the model name (filename without extension)
	Name string
	// FilePath is the absolute path to the SQL file
	FilePath string
	// Materialized defines how the model is stored: table, view, incremental
	Materialized string
	// UniqueKey for incremental models
	UniqueKey string
	// Owner is the team/person responsible for this model
	Owner string
	// Schema is the database schema for this model
	Schema string
	// Description is a human-readable description of the model
	Description string
	// Tags are metadata labels for filtering/organizing models
	Tags []string
	// Meta contains custom extension fields
	Meta map[string]any
	// Tests contains test configurations
	Tests []TestConfig
	// Imports are explicit model dependencies from @import pragmas (legacy)
	Imports []string
	// Sources are all table names referenced in the SQL
	Sources []string
	// Columns contains column-level lineage information
	Columns []ColumnInfo
	// UsesSelectStar is true if model uses SELECT * or t.*
	UsesSelectStar bool
	// SQL is the raw SQL content (excluding frontmatter)
	SQL string
	// RawContent is the full file content including frontmatter
	RawContent string
	// Conditionals are #if directives for environment-specific SQL
	Conditionals []Conditional
	// HasFrontmatter indicates if YAML frontmatter was found
	HasFrontmatter bool
}

type ModelRun struct {
	ID           string
	RunID        string
	ModelID      string
	Status       ModelRunStatus
	RowsAffected int64
	StartedAt    time.Time
	CompletedAt  *time.Time
	Error        string
	RenderMS     int64 // Time spent rendering template
	ExecutionMS  int64 // Time spent executing SQL
}

type ModelRunStatus string

type ModelRunWithInfo struct {
	ModelRun
	ModelPath string
	ModelName string
}

type ModelType string

type Node interface {
	// Pos returns the position of the first character of the node.
	Pos() token.Position
	// End returns the position of the character immediately after the node.
	End() token.Position
}

type NodeInfo struct {
	Span             token.Span
	LeadingComments  []*token.Comment
	TrailingComments []*token.Comment
}

type NormalizationStrategy int

type OperatorDef struct {
	Token      token.TokenType
	Symbol     string
	Precedence int
	Handler    any // spi.InfixHandler - cast at call site
}

type OrderByItem struct {
	Expr       Expr
	Desc       bool
	NullsFirst *bool // nil means default, true = NULLS FIRST, false = NULLS LAST
}

type ParenExpr struct {
	Expr Expr
}

type PersistedModel struct {
	*Model             // Embed core identity
	ID          string // Database primary key
	ContentHash string // For change detection
	CreatedAt   time.Time
	UpdatedAt   time.Time
}

type PivotAggregate struct {
	Func  *FuncCall // The aggregate function
	Alias string    // Optional alias for the result columns
}

type PivotInValue struct {
	Value Expr   // The value (literal, identifier, or expression)
	Alias string // Optional column name alias
}

type PivotTable struct {
	NodeInfo
	Source     TableRef         // The source table/subquery
	Aggregates []PivotAggregate // Aggregate functions to compute
	ForColumn  string           // Column to pivot on
	InValues   []PivotInValue   // Values to pivot (or InStar=true for *)
	InStar     bool             // true if IN *
	Alias      string           // Optional alias
}

type PlaceholderStyle int

type ProjectConfig struct {
	ModelsDir string        `koanf:"models_dir"`
	SeedsDir  string        `koanf:"seeds_dir"`
	MacrosDir string        `koanf:"macros_dir"`
	Target    *TargetConfig `koanf:"target"`
	Lint      *LintConfig   `koanf:"lint"`
}

type ProjectHealthConfig struct {
	// Enabled controls whether project health linting is enabled (default: true)
	Enabled *bool `koanf:"enabled"`

	// Thresholds for various rules
	Thresholds ProjectHealthThresholds `koanf:"thresholds"`

	// Rules maps rule IDs to severity overrides (off, info, warning, error)
	Rules map[string]string `koanf:"rules"`
}

type ProjectHealthThresholds struct {
	ModelFanout        int `koanf:"model_fanout"`        // PM04: default 3
	TooManyJoins       int `koanf:"too_many_joins"`      // PM05: default 7
	PassthroughColumns int `koanf:"passthrough_columns"` // PL01: default 20
	StarlarkComplexity int `koanf:"starlark_complexity"` // PT01: default 10
}

type QueryableStore interface {
	Store
	// DB returns the underlying database connection for direct queries.
	DB() *sql.DB
}

type RenameItem struct {
	OldName string
	NewName string
}

type RenameModifier struct {
	Items []RenameItem
}

type ReplaceItem struct {
	Expr  Expr   // Expression to use
	Alias string // Column name to replace
}

type ReplaceModifier struct {
	Items []ReplaceItem
}

type Rows struct {
	*sql.Rows
}

type RuleInfo struct {
	ID              string   `json:"id"`
	Name            string   `json:"name"`
	Group           string   `json:"group"`
	Description     string   `json:"description"`
	DefaultSeverity Severity `json:"default_severity"`
	ConfigKeys      []string `json:"config_keys,omitempty"`
	Dialects        []string `json:"dialects,omitempty"` // Only for SQL rules
	Type            string   `json:"type"`               // "sql" or "project"

	// Documentation fields
	Rationale   string `json:"rationale,omitempty"`
	BadExample  string `json:"bad_example,omitempty"`
	GoodExample string `json:"good_example,omitempty"`
	Fix         string `json:"fix,omitempty"`
}

type RuleOptions map[string]any

type Run struct {
	ID          string
	Environment string
	Status      RunStatus
	StartedAt   time.Time
	CompletedAt *time.Time
	Error       string
}

type RunStatus string

type SelectBody struct {
	NodeInfo
	Left   *SelectCore
	Op     SetOpType   // UNION, INTERSECT, EXCEPT, or empty
	All    bool        // UNION ALL
	ByName bool        // DuckDB: BY NAME (match columns by name, not position)
	Right  *SelectBody // For chained set operations
}

type SelectCore struct {
	NodeInfo
	Distinct       bool
	Columns        []SelectItem
	From           *FromClause
	Where          Expr
	GroupBy        []Expr
	GroupByAll     bool // DuckDB: GROUP BY ALL (auto-group by non-aggregate columns)
	Having         Expr
	Windows        []WindowDef // Named window definitions (WINDOW clause)
	Qualify        Expr        // DuckDB/Snowflake window function filter
	OrderBy        []OrderByItem
	OrderByAll     bool // DuckDB: ORDER BY ALL (order by all select columns)
	OrderByAllDesc bool // DuckDB: Direction for ORDER BY ALL (true = DESC)
	Limit          Expr
	Offset         Expr
	Fetch          *FetchClause // FETCH FIRST/NEXT support (SQL:2008)

	// Extensions holds rare/custom dialect-specific nodes (e.g., CONNECT BY, SAMPLE).
	// Use this for dialect features that are too specialized to warrant typed fields.
	Extensions []Node
}

type SelectItem struct {
	Star      bool           // SELECT *
	TableStar string         // SELECT t.*
	Expr      Expr           // Expression
	Alias     string         // AS alias
	Modifiers []StarModifier // DuckDB: EXCLUDE, REPLACE, RENAME modifiers
}

type SelectStmt struct {
	NodeInfo
	With *WithClause
	Body *SelectBody
}

type SetOpType string

type Severity int

type SourceRef struct {
	Table  string
	Column string
}

type StarExpr struct {
	Table string // optional table qualifier for t.*
}

type StarModifier interface {
	// contains filtered or unexported methods
}

type Stmt interface {
	Node
	// contains filtered or unexported methods
}

type Store interface {
	Open(path string) error
	Close() error
	InitSchema() error

	// Run operations
	CreateRun(env string) (*Run, error)
	GetRun(id string) (*Run, error)
	CompleteRun(id string, status RunStatus, errMsg string) error
	GetLatestRun(env string) (*Run, error)
	ListRuns(limit int) ([]*Run, error)

	// Model operations (uses PersistedModel for storage)
	RegisterModel(model *PersistedModel) error
	GetModelByID(id string) (*PersistedModel, error)
	GetModelByPath(path string) (*PersistedModel, error)
	GetModelByFilePath(filePath string) (*PersistedModel, error)
	UpdateModelHash(id string, contentHash string) error
	ListModels() ([]*PersistedModel, error)
	DeleteModelByFilePath(filePath string) error

	// Model run operations
	RecordModelRun(modelRun *ModelRun) error
	UpdateModelRun(id string, status ModelRunStatus, rowsAffected int64, errMsg string, renderMS int64, executionMS int64) error
	GetModelRunsForRun(runID string) ([]*ModelRun, error)
	GetModelRunsWithModelInfo(runID string) ([]*ModelRunWithInfo, error)
	GetLatestModelRun(modelID string) (*ModelRun, error)

	// Dependency operations
	SetDependencies(modelID string, parentIDs []string) error
	GetDependencies(modelID string) ([]string, error)
	GetDependents(modelID string) ([]string, error)

	// Environment operations
	CreateEnvironment(name string) (*Environment, error)
	GetEnvironment(name string) (*Environment, error)
	UpdateEnvironmentRef(name string, commitRef string) error

	// Column lineage operations
	SaveModelColumns(modelPath string, columns []ColumnInfo) error
	GetModelColumns(modelPath string) ([]ColumnInfo, error)
	DeleteModelColumns(modelPath string) error
	TraceColumnBackward(modelPath, columnName string) ([]TraceResult, error)
	TraceColumnForward(modelPath, columnName string) ([]TraceResult, error)

	// Macro operations
	SaveMacroNamespace(ns *MacroNamespace, functions []*MacroFunction) error
	GetMacroNamespaces() ([]*MacroNamespace, error)
	GetMacroNamespace(name string) (*MacroNamespace, error)
	GetMacroFunctions(namespace string) ([]*MacroFunction, error)
	GetMacroFunction(namespace, name string) (*MacroFunction, error)
	MacroFunctionExists(namespace, name string) (bool, error)
	SearchMacroNamespaces(prefix string) ([]*MacroNamespace, error)
	SearchMacroFunctions(namespace, prefix string) ([]*MacroFunction, error)
	DeleteMacroNamespace(name string) error
	DeleteMacroNamespaceByFilePath(filePath string) error

	// File hash tracking
	GetContentHash(filePath string) (string, error)
	SetContentHash(filePath, hash, fileType string) error
	DeleteContentHash(filePath string) error

	// List tracked file paths
	ListModelFilePaths() ([]string, error)
	ListMacroFilePaths() ([]string, error)

	// Column snapshot operations
	SaveColumnSnapshot(runID, modelPath, sourceTable string, columns []string) error
	GetColumnSnapshot(modelPath, sourceTable string) (columns []string, runID string, err error)
	DeleteOldSnapshots(keepRuns int) error

	// Batch operations
	BatchGetAllColumns() (map[string][]ColumnInfo, error)
	BatchGetAllDependencies() (map[string][]string, error)
	BatchGetAllDependents() (map[string][]string, error)
}

type StructField struct {
	Key   string // Field name (can be identifier or string)
	Value Expr   // Field value
}

type StructLiteral struct {
	NodeInfo
	Fields []StructField
}

type SubqueryExpr struct {
	Select *SelectStmt
}

type TableMetadata struct {
	Schema    string
	Name      string
	Columns   []Column
	RowCount  int64
	SizeBytes int64
}

type TableName struct {
	NodeInfo
	Catalog string
	Schema  string
	Name    string
	Alias   string
}

type TableRef interface {
	Node
	// contains filtered or unexported methods
}

type TargetConfig struct {
	Type string `koanf:"type"` // duckdb, postgres, snowflake, bigquery

	// File-based databases (DuckDB, SQLite)
	Database string `koanf:"database"` // file path or database name

	// Network databases
	Host     string `koanf:"host"`
	Port     int    `koanf:"port"`
	User     string `koanf:"user"`
	Password string `koanf:"password"`

	// Common
	Schema string `koanf:"schema"`

	// Snowflake-specific
	Account   string `koanf:"account"`
	Warehouse string `koanf:"warehouse"`
	Role      string `koanf:"role"`

	// Additional driver-specific options
	Options map[string]string `koanf:"options"`

	// Params holds adapter-specific configuration (e.g., DuckDB extensions, secrets, settings)
	Params map[string]any `koanf:"params"`
}

type TestConfig struct {
	Unique         []string
	NotNull        []string
	AcceptedValues *AcceptedValuesConfig
}

type TraceResult struct {
	ModelPath  string
	ColumnName string
	Depth      int
	IsExternal bool
}

type TransformType string

type UnaryExpr struct {
	Op   token.TokenType
	Expr Expr
}

type UnpivotInGroup struct {
	Columns []string // Column name(s) in this group
	Alias   string   // Optional row value alias
}

type UnpivotTable struct {
	NodeInfo
	Source       TableRef         // The source table/subquery
	ValueColumns []string         // Output column(s) for values
	NameColumn   string           // Output column for names
	InColumns    []UnpivotInGroup // Source columns to unpivot
	Alias        string           // Optional alias
}

type WhenClause struct {
	Condition Expr
	Result    Expr
}

type WindowDef struct {
	Name string
	Spec *WindowSpec
}

type WindowSpec struct {
	Name        string // Named window reference
	PartitionBy []Expr
	OrderBy     []OrderByItem
	Frame       *FrameSpec
}

type WithClause struct {
	NodeInfo
	Recursive bool
	CTEs      []*CTE
}