Skip to content

A comprehensive Windows security auditing and threat detection toolkit. Features 58 production-ready PowerShell functions organized into 14 modules for enterprise-grade security assessment, compliance validation, and incident response.

PowerShell
105 KB
Raw Blame
function Get-SecurityMetrics {
    <#
    .SYNOPSIS
        Collects and calculates comprehensive security metrics from all modules
    
    .DESCRIPTION
        Enterprise-grade security metrics aggregation system that:
        - Collects data from all 13 security modules (54 functions)
        - Calculates overall security score (0-100)
        - Performs risk assessment (Critical/High/Medium/Low)
        - Tracks threat levels (Critical/High/Medium/Low/Minimal)
        - Analyzes compliance scores (CIS, NIST, PCI-DSS)
        - Provides trend analysis (week-over-week, month-over-month)
        - Compares with baseline metrics
        - Maintains historical data
        - Exports to JSON format
        - Generates actionable recommendations
    
    .PARAMETER IncludeModules
        Security modules to include in metrics collection
        Valid values: All, Core, Detection, Analysis, Compliance, ActiveDirectory, 
                     Cloud, Vulnerability, ThreatHunting, Forensics, WindowsDefender, 
                     Hardening, Enterprise, Response
        Default: All
    
    .PARAMETER IncludeHistory
        Store metrics in historical database for trend analysis
        History is maintained in: $env:TEMP\SecurityMetricsHistory.json
    
    .PARAMETER HistoryDays
        Number of days of historical data to retain (1-365)
        Default: 30 days
    
    .PARAMETER CalculateTrends
        Calculate trend analysis comparing current metrics with historical data
        Requires at least one previous metric collection in history
    
    .PARAMETER ExportPath
        Directory path to export metrics in JSON format
        Filename: SecurityMetrics_YYYYMMDD_HHMMSS.json
    
    .PARAMETER CompareWithBaseline
        Compare current metrics with a baseline metrics file
        Useful for tracking security posture improvements over time
    
    .PARAMETER BaselinePath
        Path to baseline metrics JSON file for comparison
        Required when CompareWithBaseline is used
    
    .EXAMPLE
        Get-SecurityMetrics
        
        Collect metrics from all modules with default settings
    
    .EXAMPLE
        Get-SecurityMetrics -IncludeModules Core,Detection,Compliance
        
        Collect metrics from specific modules only
    
    .EXAMPLE
        Get-SecurityMetrics -IncludeHistory -CalculateTrends
        
        Collect metrics, save to history, and calculate trends
    
    .EXAMPLE
        Get-SecurityMetrics -ExportPath "C:\SecurityReports" -IncludeHistory
        
        Collect metrics, export to JSON, and save to history
    
    .EXAMPLE
        Get-SecurityMetrics -CompareWithBaseline -BaselinePath "C:\Baseline\metrics.json"
        
        Collect metrics and compare with baseline
    
    .EXAMPLE
        $metrics = Get-SecurityMetrics -IncludeModules All -CalculateTrends -IncludeHistory -ExportPath "C:\Reports"
        Write-Host "Security Score: $($metrics.OverallSecurityScore)%"
        Write-Host "Threat Level: $($metrics.ThreatLevel)"
        
        Full metrics collection with all features enabled
    
    .OUTPUTS
        PSCustomObject containing comprehensive security metrics:
        - Timestamp: Collection date and time
        - Hostname: Computer name
        - Domain: Domain or workgroup name
        - OverallSecurityScore: Calculated security score (0-100)
        - RiskLevel: Overall risk assessment
        - ThreatLevel: Active threat level
        - ComplianceScore: Average compliance score
        - Findings: Total, Critical, High, Medium, Low findings
        - Module-specific metrics for each security module
        - Performance metrics
        - Trend data (if CalculateTrends enabled)
        - Baseline comparison (if CompareWithBaseline enabled)
    
    .NOTES
        Author: WindowsSecurityAudit Module
        Version: 1.1.0 ULTIMATE EDITION
        
        Requires: Administrator privileges for full functionality
        PowerShell Version: 5.1 or higher
        
        All property checks use PSObject.Properties to avoid warnings
        All array operations use @() cast to prevent count errors
        All null checks are safe and defensive
        
        Performance: Typical execution time 30-60 seconds for all modules
    #>
    
    [CmdletBinding()]
    param(
        [Parameter()]
        [ValidateSet('All', 'Core', 'Detection', 'Analysis', 'Compliance', 'ActiveDirectory', 
                     'Cloud', 'Vulnerability', 'ThreatHunting', 'Forensics', 'WindowsDefender', 
                     'Hardening', 'Enterprise', 'Response')]
        [string[]]$IncludeModules = @('All'),
        
        [Parameter()]
        [switch]$IncludeHistory,
        
        [Parameter()]
        [ValidateRange(1, 365)]
        [int]$HistoryDays = 30,
        
        [Parameter()]
        [switch]$CalculateTrends,
        
        [Parameter()]
        [string]$ExportPath,
        
        [Parameter()]
        [switch]$CompareWithBaseline,
        
        [Parameter()]
        [string]$BaselinePath
    )
    
    begin {
        Write-Host "================================================================" -ForegroundColor Cyan
        Write-Host "  SECURITY METRICS COLLECTION - ULTIMATE EDITION" -ForegroundColor Cyan
        Write-Host "================================================================" -ForegroundColor Cyan
        
        $startTime = Get-Date
        
        # Validate baseline path if comparison requested
        if ($CompareWithBaseline) {
            if (-not $BaselinePath) {
                Write-Warning "CompareWithBaseline specified but no BaselinePath provided"
                $CompareWithBaseline = $false
            }
            elseif (-not (Test-Path $BaselinePath)) {
                Write-Warning "Baseline file not found: $BaselinePath"
                $CompareWithBaseline = $false
            }
        }
        
        # Determine modules to process
        $modulesToProcess = if ($IncludeModules -contains 'All') {
            @('Core', 'Detection', 'Analysis', 'Compliance', 'ActiveDirectory', 'Cloud', 
              'Vulnerability', 'ThreatHunting', 'Forensics', 'WindowsDefender', 'Hardening', 
              'Enterprise', 'Response')
        } else { 
            @($IncludeModules)
        }
        
        Write-Host "Collecting metrics from $(@($modulesToProcess).Count) modules..." -ForegroundColor Yellow
        Write-Host "Start Time: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')" -ForegroundColor Gray
        
        # Initialize comprehensive metrics structure
        $script:metrics = @{
            # Metadata
            Timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
            TimestampEpoch = [int][double]::Parse((Get-Date -UFormat %s))
            Hostname = $env:COMPUTERNAME
            Domain = if ($env:USERDNSDOMAIN) { $env:USERDNSDOMAIN } else { "WORKGROUP" }
            Username = $env:USERNAME
            OSVersion = [System.Environment]::OSVersion.VersionString
            PSVersion = $PSVersionTable.PSVersion.ToString()
            CollectionDuration = 0
            ModulesCollected = @($modulesToProcess)
            
            # Overall scores and levels
            OverallSecurityScore = 100
            RiskLevel = "Low"
            ComplianceScore = 0
            ThreatLevel = "Minimal"
            HealthStatus = "Healthy"
            ScoreConfidence = "Full"
            DataCompleteness = $null
            FailedCollectors = @()
            
            # Findings aggregation
            Findings = @{
                Total = 0
                Critical = 0
                High = 0
                Medium = 0
                Low = 0
                Informational = 0
                ByCategory = @{
                    Security = 0
                    Compliance = 0
                    Threats = 0
                    Vulnerabilities = 0
                    Configuration = 0
                }
                BySeverity = @()
                RecentFindings = @()
            }
            
            # Recommendations
            Recommendations = @{
                Critical = @()
                High = @()
                Medium = @()
                Low = @()
                Total = 0
            }
            
            # Core Module Metrics
            Core = @{
                Enabled = $false
                SystemHealth = "Unknown"
                IntegrityStatus = "Unknown"
                BaselineCompliance = 0
                LastAssessmentDate = $null
                PendingUpdates = 0
                UptimeDays = 0
            }
            
            # Detection Module Metrics
            Detection = @{
                Enabled = $false
                TotalThreats = 0
                ActiveThreats = 0
                PersistenceMechanisms = 0
                SuspiciousProcesses = 0
                SuspiciousAuthentications = 0
                LateralMovement = 0
                NetworkAnomalies = 0
                APTIndicators = 0
                LivingOffLand = 0
                DataExfiltration = 0
                LastScanDate = $null
            }
            
            # Analysis Module Metrics
            Analysis = @{
                Enabled = $false
                TotalEvents = 0
                CriticalEvents = 0
                ErrorEvents = 0
                WarningEvents = 0
                SecurityMisconfigurations = 0
                ExposedServices = 0
                RegistryIssues = 0
                FileSystemIssues = 0
                MemoryIssues = 0
            }
            
            # Compliance Module Metrics
            Compliance = @{
                Enabled = $false
                Frameworks = @{
                    CIS = @{
                        Score = $null
                        TotalControls = 0
                        PassedControls = 0
                        FailedControls = 0
                    }
                    NIST = @{
                        Score = $null
                        TotalControls = 0
                        CompliantControls = 0
                        NonCompliantControls = 0
                    }
                    PCIDSS = @{
                        Score = $null
                        TotalRequirements = 0
                        InPlace = 0
                        NotInPlace = 0
                    }
                }
                OverallScore = 0
                TotalControls = 0
                PassedControls = 0
                FailedControls = 0
                LastAuditDate = $null
            }
            
            # Active Directory Module Metrics
            ActiveDirectory = @{
                Enabled = $false
                DomainName = $null
                PrivilegedAccounts = 0
                Vulnerabilities = 0
                StaleObjects = 0
                Backdoors = 0
                PasswordPolicyScore = 0
                LastADScanDate = $null
            }
            
            # Cloud Security Module Metrics
            Cloud = @{
                Enabled = $false
                ConnectedTenant = $null
                RiskySignIns = 0
                ConditionalAccessPolicies = 0
                M365SecurityScore = 0
                AzureSecurityScore = 0
                LastCloudScanDate = $null
            }
            
            # Vulnerability Module Metrics
            Vulnerability = @{
                Enabled = $false
                Total = 0
                Critical = 0
                High = 0
                Medium = 0
                Low = 0
                EOLSoftware = 0
                OutdatedSoftware = 0
                CertificateIssues = 0
                ExpiredCertificates = 0
                WeakCertificates = 0
                LastVulnScanDate = $null
            }
            
            # Threat Hunting Module Metrics
            ThreatHunting = @{
                Enabled = $false
                IOCMatches = 0
                MITRETechniques = 0
                ThreatIntelSources = 0
                LastHuntDate = $null
            }
            
            # Forensics Module Metrics
            Forensics = @{
                Enabled = $false
                ArtifactsCollected = 0
                ExecutionArtifacts = 0
                USBDevices = 0
                RecentExecutions = 0
                LastForensicScanDate = $null
            }
            
            # Windows Defender Module Metrics
            WindowsDefender = @{
                Enabled = $false
                Status = "Unknown"
                ProtectionEnabled = $false
                RealTimeProtection = $false
                CloudProtection = $false
                SignatureAge = 999
                SignatureVersion = "Unknown"
                LastScanDays = 999
                LastQuickScan = $null
                LastFullScan = $null
                ThreatsDetected = 0
            }
            
            # Hardening Module Metrics
            Hardening = @{
                Enabled = $false
                AuditPoliciesEnabled = $false
                PowerShellSecurityEnabled = $false
                BaselineApplied = $false
                HardeningScore = 0
                LastHardeningDate = $null
            }
            
            # Enterprise Module Metrics
            Enterprise = @{
                Enabled = $false
                MultiSystemsScanned = 0
                EnterprisePoliciesApplied = 0
                CentralizedLogging = $false
                LastEnterpriseScanDate = $null
            }
            
            # Response Module Metrics
            Response = @{
                Enabled = $false
                ActiveIncidents = 0
                ResolvedIncidents = 0
                AverageResponseTime = 0
                LastIncidentDate = $null
            }
            
            # Performance Metrics
            Performance = @{
                CollectionTime = 0
                ModuleTimes = @{}
                FunctionCalls = 0
                FailedFunctions = 0
                SuccessRate = 100
            }
            
            # Trend Analysis (if enabled)
            Trends = @{
                Enabled = $CalculateTrends
                SecurityScoreChange = 0
                SecurityScoreTrend = "Stable"
                ThreatCountChange = 0
                ThreatTrend = "Stable"
                ComplianceScoreChange = 0
                ComplianceTrend = "Stable"
                FindingsChange = 0
                FindingsTrend = "Stable"
                WeekOverWeek = @{}
                MonthOverMonth = @{}
            }
            
            # Baseline Comparison (if enabled)
            Baseline = @{
                ComparisonEnabled = $CompareWithBaseline
                BaselineDate = $null
                SecurityScoreDelta = 0
                ThreatCountDelta = 0
                ComplianceScoreDelta = 0
                NewFindings = 0
                ResolvedFindings = 0
                ImprovedAreas = @()
                DeclinedAreas = @()
            }
        }
    }
    
    process {
        try {
            Write-Host "`n[COLLECTING MODULE METRICS]" -ForegroundColor Cyan
            
            $totalFunctions = 0
            $successfulFunctions = 0
            $failedFunctions = 0
            $failedCollectors = @()
            $attemptedDetectionCollectors = 0
            $failedDetectionCollectors = 0
            
            # ============================================
            # CORE MODULE (4 functions)
            # ============================================
            if ($modulesToProcess -contains 'Core') {
                Write-Host "`n[Core Module Metrics]" -ForegroundColor Cyan
                $coreStart = Get-Date
                $script:metrics.Core.Enabled = $true
                
                # Get-SecurityBaseline
                try {
                    $totalFunctions++
                    $baseline = Get-SecurityBaseline -ErrorAction Stop
                    if ($baseline) {
                        # Safe property access
                        if ($baseline.PSObject.Properties['SecurityScore']) {
                            $script:metrics.Core.BaselineCompliance = $baseline.SecurityScore
                        }
                        elseif ($baseline.PSObject.Properties['CompliancePercentage']) {
                            $script:metrics.Core.BaselineCompliance = $baseline.CompliancePercentage
                        }
                        elseif ($baseline.PSObject.Properties['ComplianceScore']) {
                            $script:metrics.Core.BaselineCompliance = $baseline.ComplianceScore
                        }
                        elseif ($baseline.PSObject.Properties['Score']) {
                            $script:metrics.Core.BaselineCompliance = $baseline.Score
                        }
                        $successfulFunctions++
                        Write-Host "  Baseline Compliance: $($script:metrics.Core.BaselineCompliance)%" -ForegroundColor Green
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-SecurityBaseline: $_"
                    $failedCollectors += 'Get-SecurityBaseline'
                }
                
                # Get-SystemInfo
                try {
                    $totalFunctions++
                    $sysInfo = Get-SystemInfo -ErrorAction Stop
                    if ($sysInfo) {
                        $script:metrics.Core.SystemHealth = "Healthy"
                        
                        # Extract uptime if available
                        if ($sysInfo.PSObject.Properties['OperatingSystem'] -and $sysInfo.OperatingSystem -and 
                            $sysInfo.OperatingSystem.PSObject.Properties['LastBootUpTime'] -and $sysInfo.OperatingSystem.LastBootUpTime) {
                            $script:metrics.Core.UptimeDays = [Math]::Round(((Get-Date) - [datetime]$sysInfo.OperatingSystem.LastBootUpTime).TotalDays, 1)
                        }
                        
                        $successfulFunctions++
                        Write-Host "  System Info: Collected (Uptime: $($script:metrics.Core.UptimeDays)d)" -ForegroundColor Green
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-SystemInfo: $_"
                    $failedCollectors += 'Get-SystemInfo'
                }
                
                # Test-SystemIntegrity
                try {
                    $totalFunctions++
                    $integrity = Test-SystemIntegrity -ErrorAction Stop
                    if ($integrity) {
                        # Safe property access
                        if ($integrity.PSObject.Properties['OverallStatus']) {
                            $script:metrics.Core.IntegrityStatus = $integrity.OverallStatus
                        }
                        elseif ($integrity.PSObject.Properties['Status']) {
                            $script:metrics.Core.IntegrityStatus = $integrity.Status
                        }
                        elseif ($integrity.PSObject.Properties['IntegrityStatus']) {
                            $script:metrics.Core.IntegrityStatus = $integrity.IntegrityStatus
                        }
                        elseif ($integrity.PSObject.Properties['SFCResult'] -and $integrity.SFCResult) {
                            $script:metrics.Core.IntegrityStatus = $integrity.SFCResult
                        }
                        
                        # Extract pending updates
                        if ($integrity.PSObject.Properties['PendingUpdates']) {
                            $script:metrics.Core.PendingUpdates = $integrity.PendingUpdates
                        }
                        
                        $successfulFunctions++
                        Write-Host "  Integrity Status: $($script:metrics.Core.IntegrityStatus)" -ForegroundColor Green
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Test-SystemIntegrity: $_"
                    $failedCollectors += 'Test-SystemIntegrity'
                }
                
                # Invoke-SecurityAssessment
                try {
                    $totalFunctions++
                    $assessment = Invoke-SecurityAssessment -ErrorAction Stop
                    if ($assessment) {
                        $script:metrics.Core.LastAssessmentDate = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
                        
                        # Extract findings if available
                        if ($assessment.PSObject.Properties['Findings']) {
                            $findings = @($assessment.Findings)
                            $script:metrics.Findings.ByCategory.Security += $findings.Count
                        }
                        
                        $successfulFunctions++
                        Write-Host "  Security Assessment: Complete" -ForegroundColor Green
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Invoke-SecurityAssessment: $_"
                    $failedCollectors += 'Invoke-SecurityAssessment'
                }
                
                $script:metrics.Performance.ModuleTimes['Core'] = [Math]::Round(((Get-Date) - $coreStart).TotalSeconds, 2)
            }
            
            # ============================================
            # DETECTION MODULE (8 functions)
            # ============================================
            if ($modulesToProcess -contains 'Detection') {
                Write-Host "`n[Detection Module Metrics]" -ForegroundColor Cyan
                $detStart = Get-Date
                $script:metrics.Detection.Enabled = $true
                
                # Find-PersistenceMechanisms
                try {
                    $totalFunctions++
                    $attemptedDetectionCollectors++
                    $persistence = Find-PersistenceMechanisms -ErrorAction Stop
                    if ($persistence -and $persistence.PSObject.Properties['SuspiciousCount']) {
                        $script:metrics.Detection.PersistenceMechanisms = $persistence.SuspiciousCount
                    } else {
                        $script:metrics.Detection.PersistenceMechanisms = @($persistence).Count
                    }
                    $successfulFunctions++
                    Write-Host "  Persistence Mechanisms: $($script:metrics.Detection.PersistenceMechanisms)" -ForegroundColor $(if ($script:metrics.Detection.PersistenceMechanisms -gt 0) { 'Yellow' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    $failedDetectionCollectors++
                    Write-Verbose "  Find-PersistenceMechanisms: $_"
                    $failedCollectors += 'Find-PersistenceMechanisms'
                }
                
                # Find-SuspiciousProcesses
                try {
                    $totalFunctions++
                    $attemptedDetectionCollectors++
                    $processes = Find-SuspiciousProcesses -ErrorAction Stop
                    $script:metrics.Detection.SuspiciousProcesses = @($processes).Count
                    $successfulFunctions++
                    Write-Host "  Suspicious Processes: $($script:metrics.Detection.SuspiciousProcesses)" -ForegroundColor $(if ($script:metrics.Detection.SuspiciousProcesses -gt 0) { 'Yellow' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    $failedDetectionCollectors++
                    Write-Verbose "  Find-SuspiciousProcesses: $_"
                    $failedCollectors += 'Find-SuspiciousProcesses'
                }
                
                # Find-SuspiciousAuthentication
                try {
                    $totalFunctions++
                    $attemptedDetectionCollectors++
                    $auth = Find-SuspiciousAuthentication -ErrorAction Stop
                    if ($auth -and $auth.PSObject.Properties['Statistics'] -and $auth.Statistics) {
                        $script:metrics.Detection.SuspiciousAuthentications = 
                            $auth.Statistics.TotalFailedLogons + $auth.Statistics.TotalLockouts +
                            $auth.Statistics.TotalPrivilegeUse + $auth.Statistics.TotalExplicitCreds
                    } else {
                        $script:metrics.Detection.SuspiciousAuthentications = @($auth).Count
                    }
                    $successfulFunctions++
                    Write-Host "  Suspicious Authentications: $($script:metrics.Detection.SuspiciousAuthentications)" -ForegroundColor $(if ($script:metrics.Detection.SuspiciousAuthentications -gt 0) { 'Yellow' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    $failedDetectionCollectors++
                    Write-Verbose "  Find-SuspiciousAuthentication: $_"
                    $failedCollectors += 'Find-SuspiciousAuthentication'
                }
                
                # Find-LateralMovement
                try {
                    $totalFunctions++
                    $attemptedDetectionCollectors++
                    $lateral = Find-LateralMovement -ErrorAction Stop
                    if ($lateral -and $lateral.PSObject.Properties['Summary'] -and $lateral.Summary) {
                        $script:metrics.Detection.LateralMovement = $lateral.Summary.TotalIndicators
                    } else {
                        $script:metrics.Detection.LateralMovement = @($lateral).Count
                    }
                    $successfulFunctions++
                    Write-Host "  Lateral Movement: $($script:metrics.Detection.LateralMovement)" -ForegroundColor $(if ($script:metrics.Detection.LateralMovement -gt 0) { 'Red' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    $failedDetectionCollectors++
                    Write-Verbose "  Find-LateralMovement: $_"
                    $failedCollectors += 'Find-LateralMovement'
                }
                
                # Find-APTIndicators
                try {
                    $totalFunctions++
                    $attemptedDetectionCollectors++
                    $apt = Find-APTIndicators -ErrorAction Stop
                    if ($apt -and $apt.PSObject.Properties['Summary'] -and $apt.Summary) {
                        $script:metrics.Detection.APTIndicators = $apt.Summary.TotalIndicators
                    } else {
                        $script:metrics.Detection.APTIndicators = @($apt).Count
                    }
                    $successfulFunctions++
                    Write-Host "  APT Indicators: $($script:metrics.Detection.APTIndicators)" -ForegroundColor $(if ($script:metrics.Detection.APTIndicators -gt 0) { 'Red' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    $failedDetectionCollectors++
                    Write-Verbose "  Find-APTIndicators: $_"
                    $failedCollectors += 'Find-APTIndicators'
                }
                
                # Find-LivingOffLand
                try {
                    $totalFunctions++
                    $attemptedDetectionCollectors++
                    $lolbins = Find-LivingOffLand -ErrorAction Stop
                    if ($lolbins -and $lolbins.PSObject.Properties['Summary'] -and $lolbins.Summary) {
                        $script:metrics.Detection.LivingOffLand = $lolbins.Summary.TotalDetections
                    } else {
                        $script:metrics.Detection.LivingOffLand = @($lolbins).Count
                    }
                    $successfulFunctions++
                    Write-Host "  Living Off Land: $($script:metrics.Detection.LivingOffLand)" -ForegroundColor $(if ($script:metrics.Detection.LivingOffLand -gt 0) { 'Yellow' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    $failedDetectionCollectors++
                    Write-Verbose "  Find-LivingOffLand: $_"
                    $failedCollectors += 'Find-LivingOffLand'
                }
                
                # Find-DataExfiltration
                try {
                    $totalFunctions++
                    $attemptedDetectionCollectors++
                    $exfil = Find-DataExfiltration -ErrorAction Stop
                    if ($exfil -and $exfil.PSObject.Properties['Summary'] -and $exfil.Summary) {
                        $script:metrics.Detection.DataExfiltration = $exfil.Summary.TotalIndicators
                    } else {
                        $script:metrics.Detection.DataExfiltration = @($exfil).Count
                    }
                    $successfulFunctions++
                    Write-Host "  Data Exfiltration: $($script:metrics.Detection.DataExfiltration)" -ForegroundColor $(if ($script:metrics.Detection.DataExfiltration -gt 0) { 'Red' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    $failedDetectionCollectors++
                    Write-Verbose "  Find-DataExfiltration: $_"
                    $failedCollectors += 'Find-DataExfiltration'
                }
                
                # Find-NetworkAnomalies
                try {
                    $totalFunctions++
                    $attemptedDetectionCollectors++
                    $network = Find-NetworkAnomalies -ErrorAction Stop
                    if ($network -and $network.PSObject.Properties['TotalAnomalies']) {
                        $script:metrics.Detection.NetworkAnomalies = $network.TotalAnomalies
                    } else {
                        $script:metrics.Detection.NetworkAnomalies = @($network).Count
                    }
                    $successfulFunctions++
                    Write-Host "  Network Anomalies: $($script:metrics.Detection.NetworkAnomalies)" -ForegroundColor $(if ($script:metrics.Detection.NetworkAnomalies -gt 0) { 'Yellow' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    $failedDetectionCollectors++
                    Write-Verbose "  Find-NetworkAnomalies: $_"
                    $failedCollectors += 'Find-NetworkAnomalies'
                }
                
                # Calculate total threats
                $script:metrics.Detection.TotalThreats = 
                    $script:metrics.Detection.PersistenceMechanisms +
                    $script:metrics.Detection.SuspiciousProcesses +
                    $script:metrics.Detection.SuspiciousAuthentications +
                    $script:metrics.Detection.LateralMovement +
                    $script:metrics.Detection.APTIndicators +
                    $script:metrics.Detection.LivingOffLand +
                    $script:metrics.Detection.DataExfiltration +
                    $script:metrics.Detection.NetworkAnomalies
                
                $script:metrics.Detection.ActiveThreats = $script:metrics.Detection.TotalThreats
                $script:metrics.Detection.LastScanDate = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
                
                Write-Host "  TOTAL THREATS: $($script:metrics.Detection.TotalThreats)" -ForegroundColor $(
                    if ($script:metrics.Detection.TotalThreats -gt 20) { 'Red' }
                    elseif ($script:metrics.Detection.TotalThreats -gt 10) { 'Yellow' }
                    else { 'Green' }
                )
                
                $script:metrics.Performance.ModuleTimes['Detection'] = [Math]::Round(((Get-Date) - $detStart).TotalSeconds, 2)
            }
            
            # ============================================
            # ANALYSIS MODULE (6 functions)
            # ============================================
            if ($modulesToProcess -contains 'Analysis') {
                Write-Host "`n[Analysis Module Metrics]" -ForegroundColor Cyan
                $analStart = Get-Date
                $script:metrics.Analysis.Enabled = $true
                
                # Get-EventLogAnalysis
                try {
                    $totalFunctions++
                    $eventLog = Get-EventLogAnalysis -ErrorAction Stop
                    if ($eventLog) {
                        if ($eventLog.PSObject.Properties['TotalEvents']) {
                            $script:metrics.Analysis.TotalEvents = $eventLog.TotalEvents
                        } elseif ($eventLog.PSObject.Properties['Statistics'] -and $eventLog.Statistics) {
                            $script:metrics.Analysis.TotalEvents = $eventLog.Statistics.TotalEventsAnalyzed
                        }
                        if ($eventLog.PSObject.Properties['CriticalEvents']) {
                            $script:metrics.Analysis.CriticalEvents = $eventLog.CriticalEvents
                        } elseif ($eventLog.PSObject.Properties['Statistics'] -and $eventLog.Statistics) {
                            $script:metrics.Analysis.CriticalEvents = $eventLog.Statistics.CriticalEvents
                        }
                        if ($eventLog.PSObject.Properties['ErrorEvents']) {
                            $script:metrics.Analysis.ErrorEvents = $eventLog.ErrorEvents
                        } elseif ($eventLog.PSObject.Properties['Statistics'] -and $eventLog.Statistics) {
                            $script:metrics.Analysis.ErrorEvents = $eventLog.Statistics.ErrorEvents
                        }
                        if ($eventLog.PSObject.Properties['WarningEvents']) {
                            $script:metrics.Analysis.WarningEvents = $eventLog.WarningEvents
                        } elseif ($eventLog.PSObject.Properties['Statistics'] -and $eventLog.Statistics) {
                            $script:metrics.Analysis.WarningEvents = $eventLog.Statistics.WarningEvents
                        }
                        $successfulFunctions++
                        Write-Host "  Event Log Analysis: $($script:metrics.Analysis.TotalEvents) events ($($script:metrics.Analysis.CriticalEvents) critical)" -ForegroundColor $(if ($script:metrics.Analysis.CriticalEvents -gt 0) { 'Red' } else { 'Green' })
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-EventLogAnalysis: $_"
                    $failedCollectors += 'Get-EventLogAnalysis'
                }
                
                # Get-RegistryAnalysis
                try {
                    $totalFunctions++
                    $registry = Get-RegistryAnalysis -ErrorAction Stop
                    if ($registry) {
                        if ($registry.PSObject.Properties['Statistics'] -and $registry.Statistics) {
                            $script:metrics.Analysis.RegistryIssues = $registry.Statistics.SuspiciousFindings
                        } else {
                            $script:metrics.Analysis.RegistryIssues = @($registry).Count
                        }
                        $successfulFunctions++
                        Write-Host "  Registry Analysis: $($script:metrics.Analysis.RegistryIssues) issues" -ForegroundColor $(if ($script:metrics.Analysis.RegistryIssues -gt 0) { 'Yellow' } else { 'Green' })
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-RegistryAnalysis: $_"
                    $failedCollectors += 'Get-RegistryAnalysis'
                }
                
                # Get-FileSystemAnalysis
                try {
                    $totalFunctions++
                    $fileSystem = Get-FileSystemAnalysis -ErrorAction Stop
                    if ($fileSystem) {
                        if ($fileSystem.PSObject.Properties['Statistics'] -and $fileSystem.Statistics) {
                            $script:metrics.Analysis.FileSystemIssues = $fileSystem.Statistics.SuspiciousFiles
                        } elseif ($fileSystem.PSObject.Properties['SuspiciousFiles']) {
                            $script:metrics.Analysis.FileSystemIssues = @($fileSystem.SuspiciousFiles).Count
                        } else {
                            $script:metrics.Analysis.FileSystemIssues = @($fileSystem).Count
                        }
                        $successfulFunctions++
                        Write-Host "  File System Analysis: $($script:metrics.Analysis.FileSystemIssues) suspicious files" -ForegroundColor $(if ($script:metrics.Analysis.FileSystemIssues -gt 100) { 'Yellow' } else { 'Green' })
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-FileSystemAnalysis: $_"
                    $failedCollectors += 'Get-FileSystemAnalysis'
                }
                
                # Get-MemoryAnalysis
                try {
                    $totalFunctions++
                    $memory = Get-MemoryAnalysis -ErrorAction Stop
                    if ($memory) {
                        if ($memory.PSObject.Properties['Statistics'] -and $memory.Statistics) {
                            $script:metrics.Analysis.MemoryIssues = $memory.Statistics.InjectionIndicators
                        } elseif ($memory.PSObject.Properties['InjectionIndicators']) {
                            $script:metrics.Analysis.MemoryIssues = @($memory.InjectionIndicators).Count
                        }
                        $successfulFunctions++
                        Write-Host "  Memory Analysis: $($script:metrics.Analysis.MemoryIssues) issues" -ForegroundColor $(if ($script:metrics.Analysis.MemoryIssues -gt 0) { 'Red' } else { 'Green' })
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-MemoryAnalysis: $_"
                    $failedCollectors += 'Get-MemoryAnalysis'
                }
                
                # Get-ExposedServices
                try {
                    $totalFunctions++
                    $exposed = Get-ExposedServices -ErrorAction Stop
                    if ($exposed) {
                        if ($exposed.PSObject.Properties['ExposedServices']) {
                            $script:metrics.Analysis.ExposedServices = @($exposed.ExposedServices).Count
                        } else {
                            $script:metrics.Analysis.ExposedServices = @($exposed).Count
                        }
                        $successfulFunctions++
                        Write-Host "  Exposed Services: $($script:metrics.Analysis.ExposedServices)" -ForegroundColor $(if ($script:metrics.Analysis.ExposedServices -gt 0) { 'Yellow' } else { 'Green' })
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-ExposedServices: $_"
                    $failedCollectors += 'Get-ExposedServices'
                }
                
                # Get-SecurityMisconfigurations
                try {
                    $totalFunctions++
                    $misconfig = Get-SecurityMisconfigurations -ErrorAction Stop
                    $script:metrics.Analysis.SecurityMisconfigurations = @($misconfig).Count
                    $successfulFunctions++
                    Write-Host "  Misconfigurations: $($script:metrics.Analysis.SecurityMisconfigurations)" -ForegroundColor $(if ($script:metrics.Analysis.SecurityMisconfigurations -gt 0) { 'Yellow' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-SecurityMisconfigurations: $_"
                    $failedCollectors += 'Get-SecurityMisconfigurations'
                }
                
                $script:metrics.Performance.ModuleTimes['Analysis'] = [Math]::Round(((Get-Date) - $analStart).TotalSeconds, 2)
            }
            
            # ============================================
            # COMPLIANCE MODULE (5 functions)
            # ============================================
            if ($modulesToProcess -contains 'Compliance') {
                Write-Host "`n[Compliance Module Metrics]" -ForegroundColor Cyan
                $compStart = Get-Date
                $script:metrics.Compliance.Enabled = $true
                
                # Test-CISBenchmark
                try {
                    $totalFunctions++
                    $cis = Test-CISBenchmark -ErrorAction Stop
                    if ($cis) {
                        # Score
                        if ($cis.PSObject.Properties['ComplianceScore']) {
                            $script:metrics.Compliance.Frameworks.CIS.Score = $cis.ComplianceScore
                        } elseif ($cis.PSObject.Properties['CompliancePercentage']) {
                            $script:metrics.Compliance.Frameworks.CIS.Score = $cis.CompliancePercentage
                        } elseif ($cis.PSObject.Properties['Compliance']) {
                            $script:metrics.Compliance.Frameworks.CIS.Score = $cis.Compliance
                        } elseif ($cis.PSObject.Properties['Summary'] -and $cis.Summary) {
                            $script:metrics.Compliance.Frameworks.CIS.Score = $cis.Summary.CompliancePercentage
                        }
                        
                        # Controls
                        if ($cis.PSObject.Properties['TotalControls']) {
                            $script:metrics.Compliance.Frameworks.CIS.TotalControls = $cis.TotalControls
                        } elseif ($cis.PSObject.Properties['Summary'] -and $cis.Summary) {
                            $script:metrics.Compliance.Frameworks.CIS.TotalControls = $cis.Summary.TotalControls
                        }
                        if ($cis.PSObject.Properties['PassedControls']) {
                            $script:metrics.Compliance.Frameworks.CIS.PassedControls = $cis.PassedControls
                        } elseif ($cis.PSObject.Properties['Passed']) {
                            $script:metrics.Compliance.Frameworks.CIS.PassedControls = $cis.Passed
                        } elseif ($cis.PSObject.Properties['Summary'] -and $cis.Summary) {
                            $script:metrics.Compliance.Frameworks.CIS.PassedControls = $cis.Summary.Passed
                        }
                        if ($cis.PSObject.Properties['FailedControls']) {
                            $script:metrics.Compliance.Frameworks.CIS.FailedControls = $cis.FailedControls
                        } elseif ($cis.PSObject.Properties['Failed']) {
                            $script:metrics.Compliance.Frameworks.CIS.FailedControls = $cis.Failed
                        } elseif ($cis.PSObject.Properties['Summary'] -and $cis.Summary) {
                            $script:metrics.Compliance.Frameworks.CIS.FailedControls = $cis.Summary.Failed
                        }
                        
                        $successfulFunctions++
                        Write-Host "  CIS Benchmark: $($script:metrics.Compliance.Frameworks.CIS.Score)%" -ForegroundColor $(if ($script:metrics.Compliance.Frameworks.CIS.Score -ge 80) { 'Green' } elseif ($script:metrics.Compliance.Frameworks.CIS.Score -ge 60) { 'Yellow' } else { 'Red' })
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Test-CISBenchmark: $_"
                    $failedCollectors += 'Test-CISBenchmark'
                }
                
                # Test-NISTCompliance
                try {
                    $totalFunctions++
                    $nist = Test-NISTCompliance -ErrorAction Stop
                    if ($nist) {
                        # Score
                        if ($nist.PSObject.Properties['ComplianceScore']) {
                            $script:metrics.Compliance.Frameworks.NIST.Score = $nist.ComplianceScore
                        } elseif ($nist.PSObject.Properties['CompliancePercentage']) {
                            $script:metrics.Compliance.Frameworks.NIST.Score = $nist.CompliancePercentage
                        } elseif ($nist.PSObject.Properties['Compliance']) {
                            $script:metrics.Compliance.Frameworks.NIST.Score = $nist.Compliance
                        } elseif ($nist.PSObject.Properties['Summary'] -and $nist.Summary) {
                            $script:metrics.Compliance.Frameworks.NIST.Score = $nist.Summary.CompliancePercentage
                        }
                        
                        # Controls
                        if ($nist.PSObject.Properties['TotalControls']) {
                            $script:metrics.Compliance.Frameworks.NIST.TotalControls = $nist.TotalControls
                        } elseif ($nist.PSObject.Properties['Summary'] -and $nist.Summary) {
                            $script:metrics.Compliance.Frameworks.NIST.TotalControls = $nist.Summary.TotalControls
                        }
                        if ($nist.PSObject.Properties['CompliantControls']) {
                            $script:metrics.Compliance.Frameworks.NIST.CompliantControls = $nist.CompliantControls
                        } elseif ($nist.PSObject.Properties['Compliant']) {
                            $script:metrics.Compliance.Frameworks.NIST.CompliantControls = $nist.Compliant
                        } elseif ($nist.PSObject.Properties['Summary'] -and $nist.Summary) {
                            $script:metrics.Compliance.Frameworks.NIST.CompliantControls = $nist.Summary.Compliant
                        }
                        if ($nist.PSObject.Properties['NonCompliantControls']) {
                            $script:metrics.Compliance.Frameworks.NIST.NonCompliantControls = $nist.NonCompliantControls
                        } elseif ($nist.PSObject.Properties['NonCompliant']) {
                            $script:metrics.Compliance.Frameworks.NIST.NonCompliantControls = $nist.NonCompliant
                        } elseif ($nist.PSObject.Properties['Summary'] -and $nist.Summary) {
                            $script:metrics.Compliance.Frameworks.NIST.NonCompliantControls = $nist.Summary.NonCompliant
                        }
                        
                        $successfulFunctions++
                        Write-Host "  NIST 800-53: $($script:metrics.Compliance.Frameworks.NIST.Score)%" -ForegroundColor $(if ($script:metrics.Compliance.Frameworks.NIST.Score -ge 80) { 'Green' } elseif ($script:metrics.Compliance.Frameworks.NIST.Score -ge 60) { 'Yellow' } else { 'Red' })
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Test-NISTCompliance: $_"
                    $failedCollectors += 'Test-NISTCompliance'
                }
                
                # Test-PciDssCompliance
                try {
                    $totalFunctions++
                    $pci = Test-PciDssCompliance -ErrorAction Stop
                    if ($pci) {
                        # Score
                        if ($pci.PSObject.Properties['ComplianceScore']) {
                            $script:metrics.Compliance.Frameworks.PCIDSS.Score = $pci.ComplianceScore
                        } elseif ($pci.PSObject.Properties['CompliancePercentage']) {
                            $script:metrics.Compliance.Frameworks.PCIDSS.Score = $pci.CompliancePercentage
                        } elseif ($pci.PSObject.Properties['Compliance']) {
                            $script:metrics.Compliance.Frameworks.PCIDSS.Score = $pci.Compliance
                        } elseif ($pci.PSObject.Properties['Summary'] -and $pci.Summary) {
                            $script:metrics.Compliance.Frameworks.PCIDSS.Score = $pci.Summary.CompliancePercentage
                        }
                        
                        # Requirements
                        if ($pci.PSObject.Properties['TotalRequirements']) {
                            $script:metrics.Compliance.Frameworks.PCIDSS.TotalRequirements = $pci.TotalRequirements
                        } elseif ($pci.PSObject.Properties['Summary'] -and $pci.Summary) {
                            $script:metrics.Compliance.Frameworks.PCIDSS.TotalRequirements = $pci.Summary.TotalRequirements
                        }
                        if ($pci.PSObject.Properties['InPlace']) {
                            $script:metrics.Compliance.Frameworks.PCIDSS.InPlace = $pci.InPlace
                        } elseif ($pci.PSObject.Properties['Summary'] -and $pci.Summary) {
                            $script:metrics.Compliance.Frameworks.PCIDSS.InPlace = $pci.Summary.InPlace
                        }
                        if ($pci.PSObject.Properties['NotInPlace']) {
                            $script:metrics.Compliance.Frameworks.PCIDSS.NotInPlace = $pci.NotInPlace
                        } elseif ($pci.PSObject.Properties['Summary'] -and $pci.Summary) {
                            $script:metrics.Compliance.Frameworks.PCIDSS.NotInPlace = $pci.Summary.NotInPlace
                        }
                        
                        $successfulFunctions++
                        Write-Host "  PCI-DSS: $($script:metrics.Compliance.Frameworks.PCIDSS.Score)%" -ForegroundColor $(if ($script:metrics.Compliance.Frameworks.PCIDSS.Score -ge 80) { 'Green' } elseif ($script:metrics.Compliance.Frameworks.PCIDSS.Score -ge 60) { 'Yellow' } else { 'Red' })
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Test-PciDssCompliance: $_"
                    $failedCollectors += 'Test-PciDssCompliance'
                }
                
                # Get-ComplianceReport
                try {
                    $totalFunctions++
                    $compReport = Get-ComplianceReport -ErrorAction Stop
                    $successfulFunctions++
                    Write-Host "  Compliance Report: Generated" -ForegroundColor Green
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-ComplianceReport: $_"
                    $failedCollectors += 'Get-ComplianceReport'
                }
                
                # Test-PatchCompliance
                try {
                    $totalFunctions++
                    $patches = Test-PatchCompliance -ErrorAction Stop
                    if ($patches) {
                        if ($patches.PSObject.Properties['MissingUpdates']) {
                            $script:metrics.Core.PendingUpdates = @($patches.MissingUpdates).Count
                        }
                    }
                    $successfulFunctions++
                    Write-Host "  Patch Compliance: OK ($($script:metrics.Core.PendingUpdates) pending)" -ForegroundColor $(if ($script:metrics.Core.PendingUpdates -gt 0) { 'Yellow' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Test-PatchCompliance: $_"
                    $failedCollectors += 'Test-PatchCompliance'
                }
                
                # Calculate overall compliance - NULL SAFE with @() cast
                # A genuinely collected 0% score is included in the average (same
                # convention as New-SecurityDashboard); a failed collector leaves a
                # $null score and is excluded
                $compScores = @(
                    $script:metrics.Compliance.Frameworks.CIS.Score, 
                    $script:metrics.Compliance.Frameworks.NIST.Score, 
                    $script:metrics.Compliance.Frameworks.PCIDSS.Score
                ) | Where-Object { $null -ne $_ }
                
                if (@($compScores).Count -gt 0) {
                    $script:metrics.Compliance.OverallScore = [Math]::Round(($compScores | Measure-Object -Average).Average, 1)
                    $script:metrics.ComplianceScore = $script:metrics.Compliance.OverallScore
                    Write-Host "  Overall Compliance: $($script:metrics.ComplianceScore)%" -ForegroundColor Cyan
                } else {
                    $script:metrics.Compliance.OverallScore = 0
                    $script:metrics.ComplianceScore = 0
                }
                
                # Calculate total controls
                $script:metrics.Compliance.TotalControls = 
                    $script:metrics.Compliance.Frameworks.CIS.TotalControls +
                    $script:metrics.Compliance.Frameworks.NIST.TotalControls +
                    $script:metrics.Compliance.Frameworks.PCIDSS.TotalRequirements
                
                $script:metrics.Compliance.PassedControls = 
                    $script:metrics.Compliance.Frameworks.CIS.PassedControls +
                    $script:metrics.Compliance.Frameworks.NIST.CompliantControls +
                    $script:metrics.Compliance.Frameworks.PCIDSS.InPlace
                
                $script:metrics.Compliance.FailedControls = 
                    $script:metrics.Compliance.Frameworks.CIS.FailedControls +
                    $script:metrics.Compliance.Frameworks.NIST.NonCompliantControls +
                    $script:metrics.Compliance.Frameworks.PCIDSS.NotInPlace
                
                $script:metrics.Compliance.LastAuditDate = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
                
                $script:metrics.Performance.ModuleTimes['Compliance'] = [Math]::Round(((Get-Date) - $compStart).TotalSeconds, 2)
            }
            
            # ============================================
            # ACTIVE DIRECTORY MODULE (6 functions)
            # ============================================
            if ($modulesToProcess -contains 'ActiveDirectory') {
                Write-Host "`n[Active Directory Module Metrics]" -ForegroundColor Cyan
                $adStart = Get-Date
                
                if ($env:USERDNSDOMAIN) {
                    $script:metrics.ActiveDirectory.Enabled = $true
                    $script:metrics.ActiveDirectory.DomainName = $env:USERDNSDOMAIN
                    
                    # Get-ADPrivilegedAccounts
                    try {
                        $totalFunctions++
                        $privAccounts = Get-ADPrivilegedAccounts -ErrorAction Stop
                        $script:metrics.ActiveDirectory.PrivilegedAccounts = @($privAccounts).Count
                        $successfulFunctions++
                        Write-Host "  Privileged Accounts: $($script:metrics.ActiveDirectory.PrivilegedAccounts)" -ForegroundColor Yellow
                    } catch { 
                        $failedFunctions++
                        Write-Verbose "  Get-ADPrivilegedAccounts: $_"
                        $failedCollectors += 'Get-ADPrivilegedAccounts'
                    }
                    
                    # Find-ADVulnerabilities
                    try {
                        $totalFunctions++
                        $adVulns = Find-ADVulnerabilities -ErrorAction Stop
                        $script:metrics.ActiveDirectory.Vulnerabilities = @($adVulns).Count
                        $successfulFunctions++
                        Write-Host "  AD Vulnerabilities: $($script:metrics.ActiveDirectory.Vulnerabilities)" -ForegroundColor $(if ($script:metrics.ActiveDirectory.Vulnerabilities -gt 0) { 'Red' } else { 'Green' })
                    } catch { 
                        $failedFunctions++
                        Write-Verbose "  Find-ADVulnerabilities: $_"
                        $failedCollectors += 'Find-ADVulnerabilities'
                    }
                    
                    # Test-ADSecurityPosture
                    try {
                        $totalFunctions++
                        $adPosture = Test-ADSecurityPosture -ErrorAction Stop
                        $successfulFunctions++
                        Write-Host "  AD Security Posture: Assessed" -ForegroundColor Green
                    } catch { 
                        $failedFunctions++
                        Write-Verbose "  Test-ADSecurityPosture: $_"
                        $failedCollectors += 'Test-ADSecurityPosture'
                    }
                    
                    # Find-ADBackdoors
                    try {
                        $totalFunctions++
                        $backdoors = Find-ADBackdoors -ErrorAction Stop
                        $script:metrics.ActiveDirectory.Backdoors = @($backdoors).Count
                        $successfulFunctions++
                        Write-Host "  AD Backdoors: $($script:metrics.ActiveDirectory.Backdoors)" -ForegroundColor $(if ($script:metrics.ActiveDirectory.Backdoors -gt 0) { 'Red' } else { 'Green' })
                    } catch { 
                        $failedFunctions++
                        Write-Verbose "  Find-ADBackdoors: $_"
                        $failedCollectors += 'Find-ADBackdoors'
                    }
                    
                    # Find-StaleADObjects
                    try {
                        $totalFunctions++
                        $stale = Find-StaleADObjects -ErrorAction Stop
                        $script:metrics.ActiveDirectory.StaleObjects = @($stale).Count
                        $successfulFunctions++
                        Write-Host "  Stale AD Objects: $($script:metrics.ActiveDirectory.StaleObjects)" -ForegroundColor $(if ($script:metrics.ActiveDirectory.StaleObjects -gt 10) { 'Yellow' } else { 'Green' })
                    } catch { 
                        $failedFunctions++
                        Write-Verbose "  Find-StaleADObjects: $_"
                        $failedCollectors += 'Find-StaleADObjects'
                    }
                    
                    # Get-ADPasswordPolicy
                    try {
                        $totalFunctions++
                        $pwdPolicy = Get-ADPasswordPolicy -ErrorAction Stop
                        if ($pwdPolicy) {
                            # Calculate password policy score
                            $policyScore = 100
                            $dp = if ($pwdPolicy.PSObject.Properties['DefaultPolicy'] -and $pwdPolicy.DefaultPolicy) { $pwdPolicy.DefaultPolicy } else { $pwdPolicy }
                            if ($dp.PSObject.Properties['MinPasswordLength'] -and $dp.MinPasswordLength -lt 14) { $policyScore -= 20 }
                            if ($dp.PSObject.Properties['ComplexityEnabled'] -and -not $dp.ComplexityEnabled) { $policyScore -= 30 }
                            if ($dp.PSObject.Properties['MaxPasswordAge'] -and $dp.MaxPasswordAge -gt 90) { $policyScore -= 15 }
                            $script:metrics.ActiveDirectory.PasswordPolicyScore = [Math]::Max(0, $policyScore)
                        }
                        $successfulFunctions++
                        Write-Host "  Password Policy Score: $($script:metrics.ActiveDirectory.PasswordPolicyScore)%" -ForegroundColor $(if ($script:metrics.ActiveDirectory.PasswordPolicyScore -ge 80) { 'Green' } elseif ($script:metrics.ActiveDirectory.PasswordPolicyScore -ge 60) { 'Yellow' } else { 'Red' })
                    } catch { 
                        $failedFunctions++
                        Write-Verbose "  Get-ADPasswordPolicy: $_"
                        $failedCollectors += 'Get-ADPasswordPolicy'
                    }
                    
                    $script:metrics.ActiveDirectory.LastADScanDate = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
                } else {
                    Write-Host "  System not domain-joined - skipping AD module" -ForegroundColor Gray
                }
                
                $script:metrics.Performance.ModuleTimes['ActiveDirectory'] = [Math]::Round(((Get-Date) - $adStart).TotalSeconds, 2)
            }
            
            # ============================================
            # CLOUD SECURITY MODULE (3 functions)
            # ============================================
            if ($modulesToProcess -contains 'Cloud') {
                Write-Host "`n[Cloud Security Module Metrics]" -ForegroundColor Cyan
                $cloudStart = Get-Date
                
                $mgContext = $null
                try {
                    $mgContext = Get-MgContext -ErrorAction Stop
                } catch {
                    Write-Verbose "  Get-MgContext unavailable: $_"
                }
                if ($mgContext) {
                    $script:metrics.Cloud.Enabled = $true
                    $script:metrics.Cloud.ConnectedTenant = if ($mgContext.PSObject.Properties['TenantId']) { $mgContext.TenantId } else { "Unknown" }
                    
                    # Get-AzureADRiskySignIns
                    try {
                        $totalFunctions++
                        $riskySignIns = Get-AzureADRiskySignIns -DaysBack 30 -ErrorAction Stop
                        $script:metrics.Cloud.RiskySignIns = @($riskySignIns).Count
                        $successfulFunctions++
                        Write-Host "  Risky Sign-Ins (30d): $($script:metrics.Cloud.RiskySignIns)" -ForegroundColor $(if ($script:metrics.Cloud.RiskySignIns -gt 0) { 'Yellow' } else { 'Green' })
                    } catch { 
                        $failedFunctions++
                        Write-Verbose "  Get-AzureADRiskySignIns: $_"
                        $failedCollectors += 'Get-AzureADRiskySignIns'
                    }
                    
                    # Test-M365SecurityPosture
                    try {
                        $totalFunctions++
                        $m365Security = Test-M365SecurityPosture -ErrorAction Stop
                        if ($m365Security -and $m365Security.PSObject.Properties['ComplianceScore']) {
                            $script:metrics.Cloud.M365SecurityScore = $m365Security.ComplianceScore
                        }
                        $successfulFunctions++
                        Write-Host "  M365 Security Score: $($script:metrics.Cloud.M365SecurityScore)%" -ForegroundColor Cyan
                    } catch { 
                        $failedFunctions++
                        Write-Verbose "  Test-M365SecurityPosture: $_"
                        $failedCollectors += 'Test-M365SecurityPosture'
                    }
                    
                    # Get-CloudComplianceStatus
                    try {
                        $totalFunctions++
                        $cloudCompliance = Get-CloudComplianceStatus -Framework CIS -ErrorAction Stop
                        $successfulFunctions++
                        Write-Host "  Cloud Compliance: Assessed" -ForegroundColor Green
                    } catch { 
                        $failedFunctions++
                        Write-Verbose "  Get-CloudComplianceStatus: $_"
                        $failedCollectors += 'Get-CloudComplianceStatus'
                    }
                    
                    $script:metrics.Cloud.LastCloudScanDate = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
                } else {
                    Write-Host "  Not connected to Microsoft Graph - skipping cloud module" -ForegroundColor Gray
                    Write-Host "  To enable: Connect-MgGraph" -ForegroundColor Gray
                }
                
                $script:metrics.Performance.ModuleTimes['Cloud'] = [Math]::Round(((Get-Date) - $cloudStart).TotalSeconds, 2)
            }
            
            # ============================================
            # VULNERABILITY MODULE (3 functions)
            # ============================================
            if ($modulesToProcess -contains 'Vulnerability') {
                Write-Host "`n[Vulnerability Module Metrics]" -ForegroundColor Cyan
                $vulnStart = Get-Date
                $script:metrics.Vulnerability.Enabled = $true
                
                # Get-VulnerabilityAssessment
                try {
                    $totalFunctions++
                    $vulnAssess = Get-VulnerabilityAssessment -ErrorAction Stop
                    if ($vulnAssess -and $vulnAssess.PSObject.Properties['Summary'] -and $vulnAssess.Summary) {
                        $summary = $vulnAssess.Summary
                        if ($null -ne $summary.CriticalVulnerabilities) {
                            $script:metrics.Vulnerability.Critical = $summary.CriticalVulnerabilities
                        }
                        if ($null -ne $summary.HighVulnerabilities) {
                            $script:metrics.Vulnerability.High = $summary.HighVulnerabilities
                        }
                        if ($null -ne $summary.MediumVulnerabilities) {
                            $script:metrics.Vulnerability.Medium = $summary.MediumVulnerabilities
                        }
                        if ($null -ne $summary.LowVulnerabilities) {
                            $script:metrics.Vulnerability.Low = $summary.LowVulnerabilities
                        }
                        $script:metrics.Vulnerability.Total =
                            $script:metrics.Vulnerability.Critical +
                            $script:metrics.Vulnerability.High +
                            $script:metrics.Vulnerability.Medium +
                            $script:metrics.Vulnerability.Low
                    }
                    $successfulFunctions++
                    Write-Host "  Vulnerabilities: $($script:metrics.Vulnerability.Total) total" -ForegroundColor $(if ($script:metrics.Vulnerability.Total -gt 0) { 'Yellow' } else { 'Green' })
                    if ($script:metrics.Vulnerability.Critical -gt 0) {
                        Write-Host "    Critical: $($script:metrics.Vulnerability.Critical)" -ForegroundColor Red
                    }
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-VulnerabilityAssessment: $_"
                    $failedCollectors += 'Get-VulnerabilityAssessment'
                }
                
                # Find-EOLSoftware
                try {
                    $totalFunctions++
                    $eol = Find-EOLSoftware -ErrorAction Stop
                    $script:metrics.Vulnerability.EOLSoftware = @($eol).Count
                    $successfulFunctions++
                    Write-Host "  EOL Software: $($script:metrics.Vulnerability.EOLSoftware)" -ForegroundColor $(if ($script:metrics.Vulnerability.EOLSoftware -gt 0) { 'Red' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Find-EOLSoftware: $_"
                    $failedCollectors += 'Find-EOLSoftware'
                }
                
                # Test-CertificateHealth
                try {
                    $totalFunctions++
                    $certs = Test-CertificateHealth -ErrorAction Stop
                    if ($certs) {
                        if ($certs.PSObject.Properties['Issues']) {
                            $script:metrics.Vulnerability.CertificateIssues = @($certs.Issues).Count
                        }
                        if ($certs.PSObject.Properties['Summary'] -and $certs.Summary) {
                            if ($null -ne $certs.Summary.Expired) {
                                $script:metrics.Vulnerability.ExpiredCertificates = $certs.Summary.Expired
                            }
                            if ($null -ne $certs.Summary.WeakSignature) {
                                $script:metrics.Vulnerability.WeakCertificates = $certs.Summary.WeakSignature
                            }
                        }
                    }
                    $successfulFunctions++
                    Write-Host "  Certificate Issues: $($script:metrics.Vulnerability.CertificateIssues) ($($script:metrics.Vulnerability.ExpiredCertificates) expired)" -ForegroundColor $(if ($script:metrics.Vulnerability.CertificateIssues -gt 0) { 'Yellow' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Test-CertificateHealth: $_"
                    $failedCollectors += 'Test-CertificateHealth'
                }
                
                $script:metrics.Vulnerability.LastVulnScanDate = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
                $script:metrics.Performance.ModuleTimes['Vulnerability'] = [Math]::Round(((Get-Date) - $vulnStart).TotalSeconds, 2)
            }
            
            # ============================================
            # THREAT HUNTING MODULE (2 functions)
            # ============================================
            if ($modulesToProcess -contains 'ThreatHunting') {
                Write-Host "`n[Threat Hunting Module Metrics]" -ForegroundColor Cyan
                $threatStart = Get-Date
                $script:metrics.ThreatHunting.Enabled = $true
                
                # Get-ThreatIntelligence
                try {
                    $totalFunctions++
                    $attemptedDetectionCollectors++
                    $threatIntel = Get-ThreatIntelligence -ErrorAction Stop
                    if ($threatIntel) {
                        if ($threatIntel.PSObject.Properties['IOCMatches']) {
                            $script:metrics.ThreatHunting.IOCMatches = @($threatIntel.IOCMatches).Count
                        } elseif ($threatIntel.PSObject.Properties['Summary'] -and $threatIntel.Summary) {
                            $script:metrics.ThreatHunting.IOCMatches = $threatIntel.Summary.TotalMatches
                        } else {
                            $script:metrics.ThreatHunting.IOCMatches = @($threatIntel).Count
                        }
                    }
                    $successfulFunctions++
                    Write-Host "  IOC Matches: $($script:metrics.ThreatHunting.IOCMatches)" -ForegroundColor $(if ($script:metrics.ThreatHunting.IOCMatches -gt 0) { 'Red' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    $failedDetectionCollectors++
                    Write-Verbose "  Get-ThreatIntelligence: $_"
                    $failedCollectors += 'Get-ThreatIntelligence'
                }
                
                # Get-MITREAttackMapping
                try {
                    $totalFunctions++
                    $attemptedDetectionCollectors++
                    $mitre = Get-MITREAttackMapping -ErrorAction Stop
                    if ($mitre) {
                        if ($mitre.PSObject.Properties['UniqueTechniques']) {
                            $script:metrics.ThreatHunting.MITRETechniques = $mitre.UniqueTechniques
                        } elseif ($mitre.PSObject.Properties['Summary'] -and $mitre.Summary) {
                            $script:metrics.ThreatHunting.MITRETechniques = $mitre.Summary.TotalTechniques
                        } else {
                            $script:metrics.ThreatHunting.MITRETechniques = @($mitre).Count
                        }
                    }
                    $successfulFunctions++
                    Write-Host "  MITRE Techniques: $($script:metrics.ThreatHunting.MITRETechniques)" -ForegroundColor $(if ($script:metrics.ThreatHunting.MITRETechniques -gt 0) { 'Yellow' } else { 'Green' })
                } catch { 
                    $failedFunctions++
                    $failedDetectionCollectors++
                    Write-Verbose "  Get-MITREAttackMapping: $_"
                    $failedCollectors += 'Get-MITREAttackMapping'
                }
                
                $script:metrics.ThreatHunting.LastHuntDate = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
                $script:metrics.Performance.ModuleTimes['ThreatHunting'] = [Math]::Round(((Get-Date) - $threatStart).TotalSeconds, 2)
            }
            
            # ============================================
            # FORENSICS MODULE (6 functions)
            # ============================================
            if ($modulesToProcess -contains 'Forensics') {
                Write-Host "`n[Forensics Module Metrics]" -ForegroundColor Cyan
                $forStart = Get-Date
                $script:metrics.Forensics.Enabled = $true
                
                # Get-ArtifactCollection
                try {
                    $totalFunctions++
                    $artifacts = Get-ArtifactCollection -ErrorAction Stop
                    if ($artifacts) {
                        if ($artifacts.PSObject.Properties['Summary'] -and $artifacts.Summary) {
                            $script:metrics.Forensics.ArtifactsCollected = $artifacts.Summary.TotalFiles
                        }
                    }
                    $successfulFunctions++
                    Write-Host "  Artifacts Collected: $($script:metrics.Forensics.ArtifactsCollected)" -ForegroundColor Green
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-ArtifactCollection: $_"
                    $failedCollectors += 'Get-ArtifactCollection'
                }
                
                # Get-ExecutionArtifacts
                try {
                    $totalFunctions++
                    $execArtifacts = Get-ExecutionArtifacts -ErrorAction Stop
                    if ($execArtifacts) {
                        if ($execArtifacts.PSObject.Properties['TotalArtifacts']) {
                            $script:metrics.Forensics.ExecutionArtifacts = $execArtifacts.TotalArtifacts
                        } elseif ($execArtifacts.PSObject.Properties['Summary'] -and $execArtifacts.Summary) {
                            $script:metrics.Forensics.ExecutionArtifacts = $execArtifacts.Summary.TotalArtifacts
                        } else {
                            $script:metrics.Forensics.ExecutionArtifacts = @($execArtifacts).Count
                        }
                        
                        if ($execArtifacts.PSObject.Properties['Summary'] -and $execArtifacts.Summary) {
                            $script:metrics.Forensics.RecentExecutions = $execArtifacts.Summary.RecentApps
                        }
                    }
                    $successfulFunctions++
                    Write-Host "  Execution Artifacts: $($script:metrics.Forensics.ExecutionArtifacts)" -ForegroundColor Green
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-ExecutionArtifacts: $_"
                    $failedCollectors += 'Get-ExecutionArtifacts'
                }
                
                # Get-USBHistory
                try {
                    $totalFunctions++
                    $usb = Get-USBHistory -ErrorAction Stop
                    $script:metrics.Forensics.USBDevices = @($usb).Count
                    $successfulFunctions++
                    Write-Host "  USB Devices: $($script:metrics.Forensics.USBDevices)" -ForegroundColor Green
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-USBHistory: $_"
                    $failedCollectors += 'Get-USBHistory'
                }
                
                # Invoke-ForensicCollection, Export-MemoryDump, New-ForensicTimeline
                # These are heavy operations - skip metrics collection unless explicitly needed
                $totalFunctions += 3
                Write-Host "  Detailed forensics: Skipped (use -DetailLevel Detailed)" -ForegroundColor Gray
                
                $script:metrics.Forensics.LastForensicScanDate = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
                $script:metrics.Performance.ModuleTimes['Forensics'] = [Math]::Round(((Get-Date) - $forStart).TotalSeconds, 2)
            }
            
            # ============================================
            # WINDOWS DEFENDER MODULE (3 functions)
            # ============================================
            if ($modulesToProcess -contains 'WindowsDefender') {
                Write-Host "`n[Windows Defender Module Metrics]" -ForegroundColor Cyan
                $defStart = Get-Date
                $script:metrics.WindowsDefender.Enabled = $true
                
                # Get-DefenderStatus
                try {
                    $totalFunctions++
                    $defStatus = Get-DefenderStatus -ErrorAction Stop
                    if ($defStatus) {
                        # Status
                        if ($defStatus.PSObject.Properties['HealthStatus']) {
                            $script:metrics.WindowsDefender.Status = $defStatus.HealthStatus
                        } elseif ($defStatus.PSObject.Properties['Status']) {
                            $script:metrics.WindowsDefender.Status = $defStatus.Status
                        }
                        
                        # Protection states
                        if ($defStatus.PSObject.Properties['ProtectionStatus'] -and $defStatus.ProtectionStatus) {
                            $script:metrics.WindowsDefender.RealTimeProtection = [bool]$defStatus.ProtectionStatus.RealTimeProtectionEnabled
                            $script:metrics.WindowsDefender.ProtectionEnabled = [bool]$defStatus.ProtectionStatus.RealTimeProtectionEnabled
                        }
                        if ($defStatus.PSObject.Properties['Configuration'] -and $defStatus.Configuration) {
                            $script:metrics.WindowsDefender.CloudProtection = ($defStatus.Configuration.MAPSReporting -gt 0)
                        }
                        
                        # Signature info
                        if ($defStatus.PSObject.Properties['SignatureStatus'] -and $defStatus.SignatureStatus) {
                            if ($defStatus.SignatureStatus.SignatureAge) {
                                $script:metrics.WindowsDefender.SignatureAge = [int]$defStatus.SignatureStatus.SignatureAge.Days
                            }
                            if ($defStatus.SignatureStatus.AntivirusSignatureVersion) {
                                $script:metrics.WindowsDefender.SignatureVersion = $defStatus.SignatureStatus.AntivirusSignatureVersion
                            }
                        }
                        
                        # Scan info
                        if ($defStatus.PSObject.Properties['ScanHistory'] -and $defStatus.ScanHistory) {
                            if ($defStatus.ScanHistory.QuickScanStartTime) {
                                $script:metrics.WindowsDefender.LastQuickScan = $defStatus.ScanHistory.QuickScanStartTime
                                $script:metrics.WindowsDefender.LastScanDays = [int]((Get-Date) - [datetime]$defStatus.ScanHistory.QuickScanStartTime).TotalDays
                            }
                            if ($defStatus.ScanHistory.FullScanStartTime) {
                                $script:metrics.WindowsDefender.LastFullScan = $defStatus.ScanHistory.FullScanStartTime
                            }
                        }
                    }
                    $successfulFunctions++
                    Write-Host "  Status: $($script:metrics.WindowsDefender.Status)" -ForegroundColor $(if ($script:metrics.WindowsDefender.ProtectionEnabled) { 'Green' } else { 'Red' })
                    Write-Host "  Real-Time Protection: $($script:metrics.WindowsDefender.RealTimeProtection)" -ForegroundColor $(if ($script:metrics.WindowsDefender.RealTimeProtection) { 'Green' } else { 'Red' })
                    Write-Host "  Signature Age: $($script:metrics.WindowsDefender.SignatureAge) days" -ForegroundColor $(if ($script:metrics.WindowsDefender.SignatureAge -le 1) { 'Green' } elseif ($script:metrics.WindowsDefender.SignatureAge -le 7) { 'Yellow' } else { 'Red' })
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Get-DefenderStatus: $_"
                    $failedCollectors += 'Get-DefenderStatus'
                }
                
                # Invoke-DefenderScan - skip for metrics
                $totalFunctions++
                Write-Host "  Defender Scan: Skipped (metrics only)" -ForegroundColor Gray
                
                # Update-DefenderConfiguration - check only
                try {
                    $totalFunctions++
                    $defConfig = Update-DefenderConfiguration -WhatIf -ErrorAction Stop
                    $successfulFunctions++
                    Write-Host "  Configuration: Checked" -ForegroundColor Green
                } catch { 
                    $failedFunctions++
                    Write-Verbose "  Update-DefenderConfiguration: $_"
                    $failedCollectors += 'Update-DefenderConfiguration'
                }
                
                $script:metrics.Performance.ModuleTimes['WindowsDefender'] = [Math]::Round(((Get-Date) - $defStart).TotalSeconds, 2)
            }
            
# ============================================
# CALCULATE AGGREGATE METRICS
# ============================================
Write-Host "`n[CALCULATING AGGREGATE METRICS]" -ForegroundColor Cyan

# Helper function to safely convert values to integers
function ConvertTo-SafeInt {
    param($Value)
    
    if ($null -eq $Value) { return 0 }
    if ($Value -is [int] -or $Value -is [long]) { return [int]$Value }
    if ($Value -is [array]) { return @($Value).Count }
    if ($Value -is [string]) {
        $trimmed = $Value.Trim()
        if ([string]::IsNullOrEmpty($trimmed)) { return 0 }
        try { return [int]$trimmed } catch { return 0 }
    }
    try { return [int]$Value } catch { return 0 }
}

# Findings by severity - SAFE CONVERSION
$script:metrics.Findings.Critical = 
    (ConvertTo-SafeInt $script:metrics.Vulnerability.Critical) +
    (ConvertTo-SafeInt $script:metrics.ActiveDirectory.Vulnerabilities) +
    (ConvertTo-SafeInt $script:metrics.ActiveDirectory.Backdoors) +
    (ConvertTo-SafeInt $script:metrics.Analysis.CriticalEvents)

$script:metrics.Findings.High = 
    (ConvertTo-SafeInt $script:metrics.Detection.TotalThreats) +
    (ConvertTo-SafeInt $script:metrics.Vulnerability.High) +
    (ConvertTo-SafeInt $script:metrics.Vulnerability.EOLSoftware) +
    (ConvertTo-SafeInt $script:metrics.ThreatHunting.IOCMatches)

$script:metrics.Findings.Medium = 
    (ConvertTo-SafeInt $script:metrics.Analysis.SecurityMisconfigurations) +
    (ConvertTo-SafeInt $script:metrics.Vulnerability.Medium) +
    (ConvertTo-SafeInt $script:metrics.Vulnerability.CertificateIssues) +
    (ConvertTo-SafeInt $script:metrics.Analysis.RegistryIssues)

$script:metrics.Findings.Low = 
    (ConvertTo-SafeInt $script:metrics.Analysis.ExposedServices) +
    (ConvertTo-SafeInt $script:metrics.ActiveDirectory.StaleObjects) +
    (ConvertTo-SafeInt $script:metrics.Cloud.RiskySignIns)

$script:metrics.Findings.Total = 
    $script:metrics.Findings.Critical +
    $script:metrics.Findings.High +
    $script:metrics.Findings.Medium +
    $script:metrics.Findings.Low

# Findings by category
$script:metrics.Findings.ByCategory.Threats = ConvertTo-SafeInt $script:metrics.Detection.TotalThreats
$script:metrics.Findings.ByCategory.Vulnerabilities = ConvertTo-SafeInt $script:metrics.Vulnerability.Total
$script:metrics.Findings.ByCategory.Configuration = ConvertTo-SafeInt $script:metrics.Analysis.SecurityMisconfigurations
$script:metrics.Findings.ByCategory.Compliance = ConvertTo-SafeInt $script:metrics.Compliance.FailedControls

Write-Host "  Total Findings: $($script:metrics.Findings.Total)" -ForegroundColor White
Write-Host "    Critical: $($script:metrics.Findings.Critical)" -ForegroundColor Red
Write-Host "    High: $($script:metrics.Findings.High)" -ForegroundColor Yellow
Write-Host "    Medium: $($script:metrics.Findings.Medium)" -ForegroundColor Yellow
Write-Host "    Low: $($script:metrics.Findings.Low)" -ForegroundColor Gray

# Calculate overall security score - FIXED IF STATEMENTS
$penalty = 0
$penalty += ($script:metrics.Findings.Critical * 20)
$penalty += ($script:metrics.Findings.High * 10)
$penalty += ($script:metrics.Findings.Medium * 5)
$penalty += ($script:metrics.Findings.Low * 2)
$penalty += ((ConvertTo-SafeInt $script:metrics.Core.PendingUpdates) * 2)

# Add penalties based on conditions (only for modules that were actually collected)
if ($script:metrics.WindowsDefender.Enabled -and -not $script:metrics.WindowsDefender.ProtectionEnabled) {
    $penalty += 15
}

$signatureAge = ConvertTo-SafeInt $script:metrics.WindowsDefender.SignatureAge
if ($script:metrics.WindowsDefender.Enabled -and $signatureAge -gt 7) {
    $penalty += 10
}

$script:metrics.OverallSecurityScore = [Math]::Max(0, [Math]::Min(100, 100 - $penalty))

# Data completeness: the score is only as trustworthy as the collectors behind it
$script:metrics.DataCompleteness = "$successfulFunctions of $totalFunctions collectors succeeded ($failedFunctions failed)"
$script:metrics.FailedCollectors = @($failedCollectors)

$majorityFailed = ($totalFunctions -gt 0) -and ($failedFunctions * 2 -gt $totalFunctions)
if ($majorityFailed) {
    Write-Warning "More than 50% of collectors failed ($failedFunctions of $totalFunctions): $($failedCollectors -join ', '). OverallSecurityScore is reported as null because the collected data is too incomplete to score reliably."
    $script:metrics.OverallSecurityScore = $null
    $script:metrics.ScoreConfidence = 'Insufficient'
}
elseif ($failedFunctions -gt 0) {
    Write-Warning "$failedFunctions of $totalFunctions collectors failed: $($failedCollectors -join ', '). The overall score is based on partial data (see DataCompleteness); the score is an upper bound."
    $script:metrics.ScoreConfidence = 'Partial'
}

Write-Host "  Overall Security Score: $(if ($null -ne $script:metrics.OverallSecurityScore) { "$($script:metrics.OverallSecurityScore)%" } else { 'N/A (insufficient data)' })" -ForegroundColor $(
    if ($null -eq $script:metrics.OverallSecurityScore) { 'Yellow' }
    elseif ($script:metrics.OverallSecurityScore -ge 80) { 'Green' }
    elseif ($script:metrics.OverallSecurityScore -ge 60) { 'Yellow' }
    else { 'Red' }
)
Write-Host "  Data Completeness: $($script:metrics.DataCompleteness)" -ForegroundColor $(if ($failedFunctions -eq 0) { 'Green' } else { 'Yellow' })

# Determine risk level
$script:metrics.RiskLevel = 
    if ($script:metrics.Findings.Critical -gt 10) { "Critical" }
    elseif ($script:metrics.Findings.Critical -gt 5) { "High" }
    elseif ($script:metrics.Findings.Critical -gt 0) { "High" }
    elseif ($script:metrics.Findings.High -gt 20) { "High" }
    elseif ($script:metrics.Findings.High -gt 10) { "Medium" }
    elseif ($script:metrics.Findings.High -gt 0) { "Medium" }
    elseif ($script:metrics.Findings.Medium -gt 20) { "Medium" }
    else { "Low" }

# Determine threat level
$script:metrics.ThreatLevel = 
    if ($script:metrics.Detection.APTIndicators -gt 0) { "Critical" }
    elseif ($script:metrics.Detection.LateralMovement -gt 0) { "High" }
    elseif ($script:metrics.Detection.TotalThreats -gt 30) { "High" }
    elseif ($script:metrics.Detection.TotalThreats -gt 20) { "Medium" }
    elseif ($script:metrics.Detection.TotalThreats -gt 10) { "Medium" }
    elseif ($script:metrics.Detection.TotalThreats -gt 0) { "Low" }
    else { "Minimal" }

# With most collectors failed, "no findings" means "no data", not "low risk"
if ($majorityFailed) {
    $script:metrics.RiskLevel   = 'Unknown'
    $script:metrics.ThreatLevel = 'Unknown'
}
elseif ($attemptedDetectionCollectors -gt 0 -and $failedDetectionCollectors -eq $attemptedDetectionCollectors) {
    $script:metrics.ThreatLevel = 'Unknown'
}

Write-Host "  Risk Level: $($script:metrics.RiskLevel)" -ForegroundColor $(
    switch ($script:metrics.RiskLevel) {
        'Critical' { 'Red' }
        'High' { 'Red' }
        'Medium' { 'Yellow' }
        'Unknown' { 'Yellow' }
        default { 'Green' }
    }
)

Write-Host "  Threat Level: $($script:metrics.ThreatLevel)" -ForegroundColor $(
    switch ($script:metrics.ThreatLevel) {
        'Critical' { 'Red' }
        'High' { 'Red' }
        'Medium' { 'Yellow' }
        'Unknown' { 'Yellow' }
        default { 'Green' }
    }
)

# Health status
$script:metrics.HealthStatus = 
    if ($null -eq $script:metrics.OverallSecurityScore) { "Unknown" }
    elseif ($script:metrics.OverallSecurityScore -ge 90 -and $script:metrics.ThreatLevel -eq 'Minimal') { "Excellent" }
    elseif ($script:metrics.OverallSecurityScore -ge 80 -and $script:metrics.ThreatLevel -in @('Minimal', 'Low')) { "Good" }
    elseif ($script:metrics.OverallSecurityScore -ge 60) { "Fair" }
    elseif ($script:metrics.OverallSecurityScore -ge 40) { "Poor" }
    else { "Critical" }

# Any collector failure reduces confidence: health can never be 'Excellent' on partial data
if ($failedFunctions -gt 0 -and $script:metrics.HealthStatus -eq 'Excellent') {
    $script:metrics.HealthStatus = 'Good'
}

Write-Host "  Health Status: $($script:metrics.HealthStatus)" -ForegroundColor $(
    switch ($script:metrics.HealthStatus) {
        'Excellent' { 'Green' }
        'Good' { 'Green' }
        'Fair' { 'Yellow' }
        'Poor' { 'Red' }
        default { 'Red' }
    }
)

# Generate recommendations
if ($script:metrics.Findings.Critical -gt 0) {
    $script:metrics.Recommendations.Critical += "Address $($script:metrics.Findings.Critical) critical security findings immediately"
}
if ($script:metrics.Vulnerability.EOLSoftware -gt 0) {
    $script:metrics.Recommendations.Critical += "Replace or upgrade $($script:metrics.Vulnerability.EOLSoftware) end-of-life software packages"
}
if ($script:metrics.WindowsDefender.Enabled -and -not $script:metrics.WindowsDefender.ProtectionEnabled) {
    $script:metrics.Recommendations.Critical += "Enable Windows Defender real-time protection immediately"
}
if ($script:metrics.Detection.APTIndicators -gt 0) {
    $script:metrics.Recommendations.Critical += "Investigate $($script:metrics.Detection.APTIndicators) APT indicators - potential advanced threat"
}

if ($script:metrics.Findings.High -gt 0) {
    $script:metrics.Recommendations.High += "Remediate $($script:metrics.Findings.High) high-severity findings within 7 days"
}
if ($script:metrics.Core.PendingUpdates -gt 0) {
    $script:metrics.Recommendations.High += "Install $($script:metrics.Core.PendingUpdates) pending security updates"
}
if ($script:metrics.WindowsDefender.Enabled -and $script:metrics.WindowsDefender.SignatureAge -gt 7) {
    $script:metrics.Recommendations.High += "Update Windows Defender signatures (currently $($script:metrics.WindowsDefender.SignatureAge) days old)"
}
if ($script:metrics.Compliance.Enabled -and $script:metrics.ComplianceScore -lt 70) {
    $script:metrics.Recommendations.High += "Improve compliance score (currently $($script:metrics.ComplianceScore)% - target: 80%+)"
}

if ($script:metrics.Findings.Medium -gt 0) {
    $script:metrics.Recommendations.Medium += "Address $($script:metrics.Findings.Medium) medium-severity issues within 30 days"
}
if ($script:metrics.Analysis.SecurityMisconfigurations -gt 0) {
    $script:metrics.Recommendations.Medium += "Fix $($script:metrics.Analysis.SecurityMisconfigurations) security misconfigurations"
}

if ($script:metrics.ActiveDirectory.StaleObjects -gt 10) {
    $script:metrics.Recommendations.Low += "Clean up $($script:metrics.ActiveDirectory.StaleObjects) stale AD objects"
}

$script:metrics.Recommendations.Total = 
    @($script:metrics.Recommendations.Critical).Count +
    @($script:metrics.Recommendations.High).Count +
    @($script:metrics.Recommendations.Medium).Count +
    @($script:metrics.Recommendations.Low).Count
            
            # ============================================
            # TREND ANALYSIS (if enabled)
            # ============================================
            if ($CalculateTrends) {
                Write-Host "`n[CALCULATING TRENDS]" -ForegroundColor Cyan
                
                try {
                    $historyPath = Join-Path $env:TEMP "SecurityMetricsHistory.json"
                    
                    if (Test-Path $historyPath) {
                        $history = Get-Content $historyPath -Raw | ConvertFrom-Json
                        $historyArray = @($history)
                        
                        if ($historyArray.Count -gt 0) {
                            $lastMetrics = $historyArray | Select-Object -Last 1
                            
                            # Security score trend
                            $scoreDelta = $script:metrics.OverallSecurityScore - $lastMetrics.OverallSecurityScore
                            $script:metrics.Trends.SecurityScoreChange = $scoreDelta
                            $script:metrics.Trends.SecurityScoreTrend = 
                                if ($scoreDelta -gt 5) { "Improving" }
                                elseif ($scoreDelta -lt -5) { "Declining" }
                                else { "Stable" }
                            
                            # Threat trend
                            $threatDelta = $script:metrics.Detection.TotalThreats - $lastMetrics.Detection.TotalThreats
                            $script:metrics.Trends.ThreatCountChange = $threatDelta
                            if ($script:metrics.Detection.TotalThreats -gt ($lastMetrics.Detection.TotalThreats * 1.2)) {
                                $script:metrics.Trends.ThreatTrend = "Increasing"
                            } elseif ($script:metrics.Detection.TotalThreats -lt ($lastMetrics.Detection.TotalThreats * 0.8)) {
                                $script:metrics.Trends.ThreatTrend = "Decreasing"
                            } else {
                                $script:metrics.Trends.ThreatTrend = "Stable"
                            }
                            
                            # Compliance trend
                            $compDelta = $script:metrics.ComplianceScore - $lastMetrics.ComplianceScore
                            $script:metrics.Trends.ComplianceScoreChange = $compDelta
                            if ($compDelta -gt 5) {
                                $script:metrics.Trends.ComplianceTrend = "Improving"
                            } elseif ($compDelta -lt -5) {
                                $script:metrics.Trends.ComplianceTrend = "Declining"
                            } else {
                                $script:metrics.Trends.ComplianceTrend = "Stable"
                            }
                            
                            # Findings trend
                            $findingsDelta = $script:metrics.Findings.Total - $lastMetrics.Findings.Total
                            $script:metrics.Trends.FindingsChange = $findingsDelta
                            if ($findingsDelta -gt 5) {
                                $script:metrics.Trends.FindingsTrend = "Increasing"
                            } elseif ($findingsDelta -lt -5) {
                                $script:metrics.Trends.FindingsTrend = "Decreasing"
                            } else {
                                $script:metrics.Trends.FindingsTrend = "Stable"
                            }
                            
                            Write-Host "  Security Score: $(if ($scoreDelta -gt 0) { '+' })$scoreDelta ($($script:metrics.Trends.SecurityScoreTrend))" -ForegroundColor $(if ($scoreDelta -gt 0) { 'Green' } elseif ($scoreDelta -lt 0) { 'Red' } else { 'Gray' })
                            Write-Host "  Threats: $(if ($threatDelta -gt 0) { '+' })$threatDelta ($($script:metrics.Trends.ThreatTrend))" -ForegroundColor $(if ($script:metrics.Trends.ThreatTrend -eq 'Increasing') { 'Red' } elseif ($script:metrics.Trends.ThreatTrend -eq 'Decreasing') { 'Green' } else { 'Gray' })
                            Write-Host "  Compliance: $(if ($compDelta -gt 0) { '+' })$compDelta ($($script:metrics.Trends.ComplianceTrend))" -ForegroundColor $(if ($script:metrics.Trends.ComplianceTrend -eq 'Improving') { 'Green' } elseif ($script:metrics.Trends.ComplianceTrend -eq 'Declining') { 'Red' } else { 'Gray' })
                            Write-Host "  Findings: $(if ($findingsDelta -gt 0) { '+' })$findingsDelta ($($script:metrics.Trends.FindingsTrend))" -ForegroundColor $(if ($findingsDelta -lt 0) { 'Green' } elseif ($findingsDelta -gt 0) { 'Red' } else { 'Gray' })
                        } else {
                            Write-Host "  Insufficient history for trend analysis" -ForegroundColor Gray
                        }
                    } else {
                        Write-Host "  No historical data found - this is the first collection" -ForegroundColor Gray
                    }
                } catch {
                    Write-Warning "  Failed to calculate trends: $_"
                }
            }
            
            # ============================================
            # BASELINE COMPARISON (if enabled)
            # ============================================
            if ($CompareWithBaseline -and $BaselinePath -and (Test-Path $BaselinePath)) {
                Write-Host "`n[COMPARING WITH BASELINE]" -ForegroundColor Cyan
                
                try {
                    $baseline = Get-Content $BaselinePath -Raw | ConvertFrom-Json
                    $script:metrics.Baseline.BaselineDate = $baseline.Timestamp
                    
                    # Security score comparison
                    $script:metrics.Baseline.SecurityScoreDelta = $script:metrics.OverallSecurityScore - $baseline.OverallSecurityScore
                    
                    # Threat count comparison
                    $script:metrics.Baseline.ThreatCountDelta = $script:metrics.Detection.TotalThreats - $baseline.Detection.TotalThreats
                    
                    # Compliance score comparison
                    $script:metrics.Baseline.ComplianceScoreDelta = $script:metrics.ComplianceScore - $baseline.ComplianceScore
                    
                    # Findings comparison
                    $script:metrics.Baseline.NewFindings = [Math]::Max(0, $script:metrics.Findings.Total - $baseline.Findings.Total)
                    $script:metrics.Baseline.ResolvedFindings = [Math]::Max(0, $baseline.Findings.Total - $script:metrics.Findings.Total)
                    
                    # Identify improved/declined areas
                    if ($script:metrics.Baseline.SecurityScoreDelta -gt 0) {
                        $script:metrics.Baseline.ImprovedAreas += "Security Score improved by $($script:metrics.Baseline.SecurityScoreDelta) points"
                    } elseif ($script:metrics.Baseline.SecurityScoreDelta -lt 0) {
                        $script:metrics.Baseline.DeclinedAreas += "Security Score declined by $([Math]::Abs($script:metrics.Baseline.SecurityScoreDelta)) points"
                    }
                    
                    if ($script:metrics.Baseline.ThreatCountDelta -lt 0) {
                        $script:metrics.Baseline.ImprovedAreas += "Threat count reduced by $([Math]::Abs($script:metrics.Baseline.ThreatCountDelta))"
                    } elseif ($script:metrics.Baseline.ThreatCountDelta -gt 0) {
                        $script:metrics.Baseline.DeclinedAreas += "Threat count increased by $($script:metrics.Baseline.ThreatCountDelta)"
                    }
                    
                    if ($script:metrics.Baseline.ComplianceScoreDelta -gt 0) {
                        $script:metrics.Baseline.ImprovedAreas += "Compliance improved by $($script:metrics.Baseline.ComplianceScoreDelta)%"
                    } elseif ($script:metrics.Baseline.ComplianceScoreDelta -lt 0) {
                        $script:metrics.Baseline.DeclinedAreas += "Compliance declined by $([Math]::Abs($script:metrics.Baseline.ComplianceScoreDelta))%"
                    }
                    
                    Write-Host "  Baseline Date: $($script:metrics.Baseline.BaselineDate)" -ForegroundColor Gray
                    Write-Host "  Security Score: $(if ($script:metrics.Baseline.SecurityScoreDelta -gt 0) { '+' })$($script:metrics.Baseline.SecurityScoreDelta)" -ForegroundColor $(if ($script:metrics.Baseline.SecurityScoreDelta -gt 0) { 'Green' } elseif ($script:metrics.Baseline.SecurityScoreDelta -lt 0) { 'Red' } else { 'Gray' })
                    Write-Host "  Threats: $(if ($script:metrics.Baseline.ThreatCountDelta -gt 0) { '+' })$($script:metrics.Baseline.ThreatCountDelta)" -ForegroundColor $(if ($script:metrics.Baseline.ThreatCountDelta -lt 0) { 'Green' } elseif ($script:metrics.Baseline.ThreatCountDelta -gt 0) { 'Red' } else { 'Gray' })
                    Write-Host "  New Findings: $($script:metrics.Baseline.NewFindings)" -ForegroundColor $(if ($script:metrics.Baseline.NewFindings -gt 0) { 'Yellow' } else { 'Green' })
                    Write-Host "  Resolved Findings: $($script:metrics.Baseline.ResolvedFindings)" -ForegroundColor $(if ($script:metrics.Baseline.ResolvedFindings -gt 0) { 'Green' } else { 'Gray' })
                    
                    if (@($script:metrics.Baseline.ImprovedAreas).Count -gt 0) {
                        Write-Host "  Improvements: $(@($script:metrics.Baseline.ImprovedAreas).Count)" -ForegroundColor Green
                    }
                    if (@($script:metrics.Baseline.DeclinedAreas).Count -gt 0) {
                        Write-Host "  Declines: $(@($script:metrics.Baseline.DeclinedAreas).Count)" -ForegroundColor Red
                    }
                } catch {
                    Write-Warning "  Failed to compare with baseline: $_"
                }
            }
            
            # ============================================
            # SAVE HISTORY (if enabled)
            # ============================================
            if ($IncludeHistory) {
                Write-Host "`n[SAVING TO HISTORY]" -ForegroundColor Cyan
                
                try {
                    $historyPath = Join-Path $env:TEMP "SecurityMetricsHistory.json"
                    $history = @()
                    
                    if (Test-Path $historyPath) {
                        $history = @(Get-Content $historyPath -Raw | ConvertFrom-Json)
                    }
                    
                    # Keep only last N days
                    $cutoffDate = (Get-Date).AddDays(-$HistoryDays)
                    $history = @($history | Where-Object { 
                        try { [DateTime]$_.Timestamp -gt $cutoffDate } catch { $false }
                    })
                    
                    # Add current metrics
                    $history += $script:metrics
                    
                    # Save atomically: write to a unique temp file, then replace the shared
                    # history file so concurrent readers never observe a torn write
                    $tempHistoryPath = "$historyPath.$(Get-Random).tmp"
                    $history | ConvertTo-Json -Depth 10 | Out-File $tempHistoryPath -Encoding UTF8 -Force
                    if (Test-Path $historyPath) {
                        [System.IO.File]::Replace($tempHistoryPath, $historyPath, [NullString]::Value)
                    } else {
                        [System.IO.File]::Move($tempHistoryPath, $historyPath)
                    }
                    
                    Write-Host "  History saved: $historyPath" -ForegroundColor Green
                    Write-Host "  History entries: $(@($history).Count)" -ForegroundColor Gray
                } catch {
                    Write-Warning "  Failed to save history: $_"
                }
            }
            
            # ============================================
            # EXPORT (if specified)
            # ============================================
            if ($ExportPath) {
                Write-Host "`n[EXPORTING METRICS]" -ForegroundColor Cyan
                
                try {
                    if (-not (Test-Path $ExportPath)) {
                        New-Item -Path $ExportPath -ItemType Directory -Force | Out-Null
                    }
                    
                    $timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
                    $exportFile = Join-Path $ExportPath "SecurityMetrics_$timestamp.json"
                    
                    $script:metrics | ConvertTo-Json -Depth 10 | Out-File $exportFile -Encoding UTF8 -Force
                    
                    Write-Host "  Exported: $exportFile" -ForegroundColor Green
                    Write-Host "  Size: $([Math]::Round((Get-Item $exportFile).Length / 1KB, 2)) KB" -ForegroundColor Gray
                } catch {
                    Write-Error "Failed to export metrics: $_"
                }
            }
            
            # Calculate performance metrics
            $script:metrics.CollectionDuration = [Math]::Round(((Get-Date) - $startTime).TotalSeconds, 2)
            $script:metrics.Performance.CollectionTime = $script:metrics.CollectionDuration
            $script:metrics.Performance.FunctionCalls = $totalFunctions
            $script:metrics.Performance.FailedFunctions = $failedFunctions
            if ($totalFunctions -gt 0) {
                $script:metrics.Performance.SuccessRate = [Math]::Round(($successfulFunctions / $totalFunctions) * 100, 1)
            }
            
            return [PSCustomObject]$script:metrics
            
        }
        catch {
            Write-Error "Metrics collection failed: $_"
            Write-Host "`nStack Trace:" -ForegroundColor Red
            Write-Host $_.ScriptStackTrace -ForegroundColor Gray
            throw
        }
    }
    
    end {
        $totalTime = [Math]::Round(((Get-Date) - $startTime).TotalSeconds, 2)
        
        Write-Host "`n================================================================" -ForegroundColor Green
        Write-Host "  METRICS COLLECTION COMPLETE" -ForegroundColor Green
        Write-Host "================================================================" -ForegroundColor Green
        Write-Host "  Collection Time: $totalTime seconds" -ForegroundColor White
        Write-Host "  Modules Processed: $(@($modulesToProcess).Count)" -ForegroundColor Yellow
        Write-Host "  Function Success Rate: $($script:metrics.Performance.SuccessRate)%" -ForegroundColor White
        
        Write-Host "`nKey Metrics:" -ForegroundColor Cyan
        Write-Host "  Security Score: $(if ($null -ne $script:metrics.OverallSecurityScore) { "$($script:metrics.OverallSecurityScore)%" } else { 'N/A (insufficient data)' })" -ForegroundColor White
        Write-Host "  Health Status: $($script:metrics.HealthStatus)" -ForegroundColor White
        Write-Host "  Risk Level: $($script:metrics.RiskLevel)" -ForegroundColor White
        Write-Host "  Threat Level: $($script:metrics.ThreatLevel)" -ForegroundColor White
        Write-Host "  Compliance Score: $($script:metrics.ComplianceScore)%" -ForegroundColor White
        Write-Host "  Total Findings: $($script:metrics.Findings.Total)" -ForegroundColor White
        Write-Host "  Recommendations: $($script:metrics.Recommendations.Total)" -ForegroundColor White
    }
}