# PowerShell script to check Teams Rooms device certification
$CertificationAPI = "https://docs.microsoft.com/en-us/microsoftteams/rooms/certified-hardware"

# Check USB devices
Get-PnpDevice -Class AudioEndpoint,Camera,HIDClass | 
    Select-Object FriendlyName, InstanceId, Status | 
    Where-Object {$_.Status -ne "OK"} |
    Format-Table -AutoSize

# Check HDMI/Display devices
Get-PnpDevice -Class Display,Monitor | 
    Select-Object FriendlyName, InstanceId, Status |
    Format-Table -AutoSize

[object Object],
Get-WmiObject -Class Win32_VideoController | 
    Select-Object Name, Status, CurrentHorizontalResolution, CurrentVerticalResolution |
    Format-Table -AutoSize

# Registry path: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\GraphicsDrivers\DCI
# Verify Timeout value is set to appropriate HDCP timeout (usually 5000ms)

# Set optimal display settings for Teams Rooms
$DisplaySettings = @{
    Resolution = "1920x1080"
    RefreshRate = "60Hz"
    ColorDepth = "32bit"
}

# Apply settings via PowerShell
Add-Type -AssemblyName System.Windows.Forms
$Screen = [System.Windows.Forms.Screen]::PrimaryScreen
Write-Host "Current Resolution: $($Screen.Bounds.Width)x$($Screen.Bounds.Height)"

# Comprehensive driver assessment script
$DriverReport = @()

Get-PnpDevice | Where-Object {$_.Status -ne "OK"} | ForEach-Object {
    $Driver = Get-PnpDeviceProperty -InstanceId $_.InstanceId -KeyName DEVPKEY_Device_DriverVersion
    $DriverReport += [PSCustomObject]@{
        DeviceName = $_.FriendlyName
        Status = $_.Status
        DriverVersion = $Driver.Data
        InstanceId = $_.InstanceId
        ProblemCode = $_.ProblemCode
    }
}

$DriverReport | Export-Csv -Path "C:\temp\DriverAssessment.csv"

# Batch script for driver updates
@echo off
echo Starting driver update process...

# Update via Windows Update
powershell -Command "Install-Module PSWindowsUpdate; Get-WUInstall -MicrosoftUpdate -AcceptAll -AutoReboot"

# Update specific device categories
pnputil /scan-devices

echo Driver update complete.
pause

# Comprehensive Teams Rooms health monitoring
function Test-TeamsRoomsHealth {
    param(
        [string]$LogPath = "C:\temp\TeamsRoomsHealth.log"
    )
    
    $HealthReport = @()
    $StartTime = Get-Date
    
    # Test 1: Hardware Status
    Write-Host "Checking hardware status..."
    $HardwareIssues = Get-PnpDevice | Where-Object {$_.Status -ne "OK"}
    
    $HealthReport += [PSCustomObject]@{
        Test = "Hardware Status"
        Status = if ($HardwareIssues.Count -eq 0) { "PASS" } else { "FAIL" }
        Details = "Found $($HardwareIssues.Count) problematic devices"
        Issues = ($HardwareIssues | Select-Object FriendlyName, Status | ConvertTo-Json)
    }
    
    # Test 2: Network Connectivity
    Write-Host "Testing network connectivity..."
    $NetworkTests = @(
        "teams.microsoft.com",
        "graph.microsoft.com",
        "login.microsoftonline.com"
    )
    
    $NetworkStatus = "PASS"
    $NetworkDetails = @()
    
    foreach ($Endpoint in $NetworkTests) {
        try {
            $Result = Test-NetConnection -ComputerName $Endpoint -Port 443 -InformationLevel Quiet
            if (-not $Result) {
                $NetworkStatus = "FAIL"
                $NetworkDetails += "Failed to connect to $Endpoint"
            }
        } catch {
            $NetworkStatus = "FAIL"
            $NetworkDetails += "Error testing $Endpoint : $($_.Exception.Message)"
        }
    }
    
    $HealthReport += [PSCustomObject]@{
        Test = "Network Connectivity"
        Status = $NetworkStatus
        Details = $NetworkDetails -join "; "
        Issues = ""
    }
    
    # Test 3: Service Status
    Write-Host "Checking service status..."
    $RequiredServices = @(
        "AudioSrv",
        "AudioEndpointBuilder",
        "Themes",
        "UxSms"
    )
    
    $ServiceStatus = "PASS"
    $ServiceIssues = @()
    
    foreach ($Service in $RequiredServices) {
        $ServiceInfo = Get-Service -Name $Service -ErrorAction SilentlyContinue
        if (-not $ServiceInfo -or $ServiceInfo.Status -ne "Running") {
            $ServiceStatus = "FAIL"
            $ServiceIssues += "$Service is not running"
        }
    }
    
    $HealthReport += [PSCustomObject]@{
        Test = "Service Status"
        Status = $ServiceStatus
        Details = $ServiceIssues -join "; "
        Issues = ""
    }
    
    # Test 4: Disk Space
    Write-Host "Checking disk space..."
    $SystemDrive = Get-WmiObject -Class Win32_LogicalDisk | Where-Object {$_.DeviceID -eq "C:"}
    $FreeSpacePercent = ($SystemDrive.FreeSpace / $SystemDrive.Size) * 100
    
    $DiskStatus = if ($FreeSpacePercent -gt 20) { "PASS" } else { "WARN" }
    if ($FreeSpacePercent -lt 10) { $DiskStatus = "FAIL" }
    
    $HealthReport += [PSCustomObject]@{
        Test = "Disk Space"
        Status = $DiskStatus
        Details = "Free space: $([math]::Round($FreeSpacePercent, 2))%"
        Issues = ""
    }
    
    # Test 5: Windows Updates
    Write-Host "Checking Windows Update status..."
    try {
        $UpdateSession = New-Object -ComObject Microsoft.Update.Session
        $UpdateSearcher = $UpdateSession.CreateUpdateSearcher()
        $SearchResult = $UpdateSearcher.Search("IsInstalled=0 and Type='Software'")
        
        $UpdateStatus = if ($SearchResult.Updates.Count -eq 0) { "PASS" } else { "WARN" }
        $UpdateDetails = "Pending updates: $($SearchResult.Updates.Count)"
    } catch {
        $UpdateStatus = "ERROR"
        $UpdateDetails = "Could not check for updates: $($_.Exception.Message)"
    }
    
    $HealthReport += [PSCustomObject]@{
        Test = "Windows Updates"
        Status = $UpdateStatus
        Details = $UpdateDetails
        Issues = ""
    }
    
    # Generate summary report
    $PassCount = ($HealthReport | Where-Object {$_.Status -eq "PASS"}).Count
    $FailCount = ($HealthReport | Where-Object {$_.Status -eq "FAIL"}).Count
    $WarnCount = ($HealthReport | Where-Object {$_.Status -eq "WARN"}).Count
    
    $Summary = @"
Teams Rooms Health Check Report
Generated: $StartTime
Total Tests: $($HealthReport.Count)
Passed: $PassCount
Failed: $FailCount
Warnings: $WarnCount

Overall Status: $(if ($FailCount -eq 0) { "HEALTHY" } else { "ISSUES DETECTED" })
"@
    
    Write-Host $Summary
    $Summary | Out-File -FilePath $LogPath -Append
    $HealthReport | Format-Table -AutoSize | Out-File -FilePath $LogPath -Append
    
    return $HealthReport
}

# Run health check
Test-TeamsRoomsHealth

[object Object],
,[object Object],
  ,[object Object],
    ,[object Object],2025-09-27T10:00:00,[object Object],
    ,[object Object],Teams Rooms Admin,[object Object],
    ,[object Object],Daily Teams Rooms health check and maintenance,[object Object],
  ,[object Object],
  ,[object Object],
    ,[object Object],
      ,[object Object],2025-09-27T02:00:00,[object Object],
      ,[object Object],true,[object Object],
      ,[object Object],
        ,[object Object],1,[object Object],
      ,[object Object],
    ,[object Object],
  ,[object Object],
  ,[object Object],
    ,[object Object],
      ,[object Object],S-1-5-18,[object Object],
      ,[object Object],HighestAvailable,[object Object],
    ,[object Object],
  ,[object Object],
  ,[object Object],
    ,[object Object],IgnoreNew,[object Object],
    ,[object Object],false,[object Object],
    ,[object Object],false,[object Object],
    ,[object Object],true,[object Object],
    ,[object Object],false,[object Object],
    ,[object Object],false,[object Object],
    ,[object Object],
      ,[object Object],false,[object Object],
      ,[object Object],false,[object Object],
    ,[object Object],
    ,[object Object],true,[object Object],
    ,[object Object],true,[object Object],
    ,[object Object],false,[object Object],
    ,[object Object],false,[object Object],
    ,[object Object],false,[object Object],
    ,[object Object],PT1H,[object Object],
    ,[object Object],7,[object Object],
  ,[object Object],
  ,[object Object],
    ,[object Object],
      ,[object Object],powershell.exe,[object Object],
      ,[object Object],-File "C:\Scripts\TeamsRoomsMaintenance.ps1",[object Object],
    ,[object Object],
  ,[object Object],
,[object Object],

# Teams Rooms update management script
function Update-TeamsRoomsSystem {
    param(
        [switch]$DriverUpdates,
        [switch]$WindowsUpdates,
        [switch]$TeamsAppUpdate,
        [string]$LogPath = "C:\temp\UpdateLog.txt"
    )
    
    $UpdateLog = @()
    $StartTime = Get-Date
    
    if ($DriverUpdates) {
        Write-Host "Updating drivers..."
        try {
            # Scan for driver updates
            pnputil /scan-devices
            
            # Get problematic devices
            $ProblematicDevices = Get-PnpDevice | Where-Object {$_.Status -ne "OK"}
            
            foreach ($Device in $ProblematicDevices) {
                try {
                    Update-PnpDevice -InstanceId $Device.InstanceId -Confirm:$false
                    $UpdateLog += "Successfully updated driver for: $($Device.FriendlyName)"
                } catch {
                    $UpdateLog += "Failed to update driver for: $($Device.FriendlyName) - $($_.Exception.Message)"
                }
            }
        } catch {
            $UpdateLog += "Driver update process failed: $($_.Exception.Message)"
        }
    }
    
    if ($WindowsUpdates) {
        Write-Host "Installing Windows updates..."
        try {
            if (-not (Get-Module -ListAvailable -Name PSWindowsUpdate)) {
                Install-Module PSWindowsUpdate -Force -Scope CurrentUser
            }
            
            Import-Module PSWindowsUpdate
            $Updates = Get-WUInstall -MicrosoftUpdate -AcceptAll -IgnoreReboot
            
            if ($Updates) {
                $UpdateLog += "Installed Windows updates: $($Updates.Count) updates"
            } else {
                $UpdateLog += "No Windows updates available"
            }
        } catch {
            $UpdateLog += "Windows update failed: $($_.Exception.Message)"
        }
    }
    
    if ($TeamsAppUpdate) {
        Write-Host "Checking Teams app updates..."
        try {
            # Check for Teams app updates via Store
            $StoreApps = Get-AppxPackage | Where-Object {$_.Name -like "*Teams*" -or $_.Name -like "*Skype*"}
            
            foreach ($App in $StoreApps) {
                $UpdateLog += "Teams/Skype app found: $($App.Name) - Version: $($App.Version)"
            }
            
            # Force store update check
            Start-Process "ms-windows-store://downloadsandupdates" -WindowStyle Hidden
            $UpdateLog += "Triggered Store update check for Teams applications"
        } catch {
            $UpdateLog += "Teams app update check failed: $($_.Exception.Message)"
        }
    }
    
    # Write log file
    $LogEntry = @"
Update Session: $StartTime
Actions Performed: $(if($DriverUpdates){"Drivers "})$(if($WindowsUpdates){"Windows "})$(if($TeamsAppUpdate){"Teams"})

$($UpdateLog -join "`n")

Session completed: $(Get-Date)
========================================
"@
    
    $LogEntry | Out-File -FilePath $LogPath -Append
    Write-Host "Update process completed. Log written to: $LogPath"
}

# Example usage:
# Update-TeamsRoomsSystem -DriverUpdates -WindowsUpdates -TeamsAppUpdate

# Teams Rooms event log analysis
function Analyze-TeamsRoomsEvents {
    param(
        [int]$HoursBack = 24,
        [string]$OutputPath = "C:\temp\EventAnalysis.html"
    )
    
    $StartTime = (Get-Date).AddHours(-$HoursBack)
    $EventSources = @(
        "Microsoft-Windows-TerminalServices-LocalSessionManager",
        "Application",
        "System",
        "Microsoft-Windows-Kernel-Power",
        "Microsoft-Windows-Audio",
        "Microsoft-Windows-USB-USBHUB3"
    )
    
    $EventReport = @()
    
    foreach ($Source in $EventSources) {
        Write-Host "Analyzing $Source events..."
        
        $Events = Get-WinEvent -FilterHashtable @{
            LogName = $Source
            StartTime = $StartTime
            Level = @(1,2,3)  # Critical, Error, Warning
        } -ErrorAction SilentlyContinue
        
        foreach ($Event in $Events) {
            $EventReport += [PSCustomObject]@{
                TimeCreated = $Event.TimeCreated
                LogName = $Event.LogName
                Level = switch($Event.Level) {
                    1 { "Critical" }
                    2 { "Error" }
                    3 { "Warning" }
                    default { "Information" }
                }
                Id = $Event.Id
                Source = $Event.ProviderName
                Message = $Event.Message -replace "`n", " " -replace "`r", ""
            }
        }
    }
    
    # Generate HTML report
    $HTMLReport = @"
<!DOCTYPE html>
<html>
<head>
    <title>Teams Rooms Event Analysis</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        table { border-collapse: collapse; width: 100%; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #f2f2f2; }
        .critical { background-color: #ffcccc; }
        .error { background-color: #ffe6cc; }
        .warning { background-color: #ffffcc; }
    </style>
</head>
<body>
    <h1>Teams Rooms Event Analysis Report</h1>
    <p>Generated: $(Get-Date)</p>
    <p>Time Range: Last $HoursBack hours</p>
    <p>Total Events: $($EventReport.Count)</p>
    
    <table>
        <tr>
            <th>Time</th>
            <th>Log</th>
            <th>Level</th>
            <th>Event ID</th>
            <th>Source</th>
            <th>Message</th>
        </tr>
"@
    
    foreach ($Event in ($EventReport | Sort-Object TimeCreated -Descending)) {
        $RowClass = switch($Event.Level) {
            "Critical" { "critical" }
            "Error" { "error" }
            "Warning" { "warning" }
            default { "" }
        }
        
        $HTMLReport += @"
        <tr class="$RowClass">
            <td>$($Event.TimeCreated)</td>
            <td>$($Event.LogName)</td>
            <td>$($Event.Level)</td>
            <td>$($Event.Id)</td>
            <td>$($Event.Source)</td>
            <td>$($Event.Message)</td>
        </tr>
"@
    }
    
    $HTMLReport += @"
    </table>
</body>
</html>
"@
    
    $HTMLReport | Out-File -FilePath $OutputPath -Encoding UTF8
    Write-Host "Event analysis report generated: $OutputPath"
    
    # Summary statistics
    $CriticalCount = ($EventReport | Where-Object {$_.Level -eq "Critical"}).Count
    $ErrorCount = ($EventReport | Where-Object {$_.Level -eq "Error"}).Count
    $WarningCount = ($EventReport | Where-Object {$_.Level -eq "Warning"}).Count
    
    Write-Host "Summary:"
    Write-Host "Critical Events: $CriticalCount"
    Write-Host "Error Events: $ErrorCount"
    Write-Host "Warning Events: $WarningCount"
    
    return $EventReport
}

# Run event analysis
Analyze-TeamsRoomsEvents -HoursBack 48

# Teams Rooms performance monitoring
function Monitor-TeamsRoomsPerformance {
    param(
        [int]$DurationMinutes = 60,
        [int]$SampleIntervalSeconds = 30,
        [string]$OutputPath = "C:\temp\PerformanceReport.csv"
    )
    
    $PerformanceData = @()
    $EndTime = (Get-Date).AddMinutes($DurationMinutes)
    
    Write-Host "Starting performance monitoring for $DurationMinutes minutes..."
    
    while ((Get-Date) -lt $EndTime) {
        $Timestamp = Get-Date
        
        # CPU Usage
        $CPUUsage = Get-Counter "\Processor(_Total)\% Processor Time" | Select-Object -ExpandProperty CounterSamples | Select-Object -ExpandProperty CookedValue
        
        # Memory Usage
        $MemoryInfo = Get-Counter "\Memory\Available MBytes" | Select-Object -ExpandProperty CounterSamples | Select-Object -ExpandProperty CookedValue
        $TotalMemory = (Get-WmiObject -Class Win32_ComputerSystem).TotalPhysicalMemory / 1MB
        $MemoryUsagePercent = (($TotalMemory - $MemoryInfo) / $TotalMemory) * 100
        
        # Disk Usage
        $DiskQueue = Get-Counter "\PhysicalDisk(_Total)\Current Disk Queue Length" | Select-Object -ExpandProperty CounterSamples | Select-Object -ExpandProperty CookedValue
        
        # Network Usage
        $NetworkBytes = Get-Counter "\Network Interface(*)\Bytes Total/sec" | Select-Object -ExpandProperty CounterSamples | Measure-Object CookedValue -Sum | Select-Object -ExpandProperty Sum
        
        # Teams Process Information
        $TeamsProcesses = Get-Process -Name "Microsoft.SkypeApp", "Teams" -ErrorAction SilentlyContinue
        $TeamsMemoryMB = ($TeamsProcesses | Measure-Object WorkingSet -Sum).Sum / 1MB
        $TeamsCPU = ($TeamsProcesses | Measure-Object CPU -Sum).Sum
        
        $PerformanceData += [PSCustomObject]@{
            Timestamp = $Timestamp
            CPUUsagePercent = [math]::Round($CPUUsage, 2)
            MemoryUsagePercent = [math]::Round($MemoryUsagePercent, 2)
            AvailableMemoryMB = [math]::Round($MemoryInfo, 0)
            DiskQueueLength = [math]::Round($DiskQueue, 2)
            NetworkBytesPerSec = [math]::Round($NetworkBytes, 0)
            TeamsMemoryMB = [math]::Round($TeamsMemoryMB, 2)
            TeamsCPUTime = [math]::Round($TeamsCPU, 2)
        }
        
        Write-Host "Sample $(($PerformanceData.Count)): CPU $([math]::Round($CPUUsage, 1))%, Memory $([math]::Round($MemoryUsagePercent, 1))%"
        
        Start-Sleep -Seconds $SampleIntervalSeconds
    }
    
    # Export data
    $PerformanceData | Export-Csv -Path $OutputPath -NoTypeInformation
    
    # Generate summary statistics
    $AvgCPU = ($PerformanceData | Measure-Object CPUUsagePercent -Average).Average
    $MaxCPU = ($PerformanceData | Measure-Object CPUUsagePercent -Maximum).Maximum
    $AvgMemory = ($PerformanceData | Measure-Object MemoryUsagePercent -Average).Average
    $MaxMemory = ($PerformanceData | Measure-Object MemoryUsagePercent -Maximum).Maximum
    
    Write-Host "`nPerformance Summary:"
    Write-Host "Average CPU Usage: $([math]::Round($AvgCPU, 2))%"
    Write-Host "Peak CPU Usage: $([math]::Round($MaxCPU, 2))%"
    Write-Host "Average Memory Usage: $([math]::Round($AvgMemory, 2))%"
    Write-Host "Peak Memory Usage: $([math]::Round($MaxMemory, 2))%"
    Write-Host "Data exported to: $OutputPath"
    
    return $PerformanceData
}

# Monitor performance for 30 minutes with 1-minute intervals
# Monitor-TeamsRoomsPerformance -DurationMinutes 30 -SampleIntervalSeconds 60

# Advanced hardware diagnostics for Teams Rooms
function Test-TeamsRoomsHardware {
    param(
        [switch]$TestAudio,
        [switch]$TestVideo,
        [switch]$TestUSB,
        [switch]$TestNetwork,
        [string]$ReportPath = "C:\temp\HardwareDiagnostics.json"
    )
    
    $DiagnosticResults = @{
        TestDate = Get-Date
        ComputerName = $env:COMPUTERNAME
        WindowsVersion = (Get-WmiObject -Class Win32_OperatingSystem).Version
        Tests = @{}
    }
    
    if ($TestAudio) {
        Write-Host "Testing audio devices..."
        
        $AudioDevices = Get-PnpDevice -Class AudioEndpoint | Where-Object {$_.Status -eq "OK"}
        $AudioTest = @{
            Status = "PASS"
            DeviceCount = $AudioDevices.Count
            Devices = @()
            Issues = @()
        }
        
        foreach ($Device in $AudioDevices) {
            $DeviceInfo = @{
                Name = $Device.FriendlyName
                Status = $Device.Status
                InstanceId = $Device.InstanceId
            }
            
            # Test device properties
            try {
                $Properties = Get-PnpDeviceProperty -InstanceId $Device.InstanceId
                $DeviceInfo.Properties = @{}
                
                foreach ($Property in $Properties) {
                    if ($Property.KeyName -match "DEVPKEY_Device_(DriverVersion|Manufacturer|HardwareIds)") {
                        $DeviceInfo.Properties[$Property.KeyName] = $Property.Data
                    }
                }
            } catch {
                $AudioTest.Issues += "Failed to get properties for $($Device.FriendlyName): $($_.Exception.Message)"
                $AudioTest.Status = "WARN"
            }
            
            $AudioTest.Devices += $DeviceInfo
        }
        
        # Test Windows Audio services
        $AudioServices = @("AudioSrv", "AudioEndpointBuilder", "Audiosrv")
        foreach ($Service in $AudioServices) {
            $ServiceStatus = Get-Service -Name $Service -ErrorAction SilentlyContinue
            if (-not $ServiceStatus -or $ServiceStatus.Status -ne "Running") {
                $AudioTest.Issues += "Audio service $Service is not running"
                $AudioTest.Status = "FAIL"
            }
        }
        
        $DiagnosticResults.Tests.Audio = $AudioTest
    }
    
    if ($TestVideo) {
        Write-Host "Testing video devices..."
        
        $VideoDevices = Get-PnpDevice -Class Camera | Where-Object {$_.Status -eq "OK"}
        $VideoTest = @{
            Status = "PASS"
            DeviceCount = $VideoDevices.Count
            Devices = @()
            Issues = @()
        }
        
        foreach ($Device in $VideoDevices) {
            $DeviceInfo = @{
                Name = $Device.FriendlyName
                Status = $Device.Status
                InstanceId = $Device.InstanceId
            }
            
            # Test USB Video Class compliance
            if ($Device.InstanceId -match "USB") {
                try {
                    $USBInfo = Get-PnpDeviceProperty -InstanceId $Device.InstanceId -KeyName DEVPKEY_Device_HardwareIds
                    $DeviceInfo.HardwareIds = $USBInfo.Data
                    
                    # Check for UVC compliance
                    if ($USBInfo.Data -match "USB\\Class_0E") {
                        $DeviceInfo.UVCCompliant = $true
                    } else {
                        $DeviceInfo.UVCCompliant = $false
                        $VideoTest.Issues += "$($Device.FriendlyName) may not be UVC compliant"
                        $VideoTest.Status = "WARN"
                    }
                } catch {
                    $VideoTest.Issues += "Failed to verify UVC compliance for $($Device.FriendlyName)"
                    $VideoTest.Status = "WARN"
                }
            }
            
            $VideoTest.Devices += $DeviceInfo
        }
        
        $DiagnosticResults.Tests.Video = $VideoTest
    }
    
    if ($TestUSB) {
        Write-Host "Testing USB controllers..."
        
        $USBControllers = Get-PnpDevice -Class USB | Where-Object {$_.FriendlyName -match "Host Controller"}
        $USBTest = @{
            Status = "PASS"
            ControllerCount = $USBControllers.Count
            Controllers = @()
            Issues = @()
        }
        
        foreach ($Controller in $USBControllers) {
            $ControllerInfo = @{
                Name = $Controller.FriendlyName
                Status = $Controller.Status
                InstanceId = $Controller.InstanceId
            }
            
            # Check USB version support
            if ($Controller.FriendlyName -match "3\.0|3\.1|3\.2") {
                $ControllerInfo.USBVersion = "3.x"
            } elseif ($Controller.FriendlyName -match "2\.0") {
                $ControllerInfo.USBVersion = "2.0"
            } else {
                $ControllerInfo.USBVersion = "Unknown"
            }
            
            if ($Controller.Status -ne "OK") {
                $USBTest.Issues += "USB Controller $($Controller.FriendlyName) status: $($Controller.Status)"
                $USBTest.Status = "FAIL"
            }
            
            $USBTest.Controllers += $ControllerInfo
        }
        
        $DiagnosticResults.Tests.USB = $USBTest
    }
    
    if ($TestNetwork) {
        Write-Host "Testing network connectivity..."
        
        $NetworkTest = @{
            Status = "PASS"
            Adapters = @()
            Connectivity = @()
            Issues = @()
        }
        
        # Test network adapters
        $NetworkAdapters = Get-NetAdapter | Where-Object {$_.Status -eq "Up"}
        foreach ($Adapter in $NetworkAdapters) {
            $AdapterInfo = @{
                Name = $Adapter.Name
                Status = $Adapter.Status
                LinkSpeed = $Adapter.LinkSpeed
                MediaType = $Adapter.MediaType
            }
            $NetworkTest.Adapters += $AdapterInfo
        }
        
        # Test connectivity to Microsoft services
        $TestEndpoints = @(
            "teams.microsoft.com",
            "graph.microsoft.com",
            "login.microsoftonline.com",
            "config.teams.microsoft.com"
        )
        
        foreach ($Endpoint in $TestEndpoints) {
            try {
                $ConnectTest = Test-NetConnection -ComputerName $Endpoint -Port 443 -InformationLevel Quiet
                $ConnectInfo = @{
                    Endpoint = $Endpoint
                    Success = $ConnectTest
                    Port = 443
                }
                
                if (-not $ConnectTest) {
                    $NetworkTest.Issues += "Failed to connect to $Endpoint on port 443"
                    $NetworkTest.Status = "FAIL"
                }
                
                $NetworkTest.Connectivity += $ConnectInfo
            } catch {
                $NetworkTest.Issues += "Error testing $Endpoint : $($_.Exception.Message)"
                $NetworkTest.Status = "FAIL"
            }
        }
        
        $DiagnosticResults.Tests.Network = $NetworkTest
    }
    
    # Export results
    $DiagnosticResults | ConvertTo-Json -Depth 10 | Out-File -FilePath $ReportPath -Encoding UTF8
    
    # Display summary
    Write-Host "`nDiagnostic Summary:"
    foreach ($TestName in $DiagnosticResults.Tests.Keys) {
        $TestResult = $DiagnosticResults.Tests[$TestName]
        Write-Host "$TestName Test: $($TestResult.Status)"
        if ($TestResult.Issues.Count -gt 0) {
            Write-Host "  Issues: $($TestResult.Issues.Count)"
        }
    }
    
    Write-Host "Full report saved to: $ReportPath"
    
    return $DiagnosticResults
}

# Run comprehensive hardware diagnostics
# Test-TeamsRoomsHardware -TestAudio -TestVideo -TestUSB -TestNetwork

Get-PnpDevice -Class AudioEndpoint,Camera,HIDClass | Where-Object {$_.Status -ne "OK"}