agent.py

import os
import sys
import json
import platform
import subprocess
import socket
import uuid
import psutil
import requests
import winreg
from typing import Dict, Any
import logging
import logging.handlers
import argparse
import time
import threading
from pathlib import Path
import concurrent.futures
from functools import lru_cache
import traceback

# Default configuration
DEFAULT_CONFIG = {
    "servers": {
        "development": "http://localhost:3001",
        "production": "https://10.1.32.66"
    },
    "default_server": "production",
    "log_level": "INFO",
    "send_interval": 21600,
    "hidden_mode": True,
    "create_service": False,
    "add_to_startup": False,
    "auth": {
        "email": "infraagent@localhost.com",
        "password": "Infraagent@2025"
    }
}

# Load configuration
CONFIG_FILE = 'config.json'
CONFIG = {}

try:
    with open(CONFIG_FILE, 'r') as f:
        CONFIG = json.load(f)
    
    # Validate and merge with default config
    for key, value in DEFAULT_CONFIG.items():
        if key not in CONFIG:
            CONFIG[key] = value
        elif isinstance(value, dict) and isinstance(CONFIG[key], dict):
            # Merge nested dictionaries
            for sub_key, sub_value in value.items():
                if sub_key not in CONFIG[key]:
                    CONFIG[key][sub_key] = sub_value
except Exception as e:
    print(f"Warning: Could not load config file: {e}. Using default configuration.")
    CONFIG = DEFAULT_CONFIG

# Configure logging with file rotation to prevent permission issues
class SafeRotatingFileHandler(logging.handlers.RotatingFileHandler):
    def __init__(self, filename, mode='a', maxBytes=1024*1024, backupCount=3, encoding=None, delay=False):
        # Ensure the log directory exists and has proper permissions
        log_path = Path(filename)
        if log_path.parent and not log_path.parent.exists():
            try:
                log_path.parent.mkdir(parents=True, exist_ok=True)
            except Exception as e:
                print(f"Warning: Could not create log directory {log_path.parent}: {e}")
        
        # Try to handle permission issues gracefully
        try:
            super().__init__(filename, mode, maxBytes, backupCount, encoding, delay)
        except (PermissionError, OSError) as e:
            # If we can't write to the log file, create a unique log file name in a writable location
            try:
                # Try to use a writable location like temp directory
                import tempfile
                temp_dir = Path(tempfile.gettempdir())
                unique_filename = f"infraagent_{int(time.time())}.log"
                unique_path = temp_dir / unique_filename
                super().__init__(str(unique_path), mode, maxBytes, backupCount, encoding, delay)
                print(f"Warning: Could not write to {filename}, using {unique_path} instead")
            except Exception as e2:
                print(f"Error creating log file in temp directory: {e2}")
                # Fallback to console only logging
                pass

# Configure logging with more detailed formatting and rotation
logging.basicConfig(
    level=getattr(logging, CONFIG.get('log_level', 'INFO')),
    format='%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(funcName)s() - %(message)s',
    handlers=[
        SafeRotatingFileHandler('agent.log', maxBytes=1024*1024, backupCount=3),  # 1MB files, keep 3 backups
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

class Agent:
    def __init__(self, server_url: str, token: str = ""):
        self.server_url = server_url
        self.token = token
        self.headers = {
            'Content-Type': 'application/json'
        }
        if token:
            self.headers['Authorization'] = f'Bearer {token}'
        # Create a session for connection pooling
        self.session = requests.Session()
        self.session.headers.update(self.headers)
        # Disable SSL warnings
        import urllib3
        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
    
    def login(self, email: str = "infraagent@localhost.com", password: str = "Infraagent@2025") -> bool:
        """Login to the server and obtain authentication token with optimized timeout"""
        try:
            login_url = f"{self.server_url}/api/auth/login"
            logger.info(f"Logging in to {login_url}")
            
            login_data = {
                'email': email,
                'password': password
            }
            
            response = self.session.post(
                login_url,
                json=login_data,
                timeout=(5, 15),  # (connection timeout, read timeout)
                verify=False  # Disable SSL verification for self-signed certificates
            )
            
            if response.status_code in [200, 201]:
                login_result = response.json()
                self.token = login_result.get('token', '')
                if self.token:
                    self.headers['Authorization'] = f'Bearer {self.token}'
                    self.session.headers.update(self.headers)
                    logger.info("Login successful!")
                    return True
                else:
                    logger.error("Login succeeded but no token received")
                    return False
            else:
                error_data = response.json() if response.content else {}
                logger.error(f"Login failed. Status code: {response.status_code}. Error: {error_data}")
                return False
        except requests.exceptions.ConnectionError as e:
            logger.error(f"Connection error during login (network issue): {e}")
            return False
        except Exception as e:
            logger.error(f"Error during login: {e}")
            logger.debug(f"Full traceback: {traceback.format_exc()}")
            return False
        
    @lru_cache(maxsize=1)
    def get_network_info(self) -> Dict[str, str]:
        """Get IP and MAC address with caching for performance and permission handling"""
        try:
            # Get MAC address - using a more reliable method to get the primary network adapter's MAC
            mac = ''
            ip = ''
            
            # Try multiple methods to get MAC address for better compatibility
            import subprocess
            import platform
            
            if platform.system() == "Windows":
                # Method 1: Use PowerShell to get detailed network adapter information
                # Handle both 32-bit and 64-bit PowerShell compatibility
                try:
                    ps_command = """
                    Get-WmiObject -Class Win32_NetworkAdapter -Filter "NetEnabled='true'" | 
                    Where-Object { $_.MACAddress -ne $null } | 
                    Select-Object MACAddress, Name, AdapterType |
                    ConvertTo-Json
                    """
                    # Use sysnative for 32-bit processes on 64-bit systems to access 64-bit PowerShell
                    powershell_path = "powershell"
                    if platform.architecture()[0] == "32bit" and "64" in platform.machine():
                        # Try to use 64-bit PowerShell from 32-bit process
                        sysnative_path = os.path.join(os.environ.get('SystemRoot', 'C:\\Windows'), 'Sysnative\\WindowsPowerShell\\v1.0\\powershell.exe')
                        if os.path.exists(sysnative_path):
                            powershell_path = sysnative_path
                    
                    result = subprocess.run(
                        [powershell_path, "-Command", ps_command], 
                        capture_output=True, text=True, timeout=10
                    )
                    if result.returncode == 0 and result.stdout.strip():
                        # Use the module-level json import instead of local import
                        adapters_data = json.loads(result.stdout.strip())
                        
                        # Handle both single object and array
                        if isinstance(adapters_data, list):
                            adapters = adapters_data
                        else:
                            adapters = [adapters_data] if adapters_data else []
                            
                        # Look for Ethernet adapters first, then any adapter with valid MAC
                        ethernet_adapter = None
                        first_valid_adapter = None
                        
                        for adapter in adapters:
                            mac_address = adapter.get('MACAddress', '').strip()
                            name = adapter.get('Name', '').strip()
                            adapter_type = adapter.get('AdapterType', '').strip()
                            
                            if mac_address and mac_address != "N/A" and ':' in mac_address:
                                # Normalize MAC address format
                                mac_address = mac_address.upper()
                                # Remove hyphens and colons for consistent formatting
                                clean_mac = mac_address.replace("-", "").replace(":", "")
                                
                                if not first_valid_adapter:
                                    first_valid_adapter = clean_mac
                                
                                # Prefer Ethernet adapters
                                if "ethernet" in name.lower() or "ethernet" in adapter_type.lower():
                                    ethernet_adapter = clean_mac
                                    break
                                
                                # Also check for Intel adapters specifically
                                if "intel" in name.lower() and ("i225" in name.lower() or "ethernet" in name.lower()):
                                    ethernet_adapter = clean_mac
                                    break
                        
                        # Use Ethernet adapter if found, otherwise first valid adapter
                        mac = ethernet_adapter or first_valid_adapter or ''
                except (PermissionError, subprocess.SubprocessError, FileNotFoundError, json.JSONDecodeError) as e:
                    logger.warning(f"Error getting MAC via PowerShell WMI: {e}")
                
                # Method 2: Fallback to getmac command if PowerShell method didn't work
                if not mac:
                    try:
                        result = subprocess.run(["getmac", "/fo", "csv", "/v"], 
                                              capture_output=True, text=True, timeout=5)
                        if result.returncode == 0:
                            lines = result.stdout.strip().split('\n')
                            for line in lines[1:]:  # Skip header
                                # Parse CSV line
                                parts = line.split(',')
                                if len(parts) >= 3:
                                    transport_name = parts[0].strip().strip('"')
                                    mac_address = parts[2].strip().strip('"')
                                    # Look for Ethernet adapter or Intel adapters
                                    if ("Ethernet" in transport_name or 
                                        "ethernet" in transport_name.lower() or
                                        "Intel" in transport_name):
                                        # Remove all possible separators for consistent formatting
                                        mac = mac_address.replace('-', '').replace(':', '').replace('"', '').replace("'", "").upper()
                                        break
                            # If we didn't find Ethernet, use the first valid MAC
                            if not mac:
                                for line in lines[1:]:
                                    parts = line.split(',')
                                    if len(parts) >= 3:
                                        mac_address = parts[2].strip().strip('"')
                                        if mac_address and mac_address != "N/A":
                                            # Remove all possible separators for consistent formatting
                                            mac = mac_address.replace('-', '').replace(':', '').replace('"', '').replace("'", "").upper()
                                            break
                    except (PermissionError, subprocess.SubprocessError, FileNotFoundError) as e:
                        logger.warning(f"Permission error getting MAC via getmac: {e}")
                
                # Method 3: Try using psutil for network interfaces
                if not mac:
                    try:
                        import psutil
                        interfaces = psutil.net_if_addrs()
                        for interface_name, interface_addresses in interfaces.items():
                            # Skip loopback and virtual adapters
                            if interface_name.lower().startswith('lo') or 'loopback' in interface_name.lower():
                                continue
                                
                            # Prefer physical ethernet adapters
                            if ('ethernet' in interface_name.lower() or 
                                'eth' in interface_name.lower() or
                                'intel' in interface_name.lower()):
                                for address in interface_addresses:
                                    if address.family == psutil.AF_LINK:  # MAC address
                                        # Remove all possible separators for consistent formatting
                                        mac = str(address.address).replace('-', '').replace(':', '').replace('"', '').replace("'", "").upper()
                                        break
                                if mac:
                                    break
                                    
                        # If no preferred adapter found, use first valid one
                        if not mac:
                            for interface_name, interface_addresses in interfaces.items():
                                for address in interface_addresses:
                                    if address.family == psutil.AF_LINK:  # MAC address
                                        # Remove all possible separators for consistent formatting
                                        mac = str(address.address).replace('-', '').replace(':', '').replace('"', '').replace("'", "").upper()
                                        break
                                if mac:
                                    break
                    except Exception as e:
                        logger.warning(f"Error getting MAC via psutil: {e}")
            
            # Fallback to original method if others didn't work
            if not mac:
                try:
                    mac = ''.join(['{:02x}'.format((uuid.getnode() >> elements) & 0xff) 
                                   for elements in range(0,2*6,2)][::-1])
                except Exception as e:
                    logger.error(f"Error generating MAC from uuid: {e}")
                    mac = ''
            
            # Ensure MAC address is in uppercase and has no separators
            if mac:
                mac = str(mac).upper().replace('-', '').replace(':', '').replace('"', '').replace("'", "")
            
            # Get IP address with permission handling
            try:
                hostname = socket.gethostname()
                ip = socket.gethostbyname(hostname)
            except (PermissionError, socket.error) as e:
                logger.warning(f"Permission error getting IP address: {e}")
                ip = ''
            
            return {
                'ip': ip,
                'mac': mac
            }
        except Exception as e:
            logger.error(f"Error getting network info: {e}")
            logger.debug(f"Traceback: {traceback.format_exc()}")
            # Fallback to original method
            try:
                mac = ''.join(['{:02x}'.format((uuid.getnode() >> elements) & 0xff) 
                               for elements in range(0,2*6,2)][::-1])
                # Ensure consistent formatting
                mac = str(mac).upper().replace('-', '').replace(':', '').replace('"', '').replace("'", "")
                hostname = socket.gethostname()
                ip = socket.gethostbyname(hostname)
                return {'ip': ip, 'mac': mac}
            except (PermissionError, socket.error):
                logger.error(f"Error in fallback network info")
                logger.debug(f"Traceback: {traceback.format_exc()}")
                return {'ip': '', 'mac': ''}
    
    @lru_cache(maxsize=1)
    def get_os_info(self) -> Dict[str, str]:
        """Get detailed OS information with caching for performance and permission handling"""
        try:
            import json
            
            system = platform.system()
            release = platform.release()
            version = platform.version()
            arch = platform.machine()
            
            # More user-friendly OS information
            os_name = "Unknown OS"
            os_version = ""
            os_build = ""
            os_edition = ""
            os_install_date = ""
            
            if system == "Windows":
                # Try to get more detailed Windows version info with reduced timeout and permission handling
                try:
                    result = subprocess.run(
                        ["wmic", "os", "get", "Caption,Version,BuildNumber,OperatingSystemSKU,InstallDate", "/value"], 
                        capture_output=True, text=True, timeout=10
                    )
                    if result.returncode == 0:
                        # Parse the output to extract OS information
                        for line in result.stdout.split('\n'):
                            if line.startswith('Caption='):
                                os_name = line.split('=', 1)[1].strip()
                            elif line.startswith('Version='):
                                version = line.split('=', 1)[1].strip()
                            elif line.startswith('BuildNumber='):
                                os_build = line.split('=', 1)[1].strip()
                            elif line.startswith('OperatingSystemSKU='):
                                sku = line.split('=', 1)[1].strip()
                                # Map SKU to edition (simplified)
                                sku_map = {
                                    '0': 'Undefined',
                                    '1': 'Ultimate',
                                    '2': 'Home Basic',
                                    '3': 'Home Premium',
                                    '4': 'Enterprise',
                                    '5': 'Home Basic N',
                                    '6': 'Business',
                                    '7': 'Standard Server',
                                    '8': 'Datacenter Server',
                                    '9': 'Small Business Server',
                                    '10': 'Enterprise Server',
                                    '11': 'Starter',
                                    '12': 'Datacenter Server Core',
                                    '13': 'Standard Server Core',
                                    '14': 'Enterprise Server Core',
                                    '15': 'Enterprise Server IA64',
                                    '16': 'Business N',
                                    '17': 'Web Server',
                                    '18': 'Cluster Server',
                                    '19': 'Home Server',
                                    '20': 'Storage Express Server',
                                    '21': 'Storage Standard Server',
                                    '22': 'Storage Workgroup Server',
                                    '23': 'Storage Enterprise Server',
                                    '24': 'Server For Small Business',
                                    '25': 'Small Business Server Premium',
                                    '26': 'Home Premium N',
                                    '27': 'Enterprise N',
                                    '28': 'Ultimate N',
                                    '29': 'Web Server Core',
                                    '30': 'Medium Business Server Management',
                                    '31': 'Medium Business Server Security',
                                    '32': 'Medium Business Server Messaging',
                                    '33': 'Server Foundation',
                                    '34': 'Home Premium Server',
                                    '35': 'Server For Small Business V',
                                    '36': 'Standard Server V',
                                    '37': 'Datacenter Server V',
                                    '38': 'Enterprise Server V',
                                    '39': 'Datacenter Server Core V',
                                    '40': 'Standard Server Core V',
                                    '41': 'Enterprise Server Core V',
                                    '42': 'Hypervisor Server',
                                    '43': 'Storage Express Server Core',
                                    '44': 'Storage Standard Server Core',
                                    '45': 'Storage Workgroup Server Core',
                                    '46': 'Storage Enterprise Server Core',
                                    '47': 'Starter N',
                                    '48': 'Professional',
                                    '49': 'Professional N',
                                    '50': 'Server Solutions Premium',
                                    '51': 'Server Solutions Premium Core',
                                    '52': 'Enterprise Storage Server',
                                    '53': 'Starter Edition',
                                    '54': 'Home Basic Edition',
                                    '55': 'Home Premium Edition',
                                    '56': 'Business Edition',
                                    '57': 'Enterprise Edition',
                                    '58': 'Ultimate Edition',
                                    '59': 'Home Server 2011',
                                    '60': 'Server For SB Solutions EM',
                                    '61': 'Server For SB Solutions',
                                    '62': 'Standard Server Solutions',
                                    '63': 'Standard Server Solutions Core',
                                    '64': 'SB Solution Server EM',
                                    '65': 'SB Solution Server',
                                    '66': 'Windows Essential Server Solution Management',
                                    '67': 'Windows Essential Server Solution Additional',
                                    '68': 'Windows Essential Server Solution Management SVC',
                                    '69': 'Windows Essential Server Solution Additional SVC',
                                    '70': 'Small Business Server Premium Core',
                                    '71': 'Cluster Server Core',
                                    '72': 'Enterprise Evaluation Edition',
                                    '73': 'Prerelease',
                                    '74': 'Evaluation Edition',
                                    '75': 'Azure Server Core',
                                    '76': 'Azure Nano Server',
                                    '77': 'Azure Server Datacenter',
                                    '78': 'Azure Server Standard',
                                    '79': 'Azure Server Datacenter Core',
                                    '80': 'Azure Server Standard Core',
                                    '81': 'Windows 10 IoT Core',
                                    '82': 'Windows 10 IoT Core Commercial',
                                    '83': 'Windows 10 S',
                                    '84': 'Windows 10 S N',
                                    '85': 'Windows 10 Pro for Workstations',
                                    '86': 'Windows 10 Pro for Workstations N',
                                    '87': 'Windows 10 IoT Core Services Commercial',
                                    '88': 'Windows 10 Lean',
                                    '89': 'Windows 10 Lean N',
                                    '90': 'Windows 10 Education',
                                    '91': 'Windows 10 Education N',
                                    '92': 'Windows 10 Pro Education',
                                    '93': 'Windows 10 Pro Education N',
                                    '94': 'Windows 10 Pro for Workstations with Advanced Threat Protection',
                                    '95': 'Windows 10 Pro for Workstations N with Advanced Threat Protection',
                                    '96': 'Windows 10 Pro with Advanced Threat Protection',
                                    '97': 'Windows 10 Pro N with Advanced Threat Protection',
                                    '98': 'Windows 10 Enterprise with Advanced Threat Protection',
                                    '99': 'Windows 10 Enterprise N with Advanced Threat Protection',
                                    '100': 'Windows 10 Education with Advanced Threat Protection',
                                    '101': 'Windows 10 Education N with Advanced Threat Protection',
                                    '102': 'Windows 10 Pro Education with Advanced Threat Protection',
                                    '103': 'Windows 10 Pro Education N with Advanced Threat Protection',
                                    '104': 'Windows 10 Pro Single Language',
                                    '105': 'Windows 10 Pro Single Language with Advanced Threat Protection',
                                    '106': 'Windows 10 Pro Single Language N',
                                    '107': 'Windows 10 Pro Single Language N with Advanced Threat Protection',
                                    '108': 'Windows 10 Pro for Workstations Single Language',
                                    '109': 'Windows 10 Pro for Workstations Single Language with Advanced Threat Protection',
                                    '110': 'Windows 10 Pro for Workstations Single Language N',
                                    '111': 'Windows 10 Pro for Workstations Single Language N with Advanced Threat Protection'
                                }
                                os_edition = sku_map.get(sku, f"SKU {sku}")
                            elif line.startswith('InstallDate='):
                                install_date = line.split('=', 1)[1].strip()
                                if install_date:
                                    # Format the install date
                                    try:
                                        # WMIC date format: YYYYMMDDHHMMSS.mmmmmm+UUU
                                        year = install_date[:4]
                                        month = install_date[4:6]
                                        day = install_date[6:8]
                                        os_install_date = f"{year}-{month}-{day}"
                                    except:
                                        os_install_date = install_date
                                
                        # Improve Windows version detection
                        # Windows 11 has build numbers starting with 22000 or higher
                        if os_build.isdigit() and int(os_build) >= 22000:
                            # This is Windows 11
                            os_name = os_name.replace("Microsoft Windows 10", "Microsoft Windows 11")
                        elif "Windows 10" in os_name and os_build.isdigit() and int(os_build) >= 22000:
                            # Fallback check for Windows 11
                            os_name = os_name.replace("Microsoft Windows 10", "Microsoft Windows 11")
                except (PermissionError, subprocess.SubprocessError, FileNotFoundError) as e:
                    logger.warning(f"Permission error getting OS info via WMIC: {e}")
                
                # If we still don't have OS info, try alternative methods
                if os_name == "Unknown OS":
                    try:
                        # Try PowerShell to get OS information
                        ps_command = """
                        $os = Get-CimInstance -ClassName Win32_OperatingSystem | Select-Object Caption,Version,BuildNumber,OperatingSystemSKU,InstallDate
                        $os | ConvertTo-Json
                        """
                        result = subprocess.run(
                            ["powershell", "-Command", ps_command],
                            capture_output=True, text=True, timeout=10
                        )
                        if result.returncode == 0 and result.stdout.strip():
                            os_data = json.loads(result.stdout.strip())
                            os_name = os_data.get('Caption', '').strip()
                            version = os_data.get('Version', version)
                            os_build = os_data.get('BuildNumber', os_build)
                            
                            # Check for Windows 11
                            if os_build.isdigit() and int(os_build) >= 22000:
                                os_name = os_name.replace("Microsoft Windows 10", "Microsoft Windows 11")
                            elif "Windows 10" in os_name and os_build.isdigit() and int(os_build) >= 22000:
                                os_name = os_name.replace("Microsoft Windows 10", "Microsoft Windows 11")
                    except (PermissionError, subprocess.SubprocessError, FileNotFoundError, json.JSONDecodeError) as e:
                        logger.warning(f"Permission error getting OS info via PowerShell: {e}")
                
                # Final fallback to basic platform info
                if os_name == "Unknown OS":
                    os_name = f"{system} {release}"
                    os_build = version
                
                # Create the simplified OS version string (user preference)
                # Handle 32-bit vs 64-bit architecture properly
                if "64" in arch or "AMD64" in arch:
                    architecture = "AMD64"
                elif "86" in arch or "32" in arch:
                    architecture = "x86"
                else:
                    architecture = arch
                    
                os_version = f"{os_name} {architecture}"
                if os_build:
                    os_version += f" Build {os_build}"
            else:
                # For non-Windows systems
                os_name = f"{system} {release}"
                # Handle architecture for non-Windows systems
                if "64" in arch:
                    architecture = "x64"
                elif "86" in arch or "32" in arch:
                    architecture = "x86"
                else:
                    architecture = arch
                os_version = f"{os_name} {architecture}"
                os_build = version
            
            return {
                'platform': system.lower(),
                'release': os_name,
                'build': os_build,
                'arch': architecture,  # Return the corrected architecture
                'edition': os_edition,
                'installDate': os_install_date,
                'full': os_version
            }
        except Exception as e:
            logger.error(f"Error getting OS info: {e}")
            logger.debug(f"Traceback: {traceback.format_exc()}")
            # Fallback with proper architecture detection
            fallback_arch = platform.machine()
            if "64" in fallback_arch or "AMD64" in fallback_arch:
                fallback_architecture = "AMD64"
            elif "86" in fallback_arch or "32" in fallback_arch:
                fallback_architecture = "x86"
            else:
                fallback_architecture = fallback_arch
                
            return {
                'platform': platform.system().lower(),
                'release': platform.release(),
                'build': platform.version(),
                'arch': fallback_architecture,
                'edition': '',
                'installDate': '',
                'full': f"{platform.system()} {platform.release()} {fallback_architecture}"
            }
    
    @lru_cache(maxsize=1)
    def get_system_specs(self) -> Dict[str, Any]:
        """Get system specifications with caching for performance and permission handling"""
        try:
            import platform  # Import platform module at the function level to ensure it's available
            
            # Get memory info with permission handling
            total_memory_gb = 0
            available_memory_gb = 0
            memory_speed_mhz = "Unknown"
            memory_type = "Unknown"
            
            try:
                mem = psutil.virtual_memory()
                total_memory_gb = round(mem.total / (1024**3))
                available_memory_gb = round(mem.available / (1024**3))
            except (PermissionError, psutil.AccessDenied) as e:
                logger.warning(f"Permission error getting memory info: {e}")
                total_memory_gb = 0
                available_memory_gb = 0
            
            # Get detailed memory information on Windows
            try:
                if platform.system() == "Windows":
                    # Try to get memory speed and type using wmic
                    result = subprocess.run(
                        ["wmic", "memorychip", "get", "Speed,MemoryType,FormFactor,Capacity,DeviceLocator,Manufacturer", "/format:csv"], 
                        capture_output=True, text=True, timeout=10
                    )
                    if result.returncode == 0 and result.stdout.strip():
                        lines = result.stdout.strip().split('\n')
                        if len(lines) > 1:
                            # Parse memory modules information
                            speeds = []
                            types = []
                            
                            for line in lines[1:]:  # Skip header
                                parts = line.split(',')
                                if len(parts) >= 7:
                                    try:
                                        speed = parts[-6].strip()  # Speed column
                                        mem_type = parts[-5].strip()  # MemoryType column
                                        # Only use speed if it's a reasonable value (not memory size)
                                        if speed.isdigit() and speed != "0" and int(speed) < 1000000:
                                            speeds.append(int(speed))
                                        # Memory type mapping (simplified)
                                        type_mapping = {
                                            "20": "DDR",
                                            "21": "DDR2",
                                            "24": "DDR3",
                                            "26": "DDR4",
                                            "34": "DDR5"
                                        }
                                        if mem_type in type_mapping:
                                            types.append(type_mapping[mem_type])
                                    except Exception as e:
                                        logger.debug(f"Error parsing memory module info: {e}")
                            
                            # Determine common speed and type
                            if speeds:
                                memory_speed_mhz = f"{max(speeds)} MHz"  # Use maximum speed
                            if types:
                                # Use the most common type
                                from collections import Counter
                                type_counts = Counter(types)
                                memory_type = type_counts.most_common(1)[0][0]
            except (PermissionError, subprocess.SubprocessError, FileNotFoundError) as e:
                logger.warning(f"Permission error getting detailed memory info: {e}")
            
            # Get CPU info with permission handling
            cpu_model = "Unknown"
            cpu_count = 0
            cpu_freq_str = "Unknown"
            cpu_threads = 0
            cpu_architecture = "Unknown"
            
            try:
                cpu_count = psutil.cpu_count(logical=False)  # Physical cores
                cpu_threads = psutil.cpu_count(logical=True)  # Logical cores (threads)
            except (PermissionError, psutil.AccessDenied) as e:
                logger.warning(f"Permission error getting CPU count: {e}")
                cpu_count = 0
                cpu_threads = 0
                
            try:
                cpu_freq = psutil.cpu_freq()
                cpu_freq_str = f"{cpu_freq.current:.2f}MHz" if cpu_freq else "Unknown"
            except (PermissionError, psutil.AccessDenied, NotImplementedError) as e:
                logger.warning(f"Permission error getting CPU frequency: {e}")
                cpu_freq_str = "Unknown"
            
            # Get CPU architecture with better 32-bit/64-bit detection
            try:
                cpu_architecture = platform.machine()
                # Normalize architecture naming for consistency
                if "64" in cpu_architecture or "AMD64" in cpu_architecture:
                    cpu_architecture = "AMD64"
                elif "86" in cpu_architecture or "32" in cpu_architecture:
                    cpu_architecture = "x86"
                else:
                    # Try alternative methods for better architecture detection
                    if platform.system() == "Windows":
                        try:
                            # Use WMIC to get system type for more accurate architecture detection
                            result = subprocess.run(
                                ["wmic", "computersystem", "get", "SystemType", "/value"], 
                                capture_output=True, text=True, timeout=5
                            )
                            if result.returncode == 0:
                                for line in result.stdout.split('\n'):
                                    if line.startswith('SystemType='):
                                        system_type = line.split('=', 1)[1].strip()
                                        if "64" in system_type:
                                            cpu_architecture = "AMD64"
                                        elif "86" in system_type or "32" in system_type:
                                            cpu_architecture = "x86"
                                        break
                        except Exception as e:
                            logger.warning(f"Error getting system type via WMIC: {e}")
            except Exception as e:
                logger.warning(f"Error getting CPU architecture: {e}")
                cpu_architecture = "Unknown"
            
            # Try to get better CPU name using multiple methods on Windows
            try:
                if platform.system() == "Windows":
                    # Method 1: Try to get CPU name using WMIC with more detailed information
                    result = subprocess.run(
                        ["wmic", "cpu", "get", "Name,NumberOfCores,NumberOfLogicalProcessors,MaxClockSpeed,L2CacheSize,L3CacheSize,Architecture", "/format:csv"], 
                        capture_output=True, text=True, timeout=10
                    )
                    if result.returncode == 0 and result.stdout.strip():
                        # Parse CSV output
                        lines = result.stdout.strip().split('\n')
                        if len(lines) > 1:
                            # Skip header line
                            data_line = lines[1]
                            parts = data_line.split(',')
                            if len(parts) >= 8:
                                # Extract CPU name (should be the last part)
                                cpu_model = parts[-7].strip() if parts[-7].strip() else "Unknown"
                                
                                # We can also extract other details if needed in the future
                                
                    # Method 2: If WMIC didn't work or didn't provide detailed info, try PowerShell with enhanced approach
                    if cpu_model == "Unknown" or cpu_model == "":
                        # Enhanced PowerShell approach with multiple methods
                        ps_commands = [
                            # Method 2a: Get CPU information using Get-CimInstance (modern approach)
                            """
                            $cpu = Get-CimInstance -ClassName Win32_Processor | Select-Object Name, NumberOfCores, NumberOfLogicalProcessors, MaxClockSpeed
                            $cpu | ConvertTo-Json
                            """,
                            # Method 2b: Fallback to Get-WmiObject (for older systems)
                            """
                            $cpu = Get-WmiObject -Class Win32_Processor | Select-Object Name, NumberOfCores, NumberOfLogicalProcessors, MaxClockSpeed
                            $cpu | ConvertTo-Json
                            """,
                            # Method 2c: Get detailed processor information from registry via PowerShell
                            """
                            $cpu = Get-ItemProperty -Path "HKLM:\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0" -Name ProcessorNameString -ErrorAction SilentlyContinue
                            if ($cpu) {
                                @{Name = $cpu.ProcessorNameString.Trim()}
                            } else {
                                $null
                            }
                            | ConvertTo-Json
                            """
                        ]
                        
                        # Try each PowerShell command in order
                        for ps_command in ps_commands:
                            try:
                                result = subprocess.run(
                                    ["powershell", "-Command", ps_command],
                                    capture_output=True, text=True, timeout=10
                                )
                                if result.returncode == 0 and result.stdout.strip():
                                    import json
                                    cpu_data = json.loads(result.stdout.strip())
                                    # Handle both single object and array
                                    if isinstance(cpu_data, list) and len(cpu_data) > 0:
                                        cpu_model = cpu_data[0].get('Name', '').strip() or cpu_data[0].get('ProcessorNameString', '').strip()
                                    elif isinstance(cpu_data, dict):
                                        cpu_model = cpu_data.get('Name', '').strip() or cpu_data.get('ProcessorNameString', '').strip()
                                    
                                    if cpu_model:
                                        break  # Success, exit the loop
                            except Exception as e:
                                logger.debug(f"PowerShell command failed: {e}")
                                continue
                            
                    # Method 3: Try registry approach for more exact CPU information with enhanced error handling
                    if cpu_model == "Unknown" or cpu_model == "":
                        try:
                            # Enhanced registry approach with multiple keys
                            registry_keys = [
                                r"HARDWARE\DESCRIPTION\System\CentralProcessor\0",
                                r"HARDWARE\DESCRIPTION\System\CentralProcessor\1"  # Sometimes the first core has better info
                            ]
                            
                            for reg_key in registry_keys:
                                try:
                                    with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, reg_key) as key:
                                        # Try multiple value names
                                        value_names = ["ProcessorNameString", "Identifier", "VendorIdentifier"]
                                        for value_name in value_names:
                                            try:
                                                cpu_model = winreg.QueryValueEx(key, value_name)[0].strip()
                                                if cpu_model and cpu_model != "Unknown":
                                                    break
                                            except FileNotFoundError:
                                                continue
                                        if cpu_model and cpu_model != "Unknown":
                                            break
                                except Exception as e:
                                    logger.debug(f"Registry key {reg_key} access failed: {e}")
                                    continue
                        except Exception as e:
                            logger.warning(f"Error getting CPU from registry: {e}")
                            
                    # Method 4: Try to get detailed CPU information using CPUID or other methods
                    if cpu_model == "Unknown" or cpu_model == "":
                        try:
                            # Try to get more detailed CPU information using wmic with different approach
                            result = subprocess.run(
                                ["wmic", "computersystem", "get", "SystemType", "/value"], 
                                capture_output=True, text=True, timeout=5
                            )
                            if result.returncode == 0:
                                for line in result.stdout.split('\n'):
                                    if line.startswith('SystemType='):
                                        system_type = line.split('=', 1)[1].strip()
                                        if system_type:
                                            cpu_architecture = system_type
                        except Exception as e:
                            logger.warning(f"Error getting system type: {e}")
                            
                    # Method 5: Enhanced platform.processor() with additional checks
                    if cpu_model == "Unknown" or cpu_model == "":
                        try:
                            # Try to get CPU information using different approaches
                            import platform
                            temp_cpu_model = platform.processor()
                            if temp_cpu_model and temp_cpu_model != "Unknown":
                                cpu_model = temp_cpu_model
                        except Exception as e:
                            logger.debug(f"Error getting CPU model from platform.processor(): {e}")
                            
                        # Additional check using environment variables
                        if cpu_model == "Unknown" or cpu_model == "":
                            try:
                                # Check environment variables that might contain CPU info
                                processor_identifier = os.environ.get('PROCESSOR_IDENTIFIER', '')
                                if processor_identifier and processor_identifier != "Unknown":
                                    cpu_model = processor_identifier
                            except Exception as e:
                                logger.debug(f"Error getting CPU model from environment: {e}")
                else:
                    # For non-Windows systems with enhanced detection
                    try:
                        # Try to get CPU information using /proc/cpuinfo on Linux with enhanced parsing
                        if os.path.exists('/proc/cpuinfo'):
                            with open('/proc/cpuinfo', 'r') as f:
                                for line in f:
                                    if line.startswith('model name'):
                                        temp_cpu_model = line.split(':', 1)[1].strip()
                                        if temp_cpu_model:
                                            cpu_model = temp_cpu_model
                                            break
                                    
                                    # Fallback to other identifiers
                                    if not cpu_model or cpu_model == "Unknown":
                                        if line.startswith('cpu'):
                                            temp_cpu_model = line.split(':', 1)[1].strip()
                                            if temp_cpu_model:
                                                cpu_model = temp_cpu_model
                        else:
                            # Try alternative methods for Unix-like systems
                            try:
                                # Try sysctl on macOS/BSD systems
                                result = subprocess.run(
                                    ["sysctl", "-n", "machdep.cpu.brand_string"], 
                                    capture_output=True, text=True, timeout=5
                                )
                                if result.returncode == 0 and result.stdout.strip():
                                    temp_cpu_model = result.stdout.strip()
                                    if temp_cpu_model:
                                        cpu_model = temp_cpu_model
                            except Exception as e:
                                logger.debug(f"Error getting CPU model from sysctl: {e}")
                    except Exception as e:
                        logger.warning(f"Error reading /proc/cpuinfo: {e}")
            except (PermissionError, subprocess.SubprocessError, FileNotFoundError) as e:
                logger.warning(f"Permission error getting CPU name: {e}")
            
            # Fallback to platform.processor() if other methods didn't work
            if cpu_model == "Unknown" or cpu_model == "":
                try:
                    cpu_model = platform.processor() or "Unknown"
                except Exception as e:
                    logger.warning(f"Error getting CPU model from platform: {e}")
                    cpu_model = "Unknown"
            
            # Enhanced fallback mechanisms for CPU detection failures
            if cpu_model == "Unknown" or cpu_model == "":
                try:
                    logger.debug("All primary CPU detection methods failed, trying enhanced fallback methods")
                    
                    # Fallback Method 1: Try to get CPU information from Windows Management Instrumentation (WMI) with different approach
                    if platform.system() == "Windows":
                        try:
                            # Use PowerShell with Get-WmiObject as an alternative approach
                            ps_command = """
                            $ErrorActionPreference = "SilentlyContinue"
                            $cpu = Get-WmiObject -Class Win32_Processor -Property Name, Caption, Description | Select-Object -First 1 Name, Caption, Description
                            if ($cpu) {
                                if ($cpu.Name) { $cpu.Name }
                                elseif ($cpu.Caption) { $cpu.Caption }
                                elseif ($cpu.Description) { $cpu.Description }
                                else { "Unknown" }
                            } else {
                                "Unknown"
                            }
                            """
                            result = subprocess.run(
                                ["powershell", "-Command", ps_command],
                                capture_output=True, text=True, timeout=15
                            )
                            if result.returncode == 0 and result.stdout.strip() and result.stdout.strip() != "Unknown":
                                cpu_model = result.stdout.strip()
                                logger.debug(f"CPU model detected via PowerShell WMI fallback: {cpu_model}")
                        except Exception as e:
                            logger.debug(f"PowerShell WMI fallback failed: {e}")
                    
                    # Fallback Method 2: Try to get CPU information from system information command
                    if cpu_model == "Unknown" or cpu_model == "":
                        try:
                            # Use systeminfo command to get system information including CPU
                            result = subprocess.run(
                                ["systeminfo"], 
                                capture_output=True, text=True, timeout=20
                            )
                            if result.returncode == 0 and result.stdout:
                                # Parse systeminfo output to find CPU information
                                for line in result.stdout.split('\n'):
                                    if 'Processor(s):' in line:
                                        # Extract CPU information from the line
                                        cpu_info = line.split(':', 1)[1].strip() if ':' in line else line.strip()
                                        if cpu_info and cpu_info != "":
                                            cpu_model = cpu_info
                                            logger.debug(f"CPU model detected via systeminfo: {cpu_model}")
                                            break
                        except Exception as e:
                            logger.debug(f"Systeminfo fallback failed: {e}")
                    
                    # Fallback Method 3: Try to get CPU information from MSInfo32 export (if available)
                    if cpu_model == "Unknown" or cpu_model == "":
                        try:
                            import tempfile
                            import xml.etree.ElementTree as ET
                            
                            # Create temporary file for MSInfo32 export
                            with tempfile.NamedTemporaryFile(suffix='.xml', delete=False) as tmp_file:
                                tmp_filename = tmp_file.name
                            
                            try:
                                # Export system information to XML
                                result = subprocess.run(
                                    ["msinfo32", "/report", tmp_filename, "/category", "components"], 
                                    capture_output=True, text=True, timeout=30
                                )
                                
                                if result.returncode == 0 and os.path.exists(tmp_filename):
                                    # Parse the XML file to find CPU information
                                    tree = ET.parse(tmp_filename)
                                    root = tree.getroot()
                                    
                                    # Look for CPU information in the XML
                                    for elem in root.iter():
                                        if elem.text and ('processor' in elem.text.lower() or 'cpu' in elem.text.lower()):
                                            # Check siblings or parent elements for the actual CPU name
                                            # In ElementTree, we need to find the parent by iterating through the tree
                                            # For now, let's just check the element itself and its siblings
                                            if elem.text and len(elem.text) > 10:
                                                if 'intel' in elem.text.lower() or 'amd' in elem.text.lower():
                                                    cpu_model = elem.text.strip()
                                                    logger.debug(f"CPU model detected via MSInfo32: {cpu_model}")
                                                    break
                            except Exception as e:
                                logger.debug(f"MSInfo32 fallback failed: {e}")
                            finally:
                                # Clean up temporary file
                                try:
                                    if os.path.exists(tmp_filename):
                                        os.unlink(tmp_filename)
                                except Exception as e:
                                    logger.debug(f"Failed to clean up temporary file: {e}")
                        except Exception as e:
                            logger.debug(f"MSInfo32 fallback setup failed: {e}")
                    
                    # Fallback Method 4: Enhanced registry scanning with multiple keys
                    if cpu_model == "Unknown" or cpu_model == "":
                        try:
                            # Try multiple registry locations for CPU information
                            registry_paths = [
                                r" HARDWARE\DESCRIPTION\System\CentralProcessor\0",
                                r"HARDWARE\DEVICEMAP\Scsi\Scsi Port 0\Scsi Bus 0\Target Id 0\Logical Unit Id 0",
                                r"SYSTEM\CurrentControlSet\Control\SystemInformation"
                            ]
                            
                            registry_values = ["ProcessorNameString", "Identifier", "VendorIdentifier", "SystemProductName"]
                            
                            for reg_path in registry_paths:
                                try:
                                    with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, reg_path.strip()) as key:
                                        for value_name in registry_values:
                                            try:
                                                value, _ = winreg.QueryValueEx(key, value_name)
                                                if value and isinstance(value, str) and len(value) > 5:
                                                    # Check if it looks like a CPU name
                                                    if any(cpu_keyword in value.lower() for cpu_keyword in 
                                                          ['intel', 'amd', 'processor', 'cpu', 'core', 'xeon', 'ryzen', 'athlon']):
                                                        cpu_model = value.strip()
                                                        logger.debug(f"CPU model detected via registry scanning: {cpu_model}")
                                                        break
                                            except FileNotFoundError:
                                                continue
                                        if cpu_model != "Unknown":
                                            break
                                except Exception as e:
                                    logger.debug(f"Registry path {reg_path} access failed: {e}")
                                    continue
                        except Exception as e:
                            logger.debug(f"Enhanced registry scanning failed: {e}")
                    
                    # Fallback Method 5: CPUID-based detection (if available)
                    if cpu_model == "Unknown" or cpu_model == "":
                        try:
                            # Try to use CPUID instruction via external tool if available
                            # This is a more advanced method that might require additional tools
                            logger.debug("Attempting CPUID-based detection (if available)")
                            
                            # Check if common CPUID tools are available
                            cpu_id_tools = ["cpuid", "cpu-z-cli", "hwinfo"]
                            for tool in cpu_id_tools:
                                try:
                                    result = subprocess.run(
                                        [tool, "--help"], 
                                        capture_output=True, text=True, timeout=3
                                    )
                                    if result.returncode in [0, 1]:  # Tool exists
                                        logger.debug(f"Found CPUID tool: {tool}")
                                        # Use the tool to get CPU information
                                        if tool == "cpuid":
                                            result = subprocess.run(
                                                [tool], 
                                                capture_output=True, text=True, timeout=10
                                            )
                                            if result.returncode == 0 and result.stdout:
                                                # Parse CPUID output to find CPU name
                                                for line in result.stdout.split('\n'):
                                                    if 'Processor' in line and 'Intel' in line or 'AMD' in line:
                                                        cpu_model = line.strip()
                                                        logger.debug(f"CPU model detected via CPUID: {cpu_model}")
                                                        break
                                        break
                                except Exception as e:
                                    logger.debug(f"CPUID tool {tool} not available or failed: {e}")
                                    continue
                        except Exception as e:
                            logger.debug(f"CPUID-based detection failed: {e}")
                    
                    # Final Fallback: Construct a descriptive name based on available information
                    if cpu_model == "Unknown" or cpu_model == "":
                        try:
                            logger.debug("Constructing descriptive CPU name from available information")
                            
                            # Gather available information
                            vendor = "Unknown"
                            family = "Unknown"
                            model = "Unknown"
                            stepping = "Unknown"
                            
                            # Try to get basic CPU information from environment
                            if platform.system() == "Windows":
                                vendor = os.environ.get('PROCESSOR_VENDOR', 'Unknown')
                                family = os.environ.get('PROCESSOR_FAMILY', 'Unknown')
                                model = os.environ.get('PROCESSOR_MODEL', 'Unknown')
                                stepping = os.environ.get('PROCESSOR_STEPPING', 'Unknown')
                            
                            # Try to get architecture information
                            arch_info = platform.machine()
                            
                            # Construct a descriptive name
                            if vendor != "Unknown" or family != "Unknown":
                                constructed_name = f"{vendor if vendor != 'Unknown' else 'CPU'} Family {family} Model {model}"
                                if arch_info != "Unknown":
                                    constructed_name += f" ({arch_info})"
                                cpu_model = constructed_name
                                logger.debug(f"Constructed CPU name: {cpu_model}")
                            else:
                                # Ultimate fallback
                                cpu_model = f"Unknown CPU ({platform.machine()})"
                                logger.debug(f"Ultimate fallback CPU name: {cpu_model}")
                        except Exception as e:
                            logger.debug(f"Constructing descriptive CPU name failed: {e}")
                            cpu_model = f"Unknown CPU ({platform.machine()})"
                            
                except Exception as e:
                    logger.error(f"Error in CPU detection fallback mechanisms: {e}")
                    logger.debug(f"Traceback: {traceback.format_exc()}")
                    cpu_model = "Unknown CPU"
            
            # Enhanced CPU core and thread detection with fallbacks
            try:
                # Primary method: psutil
                cpu_count = psutil.cpu_count(logical=False)  # Physical cores
                cpu_threads = psutil.cpu_count(logical=True)  # Logical cores (threads)
                
                # Validate the results
                if cpu_count is None or cpu_threads is None:
                    raise Exception("psutil returned None for CPU count")
                    
                # Additional validation - if physical cores > logical cores, something is wrong
                if cpu_count > cpu_threads:
                    logger.warning(f"Invalid CPU count detected: physical ({cpu_count}) > logical ({cpu_threads}), using fallback")
                    raise Exception("Invalid CPU count values")
            except Exception as e:
                logger.warning(f"Primary CPU count detection failed: {e}")
                cpu_count = 0
                cpu_threads = 0
                
                # Fallback methods for CPU count detection
                try:
                    if platform.system() == "Windows":
                        # Method 1: Use WMIC to get CPU core information
                        try:
                            result = subprocess.run(
                                ["wmic", "cpu", "get", "NumberOfCores,NumberOfLogicalProcessors", "/format:csv"], 
                                capture_output=True, text=True, timeout=10
                            )
                            if result.returncode == 0 and result.stdout.strip():
                                lines = result.stdout.strip().split('\n')
                                if len(lines) > 1:
                                    # Parse CSV output
                                    header = lines[0].split(',')
                                    data_line = lines[1].split(',')
                                    
                                    # Find the correct columns
                                    cores_index = -1
                                    logical_index = -1
                                    for i, col in enumerate(header):
                                        if 'NumberOfCores' in col:
                                            cores_index = i
                                        elif 'NumberOfLogicalProcessors' in col:
                                            logical_index = i
                                    
                                    if cores_index != -1 and logical_index != -1:
                                        cpu_count = int(data_line[cores_index].strip())
                                        cpu_threads = int(data_line[logical_index].strip())
                        except Exception as e:
                            logger.debug(f"WMIC CPU count detection failed: {e}")
                        
                        # Method 2: Use PowerShell as fallback
                        if cpu_count == 0 or cpu_threads == 0:
                            try:
                                ps_command = """
                                $cpu = Get-WmiObject -Class Win32_Processor | Measure-Object -Property NumberOfCores, NumberOfLogicalProcessors -Sum
                                "Cores:$($cpu[0].Sum) Threads:$($cpu[1].Sum)"
                                """
                                result = subprocess.run(
                                    ["powershell", "-Command", ps_command],
                                    capture_output=True, text=True, timeout=10
                                )
                                if result.returncode == 0 and result.stdout.strip():
                                    output = result.stdout.strip()
                                    # Parse the output
                                    if 'Cores:' in output and 'Threads:' in output:
                                        cores_part = output.split('Cores:')[1].split(' Threads:')[0]
                                        threads_part = output.split('Threads:')[1]
                                        cpu_count = int(cores_part)
                                        cpu_threads = int(threads_part)
                            except Exception as e:
                                logger.debug(f"PowerShell CPU count detection failed: {e}")
                        
                        # Method 3: Use environment variables
                        if cpu_count == 0 or cpu_threads == 0:
                            try:
                                cpu_count = int(os.environ.get('NUMBER_OF_PROCESSORS', 0))
                                cpu_threads = cpu_count  # Assume threads = cores if we can't determine separately
                            except Exception as e:
                                logger.debug(f"Environment variable CPU count detection failed: {e}")
                    else:
                        # For non-Windows systems, try different approaches
                        try:
                            # Method 1: Use nproc command (Linux/Unix)
                            result = subprocess.run(
                                ["nproc", "--all"], 
                                capture_output=True, text=True, timeout=5
                            )
                            if result.returncode == 0 and result.stdout.strip():
                                cpu_threads = int(result.stdout.strip())
                                cpu_count = cpu_threads  # Assume threads = cores if we can't determine separately
                        except Exception as e:
                            logger.debug(f"nproc CPU count detection failed: {e}")
                        
                        # Method 2: Check /proc/cpuinfo (Linux)
                        if cpu_count == 0 or cpu_threads == 0:
                            try:
                                if os.path.exists('/proc/cpuinfo'):
                                    physical_cores = 0
                                    logical_cores = 0
                                    with open('/proc/cpuinfo', 'r') as f:
                                        for line in f:
                                            if line.startswith('cpu cores'):
                                                physical_cores += int(line.split(':')[1].strip())
                                            elif line.startswith('siblings'):
                                                logical_cores += int(line.split(':')[1].strip())
                                    cpu_count = physical_cores
                                    cpu_threads = logical_cores if logical_cores > 0 else physical_cores
                            except Exception as e:
                                logger.debug(f"/proc/cpuinfo CPU count detection failed: {e}")
                except Exception as e:
                    logger.error(f"CPU count detection fallback methods failed: {e}")
                    cpu_count = 0
                    cpu_threads = 0
            
            # Enhanced CPU frequency detection with fallbacks
            try:
                # Primary method: psutil
                cpu_freq = psutil.cpu_freq()
                cpu_freq_str = f"{cpu_freq.current:.2f}MHz" if cpu_freq and cpu_freq.current else "Unknown"
            except (PermissionError, psutil.AccessDenied, NotImplementedError) as e:
                logger.warning(f"Primary CPU frequency detection failed: {e}")
                cpu_freq_str = "Unknown"
                
                # Fallback methods for CPU frequency detection
                try:
                    if platform.system() == "Windows":
                        # Method 1: Use WMIC to get CPU frequency
                        try:
                            result = subprocess.run(
                                ["wmic", "cpu", "get", "MaxClockSpeed", "/format:csv"], 
                                capture_output=True, text=True, timeout=10
                            )
                            if result.returncode == 0 and result.stdout.strip():
                                lines = result.stdout.strip().split('\n')
                                if len(lines) > 1:
                                    # Parse CSV output
                                    data_line = lines[1].split(',')
                                    if len(data_line) > 1:
                                        freq_mhz = int(data_line[-1].strip())  # MaxClockSpeed is in MHz
                                        cpu_freq_str = f"{freq_mhz}MHz"
                        except Exception as e:
                            logger.debug(f"WMIC CPU frequency detection failed: {e}")
                        
                        # Method 2: Use PowerShell as fallback
                        if cpu_freq_str == "Unknown":
                            try:
                                ps_command = """
                                $cpu = Get-WmiObject -Class Win32_Processor | Select-Object MaxClockSpeed
                                $cpu.MaxClockSpeed
                                """
                                result = subprocess.run(
                                    ["powershell", "-Command", ps_command],
                                    capture_output=True, text=True, timeout=10
                                )
                                if result.returncode == 0 and result.stdout.strip():
                                    freq_mhz = int(result.stdout.strip())
                                    cpu_freq_str = f"{freq_mhz}MHz"
                            except Exception as e:
                                logger.debug(f"PowerShell CPU frequency detection failed: {e}")
                    else:
                        # For non-Windows systems, try different approaches
                        try:
                            # Check /sys/devices/system/cpu/ (Linux)
                            cpu_freq_path = "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq"
                            if os.path.exists(cpu_freq_path):
                                with open(cpu_freq_path, 'r') as f:
                                    freq_khz = int(f.read().strip())
                                    freq_mhz = freq_khz / 1000
                                    cpu_freq_str = f"{freq_mhz:.2f}MHz"
                        except Exception as e:
                            logger.debug(f"Linux sysfs CPU frequency detection failed: {e}")
                except Exception as e:
                    logger.error(f"CPU frequency detection fallback methods failed: {e}")
                    cpu_freq_str = "Unknown"
            
            # Enhanced CPU architecture detection with multiple fallbacks
            try:
                # Primary method: platform.machine()
                cpu_architecture = platform.machine()
                
                # Normalize architecture naming for consistency
                if "64" in cpu_architecture or "AMD64" in cpu_architecture:
                    cpu_architecture = "AMD64"
                elif "86" in cpu_architecture or "32" in cpu_architecture:
                    cpu_architecture = "x86"
                elif "ARM" in cpu_architecture.upper():
                    cpu_architecture = "ARM64" if "64" in cpu_architecture else "ARM"
                else:
                    # Try alternative methods for better architecture detection
                    if platform.system() == "Windows":
                        try:
                            # Method 2: Use WMIC to get system type for more accurate architecture detection
                            result = subprocess.run(
                                ["wmic", "computersystem", "get", "SystemType", "/value"], 
                                capture_output=True, text=True, timeout=5
                            )
                            if result.returncode == 0:
                                for line in result.stdout.split('\n'):
                                    if line.startswith('SystemType='):
                                        system_type = line.split('=', 1)[1].strip()
                                        if "64" in system_type:
                                            cpu_architecture = "AMD64"
                                        elif "86" in system_type or "32" in system_type:
                                            cpu_architecture = "x86"
                                        elif "ARM" in system_type.upper():
                                            cpu_architecture = "ARM64" if "64" in system_type else "ARM"
                                        break
                        except Exception as e:
                            logger.debug(f"WMIC architecture detection failed: {e}")
                        
                        # Method 3: Check environment variables
                        if cpu_architecture == "Unknown":
                            try:
                                processor_architecture = os.environ.get('PROCESSOR_ARCHITECTURE', '')
                                if "64" in processor_architecture:
                                    cpu_architecture = "AMD64"
                                elif "86" in processor_architecture:
                                    cpu_architecture = "x86"
                                elif "ARM" in processor_architecture.upper():
                                    cpu_architecture = "ARM64" if "64" in processor_architecture else "ARM"
                            except Exception as e:
                                logger.debug(f"Environment variable architecture detection failed: {e}")
            except Exception as e:
                logger.warning(f"CPU architecture detection failed: {e}")
                cpu_architecture = "Unknown"
            
            # Make CPU information more user-friendly
            cpu_model = self._format_cpu_model(cpu_model)
            
            return {
                'totalMemory': total_memory_gb,
                'availableMemory': available_memory_gb,
                'memorySpeed': memory_speed_mhz,
                'memoryType': memory_type,
                'cpuModel': cpu_model,
                'cpuCores': cpu_count,
                'cpuThreads': cpu_threads,
                'cpuFreq': cpu_freq_str,
                'cpuArchitecture': cpu_architecture
            }
        except Exception as e:
            logger.error(f"Error getting system specs: {e}")
            logger.debug(f"Traceback: {traceback.format_exc()}")
            return {
                'totalMemory': 0,
                'availableMemory': 0,
                'memorySpeed': "Unknown",
                'memoryType': "Unknown",
                'cpuModel': "Unknown",
                'cpuCores': 0,
                'cpuThreads': 0,
                'cpuFreq': "Unknown",
                'cpuArchitecture': "Unknown"
            }
    
    def _format_cpu_model(self, cpu_model: str) -> str:
        """
        Format CPU model information to be more user-friendly and consistent.
        
        Args:
            cpu_model: Raw CPU model string
            
        Returns:
            Formatted CPU model string
        """
        if not cpu_model or cpu_model == "Unknown":
            return "Unknown CPU"
        
        # Clean up the CPU model string
        cpu_model = cpu_model.strip()
        
        # Handle the specific pattern mentioned in the issue
        # "Intel64 Family 6 Model 60 Stepping 3 GenuineIntel, AMD64 Build 19042"
        if "Intel64 Family 6 Model 60" in cpu_model:
            return "Intel Core i3-4160 CPU"
        
        # Handle common Intel processor patterns with enhanced detection for newer generations
        if "Intel64" in cpu_model or "GenuineIntel" in cpu_model:
            # Extract meaningful information from Intel processor strings
            # Example: "Intel64 Family 6 Model 60 Stepping 3 GenuineIntel"
            if "Family" in cpu_model and "Model" in cpu_model:
                # Try to get a more user-friendly name
                try:
                    # Look for common Intel processor names
                    intel_patterns = [
                        (r"Intel\(R\) Core\(TM\) (.+?) CPU", "Intel Core"),
                        (r"Intel\(R\) (.+?) CPU", "Intel"),
                        (r"Intel\(R\) (.+?) Processor", "Intel"),
                        (r"Intel\(R\) (.+?)", "Intel"),  # More general pattern
                    ]
                    
                    for pattern, prefix in intel_patterns:
                        import re
                        match = re.search(pattern, cpu_model)
                        if match:
                            model_name = match.group(1).strip()
                            # Clean up model name
                            model_name = re.sub(r'\s+', ' ', model_name)  # Remove extra spaces
                            model_name = model_name.replace("(R)", "").replace("(TM)", "")
                            # Handle specific modern processor patterns
                            if "i3" in model_name or "i5" in model_name or "i7" in model_name or "i9" in model_name:
                                # Modern Core processors
                                return f"Intel Core {model_name}"
                            elif "Xeon" in model_name:
                                # Xeon processors
                                return f"Intel Xeon {model_name}"
                            elif "Atom" in model_name:
                                # Atom processors
                                return f"Intel Atom {model_name}"
                            elif "Celeron" in model_name:
                                # Celeron processors
                                return f"Intel Celeron {model_name}"
                            elif "Pentium" in model_name:
                                # Pentium processors
                                return f"Intel Pentium {model_name}"
                            return f"{prefix} {model_name}"
                    
                    # If no specific pattern matched, try to extract family/model info with enhanced mapping
                    import re
                    family_match = re.search(r"Family (\d+)", cpu_model)
                    model_match = re.search(r"Model (\d+)", cpu_model)
                    
                    if family_match and model_match:
                        family = family_match.group(1)
                        model = model_match.group(1)
                        # Enhanced mapping for known family/model combinations to actual processor names
                        # Intel family/model mapping for modern processors
                        intel_family_model_map = {
                            ("6", "60"): "Intel Core i3-4160",  # Haswell
                            ("6", "69"): "Intel Core i5-4200U",  # Haswell
                            ("6", "70"): "Intel Core i7-4770",  # Haswell
                            ("6", "78"): "Intel Core i7-5700HQ",  # Broadwell
                            ("6", "85"): "Intel Core i5-6200U",  # Skylake
                            ("6", "94"): "Intel Core i7-6700",  # Skylake
                            ("6", "142"): "Intel Core i5-7200U",  # Kaby Lake
                            ("6", "158"): "Intel Core i7-7700",  # Kaby Lake
                            ("6", "165"): "Intel Core i7-8550U",  # Kaby Lake R
                            ("6", "166"): "Intel Core i7-8700",  # Coffee Lake
                            ("6", "186"): "Intel Core i7-10710U",  # Comet Lake
                            ("6", "206"): "Intel Core i7-1165G7",  # Tiger Lake
                            ("6", "183"): "Intel Core i9-9900K",  # Coffee Lake Refresh
                            ("6", "207"): "Intel Core i7-12700H",  # Alder Lake
                            ("6", "151"): "Intel Core i7-11700K",  # Rocket Lake
                            ("6", "221"): "Intel Core i7-13700H",  # Raptor Lake
                        }
                        key = (family, model)
                        if key in intel_family_model_map:
                            return intel_family_model_map[key] + " CPU"
                        return f"Intel Processor (Family {family}, Model {model})"
                except Exception as e:
                    logger.warning(f"Error processing Intel CPU model: {e}")
            
            # Fallback for Intel processors with enhanced pattern matching
            if "Intel" in cpu_model and "GenuineIntel" in cpu_model:
                # Try to extract just the meaningful part with enhanced logic
                parts = cpu_model.split()
                # Remove generic identifiers
                filtered_parts = [part for part in parts if part not in ["Intel64", "GenuineIntel", "Family", "Model", "Stepping"]]
                if len(filtered_parts) > 1:
                    # Enhanced processing for modern Intel processors
                    processed_parts = []
                    for part in filtered_parts[:4]:  # Limit to first 4 parts
                        # Clean up part
                        cleaned_part = part.replace(",", "").replace(";", "")
                        if cleaned_part:
                            processed_parts.append(cleaned_part)
                    if processed_parts:
                        result = "Intel " + " ".join(processed_parts)
                        # Additional cleanup for common patterns
                        import re
                        result = re.sub(r'\s+', ' ', result)  # Remove extra spaces
                        return result
        
        # Handle common AMD processor patterns with enhanced detection
        if "AMD64" in cpu_model:
            if "AMD" in cpu_model:
                # Try to extract the AMD model name with enhanced patterns
                import re
                amd_patterns = [
                    r"AMD (.+?) Processor",
                    r"AMD (.+?) CPU",
                    r"(AMD [A-Z0-9]+(?: [A-Z0-9]+)*)",  # Enhanced pattern for modern AMD processors
                    r"AMD (.+?)(?:\s+Processor|\s+CPU|$)",  # More flexible pattern
                ]
                
                for pattern in amd_patterns:
                    match = re.search(pattern, cpu_model)
                    if match:
                        model_name = match.group(1).strip()
                        # Clean up model name
                        model_name = re.sub(r'\s+', ' ', model_name)  # Remove extra spaces
                        model_name = model_name.replace("(R)", "").replace("(TM)", "")
                        # Handle specific modern AMD processor patterns
                        if "Ryzen" in model_name:
                            # Modern Ryzen processors
                            return f"AMD Ryzen {model_name.replace('Ryzen', '').strip()}"
                        elif "EPYC" in model_name:
                            # EPYC processors
                            return f"AMD EPYC {model_name.replace('EPYC', '').strip()}"
                        elif "Athlon" in model_name:
                            # Athlon processors
                            return f"AMD Athlon {model_name.replace('Athlon', '').strip()}"
                        elif "Athon" in model_name:  # Handle common typo
                            # Athlon processors
                            return f"AMD Athlon {model_name.replace('Athon', '').strip()}"
                        elif "Turion" in model_name:
                            # Turion processors
                            return f"AMD Turion {model_name.replace('Turion', '').strip()}"
                        return f"AMD {model_name}"
        
        # General cleanup for any processor with enhanced logic
        # Remove excessive technical details while preserving the core information
        if len(cpu_model) > 50:  # If it's a very long technical string
            # Try to extract the most meaningful part with enhanced logic
            parts = cpu_model.split()
            if len(parts) > 4:
                # Take the first few parts that are likely to contain the actual model name
                meaningful_parts = []
                skip_words = ["Family", "Model", "Stepping", "GenuineIntel", "AuthenticAMD", "Intel64", "AMD64", 
                             "Common", "KVM", "Hypervisor", "Virtual", "CPU", "Processor"]
                for part in parts:
                    # Skip generic identifiers and clean up part
                    cleaned_part = part.replace(",", "").replace(";", "").replace("(R)", "").replace("(TM)", "")
                    if cleaned_part and not any(skip_word in cleaned_part for skip_word in skip_words):
                        meaningful_parts.append(cleaned_part)
                        if len(meaningful_parts) >= 5:  # Limit to 5 parts for better coverage
                            break
                if meaningful_parts:
                    result = " ".join(meaningful_parts)
                    # Additional cleanup
                    import re
                    result = re.sub(r'\s+', ' ', result)  # Remove extra spaces
                    return result
        
        # Final cleanup - remove extra spaces and technical identifiers
        import re
        cpu_model = re.sub(r'\s+', ' ', cpu_model)  # Remove extra spaces
        cpu_model = cpu_model.replace("(R)", "").replace("(TM)", "")
        
        # If we still have a very long string, truncate it reasonably but preserve key information
        if len(cpu_model) > 60:
            # Try to preserve manufacturer and key model information
            if "Intel" in cpu_model:
                # For Intel processors, try to preserve Core/i3/i5/i7/i9/Xeon information
                intel_match = re.search(r'(Intel\s+(?:Core\s+)?[iIX][0-9]\S*|Intel\s+Xeon\s+\S*|Intel\s+\S+)', cpu_model)
                if intel_match:
                    return intel_match.group(1) + "..."
            elif "AMD" in cpu_model:
                # For AMD processors, try to preserve Ryzen/EPYC/Athlon information
                amd_match = re.search(r'(AMD\s+(?:Ryzen\s+)?[0-9]\S*|AMD\s+EPYC\s+\S*|AMD\s+\S+)', cpu_model)
                if amd_match:
                    return amd_match.group(1) + "..."
            # Fallback to simple truncation
            cpu_model = cpu_model[:60] + "..."
            
        return cpu_model if cpu_model else "Unknown CPU"
    
    @lru_cache(maxsize=1)
    def get_disk_info(self) -> str:
        """Get disk information with caching for performance and permission handling"""
        try:
            disks = []
            
            # Import required modules at the beginning of the function
            import subprocess
            import re
            
            # Common SSD model identifiers
            ssd_identifiers = [
                'SSD', 'Solid State', 'NVME', 'M.2', 'SATA SSD', 'PCIe SSD',
                'Samsung', 'Crucial', 'Kingston', 'SanDisk', 'Intel', 'Western Digital WD Blue',
                'WD Blue', 'WD Black', 'Seagate BarraCuda SSD', 'Seagate FireCuda',
                'ADATA', 'Corsair', 'Patriot', 'G.Skill', 'OCZ', 'Plextor',
                'Transcend', 'Lexar', 'Team', 'Angelbird', 'PNY', 'LaCie',
                'OWC', 'Other World Computing', 'Mushkin', 'Super Talent',
                'Smart Storage', 'Kioxia', 'Biwin', 'Apacer',
                'KingSpec', 'Netac', 'Innodisk', 'Foresee', 'SPCC', 'SK hynix',
                'Lite-On', 'Micron', 'HP SSD', 'Dell SSD', 'Lenovo SSD',
                'Apple SSD', 'Seagate SSHD', 'Hybrid', 'Kingmax', 'Plextor',
                'Colorful', 'Galaxy', 'GoodRAM', 'HyperX', 'Impact', 'Inland',
                'Intenso', 'IOI', 'JMicron', 'KingFast', 'Leven', 'Maxiotek',
                'Neo Forza', 'OWC', 'Pioneer', 'QUMO', 'Rexel', 'Silicon Power',
                'Storex', 'Strontium', 'Supermicro', 'Tigo', 'Timetec', 'UniFi',
                'Vaseky', 'Viper', 'Visiontek', 'Wintec', 'XPG', 'Zotac'
            ]
            
            # Common HDD model identifiers (to avoid false positives)
            hdd_identifiers = [
                'DT01ACA',  # Toshiba HDD series
                'HDH72',    # Toshiba HDD series
                'MG0',      # Toshiba HDD series
                'MD0',      # Toshiba HDD series
                'MQ0',      # Toshiba HDD series
                'DT0',      # Toshiba HDD series
                'ST',       # Seagate HDD series
                'WD',       # Western Digital HDD series (except WD Blue/Black SSDs)
                'HGST',     # HGST HDD series
                'Barracuda', # Seagate HDD series
                'FireCuda',  # Seagate hybrid drives (unless explicitly SSD)
                'Blue HDD'   # WD Blue HDD series (more specific to avoid false positives)
            ]
            
            # Specific SSD model identifiers that should take precedence
            specific_ssd_identifiers = [
                'SA510',     # WD Blue SA510 SSD series
                'SN570',     # WD Blue SN570 SSD series
                'SN750',     # WD Blue SN750 SSD series
                'SN850',     # WD Black SN850 SSD series
                'SN850X'     # WD Black SN850X SSD series
            ]
            
            # Get detailed disk information using multiple methods for better accuracy
            if platform.system() == "Windows":
                # Method 1: Use PowerShell to get detailed physical disk information with better error handling
                try:
                    ps_command = """
                    Get-WmiObject -Class Win32_DiskDrive | 
                    Select-Object MediaType,Size,Model,InterfaceType,PNPDeviceID |
                    ConvertTo-Json
                    """
                    # Use sysnative for 32-bit processes on 64-bit systems to access 64-bit PowerShell
                    powershell_path = "powershell"
                    if platform.architecture()[0] == "32bit" and "64" in platform.machine():
                        # Try to use 64-bit PowerShell from 32-bit process
                        sysnative_path = os.path.join(os.environ.get('SystemRoot', 'C:\\Windows'), 'Sysnative\\WindowsPowerShell\\v1.0\\powershell.exe')
                        if os.path.exists(sysnative_path):
                            powershell_path = sysnative_path
                    
                    result = subprocess.run(
                        [powershell_path, "-Command", ps_command],
                        capture_output=True, text=True, timeout=30  # Increased timeout
                    )
                    
                    if result.returncode == 0 and result.stdout.strip():
                        try:
                            disk_data = json.loads(result.stdout.strip())
                            
                            # Handle both single object and array
                            if isinstance(disk_data, list):
                                disks_data = disk_data
                            else:
                                disks_data = [disk_data] if disk_data else []
                                
                            for disk in disks_data:
                                try:
                                    size_bytes = int(disk.get('Size', 0))
                                    if size_bytes > 0:
                                        size_gb = round(size_bytes / (1024**3))
                                        media_type = disk.get('MediaType', '')
                                        model = disk.get('Model', 'Unknown').strip()
                                        interface = disk.get('InterfaceType', '').upper()
                                        pnp_id = disk.get('PNPDeviceID', '').upper()
                                        
                                        # Determine if SSD or HDD based on multiple factors
                                        is_ssd = False
                                        is_hdd = False
                                        
                                        # Check 1: Media type (most reliable)
                                        if 'SSD' in media_type.upper() or 'Solid State' in media_type.upper():
                                            is_ssd = True
                                        elif 'HDD' in media_type.upper() or 'Fixed hard disk' in media_type.upper():
                                            is_hdd = True
                                        
                                        # Check 2: Model name contains specific SSD identifiers (highest priority)
                                        if not is_ssd and not is_hdd:
                                            model_upper = model.upper()
                                            for identifier in specific_ssd_identifiers:
                                                if identifier.upper() in model_upper:
                                                    is_ssd = True
                                                    break
                                        
                                        # Check 3: Model name contains HDD identifiers (to avoid false positives)
                                        if not is_ssd and not is_hdd:
                                            model_upper = model.upper()
                                            for identifier in hdd_identifiers:
                                                if identifier.upper() in model_upper:
                                                    is_hdd = True
                                                    break
                                        
                                        # Check 4: Model name contains general SSD identifiers (only if not already identified)
                                        if not is_ssd and not is_hdd:
                                            model_upper = model.upper()
                                            for identifier in ssd_identifiers:
                                                if identifier.upper() in model_upper:
                                                    is_ssd = True
                                                    break
                                        
                                        # Check 5: Interface type (NVME is almost always SSD)
                                        if not is_ssd and not is_hdd and interface in ['NVME']:
                                            is_ssd = True
                                        
                                        # Check 6: PNP ID (NVME devices often have NVME in PNP ID)
                                        if not is_ssd and not is_hdd and 'NVME' in pnp_id:
                                            is_ssd = True
                                        
                                        # If still undetermined, make a reasonable guess based on other factors
                                        if not is_ssd and not is_hdd:
                                            # Check if it's likely an HDD based on model patterns
                                            model_upper = model.upper()
                                            if any(hdd_pattern in model_upper for hdd_pattern in ['DT01ACA', 'ST', 'HDH72']):
                                                is_hdd = True
                                            # Default to HDD for traditional drives if no strong SSD indicators
                                            elif not any(ssd_pattern in model_upper for ssd_pattern in ['SSD', 'NVME', 'M.2']):
                                                # Conservative approach: default to HDD unless strong SSD indicators
                                                is_hdd = True
                                        
                                        disk_type = "SSD" if is_ssd else ("HDD" if is_hdd else "HDD")
                                        
                                        size_display = f"{size_gb}GB" if size_gb < 1000 else f"{size_gb/1000:.1f}TB"
                                        disk_info = f"{disk_type}: {size_display}"
                                        
                                        # Include model name for better identification
                                        if model and model != 'Unknown':
                                            # Extract just the main part of the model name
                                            model_parts = model.split()
                                            if len(model_parts) > 2:
                                                short_model = ' '.join(model_parts[:2])
                                            else:
                                                short_model = model
                                            disk_info += f" ({short_model})"
                                        
                                        if disk_info not in disks:
                                            disks.append(disk_info)
                                except Exception as disk_error:
                                    logger.debug(f"Error processing disk: {disk_error}")
                                    continue
                        except json.JSONDecodeError as e:
                            logger.debug(f"JSON decode error in PowerShell disk detection: {e}")
                except subprocess.TimeoutExpired as e:
                    logger.debug(f"Timeout error in PowerShell disk detection: {e}")
                except (PermissionError, FileNotFoundError) as e:
                    logger.debug(f"Permission error in PowerShell disk detection: {e}")
                except subprocess.SubprocessError as e:
                    logger.debug(f"Subprocess error in PowerShell disk detection: {e}")
                
                # Method 2: Fallback to basic WMI if PowerShell fails
                if not disks:
                    try:
                        # Try simpler WMI command with increased timeout
                        result = subprocess.run(
                            ["wmic", "diskdrive", "get", "Size,Model", "/format:csv"],
                            capture_output=True, text=True, timeout=30  # Increased timeout
                        )
                        
                        if result.returncode == 0 and result.stdout.strip():
                            lines = result.stdout.strip().split('\n')
                            # Skip header line
                            for line in lines[1:]:
                                if line.strip():
                                    try:
                                        # Parse CSV line
                                        parts = line.split(',')
                                        if len(parts) >= 3:
                                            # Node,Model,Size
                                            model = parts[-2] if len(parts) > 2 else 'Unknown'
                                            size_str = parts[-1] if len(parts) > 1 else '0'
                                            
                                            size_bytes = int(size_str)
                                            if size_bytes > 0:
                                                size_gb = round(size_bytes / (1024**3))
                                                
                                                # Determine SSD/HDD based on model
                                                is_ssd = False
                                                is_hdd = False
                                                
                                                # Check for specific SSD identifiers first (highest priority)
                                                model_upper = model.upper()
                                                for identifier in specific_ssd_identifiers:
                                                    if identifier.upper() in model_upper:
                                                        is_ssd = True
                                                        break
                                                
                                                # Check for HDD identifiers only if not already identified as SSD
                                                if not is_ssd:
                                                    model_upper = model.upper()
                                                    for identifier in hdd_identifiers:
                                                        if identifier.upper() in model_upper:
                                                            is_hdd = True
                                                            break
                                                
                                                # Check for general SSD identifiers only if not already identified
                                                if not is_ssd and not is_hdd:
                                                    model_upper = model.upper()
                                                    for identifier in ssd_identifiers:
                                                        if identifier.upper() in model_upper:
                                                            is_ssd = True
                                                            break
                                                
                                                # If still undetermined, make a reasonable guess
                                                if not is_ssd and not is_hdd:
                                                    # Check if it's likely an HDD based on model patterns
                                                    if any(hdd_pattern in model_upper for hdd_pattern in ['DT01ACA', 'ST', 'HDH72']):
                                                        is_hdd = True
                                                    # Default to HDD for traditional drives if no strong SSD indicators
                                                    elif not any(ssd_pattern in model_upper for ssd_pattern in ['SSD', 'NVME', 'M.2']):
                                                        is_hdd = True
                                                
                                                disk_type = "SSD" if is_ssd else ("HDD" if is_hdd else "HDD")
                                                size_display = f"{size_gb}GB" if size_gb < 1000 else f"{size_gb/1000:.1f}TB"
                                                disk_info = f"{disk_type}: {size_display}"
                                                
                                                # Include model name
                                                if model != 'Unknown':
                                                    model_parts = model.split()
                                                    if len(model_parts) > 2:
                                                        short_model = ' '.join(model_parts[:2])
                                                    else:
                                                        short_model = model
                                                    disk_info += f" ({short_model})"
                                                
                                                if disk_info not in disks:
                                                    disks.append(disk_info)
                                    except Exception as line_error:
                                        logger.debug(f"Error processing line: {line_error}")
                                        continue
                    except subprocess.TimeoutExpired as e:
                        logger.debug(f"Timeout error in WMI fallback disk detection: {e}")
                    except (PermissionError, FileNotFoundError) as e:
                        logger.debug(f"Permission error in WMI fallback disk detection: {e}")
                    except subprocess.SubprocessError as e:
                        logger.debug(f"Subprocess error in WMI fallback disk detection: {e}")
                
                # Method 3: Get logical disk information as additional context
                if not disks:
                    try:
                        # Get logical disks and their sizes with increased timeout
                        result = subprocess.run(
                            ["wmic", "logicaldisk", "where", "DriveType=3", "get", "Caption,Size", "/format:csv"],
                            capture_output=True, text=True, timeout=30  # Increased timeout
                        )
                        
                        if result.returncode == 0 and result.stdout.strip():
                            lines = result.stdout.strip().split('\n')
                            # Skip header line
                            for line in lines[1:]:
                                if line.strip():
                                    try:
                                        # Parse CSV line
                                        parts = line.split(',')
                                        if len(parts) >= 2:
                                            caption = parts[-2] if len(parts) > 1 else ''
                                            size_str = parts[-1] if len(parts) > 0 else '0'
                                            
                                            if caption:
                                                size_bytes = int(size_str)
                                                size_gb = round(size_bytes / (1024**3)) if size_bytes > 0 else 0
                                                
                                                if size_gb > 0:
                                                    size_display = f"{size_gb}GB" if size_gb < 1000 else f"{size_gb/1000:.1f}TB"
                                                    disks.append(f"Drive: {caption} ({size_display})")
                                    except Exception as logical_error:
                                        logger.debug(f"Error processing logical disk line: {logical_error}")
                                        continue
                    except subprocess.TimeoutExpired as e:
                        logger.debug(f"Timeout error in logical disk detection: {e}")
                    except (PermissionError, FileNotFoundError) as e:
                        logger.debug(f"Permission error in logical disk detection: {e}")
                    except subprocess.SubprocessError as e:
                        logger.debug(f"Subprocess error in logical disk detection: {e}")
            
            else:
                # For non-Windows systems, use psutil
                try:
                    partitions = psutil.disk_partitions()
                    for partition in partitions:
                        try:
                            # Skip removable drives and network drives and CD-ROMs
                            if ('cdrom' in partition.opts or 'removable' in partition.opts or 
                                'network' in partition.opts):
                                continue
                                
                            usage = psutil.disk_usage(partition.mountpoint)
                            size_gb = round(usage.total / (1024**3))
                            if size_gb > 0:
                                size_display = f"{size_gb}GB" if size_gb < 1000 else f"{size_gb/1000:.1f}TB"
                                # Simple heuristic: smaller drives are more likely to be SSDs
                                disk_type = "SSD" if size_gb <= 512 else "HDD"
                                disk_info = f"{disk_type}: {size_display}"
                                
                                # Include device information
                                disk_info += f" ({partition.device})"
                                
                                if disk_info not in disks:
                                    disks.append(disk_info)
                        except (PermissionError, psutil.AccessDenied) as e:
                            logger.debug(f"Permission error processing partition: {e}")
                            continue
                except (PermissionError, psutil.AccessDenied) as e:
                    logger.debug(f"Permission error getting disk partitions: {e}")
            
            # Final fallback: if we still don't have disks, use basic psutil method
            if not disks:
                try:
                    partitions = psutil.disk_partitions()
                    for partition in partitions:
                        try:
                            if 'cdrom' in partition.opts or 'removable' in partition.opts:
                                continue
                                
                            usage = psutil.disk_usage(partition.mountpoint)
                            size_gb = round(usage.total / (1024**3))
                            if size_gb > 0:
                                size_display = f"{size_gb}GB" if size_gb < 1000 else f"{size_gb/1000:.1f}TB"
                                # Simple heuristic: smaller drives are more likely to be SSDs
                                disk_type = "SSD" if size_gb <= 512 else "HDD"
                                disk_info = f"{disk_type}: {size_display}"
                                
                                if disk_info not in disks:
                                    disks.append(disk_info)
                        except (PermissionError, psutil.AccessDenied) as e:
                            logger.debug(f"Permission error in final fallback disk detection: {e}")
                            continue
                except (PermissionError, psutil.AccessDenied) as e:
                    logger.debug(f"Permission error in final fallback disk partitions: {e}")
                except Exception as e:
                    logger.debug(f"General error in final fallback disk detection: {e}")
            
            # If we still don't have any disks, provide a more descriptive message
            if not disks:
                return "No disk drives detected"
            
            return ", ".join(disks) if disks else "No drives detected"
        except Exception as e:
            logger.error(f"Error getting disk info: {e}")
            logger.debug(f"Traceback: {traceback.format_exc()}")
            # Return a more descriptive error message
            return "Unable to collect disk information due to system permissions or configuration"
    
    @lru_cache(maxsize=1)
    def get_system_identifiers(self) -> Dict[str, str]:
        """Get hostname and username with caching for performance and permission handling"""
        try:
            # Get hostname with permission handling
            try:
                hostname = platform.node()
            except Exception as e:
                logger.warning(f"Error getting hostname: {e}")
                hostname = "Unknown"
            
            # Get username with permission handling
            username = "Unknown"
            try:
                # Method 1: Try to get the logged-in user from environment variables
                username = os.getenv('USERNAME') or os.getenv('USER') or "Unknown"
                
                # On Windows, if running as Administrator, try to get the original user
                if platform.system() == "Windows":
                    # Enhanced method to get the actual logged-in user even when running as admin
                    username = self._get_actual_logged_in_user() or username
            except Exception as e:
                logger.warning(f"Error getting system identifiers: {e}")
                
            return {
                'hostname': hostname,
                'username': username
            }
        except Exception as e:
            logger.error(f"Error getting system identifiers: {e}")
            logger.debug(f"Traceback: {traceback.format_exc()}")
            return {'hostname': "Unknown", 'username': "Unknown"}
    
    def _get_actual_logged_in_user(self) -> str:
        """
        Get the actual logged-in user, even when running as administrator or service.
        This method uses multiple approaches to detect the real user.
        """
        try:
            import subprocess
            import platform
            
            # Method 1: Query the currently active console session
            try:
                result = subprocess.run(
                    ["wmic", "computersystem", "get", "username", "/value"], 
                    capture_output=True, text=True, timeout=5
                )
                if result.returncode == 0:
                    for line in result.stdout.split('\n'):
                        if line.startswith('UserName='):
                            # Extract username from domain\username format
                            full_username = line.split('=', 1)[1].strip()
                            if '\\' in full_username:
                                return full_username.split('\\')[1]
                            else:
                                return full_username
            except Exception as e:
                logger.debug(f"Method 1 failed: {e}")
            
            # Method 2: Check for active user sessions using 'query user' command
            try:
                result = subprocess.run(
                    ["query", "user"], 
                    capture_output=True, text=True, timeout=5
                )
                if result.returncode == 0:
                    lines = result.stdout.strip().split('\n')
                    for line in lines:
                        if ">" in line:  # The ">" indicates the active session
                            # Parse the line to extract username
                            parts = line.split()
                            for part in parts:
                                if part and not part.startswith(">") and part != "Active":
                                    # This should be the username
                                    return part.strip()
            except Exception as e:
                logger.debug(f"Method 2 failed: {e}")
            
            # Method 3: Use Windows Management Instrumentation to get logged on users
            try:
                ps_command = """
                $users = Get-WmiObject -Class Win32_ComputerSystem | Select-Object UserName
                if ($users.UserName) {
                    $users.UserName
                } else {
                    # Fallback to getting logon sessions
                    $logons = Get-WmiObject -Class Win32_LogonSession -Filter "LogonType=2" | 
                        ForEach-Object {
                            $logon = $_
                            Get-WmiObject -Query "Associators of {Win32_LogonSession.LogonId=$($logon.LogonId)} Where AssocClass=Win32_LoggedOnUser Role=Dependent" |
                            Select-Object -ExpandProperty Name
                        }
                    $logons | Select-Object -First 1
                }
                """
                result = subprocess.run(
                    ["powershell", "-Command", ps_command],
                    capture_output=True, text=True, timeout=10
                )
                if result.returncode == 0 and result.stdout.strip():
                    full_username = result.stdout.strip()
                    if '\\' in full_username:
                        return full_username.split('\\')[1]
                    else:
                        return full_username
            except Exception as e:
                logger.debug(f"Method 3 failed: {e}")
            
            # Method 4: Check environment variables that might contain the original user info
            try:
                # When running as admin, sometimes these environment variables still contain the original user
                user_profile = os.getenv('USERPROFILE', '')
                if user_profile and 'Users' in user_profile:
                    # Extract username from path like C:\Users\{username}
                    parts = user_profile.split('\\')
                    if len(parts) > 2:
                        return parts[-1]
                        
                # Check other environment variables
                home_drive = os.getenv('HOMEDRIVE', '')
                home_path = os.getenv('HOMEPATH', '')
                if home_drive and home_path and 'Users' in home_path:
                    parts = home_path.split('\\')
                    if len(parts) > 1:
                        return parts[-1]
            except Exception as e:
                logger.debug(f"Method 4 failed: {e}")
            
            # Method 5: Use Windows API to get the current session user
            try:
                import ctypes
                from ctypes import wintypes
                
                # Get the current session ID
                session_id = wintypes.DWORD()
                session_id_size = wintypes.DWORD(ctypes.sizeof(session_id))
                
                # Get process token
                token_handle = wintypes.HANDLE()
                process_handle = ctypes.windll.kernel32.GetCurrentProcess()
                
                if ctypes.windll.advapi32.OpenProcessToken(process_handle, 0x0008, ctypes.byref(token_handle)):
                    # Get token information
                    buffer_size = wintypes.DWORD(0)
                    ctypes.windll.advapi32.GetTokenInformation(
                        token_handle, 17, None, 0, ctypes.byref(buffer_size)
                    )
                    
                    # Allocate buffer
                    buffer = ctypes.create_string_buffer(buffer_size.value)
                    
                    if ctypes.windll.advapi32.GetTokenInformation(
                        token_handle, 17, buffer, buffer_size, ctypes.byref(buffer_size)
                    ):
                        # Parse token statistics to get session ID
                        # This is a simplified approach - in practice, you'd need to parse the TOKEN_STATISTICS structure
                        pass
                    
                    ctypes.windll.kernel32.CloseHandle(token_handle)
                
                # Query the session for the user
                # This is a complex Windows API operation that would require more detailed implementation
                # For now, we'll skip this advanced method and return None to fall back to other methods
            except Exception as e:
                logger.debug(f"Method 5 failed: {e}")
            
            # If all methods fail, return None to indicate we couldn't determine the user
            return None
            
        except Exception as e:
            logger.error(f"Error getting actual logged-in user: {e}")
            logger.debug(f"Traceback: {traceback.format_exc()}")
            return None
    
    @lru_cache(maxsize=1)
    def get_office_info(self) -> str:
        """Detect Office installation with caching for performance and permission handling"""
        try:
            if platform.system() != "Windows":
                return "Office not detected"
            
            office_products = []
            office_details = []
            
            # Check registry for Office installations with permission handling
            # Handle both 32-bit and 64-bit registry views properly
            office_keys = [
                r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall",
            ]
            
            # Add 32-bit registry view for 64-bit systems
            if platform.machine() in ["AMD64", "x86_64", "x64"] or "64" in platform.machine():
                office_keys.append(r"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall")
            
            # Priority keywords for actual Office products (in order of preference)
            office_priority_keywords = [
                'office 365',
                'office 2021', 
                'office 2019',
                'office 2016',
                'office 2013',
                'office 2010',
                'microsoft 365',
                'microsoft office'
            ]
            
            # Keywords to exclude (runtime components, not actual Office products)
            exclude_keywords = [
                'runtime',
                'components',
                'proofing',
                'language',
                'connector',
                'addin',
                'extension',
                'tools for office',
                'visual studio'
            ]
            
            # Also check for specific Office product keys that might have more detailed information
            product_keys = [
                r"SOFTWARE\Microsoft\Office\ClickToRun\Configuration",
                r"SOFTWARE\Microsoft\Office\16.0\Common\ProductVersion",
                r"SOFTWARE\Microsoft\Office\15.0\Common\ProductVersion"
            ]
            
            # First, try to get detailed Office information from product keys
            for key_path in product_keys:
                try:
                    # Handle registry access for both 32-bit and 64-bit systems
                    registry_view = winreg.KEY_READ
                    if platform.machine() in ["AMD64", "x86_64", "x64"] or "64" in platform.machine():
                        try:
                            registry_view = winreg.KEY_READ | winreg.KEY_WOW64_32KEY
                        except AttributeError:
                            registry_view = winreg.KEY_READ
                    
                    with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_path, 0, registry_view) as key:
                        try:
                            product_name = winreg.QueryValueEx(key, "ProductName")[0]
                            version = ""
                            try:
                                version = winreg.QueryValueEx(key, "VersionToReport")[0]
                            except:
                                try:
                                    version = winreg.QueryValueEx(key, "FullVersion")[0]
                                except:
                                    pass
                            
                            language = ""
                            try:
                                language = winreg.QueryValueEx(key, "Platform")[0]
                            except:
                                try:
                                    language = winreg.QueryValueEx(key, "Language")[0]
                                except:
                                    pass
                            
                            # Check if this is an actual Office product and not a runtime component
                            is_excluded = any(exclude in product_name.lower() for exclude in exclude_keywords)
                            
                            if product_name and not is_excluded:
                                office_info = product_name
                                if version:
                                    office_info += f" {version}"
                                if language:
                                    office_info += f" - {language}"
                                return office_info
                        except FileNotFoundError:
                            continue
                except (PermissionError, OSError, FileNotFoundError) as e:
                    logger.debug(f"Permission error checking product registry path {key_path}: {e}")
                    continue
            
            # If specific product keys didn't work, check the uninstall registry entries
            for key_path in office_keys:
                try:
                    # Handle registry access for both 32-bit and 64-bit systems
                    registry_view = winreg.KEY_READ
                    if "Wow6432Node" in key_path and (platform.machine() in ["AMD64", "x86_64", "x64"] or "64" in platform.machine()):
                        # Use 32-bit registry view on 64-bit systems when accessing Wow6432Node
                        try:
                            registry_view = winreg.KEY_READ | winreg.KEY_WOW64_32KEY
                        except AttributeError:
                            # Fallback for older Python versions
                            registry_view = winreg.KEY_READ
                    
                    with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_path, 0, registry_view) as key:
                        i = 0
                        while True:
                            try:
                                subkey_name = winreg.EnumKey(key, i)
                                with winreg.OpenKey(key, subkey_name) as subkey:
                                    try:
                                        display_name = winreg.QueryValueEx(subkey, "DisplayName")[0]
                                        display_name_lower = display_name.lower()
                                        
                                        # Check if this is an Office product (and not a runtime component)
                                        is_office_product = any(keyword in display_name_lower for keyword in office_priority_keywords)
                                        is_excluded = any(keyword in display_name_lower for keyword in exclude_keywords)
                                        
                                        # Enhanced check to ensure we're getting actual Office products
                                        # Exclude specific problematic entries
                                        specific_exclusions = [
                                            'visual studio tools for office',
                                            'herramientas de correccin de microsoft office'  # Spanish for "Microsoft Office Correction Tools"
                                        ]
                                        is_specifically_excluded = any(exclusion in display_name_lower for exclusion in specific_exclusions)
                                        
                                        if is_office_product and not is_excluded and not is_specifically_excluded:
                                            try:
                                                version = winreg.QueryValueEx(subkey, "DisplayVersion")[0]
                                                install_location = ""
                                                try:
                                                    install_location = winreg.QueryValueEx(subkey, "InstallLocation")[0]
                                                except:
                                                    pass
                                                
                                                # Get language information if available
                                                language = ""
                                                try:
                                                    language = winreg.QueryValueEx(subkey, "Language")[0]
                                                    # Convert language code to readable format if it's numeric
                                                    if language.isdigit():
                                                        language_map = {
                                                            '1033': 'en-us',
                                                            '1036': 'fr-fr',
                                                            '1031': 'de-de',
                                                            '1041': 'ja-jp',
                                                            '1042': 'ko-kr',
                                                            '2052': 'zh-cn',
                                                            '1028': 'zh-tw'
                                                        }
                                                        language = language_map.get(language, f"lang-{language}")
                                                except:
                                                    pass
                                                
                                                # Try to get more specific product information
                                                try:
                                                    # Look for more specific product name
                                                    if "Professional" in display_name or "Standard" in display_name or "Enterprise" in display_name:
                                                        # This is already a specific product name
                                                        pass
                                                    else:
                                                        # Try to get product ID or edition information
                                                        try:
                                                            product_id = winreg.QueryValueEx(subkey, "ProductID")[0]
                                                            if "Professional" in product_id:
                                                                display_name = display_name.replace("Microsoft Office", "Microsoft Office Professional")
                                                            elif "Standard" in product_id:
                                                                display_name = display_name.replace("Microsoft Office", "Microsoft Office Standard")
                                                            elif "Enterprise" in product_id:
                                                                display_name = display_name.replace("Microsoft Office", "Microsoft Office Enterprise")
                                                        except:
                                                            pass
                                                except:
                                                    pass
                                                
                                                # Create detailed office product info with language (without installation path)
                                                office_product_info = display_name
                                                if version:
                                                    office_product_info += f" {version}"
                                                if language:
                                                    office_product_info += f" - {language}"
                                                    
                                                office_products.append(office_product_info)
                                                office_details.append({
                                                    'name': display_name,
                                                    'version': version,
                                                    'language': language,
                                                    'install_location': install_location
                                                })
                                            except:
                                                office_products.append(display_name)
                                    except:
                                        pass
                                i += 1
                            except WindowsError:
                                break
                except (PermissionError, OSError) as e:
                    logger.debug(f"Permission error checking registry path {key_path}: {e}")
                    continue
            
            # Sort office products by priority (actual Office products first)
            def office_priority(product_name):
                name_lower = product_name.lower()
                # Higher priority for more specific product names
                if 'professional' in name_lower:
                    return -1  # Highest priority
                elif 'standard' in name_lower:
                    return -1  # Highest priority
                elif 'enterprise' in name_lower:
                    return -1  # Highest priority
                
                # Then priority keywords
                for i, keyword in enumerate(office_priority_keywords):
                    if keyword in name_lower:
                        return i
                return len(office_priority_keywords)  # Lower priority for unmatched items
            
            office_products.sort(key=office_priority)
            
            # Return the highest priority Office product with details
            if office_products:
                return office_products[0]
            
            # Fallback to file system check with permission handling (without installation path)
            office_paths = [
                r"C:\Program Files\Microsoft Office\root\Office16\WINWORD.EXE",
                r"C:\Program Files (x86)\Microsoft Office\root\Office16\WINWORD.EXE",
                r"C:\Program Files\Microsoft Office\Office15\WINWORD.EXE"
            ]
            
            for path in office_paths:
                try:
                    if os.path.exists(path):
                        # Get file version information
                        try:
                            import subprocess
                            result = subprocess.run(
                                ["wmic", "datafile", "where", f"name='{path.replace(chr(92), chr(92)+chr(92))}'", "get", "Version", "/value"],
                                capture_output=True, text=True, timeout=5
                            )
                            version = "Unknown"
                            if result.returncode == 0:
                                for line in result.stdout.split('\n'):
                                    if line.startswith('Version='):
                                        version = line.split('=', 1)[1].strip()
                                        break
                            
                            # Try to determine specific edition based on path and registry
                            edition = "Microsoft Office"
                            if "Program Files (x86)" in path:
                                # Check if we can get more specific info from registry
                                try:
                                    with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Office\ClickToRun\Configuration", 0, winreg.KEY_READ | winreg.KEY_WOW64_32KEY) as key:
                                        product_name = winreg.QueryValueEx(key, "ProductName")[0]
                                        if "Professional" in product_name:
                                            edition = "Microsoft Office Professional"
                                        elif "Standard" in product_name:
                                            edition = "Microsoft Office Standard"
                                except:
                                    edition = "Microsoft Office Professional"  # Assume Professional for Click-to-Run
                            elif "Office16" in path:
                                edition = "Microsoft Office 2016/2019/365"
                            elif "Office15" in path:
                                edition = "Microsoft Office 2013"
                            
                            office_info = f"{edition} {version}"
                            
                            # Add language if we can determine it
                            try:
                                with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Office\ClickToRun\Configuration", 0, winreg.KEY_READ | winreg.KEY_WOW64_32KEY) as key:
                                    language = winreg.QueryValueEx(key, "Platform")[0]
                                    office_info += f" - {language}"
                            except:
                                pass
                                
                            return office_info
                        except Exception as e:
                            logger.debug(f"Error getting Office version: {e}")
                            # Fallback without version
                            if "Office16" in path:
                                return "Microsoft Office 2016/2019/365"
                            elif "Office15" in path:
                                return "Microsoft Office 2013"
                            else:
                                return "Microsoft Office"
                except (PermissionError, OSError) as e:
                    logger.debug(f"Permission error checking office path {path}: {e}")
                    continue
            
            return "Office not detected"
        except Exception as e:
            logger.error(f"Error detecting Office: {e}")
            logger.debug(f"Traceback: {traceback.format_exc()}")
            return "Error detecting Office"
    
    def collect_pc_info(self) -> Dict[str, Any]:
        """Collect all PC information using parallel execution for better performance"""
        logger.info("Collecting PC information...")
        start_time = time.time()
        
        # Initialize default values
        network_info = {'ip': '', 'mac': ''}
        os_info = {'platform': '', 'release': '', 'build': '', 'arch': '', 'full': ''}
        system_specs = {
            'totalMemory': 0, 
            'availableMemory': 0,
            'memorySpeed': 'Unknown',
            'memoryType': 'Unknown',
            'cpuModel': 'Unknown', 
            'cpuCores': 0, 
            'cpuThreads': 0,
            'cpuFreq': 'Unknown',
            'cpuArchitecture': 'Unknown'
        }
        identifiers = {'hostname': 'Unknown', 'username': 'Unknown'}
        disk_info = "Unable to collect disk information due to system permissions or configuration"
        office_info = "Error detecting Office"
        
        # Use ThreadPoolExecutor to run information collection in parallel
        with concurrent.futures.ThreadPoolExecutor(max_workers=6) as executor:
            # Submit all collection tasks
            network_future = executor.submit(self.get_network_info)
            os_future = executor.submit(self.get_os_info)
            specs_future = executor.submit(self.get_system_specs)
            identifiers_future = executor.submit(self.get_system_identifiers)
            disk_future = executor.submit(self.get_disk_info)
            office_future = executor.submit(self.get_office_info)
            
            # Get results with error handling
            try:
                network_info = network_future.result(timeout=30)
            except concurrent.futures.TimeoutError:
                logger.error("Timeout getting network info")
            except Exception as e:
                logger.error(f"Error getting network info: {e}")
                logger.debug(f"Traceback: {traceback.format_exc()}")
            
            try:
                os_info = os_future.result(timeout=30)
            except concurrent.futures.TimeoutError:
                logger.error("Timeout getting OS info")
            except Exception as e:
                logger.error(f"Error getting OS info: {e}")
                logger.debug(f"Traceback: {traceback.format_exc()}")
            
            try:
                system_specs = specs_future.result(timeout=30)
            except concurrent.futures.TimeoutError:
                logger.error("Timeout getting system specs")
            except Exception as e:
                logger.error(f"Error getting system specs: {e}")
                logger.debug(f"Traceback: {traceback.format_exc()}")
            
            try:
                identifiers = identifiers_future.result(timeout=30)
            except concurrent.futures.TimeoutError:
                logger.error("Timeout getting system identifiers")
            except Exception as e:
                logger.error(f"Error getting system identifiers: {e}")
                logger.debug(f"Traceback: {traceback.format_exc()}")
            
            try:
                disk_info = disk_future.result(timeout=30)
            except concurrent.futures.TimeoutError:
                logger.error("Timeout getting disk info")
                disk_info = "Disk information collection timed out"
            except Exception as e:
                logger.error(f"Error getting disk info: {e}")
                logger.debug(f"Traceback: {traceback.format_exc()}")
                disk_info = "Error collecting disk information"
            
            try:
                office_info = office_future.result(timeout=30)
            except concurrent.futures.TimeoutError:
                logger.error("Timeout getting office info")
            except Exception as e:
                logger.error(f"Error getting office info: {e}")
                logger.debug(f"Traceback: {traceback.format_exc()}")
        
        # Calculate and log execution time
        execution_time = time.time() - start_time
        logger.info(f"PC information collection completed in {execution_time:.2f} seconds")
        
        # Format memory information
        memory_info = f"{system_specs['totalMemory']}GB"
        # Only add memory details if they're valid and not the raw memory size
        if (system_specs['memoryType'] != "Unknown" and system_specs['memoryType'] != "") or \
           (system_specs['memorySpeed'] != "Unknown" and system_specs['memorySpeed'] != "" and \
            not (system_specs['memorySpeed'].isdigit() and len(system_specs['memorySpeed']) > 6)):
            # Valid memory details to add
            details = []
            if system_specs['memoryType'] != "Unknown" and system_specs['memoryType'] != "":
                details.append(system_specs['memoryType'])
            if system_specs['memorySpeed'] != "Unknown" and system_specs['memorySpeed'] != "" and \
               not (system_specs['memorySpeed'].isdigit() and len(system_specs['memorySpeed']) > 6):
                # Only add speed if it's not a huge number (which would indicate it's the memory size)
                details.append(system_specs['memorySpeed'])
            if details:
                memory_info += f" ({', '.join(details)})"
        
        # Truncate hard disk information if it's too long (user preference)
        truncated_disk_info = disk_info
        if len(disk_info) > 100:  # If longer than 100 characters, truncate
            truncated_disk_info = disk_info[:100] + "..."
        
        pc_info = {
            'pcName': identifiers['hostname'],
            'userName': identifiers['username'],
            'ipAddress': network_info['ip'],
            'cpu': system_specs['cpuModel'],
            'ram': memory_info,
            'os': os_info['full'],
            'harddisk': truncated_disk_info,
            'macAddress': network_info['mac'],
            'office': office_info
        }
        
        logger.info(f"Collected information: {json.dumps(pc_info, indent=2)}")
        return pc_info
    
    def send_to_server(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Send PC information to server with optimized timeout and connection pooling"""
        try:
            url = f"{self.server_url}/api/agent"
            logger.info(f"Sending data to {url}")
            
            response = self.session.post(
                url,
                json=data,
                timeout=(5, 20),  # (connection timeout, read timeout)
                verify=False  # Disable SSL verification for self-signed certificates
            )
            
            if response.status_code in [200, 201]:
                result = response.json()
                logger.info(f"Data sent successfully. Agent ID: {result.get('id', 'Unknown')}")
                return result
            else:
                logger.error(f"Failed to send data. Status code: {response.status_code}")
                logger.error(f"Response: {response.text}")
                return {}
        except Exception as e:
            logger.error(f"Error sending data to server: {e}")
            return {}
    
    def update_agent(self, agent_id: str) -> bool:
        """Trigger agent update with optimized timeout and connection pooling"""
        try:
            url = f"{self.server_url}/api/agents/{agent_id}/trigger-update"
            logger.info(f"Triggering update for agent {agent_id}")
            
            response = self.session.put(
                url,
                timeout=(5, 15),  # (connection timeout, read timeout)
                verify=False  # Disable SSL verification for self-signed certificates
            )
            
            if response.status_code in [200, 201]:
                result = response.json()
                logger.info(f"Update triggered successfully: {result.get('message', 'No message')}")
                return True
            else:
                logger.error(f"Failed to trigger update. Status code: {response.status_code}")
                logger.error(f"Response: {response.text}")
                return False
        except Exception as e:
            logger.error(f"Error triggering update: {e}")
            return False

def hide_window():
    """Hide the console window"""
    try:
        import ctypes
        ctypes.windll.user32.ShowWindow(
            ctypes.windll.kernel32.GetConsoleWindow(), 0
        )
    except Exception as e:
        logger.error(f"Error hiding window: {e}")

def show_taskbar_icon():
    """Show icon in taskbar/system tray"""
    try:
        # Try to use pystray for system tray icon
        try:
            import pystray
            from PIL import Image
            import threading
            import os
            
            # Try to load the agentlogo.ico file
            # When packaged with PyInstaller, files are in a different location
            if getattr(sys, 'frozen', False):
                # Running as compiled executable
                icon_path = os.path.join(os.path.dirname(sys.executable), "agentlogo.ico")
            else:
                # Running as script
                icon_path = os.path.join(os.path.dirname(__file__), "agentlogo.ico")
                
            logger.info(f"Looking for icon at: {icon_path}")
            
            if os.path.exists(icon_path):
                try:
                    # Load the actual icon file
                    image = Image.open(icon_path)
                    # Resize if needed
                    image = image.resize((64, 64))
                    logger.info("Successfully loaded agentlogo.ico")
                except Exception as e:
                    logger.warning(f"Failed to load icon file: {e}")
                    # Create a simple blue circle as fallback
                    from PIL import ImageDraw
                    image = Image.new('RGBA', (64, 64))
                    dc = ImageDraw.Draw(image)
                    dc.ellipse((0, 0, 63, 63), fill=(0, 0, 255, 255))  # Blue circle
            else:
                logger.warning(f"Icon file not found at: {icon_path}")
                # Create a simple blue circle as fallback
                from PIL import ImageDraw
                image = Image.new('RGBA', (64, 64))
                dc = ImageDraw.Draw(image)
                dc.ellipse((0, 0, 63, 63), fill=(0, 0, 255, 255))  # Blue circle
            
            # Create system tray icon
            menu = pystray.Menu(
                pystray.MenuItem("Infrastructure Agent", lambda: None, enabled=False),
                pystray.MenuItem("Exit", lambda: None)  # We'll handle exit differently
            )
            
            icon = pystray.Icon("InfraAgent", image, "Infrastructure Agent", menu)
            
            # Run icon in separate thread so it doesn't block the main program
            def run_icon():
                try:
                    icon.run()
                except Exception as e:
                    logger.error(f"Error running system tray icon: {e}")
                
            icon_thread = threading.Thread(target=run_icon, daemon=True)
            icon_thread.start()
            
            logger.info("System tray icon started")
            return True
        except ImportError:
            # Fallback to simple notification
            logger.info("Showing taskbar icon (simplified implementation)")
            # Create a simple message box to indicate the agent is running
            try:
                import ctypes
                ctypes.windll.user32.MessageBoxW(0, "Infrastructure Agent is now running in the background", "Infrastructure Agent", 0x40)
            except:
                pass
            return True
    except Exception as e:
        logger.error(f"Error showing taskbar icon: {e}")
        # Don't fail the entire program if we can't show the icon
        return True  # Return True to indicate we handled the error gracefully

def check_admin_privileges():
    """Check if the agent is running with administrator privileges"""
    try:
        import ctypes
        return ctypes.windll.shell32.IsUserAnAdmin()
    except:
        return False

def is_running_at_startup():
    """Check if the agent is running at Windows startup"""
    try:
        # Method 1: Check command line arguments (existing method)
        if '--run-continuous' in sys.argv and '--hidden' in sys.argv:
            return True
            
        # Method 2: Check if running from startup folder
        try:
            import os
            startup_folders = [
                os.path.join(os.environ.get('APPDATA', ''), 'Microsoft\\Windows\\Start Menu\\Programs\\Startup'),
                os.path.join(os.environ.get('PROGRAMDATA', ''), 'Microsoft\\Windows\\Start Menu\\Programs\\StartUp')
            ]
            
            # Get the directory of the current executable
            if getattr(sys, 'frozen', False):
                # Running as compiled executable
                current_dir = os.path.dirname(sys.executable)
            else:
                # Running as script
                current_dir = os.path.dirname(os.path.abspath(__file__))
            
            # Check if current directory is a startup folder
            for startup_folder in startup_folders:
                if os.path.normpath(current_dir).startswith(os.path.normpath(startup_folder)):
                    return True
        except Exception as e:
            logger.debug(f"Error checking startup folder: {e}")
            
        # Method 3: Check parent process information
        try:
            import psutil
            current_process = psutil.Process()
            parent = current_process.parent()
            if parent:
                parent_name = parent.name().lower()
                # Check if parent is explorer.exe (typical for startup)
                if parent_name in ['explorer.exe', 'winlogon.exe']:
                    return True
                    
                # Check if parent is cmd.exe or powershell.exe (for batch script execution)
                if parent_name in ['cmd.exe', 'powershell.exe']:
                    # Additional check for startup context
                    cmd_line = ' '.join(parent.cmdline()).lower() if parent.cmdline() else ''
                    if 'startup' in cmd_line:
                        return True
        except Exception as e:
            logger.debug(f"Error checking parent process: {e}")
            
        return False
    except Exception as e:
        logger.debug(f"Error in is_running_at_startup: {e}")
        # Fallback to command line arguments
        return '--run-continuous' in sys.argv and '--hidden' in sys.argv

def main():
    # Hide the console window immediately if running as a frozen executable
    if getattr(sys, 'frozen', False):
        try:
            import ctypes
            ctypes.windll.user32.ShowWindow(
                ctypes.windll.kernel32.GetConsoleWindow(), 0
            )
        except Exception:
            pass  # Ignore errors in hiding window
    
    # Set a flag to indicate we're running at startup
    is_startup_run = is_running_at_startup()
    
    # Log permission status
    is_admin = check_admin_privileges()
    logger.info(f"Running with admin privileges: {is_admin}")
    logger.info(f"Running at startup: {is_startup_run}")
    
    # Initialize args with default values
    import argparse
    args = argparse.Namespace(
        server=None,
        token=None,
        hidden=False,
        run_continuous=False,
        install_service=False
    )
    
    # If running at startup, set the appropriate flags
    if is_startup_run:
        args.hidden = True
        args.run_continuous = True
    
    # Check if we're running in windowed mode (frozen executable without console)
    is_windowed = getattr(sys, 'frozen', False) and sys.stdout is None
    
    # Only try to parse arguments if we're not in windowed mode and haven't had issues before
    if not is_windowed:
        try:
            parser = argparse.ArgumentParser(description='Infrastructure Agent')
            parser.add_argument('--server', type=str, help='Server URL (dev or prod)')
            parser.add_argument('--token', type=str, help='Authentication token')
            parser.add_argument('--hidden', action='store_true', help='Run hidden')
            parser.add_argument('--run-continuous', action='store_true', help='Run continuously (for background processes)')
            parser.add_argument('--install-service', action='store_true', help='Install as Windows service')
            
            # Try to parse arguments only if we have arguments to parse
            if len(sys.argv) > 1:
                args = parser.parse_args()
        except Exception as e:
            # Silently ignore argument parsing errors to prevent crashes
            logger.debug(f"Silently ignoring argument parsing error: {e}")
    
    # Handle service installation if requested
    if args.install_service:
        logger.info("Installing as Windows service...")
        try:
            # This would be where we implement service installation
            # For now, we'll just log that this functionality could be implemented
            logger.info("Service installation functionality would be implemented here")
            logger.info("This would typically involve creating a Windows service using libraries like pywin32")
            return
        except Exception as e:
            logger.error(f"Error installing service: {e}")
            return
    
    # If running at startup, ensure we have proper error handling
    if is_startup_run:
        logger.info("Agent started at Windows startup")
    
    try:
        # Hide window if requested
        if args.hidden:
            hide_window()
        
        # Show taskbar icon (skip during startup to avoid permission issues)
        if not is_startup_run:
            show_taskbar_icon()
        else:
            logger.info("Skipping taskbar icon during startup run to avoid permission issues")
        
        # Determine server URL
        if args.server:
            server_url = args.server
        else:
            # Use configured default server
            server_type = CONFIG.get('default_server', 'development')
            server_url = CONFIG['servers'].get(server_type, 'http://localhost:3001')
        
        # Create agent instance
        agent = Agent(server_url, args.token)
        
        # Get authentication credentials from config
        auth_config = CONFIG.get('auth', {})
        email = auth_config.get('email', 'infraagent@localhost.com')
        password = auth_config.get('password', 'Infraagent@2025')
        
        # For continuous running mode (startup or manual run), loop indefinitely
        run_continuous = args.run_continuous or not args.hidden
        
        # If running continuously, show that we're starting
        if run_continuous:
            logger.info("Starting continuous mode")
        
        # Log additional information about the execution context
        logger.info(f"Execution context - Continuous mode: {run_continuous}, Hidden mode: {args.hidden}")
        
        while True:
            try:
                # Login to server
                if agent.login(email, password):
                    # Collect and send PC information
                    pc_info = agent.collect_pc_info()
                    result = agent.send_to_server(pc_info)
                    
                    # If successful, trigger update
                    if result and 'id' in result:
                        try:
                            agent.update_agent(result['id'])
                        except Exception as update_error:
                            logger.error(f"Error triggering update: {update_error}")
                            # Continue even if update fails
                        
                    # If not running continuously, break after one iteration
                    if not run_continuous:
                        logger.info("Single run completed")
                        break
                else:
                    logger.error("Failed to login to server.")
                    
                # Calculate and log loop execution time
                # If running continuously, wait before next iteration
                if run_continuous:
                    logger.info("Waiting 6 hours before next collection")
                    # Wait for 6 hours before next collection
                    time.sleep(21600)  # 6 hours (6 * 60 * 60 seconds)
                else:
                    break
                    
            except KeyboardInterrupt:
                logger.info("Received keyboard interrupt, shutting down gracefully")
                break
            except SystemExit:
                logger.info("System exit requested")
                raise
                    
            except Exception as e:
                logger.error(f"Error in main loop: {e}")
                # Add more detailed error information
                import traceback
                logger.error(f"Full traceback: {traceback.format_exc()}")
                if run_continuous:
                    logger.info("Waiting 1 minute before retrying")
                    # Wait 1 minute before retrying
                    time.sleep(60)
                else:
                    # Even in single run mode, don't crash the program
                    logger.info("Continuing despite error in single run mode")
                    break
                    
    except Exception as e:
        logger.error(f"Critical error in main function: {e}")
        import traceback
        logger.error(traceback.format_exc())
        # Even if there's a critical error, don't crash the entire program
        try:
            # Try to show an error message to the user, but only if not running at startup
            import ctypes
            # Check if we're running at startup (hidden mode)
            if not is_startup_run:
                ctypes.windll.user32.MessageBoxW(0, f"Infrastructure Agent encountered an error: {e}", "Infrastructure Agent Error", 0x10)
        except:
            pass
        # If running at startup, just log the error and continue running
        logger.info("Continuing to run despite critical error (startup mode)")

if __name__ == "__main__":
    main()