analyze

type AnalysisVisitor interface {
	NodeVisitor
	GetReport() Report
}

type Analyzer interface {
	Name() string
	Flag() string
	Descriptor() Descriptor

	// Configuration.
	ListConfigurationOptions() []pipeline.ConfigurationOption
	Configure(facts map[string]any) error
}

type AnalyzerMode string

type AnalyzerResult struct {
	ID     string       `json:"id"     yaml:"id"`
	Mode   AnalyzerMode `json:"mode"   yaml:"mode"`
	Report Report       `json:"report" yaml:"report"`
}

type BaseReportSection struct {
	Title      string
	Message    string
	ScoreValue float64
}

type CommitIdentity interface {
	Hash() gitlib.Hash
	Author() gitlib.Signature
	Committer() gitlib.Signature
	Message() string
}

type CommitLike interface {
	CommitIdentity
	CommitParents
	Tree() (*gitlib.Tree, error)
	Files() (*gitlib.FileIter, error)
	File(path string) (*gitlib.File, error)
}

type CommitMeta struct {
	Hash      string `json:"hash"`
	Timestamp string `json:"timestamp"`
	Author    string `json:"author"`
	Tick      int    `json:"tick"`
}

type CommitParents interface {
	NumParents() int
	Parent(n int) (*gitlib.Commit, error)
}

type Context struct {
	Time    time.Time
	Commit  CommitLike
	Index   int
	IsMerge bool

	// Changes contains the tree diff changes for this commit.
	Changes gitlib.Changes

	// BlobCache maps blob hashes to cached blobs.
	// Populated by the runtime pipeline for efficient blob access.
	BlobCache map[gitlib.Hash]*gitlib.CachedBlob

	// FileDiffs maps file paths to diff data for modified files.
	// Populated by the runtime pipeline using native C diff computation.
	FileDiffs map[string]plumbing.FileDiffData

	// UASTChanges contains pre-computed UAST changes for this commit.
	// Populated by the UAST pipeline stage when enabled.
	UASTChanges []uast.Change
}

type Descriptor struct {
	ID          string
	Description string
	Mode        AnalyzerMode
}

type DistributionItem struct {
	Label   string  // Category label (e.g., "Simple (1-5)").
	Percent float64 // Percentage as 0-1.
	Count   int     // Absolute count.
}

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

type HistoryAnalyzer interface {
	Analyzer

	// Core analysis methods.
	Initialize(repository *gitlib.Repository) error

	// Consumption.
	Consume(ctx context.Context, ac *Context) error

	// Result handling.
	Finalize() (Report, error)

	// Branching support.
	Fork(n int) []HistoryAnalyzer
	Merge(branches []HistoryAnalyzer)

	// Formatting/Serialization.
	// Format can be: "yaml", "json", or "binary" (protobuf).
	Serialize(result Report, format string, writer io.Writer) error
}

type Issue struct {
	Name     string // Item name (e.g., function name).
	Location string // File location (e.g., "pkg/foo/bar.go:42").
	Value    string // Metric value (e.g., "12").
	Severity string // "good", "fair", "poor", or "info".
}

type MergedCommitData struct {
	Hash      string         `json:"hash"`
	Timestamp string         `json:"timestamp"`
	Author    string         `json:"author"`
	Tick      int            `json:"tick"`
	Analyzers map[string]any `json:"-"`
}

type MergedTimeSeries struct {
	Version       string             `json:"version"`
	TickSizeHours float64            `json:"tick_size_hours"`
	Analyzers     []string           `json:"analyzers"`
	Commits       []MergedCommitData `json:"commits"`
}

type Metric struct {
	Label string // Display label (e.g., "Total Functions").
	Value string // Pre-formatted value (e.g., "156").
}

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

type NodeVisitor interface {
	OnEnter(n *node.Node, depth int)
	OnExit(n *node.Node, depth int)
}

type Parallelizable interface {
	// SequentialOnly returns true if this analyzer cannot be parallelized
	// (e.g. it tracks cumulative state across all commits).
	SequentialOnly() bool

	// CPUHeavy returns true if this analyzer's Consume() is CPU-intensive
	// (e.g. UAST processing) and benefits from W parallel workers.
	// Lightweight analyzers return false and run on the main goroutine
	// to avoid fork/merge overhead.
	CPUHeavy() bool

	// SnapshotPlumbing captures the current plumbing output state.
	// Called once per commit after core analyzers have run.
	// The returned value is opaque to the framework.
	SnapshotPlumbing() PlumbingSnapshot

	// ApplySnapshot restores plumbing state from a previously captured snapshot.
	// Called on forked copies before Consume().
	ApplySnapshot(snapshot PlumbingSnapshot)

	// ReleaseSnapshot releases any resources owned by the snapshot
	// (e.g. UAST trees). Called once per snapshot after all leaves
	// in the worker have consumed it.
	ReleaseSnapshot(snapshot PlumbingSnapshot)
}

type PlotGenerator interface {
	GenerateChart(report Report) (components.Charter, error)
}

type PlotRenderer func(model UnifiedModel, writer io.Writer) error

type PlumbingSnapshot any

type PreparationConfig struct {
	// Tick0 is the time of the first commit (for tick calculation).
	Tick0 time.Time
	// TickSize is the duration of one tick.
	TickSize time.Duration
	// PeopleDict maps author keys to author IDs.
	PeopleDict map[string]int
}

type PreparedCommit struct {
	Ctx       *Context
	Changes   []*gitlib.Change
	Cache     map[gitlib.Hash]*gitlib.CachedBlob
	FileDiffs map[string]pkgplumbing.FileDiffData
	Index     int
	Err       error
	// AuthorID is the resolved author identifier.
	AuthorID int
	// Tick is the time tick for this commit.
	Tick int
}

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

type Report = map[string]any

type ReportSection interface {
	// SectionTitle returns the display title (e.g., "COMPLEXITY").
	SectionTitle() string

	// Score returns a 0-1 score, or ScoreInfoOnly for info-only sections.
	Score() float64

	// ScoreLabel returns formatted score (e.g., "8/10" or "Info").
	ScoreLabel() string

	// StatusMessage returns a summary message (e.g., "Good - reasonable complexity").
	StatusMessage() string

	// KeyMetrics returns ordered key metrics for display.
	KeyMetrics() []Metric

	// Distribution returns distribution data for bar charts.
	Distribution() []DistributionItem

	// TopIssues returns the top N issues/items to highlight.
	TopIssues(n int) []Issue

	// AllIssues returns all issues for verbose mode.
	AllIssues() []Issue
}

type ReportSectionProvider interface {
	CreateReportSection(report Report) ReportSection
}

type ResultAggregator interface {
	Aggregate(results map[string]Report)
	GetResult() Report
}

type SectionGenerator interface {
	GenerateSections(report Report) ([]plotpage.Section, error)
}

type SectionRendererFunc func(report Report) ([]plotpage.Section, error)

type StaticAnalyzer interface {
	Analyzer

	Analyze(root *node.Node) (Report, error)
	Thresholds() Thresholds

	// Aggregation methods.
	CreateAggregator() ResultAggregator

	// Formatting methods.
	FormatReport(report Report, writer io.Writer) error
	FormatReportJSON(report Report, writer io.Writer) error
	FormatReportYAML(report Report, writer io.Writer) error
	FormatReportPlot(report Report, writer io.Writer) error
	FormatReportBinary(report Report, writer io.Writer) error
}

type StaticRenderer interface {
	// SectionsToJSON converts report sections to a JSON-serializable value.
	SectionsToJSON(sections []ReportSection) any

	// RenderText writes human-readable text output for the given sections.
	RenderText(sections []ReportSection, verbose, noColor bool, writer io.Writer) error

	// RenderCompact writes single-line-per-section compact output.
	RenderCompact(sections []ReportSection, noColor bool, writer io.Writer) error
}

type StaticService struct {
	Analyzers []StaticAnalyzer

	// Renderer provides section-based output rendering.
	// Must be set before calling FormatJSON, FormatText, FormatCompact, or RunAndFormat.
	Renderer StaticRenderer
}

type Thresholds = map[string]map[string]any

type TickExtractor func(report Report) map[string]any

type UnifiedModel struct {
	Version   string           `json:"version"   yaml:"version"`
	Analyzers []AnalyzerResult `json:"analyzers" yaml:"analyzers"`
}

type VisitorProvider interface {
	CreateVisitor() AnalysisVisitor
}