formatter

type BaseConfig struct {
	ColumnLimit int // Maximum line length (default: 80)
	TabStop     int // Tab width for visual calculations (default: 8)
}

type BreakContext struct {
	Elements   []string   // The elements to format (e.g., function arguments)
	Indent     Indent     // Current base indentation
	CurrentCol int        // Starting column position
	Config     BaseConfig // Formatting configuration
}

type BreakResult struct {
	Content string // The formatted content
	Broke   bool   // Whether line breaks were added
}

type Breaker interface {
	// Break splits elements to fit within the column limit.
	Break(ctx BreakContext) BreakResult
}

type CallRule struct {
	// Patterns are the function call prefixes to match (e.g., "log.Infof(",
	// "fmt.Errorf(")
	Patterns []string

	// Breaker is the strategy for breaking arguments.
	Breaker Breaker

	// Splitter defines how to split the argument body into elements. If
	// nil, DefaultCommaSplitter is used.
	Splitter ElementSplitter

	// Priority determines application order (higher = applied first).
	Priority int
}

type CommaSplitter struct {
	RespectAllBrackets bool // If true, respects (), [], and {}; otherwise just ()
}

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

type Config struct {
	ColumnLimit int
	TabStop     int
	Targets     []string
	// Excludes is a list of substrings; if any matches the callee name of a
	// non-target call, fallback formatting will skip that call. This
	// mirrors the legacy multiline-call exclude semantics
	// (strings.Contains).
	//
	// Note: This only applies to the fallback formatter
	// (FallbackNonTargets); targeted calls (Targets) are still formatted as
	// usual.
	Excludes []string
	// FallbackNonTargets enables formatting of non-targeted function calls
	// that exceed the column limit using a packed multi-line style.
	FallbackNonTargets bool
	// FallbackNonTargetsExcludeSelectors disables fallback formatting for
	// selector calls (e.g. `pkg.Func(...)` or `x.Method(...)`). This can be
	// useful in pipelines that want selector calls handled by a dedicated
	// multiline stage instead.
	FallbackNonTargetsExcludeSelectors bool

	// UseASTSelection switches this legacy call formatter from scan-based
	// call detection to AST-based call selection. The formatting logic
	// remains the same; only the "which calls do we consider next?"
	// selector changes.
	//
	// This is intentionally opt-in to preserve golden fixtures.
	UseASTSelection bool

	// SkipGofmt skips the internal gofmt pass, useful when running in a
	// pipeline that will run gofmt at the end.
	SkipGofmt bool

	// ParseSafe enables parse-safe behavior: if the formatter's output does
	// not successfully gofmt, the original input is returned unchanged.
	// This avoids returning syntactically invalid Go when a heuristic
	// rewrite goes wrong.
	ParseSafe bool
}

type DSLBundle struct {
	Comments       DSLStageSpec
	LogCalls       DSLStageSpec
	Expressions    DSLStageSpec
	MultiLineCalls DSLStageSpec
	Signatures     DSLStageSpec
	BlankLines     DSLStageSpec
}

type DSLExprConfig struct {
	ColumnLimit   int
	TabStop       int
	Rules         []dsl.Rule // Custom rules (if nil, uses defaults)
	Trace         bool       // Enable DSL rule tracing to stderr
	TraceReasons  bool       // Include "why fired/didn't fire" reasons in DSL tracing
	NodeOrder     dsl.NodeOrder
	MaxIterations int // Override engine MaxIterations (0 keeps default)
	// AutoMaxIterations enables an AST-informed iteration cap (node-count
	// based) rather than a fixed constant. This is intended for stages that
	// legitimately need many iterations (e.g. signature formatting across
	// many declarations) while remaining protected against cycles.
	AutoMaxIterations bool
	DetectCycles      bool
	SkipGofmt         bool // Skip gofmt (pipelines may run gofmt once at end)

	StageName string

	// OwnedSpansFunc optionally declares which regions of the source this
	// stage "owns" for pipeline-level stage fighting prevention. When nil,
	// the stage declares no ownership.
	OwnedSpansFunc func(src []byte) llast.OffsetSpanSet

	// Budget provides optional safety guardrails for the DSL engine.
	Budget dsl.RewriteBudget
}

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

type DSLStageOptions struct {
	Trace        bool
	TraceReasons bool

	UseBlankLinesNative bool
	UseFuncSigsNative   bool

	AllowCallArgs bool
	AutoCallArgs  bool
}

type DSLStageSpec struct {
	Rules             []dsl.Rule
	NodeOrder         dsl.NodeOrder
	MaxIterations     int
	AutoMaxIterations bool
	DetectCycles      bool
}

type ElementSplitter interface {
	Split(content string) []string
}

type Formatter interface {
	FormatFile(src []byte) []byte
}

type FuncSigConfig struct {
	ColumnLimit int
	TabStop     int
	// CanonicalMultilineSigLists forces a gofmt-like formatting style for
	// multiline parameter and result lists. In particular, if a
	// parenthesized return list doesn't fit on one line, we prefer: f(...)
	// ( a, b, ) rather than partially breaking inside the list, e.g.:
	// f(...) (a, b)
	//
	// This is enabled for the "next" profile, but kept off for legacy
	// behavior to avoid changing golden fixtures.
	CanonicalMultilineSigLists bool

	// ReserveTrailingComma reserves space for a trailing comma on a line
	// when we might need to break before the next element. This helps avoid
	// placing a comma exactly on the column boundary (or overflowing by one
	// column) due to late comma insertion.
	ReserveTrailingComma bool

	// PreferInlineSmallReturnList prefers keeping small parenthesized
	// return lists (e.g. `([]T, error)`) on one line by breaking parameters
	// earlier.
	PreferInlineSmallReturnList bool

	// BreakLongFuncTypeParams enables breaking of function-typed parameters
	// when their inner parameter list exceeds the column limit (even when
	// there is no nested struct type).
	//
	// This is intentionally opt-in to preserve legacy fixtures; it is used
	// by the "next" profile to improve readability of long callback
	// signatures.
	BreakLongFuncTypeParams bool

	// FormatInlineStructParams forces signature reflow when parameters
	// include inline struct types with semicolons (which gofmt will expand
	// into multiline blocks). This is intentionally opt-in because it can
	// be a readability-only change even when no single line exceeds the
	// column limit.
	FormatInlineStructParams bool
}

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

type Indent struct {
	Base    string // Leading whitespace of the line (spaces and tabs)
	TabStop int    // Tab width for visual width calculations
}

type LeftFlowBreaker struct {
	Separator     string // Separator between elements (e.g., ", ")
	OpenBracket   string // Opening bracket (e.g., "(")
	CloseBracket  string // Closing bracket (e.g., ")")
	TrailingComma bool   // Add trailing comma before closing bracket
}

type NoopFormatter struct{}

type OperatorRule struct {
	Op       string // The operator (e.g., "&&", "||", ",")
	Priority int    // Lower = break first (prefer breaking here)
	Context  string // Where this applies (e.g., "expr", "case", "call")
}

type OwnedSpanProvider interface {
	OwnedSpans(src []byte) llast.OffsetSpanSet
}

type OwnershipAware interface {
	SetOwnershipRegistry(reg *OwnershipRegistry)
}

type OwnershipPolicy struct {
	Registry  *OwnershipRegistry
	StageName string
}

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

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

type PipelineConfig struct {
	ColumnLimit            int
	TabStop                int
	MoveInlineAbove        bool     // For comment formatter
	Excludes               []string // Functions to exclude from multiline formatting
	UseDSLComments         bool     // Use DSL-based comment formatting (delegates to legacy)
	UseDSLLogCalls         bool     // Use DSL-based log/printf call formatting
	UseDSLMultiLineCalls   bool     // Use DSL-based multiline call formatting
	DSLMultiLineStyle      string   // DSL multiline formatting style (empty => legacy)
	UseDSLExpr             bool     // Use DSL-based expression formatter
	UseDSLFuncSigs         bool     // Use DSL-based signature formatter (delegates to legacy)
	UseDSLFuncSigsNative   bool     // Use native DSL signature rules (fallback to legacy)
	DSLSigsStyle           string   // DSL signature style: legacy|dsl (empty => legacy)
	UseDSLBlankLines       bool     // Use DSL-based blank line formatter
	UseDSLBlankLinesNative bool     // Use native DSL blank line rules (fallback to legacy)
	// DSLBlankLinesExtraIfErrReturn inserts a blank line before:
	//
	// if err != nil { return ... }
	//
	// This is intentionally opt-in because it is opinionated and may
	// interact with users' desired grouping/spacing style.
	DSLBlankLinesExtraIfErrReturn bool
	// LogCallsMinTailLen controls the minimum tail length for string splits
	// in printf/logcall formatting under the "next" profile. When 0, a
	// profile default is used.
	LogCallsMinTailLen int
	// LogCallsSelectorNames overrides the set of recognized printf-style
	// selector names for suffix-only matching (e.g. "Infof", "Errorf").
	// When empty, a built-in default set is used.
	LogCallsSelectorNames []string
	// LogCallsSelectorPrefixes restricts log/printf call selection (compact
	// logcall formatting) to selector calls whose receiver expression has
	// one of these prefixes (e.g. "rpcLog", "zap.L().Sugar()"). When empty,
	// the next profile matches any selector prefix.
	LogCallsSelectorPrefixes []string
	TraceDSL                 bool // Enable DSL rule tracing (only when UseDSLExpr)
	TraceDSLReasons          bool // Include "why fired/didn't fire" reasons in DSL tracing

	// UseOwnershipRegistry enables pipeline-level stage ownership
	// boundaries. When enabled, the pipeline will compute owned span sets
	// for later stages and provide them to earlier stages that support
	// ownership-aware behavior.
	//
	// This remains opt-in to preserve golden fixtures.
	UseOwnershipRegistry bool

	// AllowDSLCallArgs enables limited expression formatting within call
	// arguments when using the DSL expression stage.
	AllowDSLCallArgs bool

	// AutoDSLCallArgs enables limited expression formatting within call
	// arguments only for calls that are known to be ignored by later
	// call-formatting stages. This is less invasive than AllowDSLCallArgs
	// but may miss some cases.
	AutoDSLCallArgs bool

	// DSLExprLogicalStyle controls long &&/|| chain formatting inside the
	// DSL expression stage. Empty means legacy behavior.
	DSLExprLogicalStyle string

	// DSLExprArithmeticStyle controls long arithmetic chain formatting
	// inside the DSL expression stage. Empty means legacy behavior.
	DSLExprArithmeticStyle string

	// DSLExprCaseClauseStyle controls long `case A, B, ...:` list
	// formatting inside the DSL expression stage. Empty means legacy
	// behavior.
	DSLExprCaseClauseStyle string

	// DSLExprSelectorChainStyle controls long selector chain formatting
	// inside the DSL expression stage. Empty means legacy behavior.
	DSLExprSelectorChainStyle string

	// StagePlanOverride forces an explicit stage selection for the
	// pipeline. This is intended for controlled experiments and debugging.
	StagePlanOverride *StagePlan

	// MaxPipelineIterations controls how many full pipeline passes are
	// allowed. When > 0, the pipeline will run stages + gofmt repeatedly
	// until the output stabilizes (no changes) or a cycle is detected.
	//
	// When 0, NewPipeline runs a single pass. The CLI defaults to a small
	// fixpoint search (see `--fixpoint-iters`) because it tends to produce
	// more stable results on large files.
	MaxPipelineIterations int
}

type PipelinePlan struct {
	StagePlan StagePlan

	// Key style knobs
	DSLMultiLineStyle string
	DSLSigsStyle      string

	// Native toggles
	UseDSLFuncSigsNative   bool
	UseDSLBlankLinesNative bool
	// Extra blank-line behavior (native blank lines only).
	DSLBlankLinesExtraIfErrReturn bool

	// Expression style knobs
	DSLExprLogicalStyle       string
	DSLExprArithmeticStyle    string
	DSLExprCaseClauseStyle    string
	DSLExprSelectorChainStyle string

	// Call-args policies
	AllowDSLCallArgs bool
	AutoDSLCallArgs  bool
}

type Preset struct {
	Config    BaseConfig
	CallRules []CallRule
}

type Rule interface {
	// Name returns the rule's identifier for debugging/logging.
	Name() string

	// Match returns true if this rule applies at the given position.
	Match(src []byte, pos int) bool

	// Apply formats the matched content. Returns the replacement bytes and
	// the number of source bytes consumed.
	Apply(src []byte, pos int,
		cfg BaseConfig) (replacement []byte, consumed int)
}

type RuleMatcher struct {
	Rules  []Rule
	Config BaseConfig
}

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

type SpacingOptions struct {
	BlankBeforeReturn   bool // Add blank line before return statements
	BlankBetweenCases   bool // Add blank line between case blocks
	BlankBetweenMethods bool // Add blank line between methods
}

type Stage struct {
	// Name uniquely identifies this stage.
	Name string

	// Formatter is the formatter to apply.
	Formatter Formatter

	// Requires lists the names of stages that must run before this one.
	// This allows explicit dependency declaration rather than implicit
	// ordering.
	Requires []string
}

type StageMode string

type StageOptions struct {
	Selection StageSelectionOptions
	Style     StageStyleOptions
	DSL       DSLStageOptions
}

type StagePlan struct {
	Comments       StageMode
	LogCalls       StageMode
	Expressions    StageMode
	MultiLineCalls StageMode
	Signatures     StageMode
	BlankLines     StageMode
}

type StageSelectionOptions struct {
	StagePlan *StagePlan
}

type StageStyleOptions struct {
	CommentMoveInline bool
	Excludes          []string

	DSLMultiLineStyle string
	DSLSigsStyle      string
	// DSLLogCallsMinTailLen controls how aggressively the "next" log/printf
	// call formatter avoids leaving a tiny remainder segment on the next
	// line when splitting a long string literal. A value of 0 uses the
	// profile default.
	DSLLogCallsMinTailLen int
	// DSLLogCallsSelectorNames overrides the set of recognized printf-style
	// selector names for suffix-only matching. When empty, a built-in
	// default set is used.
	DSLLogCallsSelectorNames []string
	// DSLLogCallsSelectorPrefixes restricts log/printf call selection to
	// calls whose selector receiver expression has one of these prefixes.
	// When empty, the next profile targets any selector prefix.
	DSLLogCallsSelectorPrefixes []string
	// DSLBlankLinesExtraIfErrReturn controls whether native DSL blank line
	// rules should insert a blank line before `if err != nil { return ...
	// }` patterns.
	DSLBlankLinesExtraIfErrReturn bool

	DSLExprLogicalStyle       string
	DSLExprArithmeticStyle    string
	DSLExprCaseClauseStyle    string
	DSLExprSelectorChainStyle string
}

type VerticalBreaker struct {
	Separator     string // Separator (e.g., ",")
	OpenBracket   string // Opening bracket
	CloseBracket  string // Closing bracket
	TrailingComma bool   // Add trailing comma
}