builder

type BuildOptions struct {
	// Workers is the number of parallel workers (0 = auto)
	Workers int

	// Incremental enables incremental builds
	Incremental bool

	// Cache enables caching
	Cache bool

	// CacheDir is the cache directory
	CacheDir string

	// DryRun only shows what would be built
	DryRun bool

	// Verbose enables verbose logging
	Verbose bool
}

type BuildPlan struct {
	// ProtoFiles is the list of proto files to compile
	ProtoFiles []string

	// ImportPaths are additional import paths
	ImportPaths []string

	// OutputDir is the base output directory
	OutputDir string

	// Languages are the target languages
	Languages []string

	// Options are additional build options
	Options BuildOptions
}

type BuildResult struct {
	// Success indicates if build was successful
	Success bool

	// Duration is the total build time
	Duration time.Duration

	// FilesProcessed is the number of files processed
	FilesProcessed int

	// FilesGenerated is the number of generated files
	FilesGenerated int

	// Errors contains any build errors
	Errors []error

	// Warnings contains build warnings
	Warnings []string

	// CacheHits is the number of cache hits
	CacheHits int

	// CacheMisses is the number of cache misses
	CacheMisses int
}

type Builder interface {
	// Build executes the build process
	Build(ctx context.Context, plan *BuildPlan) (*BuildResult, error)

	// GetMetrics returns build metrics
	GetMetrics() *metrics.Collector
}

type CacheEntry struct {
	// File is the proto file path
	File string

	// Hash is the file content hash
	Hash string

	// DepsHash is the dependencies hash
	DepsHash string

	// Languages are the generated languages
	Languages []string

	// GeneratedFiles are the generated file paths
	GeneratedFiles []string
}

type CacheManager interface {
	// Check checks cache for files
	Check(ctx context.Context, files []*ProtoFile) (hits int, misses int)

	// Get retrieves cache entry for a file
	Get(ctx context.Context, file *ProtoFile) (*CacheEntry, error)

	// Put stores cache entry
	Put(ctx context.Context, entry *CacheEntry) error

	// Invalidate removes cache entry
	Invalidate(ctx context.Context, file string) error

	// Clear clears all cache
	Clear(ctx context.Context) error
}

type DependencyGraph struct {
	// Nodes are the proto files
	Nodes map[string]*ProtoFile

	// Edges represent dependencies (file -> dependencies)
	Edges map[string][]string

	// CompilationOrder is the topologically sorted order
	CompilationOrder []string
}

type DependencyResolver interface {
	// Resolve builds the dependency graph and determines compilation order
	Resolve(ctx context.Context, files []*ProtoFile) (*DependencyGraph, error)
}

type Enum struct {
	Name   string
	Values []EnumValue
}

type EnumValue struct {
	Name   string
	Number int
}

type ExecutionPlan struct {
	// Graph is the dependency graph
	Graph *DependencyGraph

	// OutputDir is the output directory
	OutputDir string

	// ImportPaths are the import paths for protoc
	ImportPaths []string

	// Languages are the target languages
	Languages []string

	// Options are build options
	Options BuildOptions
}

type ExecutionResult struct {
	// FilesGenerated is the number of generated files
	FilesGenerated int

	// Warnings contains execution warnings
	Warnings []string

	// Metrics contains execution metrics
	Metrics map[string]interface{}
}

type Executor interface {
	// Execute runs the build execution
	Execute(ctx context.Context, plan *ExecutionPlan) (*ExecutionResult, error)
}

type Field struct {
	Name     string
	Type     string
	Number   int
	Repeated bool
	Optional bool
}

type Logger interface {
	Debug(msg string, args ...interface{})
	Info(msg string, args ...interface{})
	Warn(msg string, args ...interface{})
	Error(msg string, args ...interface{})
}

type Message struct {
	Name   string
	Fields []Field
}

type Method struct {
	Name       string
	InputType  string
	OutputType string
	Options    map[string]string
}

type Option func(*builder) error

type ProtoFile struct {
	// Path is the file path
	Path string

	// Package is the proto package name
	Package string

	// Syntax is the proto syntax version (proto2 or proto3)
	Syntax string

	// Imports are the imported proto files
	Imports []string

	// Services are the defined services
	Services []Service

	// Messages are the defined messages
	Messages []Message

	// Enums are the defined enums
	Enums []Enum

	// Options are file-level options
	Options map[string]string
}

type ProtoParser interface {
	// ParseFiles parses multiple proto files
	ParseFiles(ctx context.Context, files []string, importPaths []string) ([]*ProtoFile, error)

	// ParseFile parses a single proto file
	ParseFile(ctx context.Context, path string, importPaths []string) (*ProtoFile, error)
}

type Service struct {
	Name    string
	Methods []Method
}