diagnostic

type AnalysisMetadata struct {
	TotalSources    int      `json:"total_sources"`
	TotalSinks      int      `json:"total_sinks"`
	TotalSanitizers int      `json:"total_sanitizers"`
	TotalFlows      int      `json:"total_flows"`
	DangerousFlows  int      `json:"dangerous_flows"`
	SafeFlows       int      `json:"safe_flows"`
	Confidence      float64  `json:"confidence"`
	Limitations     []string `json:"limitations"`
	ProcessingTime  string   `json:"processing_time,omitempty"`
	ModelUsed       string   `json:"model_used,omitempty"`
}

type DataflowTestCase struct {
	// TestID for reference
	TestID int `json:"test_id"`

	// Description of what this test validates
	Description string `json:"description"`

	// Source information
	Source TestCaseSource `json:"source"`

	// Sink information
	Sink TestCaseSink `json:"sink"`

	// Flow path (sequence of variables/operations)
	FlowPath []FlowStep `json:"flow_path"`

	// Sanitizers in the path (if any)
	SanitizersInPath []string `json:"sanitizers_in_path"`

	// Expected detection result
	// true: Our tool SHOULD detect this flow
	// false: Our tool should NOT detect (e.g., sanitized)
	ExpectedDetection bool `json:"expected_detection"`

	// Vulnerability type (if ExpectedDetection == true)
	VulnerabilityType string `json:"vulnerability_type"`

	// Confidence score (0.0-1.0)
	Confidence float64 `json:"confidence"`

	// Reasoning for this test case
	Reasoning string `json:"reasoning"`

	// Failure category (if tool might miss this)
	// Categories: control_flow_branch, field_sensitivity, sanitizer_missed,
	//            container_operation, string_formatting, method_call_propagation,
	//            assignment_chain, return_flow, parameter_flow, complex_expression,
	//            context_required, none
	FailureCategory string `json:"failure_category,omitempty"`
}

type DiscoveredPatterns struct {
	Sources     []PatternLocation     `json:"sources"`
	Sinks       []PatternLocation     `json:"sinks"`
	Sanitizers  []PatternLocation     `json:"sanitizers"`
	Propagators []PropagatorOperation `json:"propagators"`
}

type DualLevelComparison struct {
	FunctionFQN string

	// Level 1: Binary classification
	BinaryToolResult bool // Tool says: has flow
	BinaryLLMResult  bool // LLM says: has flow
	BinaryAgreement  bool // Do they agree?

	// Level 2: Detailed flow comparison (only if both found flows)
	DetailedComparison *FlowComparisonResult // nil if N/A

	// Metrics
	Precision float64
	Recall    float64
	F1Score   float64

	// Categorization (if disagreement)
	FailureCategory string // "control_flow", "sanitizer", etc.
	FailureReason   string // From LLM reasoning
}

type FailureExample struct {
	Type         string // "FALSE_POSITIVE", "FALSE_NEGATIVE"
	FunctionFQN  string
	FunctionFile string
	FunctionLine int
	Category     string               // "control_flow", "sanitizer", etc.
	Reason       string               // From LLM
	Flow         *NormalizedTaintFlow // Flow details (if applicable)
}

type FlowComparisonResult struct {
	ToolFlows []NormalizedTaintFlow
	LLMFlows  []NormalizedTaintFlow

	Matches       []FlowMatch           // TP: Both found
	UnmatchedTool []NormalizedTaintFlow // FP: Tool only
	UnmatchedLLM  []NormalizedTaintFlow // FN: LLM only

	FlowPrecision float64 // Matches / ToolFlows
	FlowRecall    float64 // Matches / LLMFlows
	FlowF1Score   float64 // 2PR/(P+R)
}

type FlowMatch struct {
	ToolFlow  NormalizedTaintFlow
	LLMFlow   NormalizedTaintFlow
	ToolIndex int
	LLMIndex  int
}

type FlowStep struct {
	Line      int    `json:"line"`
	Variable  string `json:"variable"`
	Operation string `json:"operation"` // "source", "assignment", "call", "sanitizer", "sink"
}

type FunctionMetadata struct {
	// FilePath is the relative path to the source file
	// Example: "myapp/views.py"
	FilePath string

	// FunctionName is the simple function name
	// Example: "process_input"
	FunctionName string

	// FQN is the fully qualified name (module.Class.function)
	// Example: "myapp.views.process_input" or "myapp.models.User.save"
	FQN string

	// StartLine is the first line of the function definition (1-indexed)
	// Includes decorators if present
	StartLine int

	// EndLine is the last line of the function body (1-indexed)
	EndLine int

	// SourceCode is the complete function source code
	// Includes decorators, signature, and body
	SourceCode string

	// LOC is lines of code (EndLine - StartLine + 1)
	LOC int

	// HasDecorators indicates if function has decorators (@property, @classmethod, etc.)
	HasDecorators bool

	// ClassName is the containing class name (if method), empty if top-level function
	// Example: "User" for myapp.models.User.save
	ClassName string

	// IsMethod indicates if this is a class method (has self/cls parameter)
	IsMethod bool

	// IsAsync indicates if this is an async function
	IsAsync bool
}

type FunctionTaintResult struct {
	// FunctionFQN identifies the function
	FunctionFQN string

	// HasTaintFlow indicates if ANY taint flow was detected (binary result)
	HasTaintFlow bool

	// TaintFlows contains all detected flows (detailed result)
	TaintFlows []ToolTaintFlow

	// AnalysisError indicates if analysis failed
	AnalysisError bool

	// ErrorMessage if AnalysisError == true
	ErrorMessage string
}

type LLMAnalysisResult struct {
	// FunctionFQN identifies which function was analyzed
	FunctionFQN string `json:"function_fqn,omitempty"`

	// DiscoveredPatterns contains sources/sinks/sanitizers found by LLM
	DiscoveredPatterns DiscoveredPatterns `json:"discovered_patterns"`

	// DataflowTestCases are test cases generated by LLM
	// Each test case specifies expected dataflow behavior
	DataflowTestCases []DataflowTestCase `json:"dataflow_test_cases"`

	// VariableTracking shows how LLM traced variables through the function
	VariableTracking []VariableTrack `json:"variable_tracking"`

	// Metadata about the analysis
	AnalysisMetadata AnalysisMetadata `json:"analysis_metadata"`
}

type LLMClient struct {
	Provider    LLMProvider
	BaseURL     string
	Model       string
	Temperature float64
	MaxTokens   int
	APIKey      string // For OpenAI-compatible APIs (xAI Grok, etc.)
	HTTPClient  *http.Client
}

type LLMProvider string

type MatchConfig struct {
	// LineThreshold: Accept matches within ±N lines (default: 2)
	LineThreshold int

	// AllowVariableAliases: Match user_input vs user_input_1 (SSA) (default: true)
	AllowVariableAliases bool

	// SemanticVulnTypes: "SQL_INJECTION" == "sqli" (default: true)
	SemanticVulnTypes bool
}

type NormalizedTaintFlow struct {
	SourceLine     int
	SourceVariable string
	SourceCategory string // Semantic: "user_input", "file_read", etc.

	SinkLine     int
	SinkVariable string
	SinkCategory string // Semantic: "sql_execution", "command_exec", etc.

	VulnerabilityType string // "SQL_INJECTION", "XSS", etc.
	Confidence        float64
}

type OverallMetrics struct {
	// Total functions analyzed
	TotalFunctions int

	// Confusion Matrix
	TruePositives  int // Tool detected, LLM confirmed ✅
	FalsePositives int // Tool detected, LLM says safe ⚠️
	FalseNegatives int // Tool missed, LLM found vuln ❌
	TrueNegatives  int // Tool skipped, LLM confirmed safe ✅

	// Metrics
	Precision float64 // TP / (TP + FP)
	Recall    float64 // TP / (TP + FN)
	F1Score   float64 // 2 * (P * R) / (P + R)
	Agreement float64 // (TP + TN) / Total

	// Processing stats
	LLMProcessingTime   string
	TotalProcessingTime string
	FunctionsPerSecond  float64

	// Failure breakdown
	FailuresByCategory map[string]int
	TopFailures        []FailureExample
}

type PatternLocation struct {
	// Pattern is the code pattern (e.g., "request.GET", "os.system")
	Pattern string `json:"pattern"`

	// Lines where this pattern appears
	Lines []int `json:"lines"`

	// Variables involved
	Variables []string `json:"variables"`

	// Category for semantic grouping
	// Examples: "user_input", "file_read", "sql_execution", "command_exec"
	Category string `json:"category"`

	// Description of what this pattern does
	Description string `json:"description"`

	// Severity (for sinks): CRITICAL, HIGH, MEDIUM, LOW
	Severity string `json:"severity,omitempty"`
}

type PropagatorOperation struct {
	// Type: "assignment", "function_call", "return"
	Type string `json:"type"`

	// Line number
	Line int `json:"line"`

	// Source variable
	FromVar string `json:"from_var"`

	// Destination variable
	ToVar string `json:"to_var"`

	// Function name (if Type == "function_call")
	Function string `json:"function,omitempty"`
}

type TestCaseSink struct {
	Pattern  string `json:"pattern"` // e.g., "os.system"
	Line     int    `json:"line"`
	Variable string `json:"variable"`
}

type TestCaseSource struct {
	Pattern  string `json:"pattern"` // e.g., "request.GET['cmd']"
	Line     int    `json:"line"`
	Variable string `json:"variable"`
}

type ToolTaintFlow struct {
	// Source information
	SourceLine     int
	SourceVariable string
	SourceType     string // e.g., "request.GET['username']"
	SourceCategory string // e.g., "user_input" (semantic)

	// Sink information
	SinkLine     int
	SinkVariable string
	SinkType     string // e.g., "sqlite3.execute"
	SinkCategory string // e.g., "sql_execution" (semantic)

	// Flow details
	FlowPath []FlowStep

	// Metadata
	VulnerabilityType string  // e.g., "SQL_INJECTION"
	Confidence        float64 // 0.0-1.0
	IsSanitized       bool    // If sanitizer detected in path
}

type VariableTrack struct {
	Variable     string   `json:"variable"`
	FirstDefined int      `json:"first_defined"`
	LastUsed     int      `json:"last_used"`
	Aliases      []string `json:"aliases"` // Other variable names that hold the same data
	FlowsToLines []int    `json:"flows_to_lines"`
	FlowsToVars  []string `json:"flows_to_vars"`
}