ast

type AsPercentOf struct {
	Numerator   Node // The value to express as a percentage
	Denominator Node // The reference value (the "whole")
	Range       *Range
}

type Assignment struct {
	Name  string
	Value Node
	Range *Range
}

type BetweenExpr struct {
	// Start is the period's first day; End is its last (closed
	// interval, day precision -- mirrors *types.Period).
	Start Node
	End   Node

	// SourceText is the original source slice for diagnostics +
	// AST round-tripping.
	SourceText string

	Range *Range
}

type BinaryOp struct {
	Operator string
	Left     Node
	Right    Node
	Range    *Range
}

type BooleanLiteral struct {
	Value string // "true", "false", "yes", "no", etc.
	Range *Range
}

type ComparisonOp struct {
	Operator string // ">", "<", ">=", "<=", "==", "!="
	Left     Node
	Right    Node
	Range    *Range
}

type CurrencyLiteral struct {
	Symbol     string // Currency symbol or code
	Value      string // Numeric value
	SourceText string // Original text for debugging
	Range      *Range
}

type DateLiteral struct {
	Month string // "Dec", "December"
	Day   string // "25" — the literal day. When the user wrote no
	// day number in source, Day is "1" (lexer default) AND
	// HasExplicitDay is false.
	Year *string // nil if not provided, "2024" if provided

	// HasExplicitDay reports whether a day number was scanned from
	// the source. Discriminates `April 1` (true: specific date) from
	// `April` (false: bare month, semantically a Period). The parser
	// uses this flag to route bare-month forms to RelativeDateLiteral
	// instead of DateLiteral. Lexer-driven so the discriminator
	// doesn't depend on substring inspection of SourceText (which
	// drifts with whitespace / future lexer changes).
	HasExplicitDay bool

	SourceText string
	Range      *Range
}

type DirectiveRef struct {
	Directive string // "scale" or "globals" (or any identifier — semantic checker validates)
	Field     string // "" for @scale, "tax_rate" for @globals.tax_rate
	Range     *Range
}

type DurationLiteral struct {
	Value      string // Numeric value ("5", "3.5", etc.)
	Unit       string // Time unit ("days", "hours", "minutes", etc.)
	SourceText string // Original text from source
	Range      *Range
}

type EndOfExpr struct {
	// Period is the inner expression. Must type as Period at semantic
	// check time; runtime panics if non-Period flows through. Parser
	// uses parsePrimary() so precedence is preserved
	// (`end of Q1 + 1 day` parses as `(end of Q1) + 1 day`).
	Period Node

	// SourceText is the original source slice ("end of Q1") for
	// diagnostics + AST round-tripping.
	SourceText string

	Range *Range
}

type Expression struct {
	Expr  Node
	Range *Range
}

type FractionLiteral struct {
	Numerator   int64  // The numerator value
	Denominator int64  // The denominator value
	Unit        string // Optional unit (e.g., "cup" for "1/3 cup"), empty if dimensionless
	SourceText  string // Original text from source (e.g., "1/3")
	Range       *Range
}

type FunctionCall struct {
	Name      string // Canonical function name: "avg", "sqrt"
	Arguments []Node
	Range     *Range
}

type Identifier struct {
	Name  string
	Range *Range
}

type LengthOfExpr struct {
	// Period is the inner expression. Must type as Period at
	// semantic check time. Parser uses parsePrimary() so precedence
	// is preserved.
	Period Node

	// AsNumber discriminates the surface form: false = `length of`
	// (returns Duration); true = `days in` (returns Number, integer
	// day count).
	AsNumber bool

	// SourceText is the original source slice.
	SourceText string

	Range *Range
}

type NapkinConversion struct {
	Expression Node
	Range      *Range
}

type Node interface {
	String() string
	GetRange() *Range
}

type NumberLiteral struct {
	Value      string // Normalized value (e.g., "1000" for both "1000" and "1,000")
	SourceText string // Original text from source (e.g., "1,000", "1k", "10000")
	Range      *Range
}

type PercentageOf struct {
	Percentage Node // The percentage value (e.g., NumberLiteral for "10%")
	Value      Node // The value to take percentage of
	Range      *Range
}

type Position struct {
	Line   int
	Column int
}

type PreciseConversion struct {
	Expression Node
	Range      *Range
}

type QuantityLiteral struct {
	Value      string // The numeric value (used when Expr is nil)
	Expr       Node   // Expression providing the value (e.g., DirectiveRef); nil for literal quantities
	Unit       string // The unit identifier
	SourceText string // Original text
	Range      *Range
}

type Range struct {
	Start Position
	End   Position
}

type RateLiteral struct {
	Amount     Node   // The quantity numerator (e.g., QuantityLiteral for "100 MB")
	PerUnit    string // The time unit denominator (e.g., "second", "hour", "day")
	SourceText string //Original text
	Range      *Range
}

type RelativeDateLiteral struct {
	Keyword    string // "today", "tomorrow", "yesterday", "now"
	SourceText string
	Range      *Range
}

type StartOfExpr struct {
	Period     Node
	SourceText string
	Range      *Range
}

type TimeLiteral struct {
	Hour       string     // "10", "14"
	Minute     string     // "30"
	Second     *string    // nil or "45"
	Period     *string    // nil, "AM", or "PM"
	UTCOffset  *UTCOffset // nil or offset spec
	SourceText string
	Range      *Range
}

type UTCOffset struct {
	Sign    string  // "+" or "-"
	Hours   string  // "7", "5"
	Minutes *string // nil or "30" (for UTC+5:30)
}

type UnaryOp struct {
	Operator string
	Operand  Node
	Range    *Range
}

type UnitConversion struct {
	Quantity       Node   // The quantity expression to convert
	TargetUnit     string // The target unit to convert to
	TargetTimeUnit string // For rate conversions: the target time unit (e.g., "s" in "inch/s")
	Range          *Range
}