From bfa601d212a8623ad060144e5af2dccc343d1e21 Mon Sep 17 00:00:00 2001
From: BoiHanny <114599052+BoiHanny@users.noreply.github.com>
Date: Sat, 16 Nov 2024 21:01:50 +0100
Subject: [PATCH 01/12] Refactor NetworkStatisticsModule for better performance

Refactored NetworkStatisticsModule to improve functionality and readability. Replaced System.Timers.Timer with System.Threading.Timer, and removed unused using directives. Introduced new private fields and a constructor for initialization. Changed method visibility to encapsulate internal logic. Simplified monitoring logic and replaced PerformanceCounter with NetworkInterface statistics. Added InterfaceStats class and method to get the most active network interface. Improved exception handling, logging, and updated Dispose method.
---
 .../Modules/NetworkStatisticsModule.cs        | 481 +++++++-----------
 1 file changed, 184 insertions(+), 297 deletions(-)

diff --git a/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs b/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs
index 7750c27c..6767fb31 100644
--- a/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs
+++ b/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs
@@ -1,11 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
-using System.Diagnostics;
+using System.Linq;
 using System.Net.NetworkInformation;
 using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using System.Timers;
+using System.Threading;
 using vrcosc_magicchatbox.Classes.DataAndSecurity;
 using vrcosc_magicchatbox.DataAndSecurity;
 using vrcosc_magicchatbox.ViewModels;
@@ -15,8 +14,14 @@ namespace vrcosc_magicchatbox.Classes.Modules
     public class NetworkStatisticsModule : INotifyPropertyChanged, IDisposable
     {
         private Timer _updateTimer;
+        private NetworkInterface _activeNetworkInterface;
+        private bool _isMonitoring;
+        private long _previousBytesReceived;
+        private long _previousBytesSent;
+
         public bool IsInitialized { get; private set; }
-        public double interval { get; set; } = 1000;
+        public double Interval { get; set; } = 1000;
+
         private double _currentDownloadSpeedMbps;
         private double _currentUploadSpeedMbps;
         private double _maxDownloadSpeedMbps;
@@ -24,10 +29,22 @@ public class NetworkStatisticsModule : INotifyPropertyChanged, IDisposable
         private double _networkUtilization;
         private double _totalDownloadedMB;
         private double _totalUploadedMB;
-        public int ErrorCount = 0;
 
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        public NetworkStatisticsModule(double interval)
+        {
+            Interval = interval;
+            ViewModel.Instance.PropertyChanged += PropertyChangedHandler;
+
+            if (ShouldStartMonitoring())
+            {
+                InitializeNetworkStats();
+                StartModule();
+            }
+        }
 
-        public void PropertyChangedHandler(object sender, PropertyChangedEventArgs e)
+        private void PropertyChangedHandler(object sender, PropertyChangedEventArgs e)
         {
             if (IsRelevantPropertyChange(e.PropertyName))
             {
@@ -35,31 +52,25 @@ public void PropertyChangedHandler(object sender, PropertyChangedEventArgs e)
                 {
                     if (!IsInitialized)
                     {
-                        InitializeNetworkStatsAsync();
-                        IsInitialized = true;
+                        InitializeNetworkStats();
                     }
                     StartModule();
                 }
                 else
                 {
-                    if (!IsInitialized)
-                    {
-                        InitializeNetworkStatsAsync();
-                        IsInitialized = true;
-                    }
                     StopModule();
                 }
             }
         }
 
-
-        public bool ShouldStartMonitoring()
+        private bool ShouldStartMonitoring()
         {
-            return ViewModel.Instance.IntgrNetworkStatistics && ViewModel.Instance.IsVRRunning && ViewModel.Instance.IntgrNetworkStatistics_VR ||
-                   ViewModel.Instance.IntgrNetworkStatistics && !ViewModel.Instance.IsVRRunning && ViewModel.Instance.IntgrNetworkStatistics_DESKTOP;
+            return ViewModel.Instance.IntgrNetworkStatistics &&
+                   ((ViewModel.Instance.IsVRRunning && ViewModel.Instance.IntgrNetworkStatistics_VR) ||
+                    (!ViewModel.Instance.IsVRRunning && ViewModel.Instance.IntgrNetworkStatistics_DESKTOP));
         }
 
-        public bool IsRelevantPropertyChange(string propertyName)
+        private bool IsRelevantPropertyChange(string propertyName)
         {
             return propertyName == nameof(ViewModel.Instance.IntgrNetworkStatistics) ||
                    propertyName == nameof(ViewModel.Instance.IsVRRunning) ||
@@ -67,267 +78,164 @@ public bool IsRelevantPropertyChange(string propertyName)
                    propertyName == nameof(ViewModel.Instance.IntgrNetworkStatistics_DESKTOP);
         }
 
-        private PerformanceCounter downloadCounter;
-        private PerformanceCounter uploadCounter;
-        private DateTime previousUpdateTime;
-
-        public double TotalDownloadedMB
-        {
-            get { return _totalDownloadedMB; }
-            set { SetProperty(ref _totalDownloadedMB, value); }
-        }
-
-        public double TotalUploadedMB
-        {
-            get { return _totalUploadedMB; }
-            set { SetProperty(ref _totalUploadedMB, value); }
-        }
-
-        public double CurrentDownloadSpeedMbps
-        {
-            get { return _currentDownloadSpeedMbps; }
-            set { SetProperty(ref _currentDownloadSpeedMbps, value); }
-        }
-
-        public double CurrentUploadSpeedMbps
-        {
-            get { return _currentUploadSpeedMbps; }
-            set { SetProperty(ref _currentUploadSpeedMbps, value); }
-        }
-
-        public double MaxDownloadSpeedMbps
-        {
-            get { return _maxDownloadSpeedMbps; }
-            set { SetProperty(ref _maxDownloadSpeedMbps, value); }
-        }
-
-        public double MaxUploadSpeedMbps
-        {
-            get { return _maxUploadSpeedMbps; }
-            set { SetProperty(ref _maxUploadSpeedMbps, value); }
-        }
-
-        public double NetworkUtilization
-        {
-            get { return _networkUtilization; }
-            set { SetProperty(ref _networkUtilization, value); }
-        }
-
-        public event PropertyChangedEventHandler PropertyChanged;
-
-        public NetworkStatisticsModule(double interval)
+        private void InitializeNetworkStats()
         {
-               this.interval = interval;
-            ViewModel.Instance.PropertyChanged += PropertyChangedHandler;
-            if (ShouldStartMonitoring())
+            _activeNetworkInterface = GetActiveNetworkInterface();
+            if (_activeNetworkInterface != null)
             {
-                if(!IsInitialized)
-                {
-                    InitializeNetworkStatsAsync();
-                    IsInitialized = true;
-                }
-                StartModule();
-            }
-                
-        }
+                var speedInMbps = _activeNetworkInterface.Speed / 1e6;
+                MaxDownloadSpeedMbps = speedInMbps;
+                MaxUploadSpeedMbps = speedInMbps;
 
-        public void StartModule()
-        {
-            if (_updateTimer != null && !_updateTimer.Enabled)
-            {
-                _updateTimer.Start();
-            }
-        }
+                var stats = _activeNetworkInterface.GetIPv4Statistics();
+                _previousBytesReceived = stats.BytesReceived;
+                _previousBytesSent = stats.BytesSent;
 
-        public void StopModule()
-        {
-            if (_updateTimer != null && _updateTimer.Enabled)
-            {
-                _updateTimer.Stop();
+                IsInitialized = true;
             }
-        }
-
-        public void ForceUpdate()
-        {
-            OnTimedEvent(null, null);
-        }
-
-        private async Task InitializeNetworkStatsAsync()
-        {
-            // Attempt to initialize performance counters with an active network interface
-            await Task.Run(() =>
-            {
-                if (!InitializePerformanceCounters())
+            else
             {
-                // If initialization fails, subscribe to the NetworkAddressChanged event to retry when the network status changes
-                NetworkChange.NetworkAddressChanged += OnNetworkAddressChanged;
+                // Handle the case when no active network interface is found
+                Logging.WriteException(new Exception("No active network interface found"), MSGBox: false);
+                IsInitialized = false;
             }
-                });
-
-            // Initialize and start the update timer
-            _updateTimer = new Timer(interval)
-            {
-                AutoReset = true,
-                Enabled = false
-            };
-            _updateTimer.Elapsed += OnTimedEvent;
-
-            previousUpdateTime = DateTime.Now;
         }
 
-        private bool InitializePerformanceCounters()
+        private NetworkInterface GetActiveNetworkInterface()
         {
             try
             {
-                // Dispose of existing counters
-                downloadCounter?.Dispose();
-                uploadCounter?.Dispose();
+                var networkInterfaces = NetworkInterface.GetAllNetworkInterfaces()
+                    .Where(ni =>
+                        ni.OperationalStatus == OperationalStatus.Up &&
+                        ni.NetworkInterfaceType != NetworkInterfaceType.Loopback &&
+                        ni.NetworkInterfaceType != NetworkInterfaceType.Tunnel &&
+                        ni.GetIPProperties().UnicastAddresses.Count > 0).ToList();
 
-                // Attempt to select an active network interface
-                NetworkInterface activeNetworkInterface = GetActiveNetworkInterface();
+                if (networkInterfaces.Count == 0)
+                    return null;
 
-                if (activeNetworkInterface != null)
+                // Measure initial bytes sent/received
+                var interfaceStats = new List<InterfaceStats>();
+                foreach (var ni in networkInterfaces)
                 {
-                    // Get the correct instance name for the PerformanceCounter
-                    string instanceName = GetInstanceNameForPerformanceCounter(activeNetworkInterface);
-                    if (instanceName == null)
+                    var stats = ni.GetIPv4Statistics();
+                    interfaceStats.Add(new InterfaceStats
                     {
-                        // Handle the case where no matching instance name is found
-                        // For example, log this issue and use a default instance name or skip setting up counters
-                        return false;
-                    }
-
-                    // Initialize Performance Counters for the selected network interface
-                    downloadCounter = new PerformanceCounter("Network Interface", "Bytes Received/sec", instanceName);
-                    uploadCounter = new PerformanceCounter("Network Interface", "Bytes Sent/sec", instanceName);
-
-                    // Update maximum speeds based on the active network interface
-                    MaxDownloadSpeedMbps = activeNetworkInterface.Speed / 8e6; // Convert from bits to Megabytes
-                    MaxUploadSpeedMbps = activeNetworkInterface.Speed / 8e6; // Convert from bits to Megabytes
-
-                    return true; // Initialization succeeded
+                        NetworkInterface = ni,
+                        InitialBytesReceived = stats.BytesReceived,
+                        InitialBytesSent = stats.BytesSent
+                    });
                 }
 
-                return false; // No active network interface was found
-            }
-            catch (Exception ex)
-            {
-                Logging.WriteException(ex, MSGBox: false);
-                ErrorCount++;
-                return false;  
-            }
-            
-        }
-
-        private string GetInstanceNameForPerformanceCounter(NetworkInterface networkInterface)
-        {
-            try
-            {
-                var category = new PerformanceCounterCategory("Network Interface");
-                string[] instanceNames = category.GetInstanceNames();
-                string normalizedInterfaceName = NormalizeInterfaceName(networkInterface.Description);
+                // Wait for a short interval
+                Thread.Sleep(500);
 
-                foreach (string instanceName in instanceNames)
+                // Measure bytes sent/received after the interval
+                foreach (var stat in interfaceStats)
                 {
-                    if (instanceName.Equals(normalizedInterfaceName, StringComparison.OrdinalIgnoreCase))
-                    {
-                        return instanceName;
-                    }
+                    var stats = stat.NetworkInterface.GetIPv4Statistics();
+                    stat.BytesReceivedDiff = stats.BytesReceived - stat.InitialBytesReceived;
+                    stat.BytesSentDiff = stats.BytesSent - stat.InitialBytesSent;
+                    stat.TotalBytesDiff = stat.BytesReceivedDiff + stat.BytesSentDiff;
                 }
-                return null;
-            }
-            catch (InvalidOperationException ex)
-            {
-                // Log the exception for debugging purposes
-                Logging.WriteException(ex, MSGBox: false);
-                ErrorCount++;
 
-                // Notify user or take steps to repair or provide alternative
-                HandlePerformanceCounterError();
+                // Select the network interface with the highest total bytes difference
+                var mostActiveInterface = interfaceStats.OrderByDescending(s => s.TotalBytesDiff).FirstOrDefault();
 
-                return null;
+                if (mostActiveInterface != null && mostActiveInterface.TotalBytesDiff > 0)
+                {
+                    return mostActiveInterface.NetworkInterface;
+                }
+                else
+                {
+                    // If no activity detected, return the first interface
+                    return networkInterfaces.FirstOrDefault();
+                }
             }
             catch (Exception ex)
             {
                 Logging.WriteException(ex, MSGBox: false);
-                ErrorCount++;
                 return null;
             }
         }
 
-        private void HandlePerformanceCounterError()
+        private class InterfaceStats
         {
-            Logging.WriteException(new Exception("Performance counter error"), MSGBox: false);
+            public NetworkInterface NetworkInterface { get; set; }
+            public long InitialBytesReceived { get; set; }
+            public long InitialBytesSent { get; set; }
+            public long BytesReceivedDiff { get; set; }
+            public long BytesSentDiff { get; set; }
+            public long TotalBytesDiff { get; set; }
         }
 
-
-        private string NormalizeInterfaceName(string interfaceName)
+        public void StartModule()
         {
-            // Replace invalid characters based on the mappings provided by Microsoft documentation
-            return interfaceName
-                .Replace('(', '[')
-                .Replace(')', ']')
-                .Replace('#', '_')
-                .Replace('\\', '_')
-                .Replace('/', '_');
-            // Add any other normalization rules if needed
+            if (_isMonitoring)
+                return;
+
+            _updateTimer = new Timer(OnTimedEvent, null, 0, (int)Interval);
+            _isMonitoring = true;
         }
 
+        public void StopModule()
+        {
+            if (!_isMonitoring)
+                return;
+
+            _updateTimer?.Change(Timeout.Infinite, 0);
+            _updateTimer?.Dispose();
+            _updateTimer = null;
+            _isMonitoring = false;
+        }
 
-        private NetworkInterface GetActiveNetworkInterface()
+        private void OnTimedEvent(object state)
         {
             try
             {
-                // Retrieve all network interfaces
-                NetworkInterface[] networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
-
-                // Select the first active network interface that is up and has an IPv4 address and is not a loopback or tunnel
-                foreach (var ni in networkInterfaces)
+                if (_activeNetworkInterface == null)
                 {
-                    if (ni.OperationalStatus == OperationalStatus.Up &&
-                        // more that 0 less that 10000 (10Gbps)
-                        ni.Speed > 0 && ni.Speed < 10000000000 &&
-                        ni.NetworkInterfaceType != NetworkInterfaceType.Loopback &&
-                        ni.NetworkInterfaceType != NetworkInterfaceType.Tunnel &&
-                        ni.GetIPProperties().UnicastAddresses.Count > 0) // Check for an IPv4 address
-                    {
-                        return ni;
-                    }
+                    InitializeNetworkStats();
+                    if (_activeNetworkInterface == null)
+                        return;
                 }
-                return null; // No active network interface found
-            }
-            catch (Exception ex)
-            {
-                ErrorCount++;
-                Logging.WriteException(ex, MSGBox: false);
-                return null;
-            }
-            
-        }
 
+                var stats = _activeNetworkInterface.GetIPv4Statistics();
 
-        private void ResetCurrentStatistics()
-        {
-            // Reset current network statistics
-            CurrentDownloadSpeedMbps = 0;
-            CurrentUploadSpeedMbps = 0;
-            NetworkUtilization = 0;
-        }
+                // Calculate the differences since the last check
+                var bytesReceivedDiff = stats.BytesReceived - _previousBytesReceived;
+                var bytesSentDiff = stats.BytesSent - _previousBytesSent;
 
-        private void OnNetworkAddressChanged(object sender, EventArgs e)
-        {
-            // When the network address changes, try to re-initialize the performance counters
-            if (InitializePerformanceCounters())
-            {
-                // If the re-initialization is successful, reset the current statistics
-                ResetCurrentStatistics();
+                // Update previous values
+                _previousBytesReceived = stats.BytesReceived;
+                _previousBytesSent = stats.BytesSent;
+
+                // Calculate speeds in Mbps
+                var intervalInSeconds = Interval / 1000;
+                CurrentDownloadSpeedMbps = (bytesReceivedDiff * 8) / 1e6 / intervalInSeconds;
+                CurrentUploadSpeedMbps = (bytesSentDiff * 8) / 1e6 / intervalInSeconds;
+
+                // Update total downloaded and uploaded data in MB
+                TotalDownloadedMB += bytesReceivedDiff / 1e6;
+                TotalUploadedMB += bytesSentDiff / 1e6;
+
+                // Update network utilization
+                NetworkUtilization = Math.Min(100, (CurrentDownloadSpeedMbps / MaxDownloadSpeedMbps) * 100);
+
+                // Notify property changes
+                OnPropertyChanged(nameof(CurrentDownloadSpeedMbps));
+                OnPropertyChanged(nameof(CurrentUploadSpeedMbps));
+                OnPropertyChanged(nameof(TotalDownloadedMB));
+                OnPropertyChanged(nameof(TotalUploadedMB));
+                OnPropertyChanged(nameof(NetworkUtilization));
             }
-            else
+            catch (Exception ex)
             {
-                // Log or handle the error if no active network interface is found after a network change
-                // This is application-specific and you should decide how to handle this case
+                Logging.WriteException(ex, MSGBox: false);
             }
         }
+
         public string GenerateDescription()
         {
             const int maxLineWidth = 25;
@@ -348,18 +256,18 @@ public string GenerateDescription()
                 networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Max Down: ")} {FormatSpeed(MaxDownloadSpeedMbps)}");
 
             if (ViewModel.Instance.NetworkStats_ShowMaxUp)
-                networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Max Up: ")}{FormatSpeed(MaxUploadSpeedMbps)}");
+                networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Max Up: ")} {FormatSpeed(MaxUploadSpeedMbps)}");
 
             if (ViewModel.Instance.NetworkStats_ShowTotalDown)
-                networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Total Down: ")}{FormatData(TotalDownloadedMB)}");
+                networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Total Down: ")} {FormatData(TotalDownloadedMB)}");
 
             if (ViewModel.Instance.NetworkStats_ShowTotalUp)
-                networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Total Up: ")}{FormatData(TotalUploadedMB)}");
+                networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Total Up: ")} {FormatData(TotalUploadedMB)}");
 
             if (ViewModel.Instance.NetworkStats_ShowNetworkUtilization)
-                networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Network utilization: ")}{NetworkUtilization:N2} %");
+                networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Network utilization: ")} {NetworkUtilization:N2} %");
 
-            if(networkStatsDescriptions.Count == 0)
+            if (networkStatsDescriptions.Count == 0)
             {
                 return "";
             }
@@ -410,7 +318,6 @@ public string GenerateDescription()
             }
 
             return string.Join("\v", lines);
-
         }
 
         private string FormatSpeed(double speedMbps)
@@ -447,87 +354,67 @@ private string FormatData(double dataMB)
                 return $"{dataMB:N2} {ConvertToSuperScriptIfNeeded("MB")}";
         }
 
-
-        private void OnTimedEvent(Object source, ElapsedEventArgs e)
+        // Implement property getters and setters with OnPropertyChanged notifications
+        public double CurrentDownloadSpeedMbps
         {
-            try
-            {
-                // Current time
-                DateTime currentTime = DateTime.Now;
+            get => _currentDownloadSpeedMbps;
+            set => SetProperty(ref _currentDownloadSpeedMbps, value);
+        }
 
-                // Calculate the number of seconds elapsed
-                double elapsedSeconds = (currentTime - previousUpdateTime).TotalSeconds;
-                previousUpdateTime = currentTime;
+        public double CurrentUploadSpeedMbps
+        {
+            get => _currentUploadSpeedMbps;
+            set => SetProperty(ref _currentUploadSpeedMbps, value);
+        }
 
-                // Fetch current network usage once
-                double currentDownloadBytes = downloadCounter.NextValue();
-                double currentUploadBytes = uploadCounter.NextValue();
+        public double MaxDownloadSpeedMbps
+        {
+            get => _maxDownloadSpeedMbps;
+            set => SetProperty(ref _maxDownloadSpeedMbps, value);
+        }
 
-                // Calculate speeds in Mbps
-                CurrentDownloadSpeedMbps = currentDownloadBytes / 1e6 * 8;
-                CurrentUploadSpeedMbps = currentUploadBytes / 1e6 * 8;
+        public double MaxUploadSpeedMbps
+        {
+            get => _maxUploadSpeedMbps;
+            set => SetProperty(ref _maxUploadSpeedMbps, value);
+        }
 
-                // Update total downloaded and uploaded data in MB
-                TotalDownloadedMB += currentDownloadBytes / 1e6 * elapsedSeconds;
-                TotalUploadedMB += currentUploadBytes / 1e6 * elapsedSeconds;
+        public double NetworkUtilization
+        {
+            get => _networkUtilization;
+            set => SetProperty(ref _networkUtilization, value);
+        }
 
-                // Update network utilization
-                NetworkUtilization = Math.Min(100, (CurrentDownloadSpeedMbps / MaxDownloadSpeedMbps) * 100);
-            }
-            catch (Exception ex)
-            {
-                Logging.WriteException(ex, MSGBox: false);
-                ErrorCount++;
-                if(ErrorCount > 3)
-                {
-                    ViewModel.Instance.IntgrNetworkStatistics = false;
-                    ErrorCount = 0;
-                }
-            }
+        public double TotalDownloadedMB
+        {
+            get => _totalDownloadedMB;
+            set => SetProperty(ref _totalDownloadedMB, value);
         }
 
-        protected void OnPropertyChanged(string propertyName)
+        public double TotalUploadedMB
         {
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+            get => _totalUploadedMB;
+            set => SetProperty(ref _totalUploadedMB, value);
         }
 
         protected bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
         {
-            try
-            {
-                if (EqualityComparer<T>.Default.Equals(storage, value))
-                {
-                    return false;
-                }
-                storage = value;
-                OnPropertyChanged(propertyName);
-                return true;
-            }
-            catch (Exception ex)
-            {
-                // Log the exception
-                Logging.WriteException(ex);
+            if (EqualityComparer<T>.Default.Equals(storage, value))
                 return false;
-            }
+            storage = value;
+            OnPropertyChanged(propertyName);
+            return true;
         }
 
+        protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
 
         public void Dispose()
         {
-            try
-            {
-                _updateTimer?.Stop();
-                _updateTimer?.Dispose();
-                downloadCounter?.Dispose();
-                uploadCounter?.Dispose();
-                NetworkChange.NetworkAddressChanged -= OnNetworkAddressChanged;
-            }
-            catch (Exception ex)
-            {
-                // Log the exception
-                Logging.WriteException(ex);
-            }
+            StopModule();
+            ViewModel.Instance.PropertyChanged -= PropertyChangedHandler;
         }
-
     }
 }

From 17c3c588d7c7f28778a197875a94e58605ecca76 Mon Sep 17 00:00:00 2001
From: BoiHanny <114599052+BoiHanny@users.noreply.github.com>
Date: Sat, 16 Nov 2024 21:19:33 +0100
Subject: [PATCH 02/12] Update version and adjust GitHubChanges TextBlock
 layout

Updated version number in MagicChatbox.csproj from 0.9.052 to 0.9.053.
Moved GitHubChanges TextBlock into a StackPanel with VerticalAlignment set to Bottom in MainWindow.xaml.
Added Margin and RenderOptions.BitmapScalingMode to enhance UI appearance.
---
 vrcosc-magicchatbox/MagicChatbox.csproj |  2 +-
 vrcosc-magicchatbox/MainWindow.xaml     | 43 +++++++++++++------------
 2 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/vrcosc-magicchatbox/MagicChatbox.csproj b/vrcosc-magicchatbox/MagicChatbox.csproj
index 51d64970..05cdb022 100644
--- a/vrcosc-magicchatbox/MagicChatbox.csproj
+++ b/vrcosc-magicchatbox/MagicChatbox.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
-	<Version>0.9.052</Version>
+	<Version>0.9.053</Version>
     <TargetFramework>net8.0-windows10.0.22000.0</TargetFramework>
     <RootNamespace>vrcosc_magicchatbox</RootNamespace>
     <Nullable>enable</Nullable>
diff --git a/vrcosc-magicchatbox/MainWindow.xaml b/vrcosc-magicchatbox/MainWindow.xaml
index 5b24b8b1..b30771a8 100644
--- a/vrcosc-magicchatbox/MainWindow.xaml
+++ b/vrcosc-magicchatbox/MainWindow.xaml
@@ -7573,27 +7573,30 @@
                         FontSize="12"
                         Foreground="#FF7D7397"
                         Text="{Binding UpdateStatustxt}" />
-                    <TextBlock
-                        x:Name="GitHubChanges"
-                        Width="auto"
-                        HorizontalAlignment="Center"
-                        Cursor="Hand"
-                        FontFamily="Albert Sans Thin"
-                        FontSize="8.5"
-                        Foreground="#26A1FA"
-                        MouseUp="GitHubChanges_MouseUp"
-                        Text="View changes on GitHub"
-                        TextDecorations="Underline"
-                        Visibility="{Binding CanUpdateLabel, Converter={StaticResource InverseBoolToHiddenConverter}, UpdateSourceTrigger=PropertyChanged}">
-                        <TextBlock.Effect>
-                            <DropShadowEffect
-                                BlurRadius="10"
-                                Opacity="0.3"
-                                ShadowDepth="0"
-                                Color="#251153" />
-                        </TextBlock.Effect>
-                    </TextBlock>
+
                     <StackPanel VerticalAlignment="Bottom">
+                        <TextBlock
+                            x:Name="GitHubChanges"
+                            Width="auto"
+                            Margin="0,0,0,10"
+                            HorizontalAlignment="Center"
+                            Cursor="Hand"
+                            FontFamily="Albert Sans Thin"
+                            FontSize="8.5"
+                            Foreground="#26A1FA"
+                            RenderOptions.BitmapScalingMode="NearestNeighbor"
+                            MouseUp="GitHubChanges_MouseUp"
+                            Text="View changes on GitHub"
+                            TextDecorations="Underline"
+                            Visibility="{Binding CanUpdateLabel, Converter={StaticResource InverseBoolToHiddenConverter}, UpdateSourceTrigger=PropertyChanged}">
+                            <TextBlock.Effect>
+                                <DropShadowEffect
+                                    BlurRadius="10"
+                                    Opacity="0.3"
+                                    ShadowDepth="0"
+                                    Color="#251153" />
+                            </TextBlock.Effect>
+                        </TextBlock>
                         <StackPanel HorizontalAlignment="Center" Orientation="Horizontal">
                             <Button
                                 x:Name="CheckUpdateBtnn"

From ac865bcaf2dcd71ec393f9bbe492b411d88bb016 Mon Sep 17 00:00:00 2001
From: BoiHanny <114599052+BoiHanny@users.noreply.github.com>
Date: Sat, 16 Nov 2024 22:12:00 +0100
Subject: [PATCH 03/12] Add functionality to fetch and display RAM DDR version

Introduce methods to query and display DDR version in ComponentStatsModule.
Add System.Management namespace and update project file.
Enhance UI with a checkbox to toggle DDR version display.
Update ComponentStatsItem and ViewModel classes to support new feature.
---
 .../Classes/Modules/ComponentStatsModule.cs   | 86 ++++++++++++++++++-
 vrcosc-magicchatbox/MagicChatbox.csproj       |  1 +
 vrcosc-magicchatbox/MainWindow.xaml           | 13 +++
 .../ViewModels/Models/ComponentStatsItem.cs   |  2 +
 vrcosc-magicchatbox/ViewModels/ViewModel.cs   | 17 ++++
 5 files changed, 118 insertions(+), 1 deletion(-)

diff --git a/vrcosc-magicchatbox/Classes/Modules/ComponentStatsModule.cs b/vrcosc-magicchatbox/Classes/Modules/ComponentStatsModule.cs
index 1b54eb80..08657096 100644
--- a/vrcosc-magicchatbox/Classes/Modules/ComponentStatsModule.cs
+++ b/vrcosc-magicchatbox/Classes/Modules/ComponentStatsModule.cs
@@ -6,6 +6,7 @@
 using System.Globalization;
 using System.IO;
 using System.Linq;
+using System.Management;
 using System.Threading.Tasks;
 using System.Windows;
 using vrcosc_magicchatbox.Classes.DataAndSecurity;
@@ -20,6 +21,7 @@ public class ComponentStatsModule
         private readonly List<ComponentStatsItem> _componentStats = new List<ComponentStatsItem>();
         private static string FileName = null;
         public bool started = false;
+        private string _ramDDRVersion = "Unknown";
 
         public void StartModule()
         {
@@ -27,9 +29,70 @@ public void StartModule()
                     ViewModel.Instance.IsVRRunning || ViewModel.Instance.IntgrComponentStats &&
                     ViewModel.Instance.IntgrComponentStats_DESKTOP &&
                     !ViewModel.Instance.IsVRRunning)
+            {
                 LoadComponentStats();
+                FetchAndStoreDDRVersion();
+            }
+                
+        }
+
+        private void FetchAndStoreDDRVersion()
+        {
+            _ramDDRVersion = GetDDRVersion();
+            var ramItem = _componentStats.FirstOrDefault(stat => stat.ComponentType == StatsComponentType.RAM);
+            if (ramItem != null)
+            {
+                ramItem.DDRVersion = _ramDDRVersion;
+            }
         }
 
+        public static string GetDDRVersion()
+        {
+            try
+            {
+                using (ManagementObjectSearcher mos = new ManagementObjectSearcher("SELECT SMBIOSMemoryType FROM Win32_PhysicalMemory"))
+                {
+                    HashSet<int> memoryTypes = new HashSet<int>();
+
+                    foreach (ManagementObject mo in mos.Get())
+                    {
+                        var smbiosMemoryType = mo["SMBIOSMemoryType"];
+
+                        if (smbiosMemoryType != null)
+                        {
+                            int type = Convert.ToInt32(smbiosMemoryType);
+                            memoryTypes.Add(type);
+                        }
+                    }
+
+                    if (memoryTypes.Count > 0)
+                    {
+                        return MapMemoryTypeToDDR(memoryTypes.First());
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Logging.WriteException(ex, MSGBox: false);
+            }
+            return "Unknown";
+        }
+
+        private static string MapMemoryTypeToDDR(int type)
+        {
+            switch (type)
+            {
+                case 20: return "ᴰᴰᴿ";
+                case 21: return "ᴰᴰᴿ²";
+                case 24: return "ᴰᴰᴿ³";
+                case 26: return "ᴰᴰᴿ⁴";
+                case 28:
+                case 34: return "ᴰᴰᴿ⁵";
+                default: return string.Empty;
+            }
+        }
+
+
         public IReadOnlyList<ComponentStatsItem> GetAllStats()
         {
             return _componentStats.AsReadOnly();
@@ -346,6 +409,21 @@ public void SetShowGPUTemperature(bool state)
             }
         }
 
+        public bool GetShowRamDDRVersion()
+        {
+            var item = _componentStats.FirstOrDefault(stat => stat.ComponentType == StatsComponentType.RAM);
+            return item?.ShowDDRVersion ?? false;
+        }
+
+        public void SetShowRamDDRVersion(bool state)
+        {
+            var item = _componentStats.FirstOrDefault(stat => stat.ComponentType == StatsComponentType.RAM);
+            if (item != null)
+            {
+                item.ShowDDRVersion = state;
+            }
+        }
+
         public bool GetShowGPUHotspotTemperature()
         {
             var item = _componentStats.FirstOrDefault(stat => stat.ComponentType == StatsComponentType.GPU);
@@ -499,7 +577,6 @@ public void SetStatMaxValueShown(StatsComponentType type, bool state)
             StatsComponentType.GPU,
             StatsComponentType.VRAM,
             StatsComponentType.RAM,
-            //StatsComponentType.FPS
         };
 
         public string GenerateStatsDescription()
@@ -551,6 +628,11 @@ public string GenerateStatsDescription()
                         }
                     }
 
+                    if (stat.ComponentType == StatsComponentType.RAM && stat.ShowDDRVersion)
+                    {
+                        componentDescription += $" ⁽{stat.DDRVersion}⁾";
+                    }
+
                     // Combine the additionalInfo parts with a single space
                     string additionalInfo = string.Join(" ", additionalInfoParts).Trim();
 
@@ -1100,6 +1182,8 @@ private static string FetchStat(
             }
         }
 
+     
+
         private static string FetchHotspotTemperatureStat(IHardware hardware, ComponentStatsItem item)
         {
             foreach (var sensor in hardware.Sensors)
diff --git a/vrcosc-magicchatbox/MagicChatbox.csproj b/vrcosc-magicchatbox/MagicChatbox.csproj
index 05cdb022..731c3308 100644
--- a/vrcosc-magicchatbox/MagicChatbox.csproj
+++ b/vrcosc-magicchatbox/MagicChatbox.csproj
@@ -199,6 +199,7 @@
     <PackageReference Include="NHotkey.Wpf" Version="3.0.0" />
     <PackageReference Include="NLog" Version="5.3.4" />
 	  <PackageReference Include="OpenAI-DotNet" Version="8.4.1" />
+	  <PackageReference Include="System.Management" Version="9.0.0" />
 	  <PackageReference Include="VRChat.OSCQuery" Version="0.0.7" />
   </ItemGroup>
 
diff --git a/vrcosc-magicchatbox/MainWindow.xaml b/vrcosc-magicchatbox/MainWindow.xaml
index b30771a8..0d56cd12 100644
--- a/vrcosc-magicchatbox/MainWindow.xaml
+++ b/vrcosc-magicchatbox/MainWindow.xaml
@@ -3834,6 +3834,19 @@
                                         IsChecked="{Binding RAM_ShowMaxValue, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
                                         Style="{DynamicResource SettingsCheckbox}"
                                         ToolTip="When checked, the VRAM usage label will display the model name of ur GPU." />
+                                    <CheckBox
+                                        x:Name="RAM_ShowDDRVersion_checkbox"
+                                        Height="20"
+                                        Margin="5,5"
+                                        BorderBrush="#FF2D1265"
+                                        Checked="Update_Click"
+                                        Content="Show RAM DDR version"
+                                        FontFamily="Comfortaa Light"
+                                        FontSize="18"
+                                        Foreground="#FFB9B5C1"
+                                        IsChecked="{Binding RAM_ShowDDRVersion, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                                        Style="{DynamicResource SettingsCheckbox}"
+                                        ToolTip="When checked, the DDR version of the RAM will be displayed." />
                                     <CheckBox
                                         x:Name="RAM_NumberTrailingZeros_checkbox"
                                         Height="20"
diff --git a/vrcosc-magicchatbox/ViewModels/Models/ComponentStatsItem.cs b/vrcosc-magicchatbox/ViewModels/Models/ComponentStatsItem.cs
index 7477d2fe..4b800be0 100644
--- a/vrcosc-magicchatbox/ViewModels/Models/ComponentStatsItem.cs
+++ b/vrcosc-magicchatbox/ViewModels/Models/ComponentStatsItem.cs
@@ -31,6 +31,8 @@ public class ComponentStatsItem
         public bool ShowMaxValue { get; set; }
         public bool IsEnabled { get; set; } = true;
         public bool ShowSmallName { get; set; } = true;
+        public bool ShowDDRVersion { get; set; } = true;
+        public string DDRVersion { get; set; }
 
         public string GetFormattedValue() { return ShowUnit ? $"{ComponentValue}{Unit}" : ComponentValue; }
         public string GetFormattedMaxValue()
diff --git a/vrcosc-magicchatbox/ViewModels/ViewModel.cs b/vrcosc-magicchatbox/ViewModels/ViewModel.cs
index 4d29e225..8bb8c82a 100644
--- a/vrcosc-magicchatbox/ViewModels/ViewModel.cs
+++ b/vrcosc-magicchatbox/ViewModels/ViewModel.cs
@@ -1722,6 +1722,23 @@ public bool RAM_ShowMaxValue
             }
         }
 
+        public bool RAM_ShowDDRVersion
+        {
+            get => _statsManager.GetShowRamDDRVersion();
+            set
+            {
+                if (value)
+                {
+                    _statsManager.SetShowRamDDRVersion(true);
+                }
+                else
+                {
+                    _statsManager.SetShowRamDDRVersion(false);
+                }
+                NotifyPropertyChanged(nameof(RAM_ShowDDRVersion));
+            }
+        }
+
         public bool JoinedAlphaChannel
         {
             get { return _JoinedAlphaChannel; }

From 0d6eefa6e3316fc4c4e80a5f3767369df07b151d Mon Sep 17 00:00:00 2001
From: BoiHanny <114599052+BoiHanny@users.noreply.github.com>
Date: Sat, 16 Nov 2024 22:12:32 +0100
Subject: [PATCH 04/12] Bump version to 0.9.055

Updated the version number in MagicChatbox.csproj from 0.9.053 to 0.9.055, indicating a new release with minor changes or improvements.
---
 vrcosc-magicchatbox/MagicChatbox.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vrcosc-magicchatbox/MagicChatbox.csproj b/vrcosc-magicchatbox/MagicChatbox.csproj
index 731c3308..354e5fca 100644
--- a/vrcosc-magicchatbox/MagicChatbox.csproj
+++ b/vrcosc-magicchatbox/MagicChatbox.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
-	<Version>0.9.053</Version>
+	<Version>0.9.055</Version>
     <TargetFramework>net8.0-windows10.0.22000.0</TargetFramework>
     <RootNamespace>vrcosc_magicchatbox</RootNamespace>
     <Nullable>enable</Nullable>

From fe27117a0ed2e5a90fc0e704cfc21f6a6972dbf8 Mon Sep 17 00:00:00 2001
From: BoiHanny <114599052+BoiHanny@users.noreply.github.com>
Date: Sat, 30 Nov 2024 20:07:10 +0100
Subject: [PATCH 05/12] Refactor DDR version handling in ComponentStatsModule

Refactored the `GetDDRVersion` method in `ComponentStatsModule.cs` from a static to an instance method, now using a `HashSet<string>` for DDR versions. Updated the logic to query and convert `SMBIOSMemoryType` to DDR versions using the new helper method `GetDDRVersionFromSMBIOSMemoryType`. Removed the `MapMemoryTypeToDDR` method and replaced it with `GetDDRVersionFromSMBIOSMemoryType`. The `GetDDRVersion` method now returns `null` instead of "Unknown" if the DDR version cannot be determined. Updated the condition to append DDR version to the component description to check if `stat.DDRVersion` is not null or whitespace. Initialized the `DDRVersion` property to `null` by default in `ComponentStatsItem.cs`.
---
 .../Classes/Modules/ComponentStatsModule.cs   | 69 +++++++++++--------
 .../ViewModels/Models/ComponentStatsItem.cs   |  2 +-
 2 files changed, 42 insertions(+), 29 deletions(-)

diff --git a/vrcosc-magicchatbox/Classes/Modules/ComponentStatsModule.cs b/vrcosc-magicchatbox/Classes/Modules/ComponentStatsModule.cs
index 08657096..8d854891 100644
--- a/vrcosc-magicchatbox/Classes/Modules/ComponentStatsModule.cs
+++ b/vrcosc-magicchatbox/Classes/Modules/ComponentStatsModule.cs
@@ -46,53 +46,66 @@ private void FetchAndStoreDDRVersion()
             }
         }
 
-        public static string GetDDRVersion()
+        public string GetDDRVersion()
         {
             try
             {
-                using (ManagementObjectSearcher mos = new ManagementObjectSearcher("SELECT SMBIOSMemoryType FROM Win32_PhysicalMemory"))
-                {
-                    HashSet<int> memoryTypes = new HashSet<int>();
+                HashSet<string> ddrVersions = new HashSet<string>();
 
-                    foreach (ManagementObject mo in mos.Get())
+                ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT SMBIOSMemoryType FROM Win32_PhysicalMemory");
+                foreach (ManagementObject queryObj in searcher.Get())
+                {
+                    ushort smbiosMemoryType = Convert.ToUInt16(queryObj["SMBIOSMemoryType"]);
+                    string ddrVersion = GetDDRVersionFromSMBIOSMemoryType(smbiosMemoryType);
+                    if (!string.IsNullOrEmpty(ddrVersion))
                     {
-                        var smbiosMemoryType = mo["SMBIOSMemoryType"];
-
-                        if (smbiosMemoryType != null)
-                        {
-                            int type = Convert.ToInt32(smbiosMemoryType);
-                            memoryTypes.Add(type);
-                        }
+                        ddrVersions.Add(ddrVersion);
                     }
+                }
 
-                    if (memoryTypes.Count > 0)
-                    {
-                        return MapMemoryTypeToDDR(memoryTypes.First());
-                    }
+                if (ddrVersions.Count > 0)
+                {
+                    // Return the unique DDR versions, joined by a slash if multiple
+                    return string.Join("'", ddrVersions);
                 }
             }
             catch (Exception ex)
             {
                 Logging.WriteException(ex, MSGBox: false);
             }
-            return "Unknown";
+
+            // Return null if DDR version cannot be determined
+            return null;
         }
 
-        private static string MapMemoryTypeToDDR(int type)
+        private string GetDDRVersionFromSMBIOSMemoryType(ushort smbiosMemoryType)
         {
-            switch (type)
+            // Map the SMBIOSMemoryType to DDR version numbers 0-5
+            switch (smbiosMemoryType)
             {
-                case 20: return "ᴰᴰᴿ";
-                case 21: return "ᴰᴰᴿ²";
-                case 24: return "ᴰᴰᴿ³";
-                case 26: return "ᴰᴰᴿ⁴";
-                case 28:
-                case 34: return "ᴰᴰᴿ⁵";
-                default: return string.Empty;
+                case 0:
+                case 1:
+                case 2:
+                case 3:
+                case 4:
+                case 5:
+                    return "ᴰᴰᴿ";
+                case 20:
+                    return "ᴰᴰᴿ¹";
+                case 21:
+                    return "ᴰᴰᴿ²";
+                case 24:
+                    return "ᴰᴰᴿ³";
+                case 26:
+                    return "ᴰᴰᴿ⁴";
+                case 34:
+                    return "ᴰᴰᴿ⁵";
+                // Include other cases as needed
+                default:
+                    return null;
             }
         }
 
-
         public IReadOnlyList<ComponentStatsItem> GetAllStats()
         {
             return _componentStats.AsReadOnly();
@@ -628,7 +641,7 @@ public string GenerateStatsDescription()
                         }
                     }
 
-                    if (stat.ComponentType == StatsComponentType.RAM && stat.ShowDDRVersion)
+                    if (stat.ComponentType == StatsComponentType.RAM && stat.ShowDDRVersion && !string.IsNullOrWhiteSpace(stat.DDRVersion))
                     {
                         componentDescription += $" ⁽{stat.DDRVersion}⁾";
                     }
diff --git a/vrcosc-magicchatbox/ViewModels/Models/ComponentStatsItem.cs b/vrcosc-magicchatbox/ViewModels/Models/ComponentStatsItem.cs
index 4b800be0..2ae6a2b6 100644
--- a/vrcosc-magicchatbox/ViewModels/Models/ComponentStatsItem.cs
+++ b/vrcosc-magicchatbox/ViewModels/Models/ComponentStatsItem.cs
@@ -32,7 +32,7 @@ public class ComponentStatsItem
         public bool IsEnabled { get; set; } = true;
         public bool ShowSmallName { get; set; } = true;
         public bool ShowDDRVersion { get; set; } = true;
-        public string DDRVersion { get; set; }
+        public string DDRVersion { get; set; } = null;
 
         public string GetFormattedValue() { return ShowUnit ? $"{ComponentValue}{Unit}" : ComponentValue; }
         public string GetFormattedMaxValue()

From 18ee44131d07eba9ad002d6e9144858704125984 Mon Sep 17 00:00:00 2001
From: BoiHanny <114599052+BoiHanny@users.noreply.github.com>
Date: Sat, 30 Nov 2024 20:21:48 +0100
Subject: [PATCH 06/12] Add "HideOpenAITools" setting to hide OpenAI toolbar

Introduced a new "HideOpenAITools" setting to allow users to hide the OpenAI toolbar in the chat interface. Updated `DataController.cs` to include this configuration option. Modified `MainWindow.xaml` to add a checkbox for toggling this setting and adjusted the layout for better dynamic resizing. Added a binding to control the visibility of the `StackPanel` based on this setting using an `InverseBoolToVisibilityConverter`. Updated `ViewModel.cs` to include a new property for `HideOpenAITools` to ensure UI reflects changes.
---
 .../Classes/DataAndSecurity/DataController.cs |  1 +
 vrcosc-magicchatbox/MainWindow.xaml           | 32 ++++++++++++++++---
 vrcosc-magicchatbox/ViewModels/ViewModel.cs   | 12 +++++++
 3 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/vrcosc-magicchatbox/Classes/DataAndSecurity/DataController.cs b/vrcosc-magicchatbox/Classes/DataAndSecurity/DataController.cs
index f9cdf857..35344198 100644
--- a/vrcosc-magicchatbox/Classes/DataAndSecurity/DataController.cs
+++ b/vrcosc-magicchatbox/Classes/DataAndSecurity/DataController.cs
@@ -393,6 +393,7 @@ public static void LoadComponentStats()
         { "ChatAddSmallDelayTIME", (typeof(double), "Chat") },
         { "ChattingUpdateRate", (typeof(double), "Chat") },
         { "RealTimeChatEdit", (typeof(bool), "Chat") },
+        { "HideOpenAITools", (typeof(bool), "Chat") },
 
         { "SeperateWithENTERS", (typeof(bool), "Custom") },
 
diff --git a/vrcosc-magicchatbox/MainWindow.xaml b/vrcosc-magicchatbox/MainWindow.xaml
index 0d56cd12..64eb4118 100644
--- a/vrcosc-magicchatbox/MainWindow.xaml
+++ b/vrcosc-magicchatbox/MainWindow.xaml
@@ -3257,6 +3257,28 @@
 
                                     </StackPanel>
                                 </Border>
+
+                                <Border
+                                    Margin="0,0,0,5"
+                                    Background="#FF3B3054"
+                                    CornerRadius="5,0,0,5">
+                                    <StackPanel Margin="5">
+                                        <CheckBox
+                                            x:Name="HideOpenAITools"
+                                            Height="20"
+                                            BorderBrush="#FF2D1265"
+                                            Checked="Update_Click"
+                                            FontFamily="Comfortaa Light"
+                                            FontSize="18"
+                                            Foreground="#FFB9B5C1"
+                                            IsChecked="{Binding HideOpenAITools, Mode=TwoWay}"
+                                            Style="{DynamicResource SettingsCheckbox}">
+                                            Hide OpenAI toolbar in chatting tab
+                                        </CheckBox>
+
+                                    </StackPanel>
+                                </Border>
+
                             </StackPanel>
                         </Grid>
                     </Grid>
@@ -6120,7 +6142,7 @@
                     <RowDefinition Height="31" />
                     <RowDefinition Height="35" />
                     <RowDefinition Height="*" />
-                    <RowDefinition Height="40" />
+                    <RowDefinition Height="auto" />
                     <RowDefinition Height="60" />
                 </Grid.RowDefinitions>
                 <Border
@@ -6985,6 +7007,7 @@
                 </Grid>
                 <Grid
                     Grid.Row="3"
+                    Height="auto"
                     HorizontalAlignment="Stretch"
                     Background="#FF493F65">
                     <Grid.Effect>
@@ -6997,11 +7020,12 @@
                             Color="#FF7F759A" />
                     </Grid.Effect>
                     <StackPanel
-                        Margin="13,0,0,0"
+                        Margin="15,5,0,5"
                         HorizontalAlignment="Left"
                         VerticalAlignment="Center"
                         Orientation="Horizontal"
-                        RenderOptions.BitmapScalingMode="NearestNeighbor">
+                        RenderOptions.BitmapScalingMode="NearestNeighbor"
+                        Visibility="{Binding HideOpenAITools, Converter={StaticResource InverseBoolToVisibilityConverter}}">
                         <StackPanel.Style>
                             <Style TargetType="StackPanel">
                                 <Style.Triggers>
@@ -7597,8 +7621,8 @@
                             FontFamily="Albert Sans Thin"
                             FontSize="8.5"
                             Foreground="#26A1FA"
-                            RenderOptions.BitmapScalingMode="NearestNeighbor"
                             MouseUp="GitHubChanges_MouseUp"
+                            RenderOptions.BitmapScalingMode="NearestNeighbor"
                             Text="View changes on GitHub"
                             TextDecorations="Underline"
                             Visibility="{Binding CanUpdateLabel, Converter={StaticResource InverseBoolToHiddenConverter}, UpdateSourceTrigger=PropertyChanged}">
diff --git a/vrcosc-magicchatbox/ViewModels/ViewModel.cs b/vrcosc-magicchatbox/ViewModels/ViewModel.cs
index 8bb8c82a..f33d4d85 100644
--- a/vrcosc-magicchatbox/ViewModels/ViewModel.cs
+++ b/vrcosc-magicchatbox/ViewModels/ViewModel.cs
@@ -4253,6 +4253,18 @@ private void ShuffleEmojis()
             _shuffledEmojis = new Queue<string>(shuffledList);
         }
 
+
+        private bool _HideOpenAITools = false;
+        public bool HideOpenAITools
+        {
+            get { return _HideOpenAITools; }
+            set
+            {
+                _HideOpenAITools = value;
+                NotifyPropertyChanged(nameof(HideOpenAITools));
+            }
+        }
+
         public string GetNextEmoji(bool IsChat = false)
         {
             string defaulticon = "💬";

From 301dbf87e0a8a94dc4d43c0b3c6ff0d49d08d954 Mon Sep 17 00:00:00 2001
From: BoiHanny <114599052+BoiHanny@users.noreply.github.com>
Date: Sat, 30 Nov 2024 20:22:01 +0100
Subject: [PATCH 07/12] Update NuGet packages in MagicChatbox.csproj

Updated CommunityToolkit.Mvvm from 8.2.2 to 8.4.0-preview3.
Updated LibreHardwareMonitorLib from 0.9.4-pre358 to 0.9.5-pre370.
These updates may include new features, bug fixes, or performance improvements.
---
 vrcosc-magicchatbox/MagicChatbox.csproj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/vrcosc-magicchatbox/MagicChatbox.csproj b/vrcosc-magicchatbox/MagicChatbox.csproj
index 354e5fca..59de8a1a 100644
--- a/vrcosc-magicchatbox/MagicChatbox.csproj
+++ b/vrcosc-magicchatbox/MagicChatbox.csproj
@@ -190,9 +190,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="CommunityToolkit.Mvvm" Version="8.2.2" />
+    <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.0-preview3" />
     <PackageReference Include="Dubya.WindowsMediaController" Version="2.5.5" />
-    <PackageReference Include="LibreHardwareMonitorLib" Version="0.9.4-pre358" />
+    <PackageReference Include="LibreHardwareMonitorLib" Version="0.9.5-pre370" />
     <PackageReference Include="Microsoft.Xaml.Behaviors.Wpf" Version="1.1.135" />
     <PackageReference Include="NAudio" Version="2.2.1" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />

From 6951b3b01c80425b6507ea001a52fe143e680928 Mon Sep 17 00:00:00 2001
From: BoiHanny <114599052+BoiHanny@users.noreply.github.com>
Date: Sat, 30 Nov 2024 20:22:48 +0100
Subject: [PATCH 08/12] Bump version to 0.9.060

Updated the version number in MagicChatbox.csproj from 0.9.055 to 0.9.060, indicating a new release or update of the project. This may include new features, bug fixes, or other improvements.
---
 vrcosc-magicchatbox/MagicChatbox.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vrcosc-magicchatbox/MagicChatbox.csproj b/vrcosc-magicchatbox/MagicChatbox.csproj
index 59de8a1a..3925950d 100644
--- a/vrcosc-magicchatbox/MagicChatbox.csproj
+++ b/vrcosc-magicchatbox/MagicChatbox.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
-	<Version>0.9.055</Version>
+	<Version>0.9.060</Version>
     <TargetFramework>net8.0-windows10.0.22000.0</TargetFramework>
     <RootNamespace>vrcosc_magicchatbox</RootNamespace>
     <Nullable>enable</Nullable>

From d0822f3a4986987ba213e845f5e1e6bdb11dd133 Mon Sep 17 00:00:00 2001
From: BoiHanny <114599052+BoiHanny@users.noreply.github.com>
Date: Sat, 30 Nov 2024 21:23:17 +0100
Subject: [PATCH 09/12] Add UI thread support and max speed control for network
 stats

- Added `System.Windows` and `System.Windows.Threading` namespaces to `NetworkStatisticsModule.cs` for UI thread operations.
- Introduced `_dispatcher` in `NetworkStatisticsModule` for UI thread property updates.
- Added `UseInterfaceMaxSpeed` property to control network speed calculations.
- Modified `InitializeNetworkStats` to conditionally set max speeds based on `UseInterfaceMaxSpeed`.
- Updated network stats calculations to reset max speeds if `UseInterfaceMaxSpeed` changes.
- Changed speed and data calculations to use local variables.
- Added logic to update max observed speeds if `UseInterfaceMaxSpeed` is false.
- Updated network utilization calculation to use the determined max speed.
- Modified property updates to be performed on the UI thread using `_dispatcher.BeginInvoke`.
- Added `CheckBox` in `MainWindow.xaml` to control `NetworkStats_UseInterfaceMaxSpeed` with bindings and event handlers.
- Introduced `NetworkStats_UseInterfaceMaxSpeed` property in `ViewModel.cs` with change notification.
- Updated `OnPropertyChanged` to use `_dispatcher` for UI thread property change notifications.
- Minor formatting changes in `FormatData` method for readability.
---
 .../Modules/NetworkStatisticsModule.cs        | 108 +++++++++++++-----
 vrcosc-magicchatbox/MainWindow.xaml           |  20 +++-
 vrcosc-magicchatbox/ViewModels/ViewModel.cs   |  15 +++
 3 files changed, 113 insertions(+), 30 deletions(-)

diff --git a/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs b/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs
index 6767fb31..a8b65ffc 100644
--- a/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs
+++ b/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs
@@ -5,6 +5,8 @@
 using System.Net.NetworkInformation;
 using System.Runtime.CompilerServices;
 using System.Threading;
+using System.Windows;
+using System.Windows.Threading;
 using vrcosc_magicchatbox.Classes.DataAndSecurity;
 using vrcosc_magicchatbox.DataAndSecurity;
 using vrcosc_magicchatbox.ViewModels;
@@ -18,6 +20,7 @@ public class NetworkStatisticsModule : INotifyPropertyChanged, IDisposable
         private bool _isMonitoring;
         private long _previousBytesReceived;
         private long _previousBytesSent;
+        private readonly Dispatcher _dispatcher;
 
         public bool IsInitialized { get; private set; }
         public double Interval { get; set; } = 1000;
@@ -32,9 +35,13 @@ public class NetworkStatisticsModule : INotifyPropertyChanged, IDisposable
 
         public event PropertyChangedEventHandler PropertyChanged;
 
+        // New property to control max speed source
+        public bool UseInterfaceMaxSpeed { get; set; } = false;
+
         public NetworkStatisticsModule(double interval)
         {
             Interval = interval;
+            _dispatcher = Application.Current.Dispatcher;
             ViewModel.Instance.PropertyChanged += PropertyChangedHandler;
 
             if (ShouldStartMonitoring())
@@ -83,9 +90,17 @@ private void InitializeNetworkStats()
             _activeNetworkInterface = GetActiveNetworkInterface();
             if (_activeNetworkInterface != null)
             {
-                var speedInMbps = _activeNetworkInterface.Speed / 1e6;
-                MaxDownloadSpeedMbps = speedInMbps;
-                MaxUploadSpeedMbps = speedInMbps;
+                if (UseInterfaceMaxSpeed)
+                {
+                    var speedInMbps = _activeNetworkInterface.Speed / 1e6;
+                    MaxDownloadSpeedMbps = speedInMbps;
+                    MaxUploadSpeedMbps = speedInMbps;
+                }
+                else
+                {
+                    MaxDownloadSpeedMbps = 0;
+                    MaxUploadSpeedMbps = 0;
+                }
 
                 var stats = _activeNetworkInterface.GetIPv4Statistics();
                 _previousBytesReceived = stats.BytesReceived;
@@ -201,6 +216,15 @@ private void OnTimedEvent(object state)
                         return;
                 }
 
+                if (UseInterfaceMaxSpeed != ViewModel.Instance.NetworkStats_UseInterfaceMaxSpeed)
+                {
+                    UseInterfaceMaxSpeed = ViewModel.Instance.NetworkStats_UseInterfaceMaxSpeed;
+                    MaxDownloadSpeedMbps = 0;
+                    MaxUploadSpeedMbps = 0;
+                }
+
+
+
                 var stats = _activeNetworkInterface.GetIPv4Statistics();
 
                 // Calculate the differences since the last check
@@ -213,22 +237,48 @@ private void OnTimedEvent(object state)
 
                 // Calculate speeds in Mbps
                 var intervalInSeconds = Interval / 1000;
-                CurrentDownloadSpeedMbps = (bytesReceivedDiff * 8) / 1e6 / intervalInSeconds;
-                CurrentUploadSpeedMbps = (bytesSentDiff * 8) / 1e6 / intervalInSeconds;
+                var downloadSpeed = (bytesReceivedDiff * 8) / 1e6 / intervalInSeconds;
+                var uploadSpeed = (bytesSentDiff * 8) / 1e6 / intervalInSeconds;
 
                 // Update total downloaded and uploaded data in MB
-                TotalDownloadedMB += bytesReceivedDiff / 1e6;
-                TotalUploadedMB += bytesSentDiff / 1e6;
+                var totalDownloaded = TotalDownloadedMB + bytesReceivedDiff / 1e6;
+                var totalUploaded = TotalUploadedMB + bytesSentDiff / 1e6;
+
+                // Update maximum observed speeds if not using interface max speed
+                if (!UseInterfaceMaxSpeed)
+                {
+                    if (downloadSpeed > MaxDownloadSpeedMbps)
+                        MaxDownloadSpeedMbps = downloadSpeed;
+
+                    if (uploadSpeed > MaxUploadSpeedMbps)
+                        MaxUploadSpeedMbps = uploadSpeed;
+                }
+
+                // Determine the max speed to use for utilization calculation
+                var maxDownloadSpeed = UseInterfaceMaxSpeed
+                    ? _activeNetworkInterface.Speed / 1e6
+                    : MaxDownloadSpeedMbps;
+
+                var maxUploadSpeed = UseInterfaceMaxSpeed
+                    ? _activeNetworkInterface.Speed / 1e6
+                    : MaxUploadSpeedMbps;
 
                 // Update network utilization
-                NetworkUtilization = Math.Min(100, (CurrentDownloadSpeedMbps / MaxDownloadSpeedMbps) * 100);
-
-                // Notify property changes
-                OnPropertyChanged(nameof(CurrentDownloadSpeedMbps));
-                OnPropertyChanged(nameof(CurrentUploadSpeedMbps));
-                OnPropertyChanged(nameof(TotalDownloadedMB));
-                OnPropertyChanged(nameof(TotalUploadedMB));
-                OnPropertyChanged(nameof(NetworkUtilization));
+                var utilization = maxDownloadSpeed > 0
+                    ? Math.Min(100, (downloadSpeed / maxDownloadSpeed) * 100)
+                    : 0;
+
+                // Update properties on the UI thread
+                _dispatcher.BeginInvoke(new Action(() =>
+                {
+                    CurrentDownloadSpeedMbps = downloadSpeed;
+                    CurrentUploadSpeedMbps = uploadSpeed;
+                    TotalDownloadedMB = totalDownloaded;
+                    TotalUploadedMB = totalUploaded;
+                    NetworkUtilization = utilization;
+                    MaxDownloadSpeedMbps = maxDownloadSpeed;
+                    MaxUploadSpeedMbps = maxUploadSpeed;
+                }));
             }
             catch (Exception ex)
             {
@@ -246,6 +296,8 @@ public string GenerateDescription()
             // List to store individual network stats descriptions
             var networkStatsDescriptions = new List<string>();
 
+
+
             if (ViewModel.Instance.NetworkStats_ShowCurrentDown)
                 networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Down: ")} {FormatSpeed(CurrentDownloadSpeedMbps)}");
 
@@ -274,15 +326,11 @@ public string GenerateDescription()
 
             foreach (var description in networkStatsDescriptions)
             {
-                // Skip any descriptions that are null or whitespace.
                 if (string.IsNullOrWhiteSpace(description))
                 {
                     continue;
                 }
 
-                // If adding the next description would exceed the max line width,
-                // or if the description is the only item and should be displayed alone,
-                // add currentLine to lines and reset it.
                 if (currentLine.Length + description.Length > maxLineWidth || (currentLine.Length == 0 && description.Length <= maxLineWidth))
                 {
                     if (currentLine.Length > 0)
@@ -291,8 +339,6 @@ public string GenerateDescription()
                         currentLine = "";
                     }
 
-                    // If the description is short enough and currentLine is empty,
-                    // add it directly to lines instead of appending to currentLine.
                     if (description.Length <= maxLineWidth)
                     {
                         lines.Add(description);
@@ -300,18 +346,14 @@ public string GenerateDescription()
                     }
                 }
 
-                // If currentLine is not empty, append the separator before adding the new description.
                 if (currentLine.Length > 0)
                 {
                     currentLine += separator;
                 }
 
-                // Append the current description to currentLine.
                 currentLine += description;
             }
 
-            // After processing all descriptions, if there's any content left in currentLine,
-            // add it to lines.
             if (currentLine.Length > 0)
             {
                 lines.Add(currentLine.TrimEnd());
@@ -322,7 +364,6 @@ public string GenerateDescription()
 
         private string FormatSpeed(double speedMbps)
         {
-            // Convert and format speed based on its magnitude
             if (speedMbps < 1)
                 return $"{speedMbps * 1000:N2} {ConvertToSuperScriptIfNeeded("Kbps")}";
             else if (speedMbps >= 1000)
@@ -345,11 +386,10 @@ private string ConvertToSuperScriptIfNeeded(string unitstring)
 
         private string FormatData(double dataMB)
         {
-            // Convert and format data based on its magnitude
             if (dataMB < 1)
                 return $"{dataMB * 1000:N2} {ConvertToSuperScriptIfNeeded("KB")}";
             else if (dataMB >= 1000)
-                return dataMB >= 1000000 ? $"{dataMB / 1e6:N2} TB" : $"{dataMB / 1000:N2} {ConvertToSuperScriptIfNeeded("GB")}";
+                return dataMB >= 1_000_000 ? $"{dataMB / 1e6:N2} TB" : $"{dataMB / 1000:N2} {ConvertToSuperScriptIfNeeded("GB")}";
             else
                 return $"{dataMB:N2} {ConvertToSuperScriptIfNeeded("MB")}";
         }
@@ -408,7 +448,17 @@ protected bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string
 
         protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
         {
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+            if (!_dispatcher.CheckAccess())
+            {
+                _dispatcher.BeginInvoke(() =>
+                {
+                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+                });
+            }
+            else
+            {
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+            }
         }
 
         public void Dispose()
diff --git a/vrcosc-magicchatbox/MainWindow.xaml b/vrcosc-magicchatbox/MainWindow.xaml
index 64eb4118..facca2b8 100644
--- a/vrcosc-magicchatbox/MainWindow.xaml
+++ b/vrcosc-magicchatbox/MainWindow.xaml
@@ -3957,7 +3957,25 @@
                             Margin="34,0,0,0"
                             Visibility="{Binding Settings_NetworkStatistics, Converter={StaticResource InverseBoolToHiddenConverter}, UpdateSourceTrigger=PropertyChanged}">
                             <StackPanel>
-
+                                <Border
+                                    Margin="0,0,0,5"
+                                    Background="#FF3B3054"
+                                    CornerRadius="5,0,0,5">
+                                    <CheckBox
+                                        x:Name="NetworkStats_UseInterfaceMaxSpeed"
+                                        Height="20"
+                                        Margin="5"
+                                        BorderBrush="#FF2D1265"
+                                        Checked="Update_Click"
+                                        FontFamily="Comfortaa Light"
+                                        FontSize="18"
+                                        Foreground="#FFB9B5C1"
+                                        IsChecked="{Binding NetworkStats_UseInterfaceMaxSpeed, Mode=TwoWay}"
+                                        Style="{DynamicResource SettingsCheckbox}"
+                                        Unchecked="Update_Click">
+                                        Use network interface as the max speed
+                                    </CheckBox>
+                                </Border>
                                 <Border
                                     Margin="0,0,0,5"
                                     Background="#FF3B3054"
diff --git a/vrcosc-magicchatbox/ViewModels/ViewModel.cs b/vrcosc-magicchatbox/ViewModels/ViewModel.cs
index f33d4d85..b2ee9c86 100644
--- a/vrcosc-magicchatbox/ViewModels/ViewModel.cs
+++ b/vrcosc-magicchatbox/ViewModels/ViewModel.cs
@@ -3936,6 +3936,21 @@ public bool NetworkStats_ShowCurrentDown
             }
         }
 
+        private bool _NetworkStats_UseInterfaceMaxSpeed = false;
+
+        public bool NetworkStats_UseInterfaceMaxSpeed
+        {
+            get { return _NetworkStats_UseInterfaceMaxSpeed; }
+            set
+            {
+                if (_NetworkStats_UseInterfaceMaxSpeed != value)
+                {
+                    _NetworkStats_UseInterfaceMaxSpeed = value;
+                    NotifyPropertyChanged(nameof(NetworkStats_UseInterfaceMaxSpeed));
+                }
+            }
+        }
+
 
         private bool _NetworkStats_ShowCurrentUp = false;
 

From 5114b0c1dcc49f19c9bc8fd7ff92edacf0279521 Mon Sep 17 00:00:00 2001
From: BoiHanny <114599052+BoiHanny@users.noreply.github.com>
Date: Sat, 30 Nov 2024 21:24:01 +0100
Subject: [PATCH 10/12] Refactor ReadTkTkTTSVoices method for dynamic path

Updated ReadTkTkTTSVoices in DataController.cs to dynamically determine the application's directory and construct the path to voices.json. Simplified conditional check for selectedVoice by removing the empty if block.
---
 .../Classes/DataAndSecurity/DataController.cs         | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/vrcosc-magicchatbox/Classes/DataAndSecurity/DataController.cs b/vrcosc-magicchatbox/Classes/DataAndSecurity/DataController.cs
index 35344198..89411789 100644
--- a/vrcosc-magicchatbox/Classes/DataAndSecurity/DataController.cs
+++ b/vrcosc-magicchatbox/Classes/DataAndSecurity/DataController.cs
@@ -1055,7 +1055,11 @@ public static List<Voice> ReadTkTkTTSVoices()
         {
             try
             {
-                string json = File.ReadAllText(@"Json\voices.json");
+                string currentrunningAppdir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+
+
+                string voicesFilePath = Path.Combine(currentrunningAppdir, "Json", "voices.json");
+                string json = File.ReadAllText(voicesFilePath);
                 List<Voice> ConfirmList = JsonConvert.DeserializeObject<List<Voice>>(json);
 
                 if (string.IsNullOrEmpty(ViewModel.Instance.RecentTikTokTTSVoice) || ConfirmList.Count == 0)
@@ -1065,10 +1069,7 @@ public static List<Voice> ReadTkTkTTSVoices()
                 if (!string.IsNullOrEmpty(ViewModel.Instance.RecentTikTokTTSVoice) || ConfirmList.Count == 0)
                 {
                     Voice selectedVoice = ConfirmList.FirstOrDefault(v => v.ApiName == ViewModel.Instance.RecentTikTokTTSVoice);
-                    if (selectedVoice == null)
-                    {
-                    }
-                    else
+                    if (selectedVoice != null)
                     {
                         ViewModel.Instance.SelectedTikTokTTSVoice = selectedVoice;
                     }

From 0d0805cba8fa7fdf8ef2fd58ccd00a1b8049dc3c Mon Sep 17 00:00:00 2001
From: BoiHanny <114599052+BoiHanny@users.noreply.github.com>
Date: Sat, 30 Nov 2024 21:37:46 +0100
Subject: [PATCH 11/12] Improve network interface selection and error handling

- Return single active network interface directly if only one is found.
- Enhance error handling to log exceptions and fallback to a valid interface.
- Remove redundant code for obtaining IPv4 statistics.
- Simplify code by removing conditional block for download speed display.
---
 .../Modules/NetworkStatisticsModule.cs        | 20 +++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs b/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs
index a8b65ffc..418b5776 100644
--- a/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs
+++ b/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs
@@ -130,6 +130,12 @@ private NetworkInterface GetActiveNetworkInterface()
                 if (networkInterfaces.Count == 0)
                     return null;
 
+                // If there's only one active network interface, return it directly
+                if (networkInterfaces.Count == 1)
+                {
+                    return networkInterfaces.First();
+                }
+
                 // Measure initial bytes sent/received
                 var interfaceStats = new List<InterfaceStats>();
                 foreach (var ni in networkInterfaces)
@@ -164,14 +170,20 @@ private NetworkInterface GetActiveNetworkInterface()
                 }
                 else
                 {
-                    // If no activity detected, return the first interface
+                    // If no activity detected or measurement fails, fallback to selecting the first interface
                     return networkInterfaces.FirstOrDefault();
                 }
             }
             catch (Exception ex)
             {
+                // Log the exception and fallback to the first available network interface
                 Logging.WriteException(ex, MSGBox: false);
-                return null;
+                return NetworkInterface.GetAllNetworkInterfaces()
+                    .FirstOrDefault(ni =>
+                        ni.OperationalStatus == OperationalStatus.Up &&
+                        ni.NetworkInterfaceType != NetworkInterfaceType.Loopback &&
+                        ni.NetworkInterfaceType != NetworkInterfaceType.Tunnel &&
+                        ni.GetIPProperties().UnicastAddresses.Count > 0);
             }
         }
 
@@ -223,8 +235,6 @@ private void OnTimedEvent(object state)
                     MaxUploadSpeedMbps = 0;
                 }
 
-
-
                 var stats = _activeNetworkInterface.GetIPv4Statistics();
 
                 // Calculate the differences since the last check
@@ -296,8 +306,6 @@ public string GenerateDescription()
             // List to store individual network stats descriptions
             var networkStatsDescriptions = new List<string>();
 
-
-
             if (ViewModel.Instance.NetworkStats_ShowCurrentDown)
                 networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Down: ")} {FormatSpeed(CurrentDownloadSpeedMbps)}");
 

From f1fe706a947ec0860bb87ab9a1162c0fbf3c5791 Mon Sep 17 00:00:00 2001
From: BoiHanny <114599052+BoiHanny@users.noreply.github.com>
Date: Sat, 30 Nov 2024 21:40:55 +0100
Subject: [PATCH 12/12] Refactor NetworkStatisticsModule for async and thread
 safety

Added System.Collections.Generic namespace to NetworkStatisticsModule.cs.
Introduced private fields _initLock and _isInitializing for thread-safe initialization.
Refactored Interval property for validation and timer updates.
Added CancellationTokenSource for async initialization.
Updated constructor to call InitializeNetworkStatsAsync.
Replaced InitializeNetworkStats with async InitializeNetworkStatsAsync.
Replaced GetActiveNetworkInterface with async GetActiveNetworkInterfaceAsync.
Added GetInterfacePriority method for network interface prioritization.
Added GetTotalBytes method to retrieve total bytes sent and received.
Introduced TotalBytes struct to encapsulate bytes data.
Updated StartModule to check initialization status.
Updated StopModule to use Timeout.Infinite for stopping the timer.
Updated OnTimedEvent to call async initialization if network interface is null.
Enhanced FormatData to handle data sizes in terabytes (TB).
Updated Dispose method to cancel and dispose of CancellationTokenSource.
Made minor formatting changes for code readability.
---
 .../Modules/NetworkStatisticsModule.cs        | 278 +++++++++++-------
 1 file changed, 179 insertions(+), 99 deletions(-)

diff --git a/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs b/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs
index 418b5776..0749f2d5 100644
--- a/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs
+++ b/vrcosc-magicchatbox/Classes/Modules/NetworkStatisticsModule.cs
@@ -5,6 +5,7 @@
 using System.Net.NetworkInformation;
 using System.Runtime.CompilerServices;
 using System.Threading;
+using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Threading;
 using vrcosc_magicchatbox.Classes.DataAndSecurity;
@@ -21,9 +22,25 @@ public class NetworkStatisticsModule : INotifyPropertyChanged, IDisposable
         private long _previousBytesReceived;
         private long _previousBytesSent;
         private readonly Dispatcher _dispatcher;
+        private readonly object _initLock = new object();
+        private bool _isInitializing;
 
         public bool IsInitialized { get; private set; }
-        public double Interval { get; set; } = 1000;
+        private double _interval = 1000;
+        public double Interval
+        {
+            get => _interval;
+            set
+            {
+                if (value <= 0)
+                    throw new ArgumentOutOfRangeException(nameof(Interval), "Interval must be greater than zero.");
+                _interval = value;
+                if (_isMonitoring)
+                {
+                    _updateTimer.Change(TimeSpan.Zero, TimeSpan.FromMilliseconds(_interval));
+                }
+            }
+        }
 
         private double _currentDownloadSpeedMbps;
         private double _currentUploadSpeedMbps;
@@ -38,17 +55,16 @@ public class NetworkStatisticsModule : INotifyPropertyChanged, IDisposable
         // New property to control max speed source
         public bool UseInterfaceMaxSpeed { get; set; } = false;
 
-        public NetworkStatisticsModule(double interval)
+        // CancellationTokenSource for asynchronous initialization
+        private CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+
+        public NetworkStatisticsModule(double interval = 1000)
         {
             Interval = interval;
             _dispatcher = Application.Current.Dispatcher;
             ViewModel.Instance.PropertyChanged += PropertyChangedHandler;
 
-            if (ShouldStartMonitoring())
-            {
-                InitializeNetworkStats();
-                StartModule();
-            }
+            InitializeNetworkStatsAsync().ConfigureAwait(false);
         }
 
         private void PropertyChangedHandler(object sender, PropertyChangedEventArgs e)
@@ -57,11 +73,7 @@ private void PropertyChangedHandler(object sender, PropertyChangedEventArgs e)
             {
                 if (ShouldStartMonitoring())
                 {
-                    if (!IsInitialized)
-                    {
-                        InitializeNetworkStats();
-                    }
-                    StartModule();
+                    InitializeNetworkStatsAsync().ConfigureAwait(false);
                 }
                 else
                 {
@@ -85,106 +97,168 @@ private bool IsRelevantPropertyChange(string propertyName)
                    propertyName == nameof(ViewModel.Instance.IntgrNetworkStatistics_DESKTOP);
         }
 
-        private void InitializeNetworkStats()
+        /// <summary>
+        /// Asynchronously initializes network statistics.
+        /// Ensures that initialization is thread-safe and does not block the UI thread.
+        /// </summary>
+        private async Task InitializeNetworkStatsAsync()
         {
-            _activeNetworkInterface = GetActiveNetworkInterface();
-            if (_activeNetworkInterface != null)
-            {
-                if (UseInterfaceMaxSpeed)
-                {
-                    var speedInMbps = _activeNetworkInterface.Speed / 1e6;
-                    MaxDownloadSpeedMbps = speedInMbps;
-                    MaxUploadSpeedMbps = speedInMbps;
-                }
-                else
-                {
-                    MaxDownloadSpeedMbps = 0;
-                    MaxUploadSpeedMbps = 0;
-                }
-
-                var stats = _activeNetworkInterface.GetIPv4Statistics();
-                _previousBytesReceived = stats.BytesReceived;
-                _previousBytesSent = stats.BytesSent;
+            if (_isInitializing)
+                return;
 
-                IsInitialized = true;
-            }
-            else
+            lock (_initLock)
             {
-                // Handle the case when no active network interface is found
-                Logging.WriteException(new Exception("No active network interface found"), MSGBox: false);
-                IsInitialized = false;
+                if (_isInitializing)
+                    return;
+                _isInitializing = true;
             }
-        }
 
-        private NetworkInterface GetActiveNetworkInterface()
-        {
             try
             {
-                var networkInterfaces = NetworkInterface.GetAllNetworkInterfaces()
-                    .Where(ni =>
-                        ni.OperationalStatus == OperationalStatus.Up &&
-                        ni.NetworkInterfaceType != NetworkInterfaceType.Loopback &&
-                        ni.NetworkInterfaceType != NetworkInterfaceType.Tunnel &&
-                        ni.GetIPProperties().UnicastAddresses.Count > 0).ToList();
-
-                if (networkInterfaces.Count == 0)
-                    return null;
-
-                // If there's only one active network interface, return it directly
-                if (networkInterfaces.Count == 1)
+                var networkInterface = await Task.Run(() => GetActiveNetworkInterfaceAsync(_cancellationTokenSource.Token));
+                if (networkInterface != null)
                 {
-                    return networkInterfaces.First();
-                }
+                    _activeNetworkInterface = networkInterface;
 
-                // Measure initial bytes sent/received
-                var interfaceStats = new List<InterfaceStats>();
-                foreach (var ni in networkInterfaces)
-                {
-                    var stats = ni.GetIPv4Statistics();
-                    interfaceStats.Add(new InterfaceStats
+                    if (UseInterfaceMaxSpeed)
                     {
-                        NetworkInterface = ni,
-                        InitialBytesReceived = stats.BytesReceived,
-                        InitialBytesSent = stats.BytesSent
-                    });
-                }
-
-                // Wait for a short interval
-                Thread.Sleep(500);
+                        var speedInMbps = _activeNetworkInterface.Speed / 1e6;
+                        MaxDownloadSpeedMbps = speedInMbps;
+                        MaxUploadSpeedMbps = speedInMbps;
+                    }
+                    else
+                    {
+                        MaxDownloadSpeedMbps = 0;
+                        MaxUploadSpeedMbps = 0;
+                    }
 
-                // Measure bytes sent/received after the interval
-                foreach (var stat in interfaceStats)
-                {
-                    var stats = stat.NetworkInterface.GetIPv4Statistics();
-                    stat.BytesReceivedDiff = stats.BytesReceived - stat.InitialBytesReceived;
-                    stat.BytesSentDiff = stats.BytesSent - stat.InitialBytesSent;
-                    stat.TotalBytesDiff = stat.BytesReceivedDiff + stat.BytesSentDiff;
-                }
+                    var stats = GetTotalBytes(_activeNetworkInterface);
+                    _previousBytesReceived = stats.BytesReceived;
+                    _previousBytesSent = stats.BytesSent;
 
-                // Select the network interface with the highest total bytes difference
-                var mostActiveInterface = interfaceStats.OrderByDescending(s => s.TotalBytesDiff).FirstOrDefault();
+                    IsInitialized = true;
 
-                if (mostActiveInterface != null && mostActiveInterface.TotalBytesDiff > 0)
-                {
-                    return mostActiveInterface.NetworkInterface;
+                    if (!_isMonitoring)
+                    {
+                        StartModule();
+                    }
                 }
                 else
                 {
-                    // If no activity detected or measurement fails, fallback to selecting the first interface
-                    return networkInterfaces.FirstOrDefault();
+                    // Handle the case when no active network interface is found
+                    Logging.WriteException(new Exception("No active network interface found"), MSGBox: false);
+                    IsInitialized = false;
                 }
             }
+            catch (OperationCanceledException)
+            {
+                // Initialization was canceled; do nothing.
+            }
             catch (Exception ex)
             {
-                // Log the exception and fallback to the first available network interface
                 Logging.WriteException(ex, MSGBox: false);
-                return NetworkInterface.GetAllNetworkInterfaces()
-                    .FirstOrDefault(ni =>
-                        ni.OperationalStatus == OperationalStatus.Up &&
-                        ni.NetworkInterfaceType != NetworkInterfaceType.Loopback &&
-                        ni.NetworkInterfaceType != NetworkInterfaceType.Tunnel &&
-                        ni.GetIPProperties().UnicastAddresses.Count > 0);
+                IsInitialized = false;
+            }
+            finally
+            {
+                lock (_initLock)
+                {
+                    _isInitializing = false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously determines the active network interface.
+        /// Includes both IPv4 and IPv6 statistics.
+        /// </summary>
+        /// <param name="cancellationToken">Cancellation token.</param>
+        /// <returns>The selected active NetworkInterface or null if none found.</returns>
+        private NetworkInterface GetActiveNetworkInterfaceAsync(CancellationToken cancellationToken)
+        {
+            var networkInterfaces = NetworkInterface.GetAllNetworkInterfaces()
+                .Where(ni =>
+                    ni.OperationalStatus == OperationalStatus.Up &&
+                    ni.NetworkInterfaceType != NetworkInterfaceType.Loopback &&
+                    ni.NetworkInterfaceType != NetworkInterfaceType.Tunnel &&
+                    ni.GetIPProperties().UnicastAddresses.Any()).ToList();
+
+            if (networkInterfaces.Count == 0)
+                return null;
+
+            // If there's only one active network interface, return it directly
+            if (networkInterfaces.Count == 1)
+            {
+                return networkInterfaces.First();
+            }
+
+            // Prioritize network interfaces based on type (e.g., Ethernet over Wireless)
+            var prioritizedInterfaces = networkInterfaces.OrderByDescending(ni => GetInterfacePriority(ni)).ToList();
+
+            // Measure initial bytes sent/received for all interfaces
+            var interfaceStats = prioritizedInterfaces.Select(ni => new InterfaceStats
+            {
+                NetworkInterface = ni,
+                InitialBytesReceived = GetTotalBytes(ni).BytesReceived,
+                InitialBytesSent = GetTotalBytes(ni).BytesSent
+            }).ToList();
+
+            // Wait for a short interval asynchronously
+            Task.Delay(500, cancellationToken).Wait(cancellationToken);
+
+            // Measure bytes sent/received after the interval
+            foreach (var stat in interfaceStats)
+            {
+                var currentStats = GetTotalBytes(stat.NetworkInterface);
+                stat.BytesReceivedDiff = currentStats.BytesReceived - stat.InitialBytesReceived;
+                stat.BytesSentDiff = currentStats.BytesSent - stat.InitialBytesSent;
+                stat.TotalBytesDiff = stat.BytesReceivedDiff + stat.BytesSentDiff;
             }
+
+            // Select the network interface with the highest total bytes difference
+            var mostActiveInterface = interfaceStats
+                .OrderByDescending(s => s.TotalBytesDiff)
+                .FirstOrDefault(s => s.TotalBytesDiff > 0);
+
+            return mostActiveInterface?.NetworkInterface ?? prioritizedInterfaces.FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Assigns a priority to network interfaces based on their type.
+        /// Higher priority for Ethernet, then Wireless, then others.
+        /// </summary>
+        /// <param name="ni">NetworkInterface.</param>
+        /// <returns>Integer priority.</returns>
+        private int GetInterfacePriority(NetworkInterface ni)
+        {
+            return ni.NetworkInterfaceType switch
+            {
+                NetworkInterfaceType.Ethernet => 3,
+                NetworkInterfaceType.Wireless80211 => 2,
+                _ => 1,
+            };
+        }
+
+        /// <summary>
+        /// Retrieves total bytes sent and received, including both IPv4 and IPv6.
+        /// </summary>
+        /// <param name="ni">NetworkInterface.</param>
+        /// <returns>TotalBytes struct containing BytesReceived and BytesSent.</returns>
+        private TotalBytes GetTotalBytes(NetworkInterface ni)
+        {
+            var ipv4Stats = ni.GetIPv4Statistics();
+            var ipv6Stats = ni.GetIPStatistics();
+            return new TotalBytes
+            {
+                BytesReceived = ipv4Stats.BytesReceived + ipv6Stats.BytesReceived,
+                BytesSent = ipv4Stats.BytesSent + ipv6Stats.BytesSent
+            };
+        }
+
+        private struct TotalBytes
+        {
+            public long BytesReceived;
+            public long BytesSent;
         }
 
         private class InterfaceStats
@@ -199,10 +273,10 @@ private class InterfaceStats
 
         public void StartModule()
         {
-            if (_isMonitoring)
+            if (_isMonitoring || !IsInitialized)
                 return;
 
-            _updateTimer = new Timer(OnTimedEvent, null, 0, (int)Interval);
+            _updateTimer = new Timer(OnTimedEvent, null, TimeSpan.Zero, TimeSpan.FromMilliseconds(Interval));
             _isMonitoring = true;
         }
 
@@ -211,7 +285,7 @@ public void StopModule()
             if (!_isMonitoring)
                 return;
 
-            _updateTimer?.Change(Timeout.Infinite, 0);
+            _updateTimer?.Change(Timeout.Infinite, Timeout.Infinite);
             _updateTimer?.Dispose();
             _updateTimer = null;
             _isMonitoring = false;
@@ -223,11 +297,13 @@ private void OnTimedEvent(object state)
             {
                 if (_activeNetworkInterface == null)
                 {
-                    InitializeNetworkStats();
+                    // Attempt to re-initialize if the active interface is null
+                    InitializeNetworkStatsAsync().ConfigureAwait(false);
                     if (_activeNetworkInterface == null)
                         return;
                 }
 
+                // Update UseInterfaceMaxSpeed based on ViewModel
                 if (UseInterfaceMaxSpeed != ViewModel.Instance.NetworkStats_UseInterfaceMaxSpeed)
                 {
                     UseInterfaceMaxSpeed = ViewModel.Instance.NetworkStats_UseInterfaceMaxSpeed;
@@ -235,7 +311,7 @@ private void OnTimedEvent(object state)
                     MaxUploadSpeedMbps = 0;
                 }
 
-                var stats = _activeNetworkInterface.GetIPv4Statistics();
+                var stats = GetTotalBytes(_activeNetworkInterface);
 
                 // Calculate the differences since the last check
                 var bytesReceivedDiff = stats.BytesReceived - _previousBytesReceived;
@@ -251,8 +327,8 @@ private void OnTimedEvent(object state)
                 var uploadSpeed = (bytesSentDiff * 8) / 1e6 / intervalInSeconds;
 
                 // Update total downloaded and uploaded data in MB
-                var totalDownloaded = TotalDownloadedMB + bytesReceivedDiff / 1e6;
-                var totalUploaded = TotalUploadedMB + bytesSentDiff / 1e6;
+                var totalDownloaded = TotalDownloadedMB + (bytesReceivedDiff / 1e6);
+                var totalUploaded = TotalUploadedMB + (bytesSentDiff / 1e6);
 
                 // Update maximum observed speeds if not using interface max speed
                 if (!UseInterfaceMaxSpeed)
@@ -325,7 +401,7 @@ public string GenerateDescription()
                 networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Total Up: ")} {FormatData(TotalUploadedMB)}");
 
             if (ViewModel.Instance.NetworkStats_ShowNetworkUtilization)
-                networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Network utilization: ")} {NetworkUtilization:N2} %");
+                networkStatsDescriptions.Add($"{ConvertToSuperScriptIfNeeded("Network Utilization: ")} {NetworkUtilization:N2} %");
 
             if (networkStatsDescriptions.Count == 0)
             {
@@ -396,8 +472,10 @@ private string FormatData(double dataMB)
         {
             if (dataMB < 1)
                 return $"{dataMB * 1000:N2} {ConvertToSuperScriptIfNeeded("KB")}";
+            else if (dataMB >= 1_000_000)
+                return $"{dataMB / 1e6:N2} {ConvertToSuperScriptIfNeeded("TB")}";
             else if (dataMB >= 1000)
-                return dataMB >= 1_000_000 ? $"{dataMB / 1e6:N2} TB" : $"{dataMB / 1000:N2} {ConvertToSuperScriptIfNeeded("GB")}";
+                return $"{dataMB / 1000:N2} {ConvertToSuperScriptIfNeeded("GB")}";
             else
                 return $"{dataMB:N2} {ConvertToSuperScriptIfNeeded("MB")}";
         }
@@ -472,6 +550,8 @@ protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
         public void Dispose()
         {
             StopModule();
+            _cancellationTokenSource.Cancel();
+            _cancellationTokenSource.Dispose();
             ViewModel.Instance.PropertyChanged -= PropertyChangedHandler;
         }
     }