analyzer

type AnalysisInput struct {
	ProjectID string             // Project identifier
	Files     []*parser.FileInfo // Parsed file information
}

type AnalysisReport struct {
	ProjectID                string                     // Project identifier
	Timestamp                int64                      // Analysis timestamp
	DependencyGraph          *DependencyGraph           // Project dependencies
	InterfaceImplementations []*InterfaceImplementation // Interface implementations
	CallChains               []*CallChain               // Function call relationships
	CircularDependencies     []*CircularDependency      // Circular import cycles
	Metrics                  *CodeMetrics               // Code quality metrics
}

type Analyzer interface {
	// AnalyzeProject performs comprehensive analysis on parsed project data
	AnalyzeProject(ctx context.Context, input *AnalysisInput) (*AnalysisReport, error)

	// BuildDependencyGraph constructs a dependency graph from file imports
	BuildDependencyGraph(ctx context.Context, files []*parser.FileInfo) (*DependencyGraph, error)

	// DetectInterfaceImplementations finds all structs that implement interfaces
	DetectInterfaceImplementations(
		ctx context.Context,
		files []*parser.FileInfo,
	) ([]*InterfaceImplementation, error)

	// MapCallChains traces function call relationships
	MapCallChains(ctx context.Context, files []*parser.FileInfo) ([]*CallChain, error)

	// DetectCircularDependencies identifies circular import cycles
	DetectCircularDependencies(ctx context.Context, graph *DependencyGraph) ([]*CircularDependency, error)
}

type CallChain struct {
	Caller      *FunctionReference // The calling function
	Callee      *FunctionReference // The called function
	CallSites   []CallSite         // Where the calls occur
	IsRecursive bool               // Whether this is a recursive call
}

type CallSite struct {
	File       string // File path
	Line       int    // Line number
	Column     int    // Column position
	Expression string // Call expression
}

type CircularDependency struct {
	Cycle    []string      // Ordered list of paths forming the cycle
	Severity SeverityLevel // Impact severity
	Impact   []string      // Affected components
}

type CodeMetrics struct {
	TotalFiles           int            // Total number of files
	TotalLines           int            // Total lines of code
	TotalFunctions       int            // Total number of functions
	TotalInterfaces      int            // Total number of interfaces
	TotalStructs         int            // Total number of structs
	CyclomaticComplexity map[string]int // Function complexity scores
	TestCoverage         float64        // Percentage of code covered by tests
	DependencyDepth      int            // Maximum dependency chain length
	CouplingScore        float64        // Inter-package coupling metric
}

type Config struct {
	MaxDependencyDepth int  // Maximum allowed dependency depth
	IgnoreTestFiles    bool // Skip test file analysis
	IgnoreVendor       bool // Skip vendor directory
	IncludeMetrics     bool // Calculate code metrics
	ParallelWorkers    int  // Number of concurrent workers
}

type DependencyEdge struct {
	From string         // Source path
	To   string         // Target path
	Type DependencyType // Import type
	Line int            // Line number of import
}

type DependencyGraph struct {
	Nodes map[string]*DependencyNode // Map of file path to node
	Edges []*DependencyEdge          // All dependency relationships
	Root  string                     // Project root path
}

type DependencyNode struct {
	Path         string   // File or package path
	Type         NodeType // File or Package
	Dependencies []string // Paths of direct dependencies
	Dependents   []string // Paths that depend on this node
}

type DependencyType string

type FunctionReference struct {
	Name      string // Function name
	Package   string // Package name
	Receiver  string // Receiver type if method
	Signature string // Full signature
}

type InterfaceImplementation struct {
	Interface      *InterfaceRef // The interface being implemented with package info
	Implementor    *StructRef    // The struct implementing it with package info
	Methods        []MethodMatch // Matched methods
	IsComplete     bool          // Whether all methods are implemented
	MissingMethods []string      // Names of unimplemented methods
}

type InterfaceRef struct {
	*parser.InterfaceInfo
	Package  string // Package name
	FilePath string // File path where interface is defined
}

type MethodMatch struct {
	InterfaceMethod string // Interface method name
	StructMethod    string // Implementing method name
	Signature       string // Method signature
}

type NodeType string

type SeverityLevel string

type StructRef struct {
	*parser.StructInfo
	Package  string // Package name
	FilePath string // File path where struct is defined
}