pathfinder

type AnnotationMetrics struct {
	TotalTODO        int // Count of "TODO" tags
	TotalFIXME       int // Count of "FIXME" tags
	TotalHACK        int // Count of "HACK" tags
	TotalAnnotations int // Sum of all annotation types
}

type CodebaseMetrics struct {
	TotalFiles     int // Total files scanned
	TotalDirs      int // Total directories encountered
	TotalLanguages int // Number of distinct languages detected
	TotalCode      int // Total lines of code across all languages
	TotalComments  int // Total lines of comments across all languages
	TotalBlanks    int // Total blank lines across all languages
	TotalLines     int // Grand total of all lines
}

type CodebaseReport struct {
	LanguageMetrics    []LanguageMetricsReport
	FileMetrics        []FileMetricsReport
	DirMetrics         []DirMetricsReport
	CodebaseMetrics    CodebaseMetrics
	AnnotationMetrics  AnnotationMetrics
	DependencyMetrics  DependencyMetrics
	PerformanceMetrics PerformanceMetrics
}

type CommentType struct {
	SingleLine string // Prefix for single-line comments (e.g., "//" or "#")
	BlockStart string // Start marker for block comments (e.g., "/*")
	BlockEnd   string // End marker for block comments (e.g., "*/")
}

type Config struct {
	// PathFlag is the root path to the codebase or repository to scan.
	PathFlag string

	// HiddenFlag, if true, includes hidden files and directories (starting with .) in the scan.
	HiddenFlag bool

	// BufferSizeFlag sets the buffer size (in bytes) for reading files.
	// specific values like 4KB, 8KB, 16KB is usually the best performance.
	BufferSizeFlag int

	// RecursiveFlag, if true, scans subdirectories recursively.
	RecursiveFlag bool

	// MaxDepthFlag limits the recursion depth. Set to -1 for no limit.
	// Only applies if RecursiveFlag is true.
	MaxDepthFlag int

	// DependencyFlag, if true, attempts to analyze dependency files (e.g. go.mod, package.json).
	DependencyFlag bool

	// GitFlag, if true, analyzes git information (commits, history).
	GitFlag bool

	// WorkerFlag, if set, defines the number of concurrent workers for scanning files. Default is 16
	WorkerFlag int

	// ThroughputFlag, if true, shows throughput information without the detailed report.
	ThroughputFlag bool
}

type DependencyFile struct {
	Path         string   // File path to the manifest
	Type         string   // Type of dependency manager (e.g., "Go Modules", "npm")
	Dependencies []string // List of dependencies found in the file
}

type DependencyMetrics struct {
	TotalDependencies int              // Total count of individual dependencies found
	DependencyFiles   []DependencyFile // List of files that were parsed for dependencies
}

type DirMetricsReport struct {
	Directory  string  // Path to the directory
	Percentage float64 // Percentage of the codebase contained in this directory
	Lines      int     // Total lines in this directory
}

type FileMetricsReport struct {
	Path    string          // Relative path to the file
	Metrics LanguageMetrics // The metrics calculated for this file
}

type LanguageDefinition struct {
	Name string      // The common name of the language (e.g., "Go", "Python")
	Type CommentType // The comment syntax definition
	Ext  []string    // List of file extensions (e.g., ".go", ".py")
}

type LanguageMetrics struct {
	Language string // Name of the language
	Files    int    // Number of files detected
	Code     int    // Lines of actual code
	Comments int    // Lines of comments
	Blanks   int    // Empty lines
	Lines    int    // Total lines (Code + Comments + Blanks)
}

type LanguageMetricsReport struct {
	Percentage float64         // Percentage of the codebase written in this language
	Metrics    LanguageMetrics // The raw metrics
}

type PerformanceMetrics struct {
	TotalWorkers      int            // Number of concurrent workers used
	WorkerStats       []*WorkerStats // Detailed stats per worker
	TotalTimeSeconds  float64        // Total time taken for the scan in seconds
	OverallThroughput float64        // Files processed per second
}

type WorkerStats struct {
	Id         int     // worker ID
	Processed  int     // number of files processed
	Throughput float64 // files per second
	Duration   float64 // total time taken
	Start      time.Time
	End        time.Time
}