fix

type AppliedFix struct {
	// RuleCode identifies which rule this fix is for.
	RuleCode string

	// Description explains what the fix did.
	Description string

	// Location is where the fix was applied.
	Location rules.Location

	// Edits are the original (pre-adjustment) text edits of this fix.
	// Positions reference the original document content, making them
	// suitable for direct conversion to LSP TextEdits.
	Edits []rules.TextEdit
}

type FileChange struct {
	// Path is the file path.
	Path string

	// FixesApplied lists the fixes that were applied.
	FixesApplied []AppliedFix

	// FixesSkipped lists fixes that couldn't be applied.
	FixesSkipped []SkippedFix

	// OriginalContent is the file content before fixes.
	OriginalContent []byte

	// ModifiedContent is the file content after fixes.
	ModifiedContent []byte
}

type FixMode = config.FixMode

type FixResolver interface {
	// ID returns the unique identifier for this resolver.
	// This matches the ResolverID field in SuggestedFix.
	ID() string

	// Resolve computes the actual edits for a fix.
	// The fix.ResolverData contains resolver-specific data needed for resolution.
	// The resolveCtx provides the current file content after sync fixes.
	// Returns the edits to apply, or an error if resolution fails.
	//
	// Implementations should respect context cancellation and timeouts.
	Resolve(ctx context.Context, resolveCtx ResolveContext, fix *rules.SuggestedFix) ([]rules.TextEdit, error)
}

type FixSafety = rules.FixSafety

type Fixer struct {
	// SafetyThreshold determines the minimum safety level for fixes.
	// Only fixes with Safety <= SafetyThreshold will be applied.
	SafetyThreshold FixSafety

	// RuleFilter limits fixes to specific rule codes.
	// If empty, all rules are eligible.
	RuleFilter []string

	// FixModes maps file paths to their per-rule fix modes.
	// Outer key is the normalized file path, inner key is the rule code.
	// Uses config.FixMode constants (FixModeAlways, FixModeNever, etc.).
	// If nil or a file/rule is not present, FixModeAlways is assumed.
	FixModes map[string]map[string]FixMode

	// Concurrency sets the number of parallel async resolutions.
	// Defaults to 4 if not set.
	Concurrency int
}

type ResolveContext struct {
	// FilePath is the path to the file being fixed.
	FilePath string

	// Content is the current file content after sync fixes have been applied.
	// Resolvers should parse this to compute correct positions.
	Content []byte
}

type Result struct {
	// Changes contains modifications for each file.
	Changes map[string]*FileChange
}

type SkipReason int

type SkippedFix struct {
	// RuleCode identifies which rule this fix is for.
	RuleCode string

	// Reason explains why the fix was skipped.
	Reason SkipReason

	// Location is where the fix would have been applied.
	Location rules.Location

	// Error contains the error message if Reason is SkipResolveError.
	Error string
}