diff --git a/WhackerLinkConsoleV2/App.xaml b/WhackerLinkConsoleV2/App.xaml
index 48129b4..5f0455a 100644
--- a/WhackerLinkConsoleV2/App.xaml
+++ b/WhackerLinkConsoleV2/App.xaml
@@ -1,7 +1,8 @@
 <Application x:Class="WhackerLinkConsoleV2.App"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             StartupUri="MainWindow.xaml">
+             StartupUri="MainWindow.xaml"
+             ShutdownMode="OnMainWindowClose">
     <Application.Resources>
         <!-- Default Button Style -->
         <Style TargetType="Button" x:Key="FlatButton">
diff --git a/WhackerLinkConsoleV2/Assets/app-icon.ico b/WhackerLinkConsoleV2/Assets/app-icon.ico
new file mode 100644
index 0000000..59d61f3
Binary files /dev/null and b/WhackerLinkConsoleV2/Assets/app-icon.ico differ
diff --git a/WhackerLinkConsoleV2/Assets/whackerlink-logo-icon.png b/WhackerLinkConsoleV2/Assets/whackerlink-logo-icon.png
new file mode 100644
index 0000000..ffbc01f
Binary files /dev/null and b/WhackerLinkConsoleV2/Assets/whackerlink-logo-icon.png differ
diff --git a/WhackerLinkConsoleV2/ChannelBox.xaml.cs b/WhackerLinkConsoleV2/ChannelBox.xaml.cs
index 18c9d2d..d08f74e 100644
--- a/WhackerLinkConsoleV2/ChannelBox.xaml.cs
+++ b/WhackerLinkConsoleV2/ChannelBox.xaml.cs
@@ -244,6 +244,26 @@ private void ChannelBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs
             }
         }
 
+        /// <summary>
+        /// Toggles the channel selection state programmatically (used by keybinds)
+        /// </summary>
+        public void ToggleSelection()
+        {
+            if (IsEditMode) return;
+
+            IsSelected = !IsSelected;
+            Background = IsSelected ? (Brush)new BrushConverter().ConvertFrom("#FF0B004B") : Brushes.Gray;
+
+            if (IsSelected)
+            {
+                _selectedChannelsManager.AddSelectedChannel(this);
+            }
+            else
+            {
+                _selectedChannelsManager.RemoveSelectedChannel(this);
+            }
+        }
+
         private void UpdatePTTColor()
         {
             if (IsEditMode) return;
diff --git a/WhackerLinkConsoleV2/ChannelHotKeyManager.cs b/WhackerLinkConsoleV2/ChannelHotKeyManager.cs
new file mode 100644
index 0000000..fc6f9c9
--- /dev/null
+++ b/WhackerLinkConsoleV2/ChannelHotKeyManager.cs
@@ -0,0 +1,280 @@
+/*
+* WhackerLink - WhackerLinkConsoleV2
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* 
+* Copyright (C) 2024-2025 Caleb, K4PHP
+* Copyright (C) 2025 Firav (firavdev@gmail.com)
+* 
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Input;
+using WhackerLinkConsoleV2.Controls;
+
+namespace WhackerLinkConsoleV2
+{
+    /// <summary>
+    /// Manages per-channel PTT and toggle hotkey registrations and triggering
+    /// </summary>
+    public class ChannelHotKeyManager
+    {
+        private GlobalHotKeyManager _globalHotKeyManager;
+        private ChannelKeybindingManager _channelKeybindingManager;
+        private Dictionary<string, int> _channelHotKeyIds = new Dictionary<string, int>();
+        private Dictionary<string, int> _channelToggleHotKeyIds = new Dictionary<string, int>();
+        private Dictionary<int, string> _hotKeyIdToChannelName = new Dictionary<int, string>();
+        private Dictionary<int, string> _toggleHotKeyIdToChannelName = new Dictionary<int, string>();
+        private List<ChannelBox> _allChannels = new List<ChannelBox>();
+        private string _currentCodeplugIdentifier;
+        private Action<ChannelBox, bool> _onChannelPttTriggered;
+        private Action<ChannelBox> _onChannelToggleTriggered;
+
+        public ChannelHotKeyManager(GlobalHotKeyManager globalHotKeyManager, ChannelKeybindingManager channelKeybindingManager, Action<ChannelBox, bool> onChannelPttTriggered, Action<ChannelBox> onChannelToggleTriggered = null)
+        {
+            _globalHotKeyManager = globalHotKeyManager;
+            _channelKeybindingManager = channelKeybindingManager;
+            _onChannelPttTriggered = onChannelPttTriggered;
+            _onChannelToggleTriggered = onChannelToggleTriggered;
+        }
+
+        /// <summary>
+        /// Initializes channel hotkeys for the current codeplug
+        /// </summary>
+        public void InitializeChannelHotkeys(string codeplugIdentifier, List<ChannelBox> channels)
+        {
+            // Always unregister all existing channel hotkeys first to ensure 
+            // cleared keybindings are properly removed
+            UnregisterAllChannelHotkeys();
+            
+            // Update current codeplug identifier
+            _currentCodeplugIdentifier = codeplugIdentifier;
+            _allChannels = channels;
+
+            // Register PTT hotkeys for channels that have PTT keybindings
+            int registeredPttCount = 0;
+            int registeredToggleCount = 0;
+            
+            foreach (var channel in channels)
+            {
+                // Register PTT hotkey
+                var pttKeybinding = _channelKeybindingManager.GetChannelKeybinding(codeplugIdentifier, channel.ChannelName);
+                if (!string.IsNullOrWhiteSpace(pttKeybinding))
+                {
+                    RegisterChannelHotkey(channel.ChannelName, pttKeybinding);
+                    registeredPttCount++;
+                }
+
+                // Register toggle hotkey
+                var toggleKeybinding = _channelKeybindingManager.GetChannelToggleKeybinding(codeplugIdentifier, channel.ChannelName);
+                if (!string.IsNullOrWhiteSpace(toggleKeybinding))
+                {
+                    RegisterChannelToggleHotkey(channel.ChannelName, toggleKeybinding);
+                    registeredToggleCount++;
+                }
+            }
+            
+            if (registeredPttCount > 0)
+            {
+                Console.WriteLine($"Registered {registeredPttCount} channel PTT hotkey(s)");
+            }
+            if (registeredToggleCount > 0)
+            {
+                Console.WriteLine($"Registered {registeredToggleCount} channel toggle hotkey(s)");
+            }
+        }
+
+        /// <summary>
+        /// Registers a hotkey for a specific channel
+        /// </summary>
+        private void RegisterChannelHotkey(string channelName, string keybinding)
+        {
+            if (_globalHotKeyManager == null)
+            {
+                Console.WriteLine($"ERROR: GlobalHotKeyManager is null! Cannot register hotkey for '{channelName}'");
+                return;
+            }
+
+            // Unregister old hotkey if it exists
+            if (_channelHotKeyIds.ContainsKey(channelName))
+            {
+                var oldHotKeyId = _channelHotKeyIds[channelName];
+                _globalHotKeyManager.UnregisterHotKey(oldHotKeyId);
+                _channelHotKeyIds.Remove(channelName);
+                _hotKeyIdToChannelName.Remove(oldHotKeyId);
+            }
+
+            // Parse the keybinding
+            if (!KeybindingParser.TryParseKeybinding(keybinding, out var modifiers, out var key))
+            {
+                Console.WriteLine($"ERROR: Failed to parse keybinding '{keybinding}' for channel '{channelName}'");
+                return;
+            }
+
+            // Register with global hotkey manager
+            var hotKeyId = _globalHotKeyManager.RegisterHotKey(
+                modifiers,
+                key,
+                () => OnChannelHotKeyDown(channelName),
+                () => OnChannelHotKeyUp(channelName)
+            );
+
+            if (hotKeyId != -1)
+            {
+                _channelHotKeyIds[channelName] = hotKeyId;
+                _hotKeyIdToChannelName[hotKeyId] = channelName;
+            }
+            else
+            {
+                Console.WriteLine($"Failed to register hotkey '{keybinding}' for channel '{channelName}'");
+            }
+        }
+
+        /// <summary>
+        /// Registers a toggle hotkey for a specific channel
+        /// </summary>
+        private void RegisterChannelToggleHotkey(string channelName, string keybinding)
+        {
+            if (_globalHotKeyManager == null)
+            {
+                Console.WriteLine($"ERROR: GlobalHotKeyManager is null! Cannot register toggle hotkey for '{channelName}'");
+                return;
+            }
+
+            // Unregister old toggle hotkey if it exists
+            if (_channelToggleHotKeyIds.ContainsKey(channelName))
+            {
+                var oldHotKeyId = _channelToggleHotKeyIds[channelName];
+                _globalHotKeyManager.UnregisterHotKey(oldHotKeyId);
+                _channelToggleHotKeyIds.Remove(channelName);
+                _toggleHotKeyIdToChannelName.Remove(oldHotKeyId);
+            }
+
+            // Parse the keybinding
+            if (!KeybindingParser.TryParseKeybinding(keybinding, out var modifiers, out var key))
+            {
+                Console.WriteLine($"ERROR: Failed to parse toggle keybinding '{keybinding}' for channel '{channelName}'");
+                return;
+            }
+
+            // Register with global hotkey manager (toggle only needs key down event)
+            var hotKeyId = _globalHotKeyManager.RegisterHotKey(
+                modifiers,
+                key,
+                () => OnChannelToggleHotKeyDown(channelName),
+                null // No key up action needed for toggle
+            );
+
+            if (hotKeyId != -1)
+            {
+                _channelToggleHotKeyIds[channelName] = hotKeyId;
+                _toggleHotKeyIdToChannelName[hotKeyId] = channelName;
+            }
+            else
+            {
+                Console.WriteLine($"Failed to register toggle hotkey '{keybinding}' for channel '{channelName}'");
+            }
+        }
+
+        /// <summary>
+        /// Unregisters a hotkey for a specific channel
+        /// </summary>
+        public void UnregisterChannelHotkey(string channelName)
+        {
+            // Unregister PTT hotkey
+            if (_channelHotKeyIds.TryGetValue(channelName, out var pttHotKeyId))
+            {
+                _globalHotKeyManager.UnregisterHotKey(pttHotKeyId);
+                _channelHotKeyIds.Remove(channelName);
+                _hotKeyIdToChannelName.Remove(pttHotKeyId);
+            }
+
+            // Unregister toggle hotkey
+            if (_channelToggleHotKeyIds.TryGetValue(channelName, out var toggleHotKeyId))
+            {
+                _globalHotKeyManager.UnregisterHotKey(toggleHotKeyId);
+                _channelToggleHotKeyIds.Remove(channelName);
+                _toggleHotKeyIdToChannelName.Remove(toggleHotKeyId);
+            }
+        }
+
+        /// <summary>
+        /// Unregisters all channel hotkeys
+        /// </summary>
+        public void UnregisterAllChannelHotkeys()
+        {
+            // Unregister all PTT hotkeys
+            var channelNames = new List<string>(_channelHotKeyIds.Keys);
+            foreach (var channelName in channelNames)
+            {
+                if (_channelHotKeyIds.TryGetValue(channelName, out var hotKeyId))
+                {
+                    _globalHotKeyManager.UnregisterHotKey(hotKeyId);
+                    _channelHotKeyIds.Remove(channelName);
+                    _hotKeyIdToChannelName.Remove(hotKeyId);
+                }
+            }
+
+            // Unregister all toggle hotkeys
+            var toggleChannelNames = new List<string>(_channelToggleHotKeyIds.Keys);
+            foreach (var channelName in toggleChannelNames)
+            {
+                if (_channelToggleHotKeyIds.TryGetValue(channelName, out var hotKeyId))
+                {
+                    _globalHotKeyManager.UnregisterHotKey(hotKeyId);
+                    _channelToggleHotKeyIds.Remove(channelName);
+                    _toggleHotKeyIdToChannelName.Remove(hotKeyId);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Called when a channel hotkey is pressed
+        /// </summary>
+        private void OnChannelHotKeyDown(string channelName)
+        {
+            var channel = _allChannels.FirstOrDefault(c => c.ChannelName == channelName);
+            if (channel != null)
+            {
+                _onChannelPttTriggered?.Invoke(channel, true);
+            }
+        }
+
+        /// <summary>
+        /// Called when a channel hotkey is released
+        /// </summary>
+        private void OnChannelHotKeyUp(string channelName)
+        {
+            var channel = _allChannels.FirstOrDefault(c => c.ChannelName == channelName);
+            if (channel != null)
+            {
+                _onChannelPttTriggered?.Invoke(channel, false);
+            }
+        }
+
+        /// <summary>
+        /// Called when a channel toggle hotkey is pressed
+        /// </summary>
+        private void OnChannelToggleHotKeyDown(string channelName)
+        {
+            var channel = _allChannels.FirstOrDefault(c => c.ChannelName == channelName);
+            if (channel != null)
+            {
+                _onChannelToggleTriggered?.Invoke(channel);
+            }
+        }
+    }
+}
diff --git a/WhackerLinkConsoleV2/ChannelKeybindingManager.cs b/WhackerLinkConsoleV2/ChannelKeybindingManager.cs
new file mode 100644
index 0000000..cf56396
--- /dev/null
+++ b/WhackerLinkConsoleV2/ChannelKeybindingManager.cs
@@ -0,0 +1,278 @@
+/*
+* WhackerLink - WhackerLinkConsoleV2
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* 
+* Copyright (C) 2024-2025 Caleb, K4PHP
+* Copyright (C) 2025 Firav (firavdev@gmail.com)
+* 
+*/
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+using Newtonsoft.Json;
+
+namespace WhackerLinkConsoleV2
+{
+    /// <summary>
+    /// Manages per-channel PTT keybindings, storing them persistently.
+    /// Bindings are organized by codeplug + channel name for dynamic channel support.
+    /// </summary>
+    public class ChannelKeybindingManager
+    {
+        private const string ChannelKeybindingsFilePath = "ChannelKeybindings.json";
+
+        private Dictionary<string, ChannelKeybindingProfile> _keybindingProfiles = 
+            new Dictionary<string, ChannelKeybindingProfile>();
+
+        /// <summary>
+        /// Represents keybindings for a specific codeplug
+        /// </summary>
+        public class ChannelKeybindingProfile
+        {
+            /// <summary>
+            /// Channel name -> PTT keybinding string mapping (e.g., "MainChannel" -> "Ctrl+T")
+            /// </summary>
+            public Dictionary<string, string> ChannelKeybindings { get; set; } = 
+                new Dictionary<string, string>();
+                
+            /// <summary>
+            /// Channel name -> toggle keybinding string mapping (e.g., "MainChannel" -> "Ctrl+G")
+            /// </summary>
+            public Dictionary<string, string> ChannelToggleKeybindings { get; set; } = 
+                new Dictionary<string, string>();
+        }
+
+        /// <summary>
+        /// Loads keybinding profiles from disk
+        /// </summary>
+        public void LoadKeybindings()
+        {
+            if (!File.Exists(ChannelKeybindingsFilePath))
+            {
+                Console.WriteLine("Channel keybindings file not found. Starting with empty configuration.");
+                return;
+            }
+
+            try
+            {
+                var json = File.ReadAllText(ChannelKeybindingsFilePath);
+                var loadedProfiles = JsonConvert.DeserializeObject<Dictionary<string, ChannelKeybindingProfile>>(json);
+
+                if (loadedProfiles != null)
+                {
+                    _keybindingProfiles = loadedProfiles;
+                    Console.WriteLine($"Loaded {_keybindingProfiles.Count} channel keybinding profiles.");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Failed to load channel keybindings: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Saves all keybinding profiles to disk
+        /// </summary>
+        public void SaveKeybindings()
+        {
+            try
+            {
+                var json = JsonConvert.SerializeObject(_keybindingProfiles, Formatting.Indented);
+                File.WriteAllText(ChannelKeybindingsFilePath, json);
+                Console.WriteLine("Channel keybindings saved.");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Failed to save channel keybindings: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Gets or creates a keybinding profile for a codeplug
+        /// </summary>
+        private ChannelKeybindingProfile GetOrCreateProfile(string codeplugIdentifier)
+        {
+            if (!_keybindingProfiles.ContainsKey(codeplugIdentifier))
+            {
+                _keybindingProfiles[codeplugIdentifier] = new ChannelKeybindingProfile();
+            }
+
+            return _keybindingProfiles[codeplugIdentifier];
+        }
+
+        /// <summary>
+        /// Sets a keybinding for a specific channel in a codeplug
+        /// </summary>
+        public void SetChannelKeybinding(string codeplugIdentifier, string channelName, string keybinding)
+        {
+            var profile = GetOrCreateProfile(codeplugIdentifier);
+            
+            if (string.IsNullOrWhiteSpace(keybinding))
+            {
+                profile.ChannelKeybindings.Remove(channelName);
+            }
+            else
+            {
+                profile.ChannelKeybindings[channelName] = keybinding;
+            }
+
+            SaveKeybindings();
+            Console.WriteLine($"Set keybinding for {channelName}: {keybinding}");
+        }
+
+        /// <summary>
+        /// Gets the keybinding for a specific channel, returns null if not set
+        /// </summary>
+        public string GetChannelKeybinding(string codeplugIdentifier, string channelName)
+        {
+            if (!_keybindingProfiles.TryGetValue(codeplugIdentifier, out var profile))
+                return null;
+
+            if (profile.ChannelKeybindings.TryGetValue(channelName, out var keybinding))
+                return keybinding;
+
+            return null;
+        }
+
+        /// <summary>
+        /// Sets a toggle keybinding for a specific channel in a codeplug
+        /// </summary>
+        public void SetChannelToggleKeybinding(string codeplugIdentifier, string channelName, string keybinding)
+        {
+            var profile = GetOrCreateProfile(codeplugIdentifier);
+            
+            if (string.IsNullOrWhiteSpace(keybinding))
+            {
+                profile.ChannelToggleKeybindings.Remove(channelName);
+            }
+            else
+            {
+                profile.ChannelToggleKeybindings[channelName] = keybinding;
+            }
+
+            SaveKeybindings();
+            Console.WriteLine($"Set toggle keybinding for {channelName}: {keybinding}");
+        }
+
+        /// <summary>
+        /// Gets the toggle keybinding for a specific channel, returns null if not set
+        /// </summary>
+        public string GetChannelToggleKeybinding(string codeplugIdentifier, string channelName)
+        {
+            if (!_keybindingProfiles.TryGetValue(codeplugIdentifier, out var profile))
+                return null;
+
+            if (profile.ChannelToggleKeybindings.TryGetValue(channelName, out var keybinding))
+                return keybinding;
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets all channels with keybindings for a codeplug
+        /// </summary>
+        public IEnumerable<string> GetChannelsWithKeybindings(string codeplugIdentifier)
+        {
+            if (_keybindingProfiles.TryGetValue(codeplugIdentifier, out var profile))
+                return profile.ChannelKeybindings.Keys;
+
+            return new List<string>();
+        }
+
+        /// <summary>
+        /// Gets all channels with toggle keybindings for a codeplug
+        /// </summary>
+        public IEnumerable<string> GetChannelsWithToggleKeybindings(string codeplugIdentifier)
+        {
+            if (_keybindingProfiles.TryGetValue(codeplugIdentifier, out var profile))
+                return profile.ChannelToggleKeybindings.Keys;
+
+            return new List<string>();
+        }
+
+        /// <summary>
+        /// Removes a keybinding for a specific channel
+        /// </summary>
+        public void RemoveChannelKeybinding(string codeplugIdentifier, string channelName)
+        {
+            var profile = GetOrCreateProfile(codeplugIdentifier);
+            if (profile.ChannelKeybindings.Remove(channelName))
+            {
+                SaveKeybindings();
+                Console.WriteLine($"Removed keybinding for {channelName}");
+            }
+        }
+
+        /// <summary>
+        /// Removes a toggle keybinding for a specific channel
+        /// </summary>
+        public void RemoveChannelToggleKeybinding(string codeplugIdentifier, string channelName)
+        {
+            var profile = GetOrCreateProfile(codeplugIdentifier);
+            if (profile.ChannelToggleKeybindings.Remove(channelName))
+            {
+                SaveKeybindings();
+                Console.WriteLine($"Removed toggle keybinding for {channelName}");
+            }
+        }
+
+        /// <summary>
+        /// Clears all keybindings for a codeplug profile
+        /// </summary>
+        public void ClearProfile(string codeplugIdentifier)
+        {
+            if (_keybindingProfiles.Remove(codeplugIdentifier))
+            {
+                SaveKeybindings();
+                Console.WriteLine($"Cleared all keybindings for profile: {codeplugIdentifier}");
+            }
+        }
+
+        /// <summary>
+        /// Gets all keybinding profiles
+        /// </summary>
+        public Dictionary<string, ChannelKeybindingProfile> GetAllProfiles()
+        {
+            return new Dictionary<string, ChannelKeybindingProfile>(_keybindingProfiles);
+        }
+
+        /// <summary>
+        /// Generates a unique identifier for a codeplug (using deterministic file path hash)
+        /// </summary>
+        public static string GenerateCodeplugIdentifier(string codeplugFilePath)
+        {
+            if (string.IsNullOrWhiteSpace(codeplugFilePath))
+                return "default";
+
+            // Use a combination of filename and deterministic path hash
+            var fileName = Path.GetFileNameWithoutExtension(codeplugFilePath);
+            
+            // Use SHA256 for deterministic hashing (same path always produces same hash)
+            using (var sha256 = SHA256.Create())
+            {
+                var pathBytes = Encoding.UTF8.GetBytes(codeplugFilePath.ToLowerInvariant());
+                var hashBytes = sha256.ComputeHash(pathBytes);
+                
+                // Take first 4 bytes and convert to hex (8 characters)
+                var pathHash = BitConverter.ToString(hashBytes, 0, 4).Replace("-", "");
+                
+                return $"{fileName}_{pathHash}";
+            }
+        }
+    }
+}
diff --git a/WhackerLinkConsoleV2/GlobalHotKeyManager.cs b/WhackerLinkConsoleV2/GlobalHotKeyManager.cs
new file mode 100644
index 0000000..b72f587
--- /dev/null
+++ b/WhackerLinkConsoleV2/GlobalHotKeyManager.cs
@@ -0,0 +1,399 @@
+/*
+* WhackerLink - WhackerLinkConsoleV2
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* 
+* Copyright (C) 2024-2025 Caleb, K4PHP
+* Copyright (C) 2025 Firav (firavdev@gmail.com)
+* 
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Windows.Interop;
+using System.Windows;
+using System.Windows.Input;
+using System.Diagnostics;
+
+namespace WhackerLinkConsoleV2
+{
+    /// <summary>
+    /// Represents arguments for hotkey events
+    /// </summary>
+    public class HotKeyEventArgs : EventArgs
+    {
+        public int HotKeyId { get; set; }
+        public Key Key { get; set; }
+        public ModifierKeys Modifiers { get; set; }
+    }
+
+    /// <summary>
+    /// Manages global system hotkeys using low-level keyboard hooks
+    /// </summary>
+    public class GlobalHotKeyManager : IDisposable
+    {
+        // Windows API P/Invoke declarations for keyboard hooks
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool UnhookWindowsHookEx(IntPtr hhk);
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        private static extern IntPtr GetModuleHandle(string lpModuleName);
+
+        [DllImport("user32.dll")]
+        private static extern short GetAsyncKeyState(int vKey);
+
+        [DllImport("user32.dll")]
+        private static extern IntPtr GetForegroundWindow();
+
+        // Hook constants
+        private const int WH_KEYBOARD_LL = 13;
+        private const int WM_KEYDOWN = 0x0100;
+        private const int WM_KEYUP = 0x0101;
+        private const int WM_SYSKEYDOWN = 0x0104;
+        private const int WM_SYSKEYUP = 0x0105;
+
+        // Virtual key codes for modifier keys
+        private const int VK_CONTROL = 0x11;
+        private const int VK_SHIFT = 0x10;
+        private const int VK_MENU = 0x12; // Alt key
+
+        // Delegate for low-level keyboard hook
+        private delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct KBDLLHOOKSTRUCT
+        {
+            public uint vkCode;
+            public uint scanCode;
+            public uint flags;
+            public uint time;
+            public IntPtr dwExtraInfo;
+        }
+
+        private Window _window;
+        private IntPtr _windowHandle;
+        private IntPtr _hookId = IntPtr.Zero;
+        private LowLevelKeyboardProc _hookCallback;
+        private Dictionary<int, HotKeyInfo> _registeredHotKeys = new Dictionary<int, HotKeyInfo>();
+        private Dictionary<int, bool> _hotKeyStates = new Dictionary<int, bool>(); // Track if hotkey is currently pressed
+        private Dictionary<int, int> _vkCodeToHotKeyId = new Dictionary<int, int>(); // Map VK code to the currently active hotkey ID for that key
+        private int _nextHotKeyId = 1;
+        private HashSet<int> _currentlyPressedVKs = new HashSet<int>(); // Track currently pressed virtual keys
+        
+        /// <summary>
+        /// Gets or sets whether hotkeys should work when the application is not focused
+        /// </summary>
+        public bool WorkWhenUnfocused { get; set; } = true;
+
+        public event EventHandler<HotKeyEventArgs> HotKeyPressed;
+        public event EventHandler<HotKeyEventArgs> HotKeyReleased;
+
+        /// <summary>
+        /// Internal class to track hotkey information
+        /// </summary>
+        private class HotKeyInfo
+        {
+            public int Id { get; set; }
+            public Key Key { get; set; }
+            public ModifierKeys Modifiers { get; set; }
+            public Action OnKeyDown { get; set; }
+            public Action OnKeyUp { get; set; }
+        }
+
+        /// <summary>
+        /// Initializes the global hotkey manager for the specified window
+        /// </summary>
+        public void Initialize(Window window)
+        {
+            _window = window;
+            _windowHandle = new WindowInteropHelper(window).Handle;
+            
+            if (_windowHandle == IntPtr.Zero)
+            {
+                throw new InvalidOperationException("Window handle is invalid. Ensure the window is fully initialized.");
+            }
+
+            // Set up the low-level keyboard hook
+            _hookCallback = HookCallback;
+            using (Process curProcess = Process.GetCurrentProcess())
+            using (ProcessModule curModule = curProcess.MainModule)
+            {
+                _hookId = SetWindowsHookEx(WH_KEYBOARD_LL, _hookCallback, GetModuleHandle(curModule.ModuleName), 0);
+            }
+
+            if (_hookId == IntPtr.Zero)
+            {
+                throw new InvalidOperationException("Failed to install keyboard hook.");
+            }
+
+            Console.WriteLine("Low-level keyboard hook installed successfully.");
+        }
+
+        /// <summary>
+        /// Registers a global hotkey
+        /// </summary>
+        /// <returns>Returns the hotkey ID if successful, -1 if failed</returns>
+        public int RegisterHotKey(ModifierKeys modifier, Key key, Action onKeyDown = null, Action onKeyUp = null)
+        {
+            if (_hookId == IntPtr.Zero)
+            {
+                Console.WriteLine($"ERROR: GlobalHotKeyManager not initialized. Call Initialize() first.");
+                return -1;
+            }
+
+            int hotKeyId = _nextHotKeyId++;
+            uint vkCode = (uint)KeyInterop.VirtualKeyFromKey(key);
+
+            if (vkCode == 0)
+            {
+                Console.WriteLine($"ERROR: Could not convert key {key} to virtual key code.");
+                return -1;
+            }
+
+            var hotKeyInfo = new HotKeyInfo
+            {
+                Id = hotKeyId,
+                Key = key,
+                Modifiers = modifier,
+                OnKeyDown = onKeyDown,
+                OnKeyUp = onKeyUp
+            };
+
+            _registeredHotKeys[hotKeyId] = hotKeyInfo;
+            
+            string modifierStr = modifier == ModifierKeys.None ? "(no modifiers)" : modifier.ToString();
+            Console.WriteLine($"Registered hotkey: {modifierStr}+{key} (ID: {hotKeyId})");
+            
+            return hotKeyId;
+        }
+
+        /// <summary>
+        /// Unregisters a global hotkey by ID
+        /// </summary>
+        public bool UnregisterHotKey(int hotKeyId)
+        {
+            if (!_registeredHotKeys.ContainsKey(hotKeyId))
+            {
+                Console.WriteLine($"WARNING: Hotkey ID {hotKeyId} not found in registered hotkeys.");
+                return false;
+            }
+
+            _registeredHotKeys.Remove(hotKeyId);
+            _hotKeyStates.Remove(hotKeyId);
+            Console.WriteLine($"Unregistered hotkey ID {hotKeyId}");
+            return true;
+        }
+
+        /// <summary>
+        /// Unregisters all registered hotkeys
+        /// </summary>
+        public void UnregisterAllHotKeys()
+        {
+            var hotKeyIds = new List<int>(_registeredHotKeys.Keys);
+            foreach (var id in hotKeyIds)
+            {
+                UnregisterHotKey(id);
+            }
+        }
+
+        /// <summary>
+        /// Gets information about a registered hotkey
+        /// </summary>
+        public bool GetHotKeyInfo(int hotKeyId, out ModifierKeys modifier, out Key key)
+        {
+            modifier = ModifierKeys.None;
+            key = Key.None;
+
+            if (_registeredHotKeys.TryGetValue(hotKeyId, out var hotKeyInfo))
+            {
+                modifier = hotKeyInfo.Modifiers;
+                key = hotKeyInfo.Key;
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Gets the list of all registered hotkey IDs
+        /// </summary>
+        public IEnumerable<int> GetRegisteredHotKeyIds()
+        {
+            return new List<int>(_registeredHotKeys.Keys);
+        }
+
+        /// <summary>
+        /// Low-level keyboard hook callback
+        /// </summary>
+        private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
+        {
+            if (nCode >= 0)
+            {
+                bool isKeyDown = (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN);
+                bool isKeyUp = (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP);
+
+                if (isKeyDown || isKeyUp)
+                {
+                    KBDLLHOOKSTRUCT hookStruct = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
+                    int vkCode = (int)hookStruct.vkCode;
+
+                    // Track currently pressed keys
+                    if (isKeyDown)
+                    {
+                        _currentlyPressedVKs.Add(vkCode);
+                    }
+                    else if (isKeyUp)
+                    {
+                        _currentlyPressedVKs.Remove(vkCode);
+                    }
+
+                    // Check if we should process hotkeys (based on focus setting)
+                    if (!WorkWhenUnfocused)
+                    {
+                        IntPtr foregroundWindow = GetForegroundWindow();
+                        if (foregroundWindow != _windowHandle)
+                        {
+                            // App is not focused and WorkWhenUnfocused is false, so ignore
+                            return CallNextHookEx(_hookId, nCode, wParam, lParam);
+                        }
+                    }
+
+                    if (isKeyDown)
+                    {
+                        // Get current modifier state
+                        ModifierKeys currentModifiers = GetCurrentModifiers();
+
+                        // Check all registered hotkeys for a match
+                        foreach (var kvp in _registeredHotKeys)
+                        {
+                            var hotKeyInfo = kvp.Value;
+                            int hotKeyId = kvp.Key;
+
+                            // Check if this hotkey matches the current key + modifiers
+                            int hotKeyVK = KeyInterop.VirtualKeyFromKey(hotKeyInfo.Key);
+                            
+                            if (hotKeyVK == vkCode && currentModifiers == hotKeyInfo.Modifiers)
+                            {
+                                // Check if already pressed to prevent repeats
+                                bool wasAlreadyPressed = _hotKeyStates.TryGetValue(hotKeyId, out bool isPressed) && isPressed;
+                                
+                                if (!wasAlreadyPressed)
+                                {
+                                    _hotKeyStates[hotKeyId] = true;
+                                    _vkCodeToHotKeyId[vkCode] = hotKeyId; // Track which hotkey this VK is associated with
+
+                                    // Dispatch to UI thread
+                                    _window?.Dispatcher.BeginInvoke(new Action(() =>
+                                    {
+                                        var args = new HotKeyEventArgs
+                                        {
+                                            HotKeyId = hotKeyId,
+                                            Key = hotKeyInfo.Key,
+                                            Modifiers = hotKeyInfo.Modifiers
+                                        };
+
+                                        HotKeyPressed?.Invoke(this, args);
+                                        hotKeyInfo.OnKeyDown?.Invoke();
+                                    }));
+                                }
+                                break; // Found a match, no need to check other hotkeys
+                            }
+                        }
+                    }
+                    else if (isKeyUp)
+                    {
+                        // Check if this VK code was associated with a hotkey press
+                        if (_vkCodeToHotKeyId.TryGetValue(vkCode, out int hotKeyId))
+                        {
+                            // Mark as released
+                            if (_hotKeyStates.ContainsKey(hotKeyId) && _hotKeyStates[hotKeyId])
+                            {
+                                _hotKeyStates[hotKeyId] = false;
+                                _vkCodeToHotKeyId.Remove(vkCode);
+
+                                if (_registeredHotKeys.TryGetValue(hotKeyId, out var hotKeyInfo))
+                                {
+                                    // Dispatch to UI thread
+                                    _window?.Dispatcher.BeginInvoke(new Action(() =>
+                                    {
+                                        var args = new HotKeyEventArgs
+                                        {
+                                            HotKeyId = hotKeyId,
+                                            Key = hotKeyInfo.Key,
+                                            Modifiers = hotKeyInfo.Modifiers
+                                        };
+
+                                        HotKeyReleased?.Invoke(this, args);
+                                        hotKeyInfo.OnKeyUp?.Invoke();
+                                    }));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Always call the next hook - this ensures keys work in other applications
+            return CallNextHookEx(_hookId, nCode, wParam, lParam);
+        }
+
+        /// <summary>
+        /// Gets the current modifier keys state
+        /// </summary>
+        private ModifierKeys GetCurrentModifiers()
+        {
+            ModifierKeys modifiers = ModifierKeys.None;
+
+            if ((GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0)
+                modifiers |= ModifierKeys.Control;
+            if ((GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0)
+                modifiers |= ModifierKeys.Shift;
+            if ((GetAsyncKeyState(VK_MENU) & 0x8000) != 0)
+                modifiers |= ModifierKeys.Alt;
+            if ((GetAsyncKeyState((int)Key.LWin) & 0x8000) != 0 || (GetAsyncKeyState((int)Key.RWin) & 0x8000) != 0)
+                modifiers |= ModifierKeys.Windows;
+
+            return modifiers;
+        }
+
+        /// <summary>
+        /// Cleanup resources
+        /// </summary>
+        public void Dispose()
+        {
+            // Unhook the keyboard hook
+            if (_hookId != IntPtr.Zero)
+            {
+                UnhookWindowsHookEx(_hookId);
+                _hookId = IntPtr.Zero;
+                Console.WriteLine("Keyboard hook uninstalled.");
+            }
+
+            UnregisterAllHotKeys();
+
+            _window = null;
+            _windowHandle = IntPtr.Zero;
+            _currentlyPressedVKs.Clear();
+            _vkCodeToHotKeyId.Clear();
+        }
+    }
+}
\ No newline at end of file
diff --git a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml
new file mode 100644
index 0000000..84d3ef2
--- /dev/null
+++ b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml
@@ -0,0 +1,120 @@
+<Window x:Class="WhackerLinkConsoleV2.KeybindingConfigWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="Keybinding Configuration" Height="650" Width="800"
+        WindowStartupLocation="CenterScreen">
+    <Grid Margin="10">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <!-- Global PTT Section -->
+        <TextBlock Text="Global PTT Keybind" FontWeight="Bold" Margin="0,0,0,5" Grid.Row="0"/>
+        <Grid Grid.Row="1" Margin="0,5,0,15">
+            <Grid.RowDefinitions>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="Auto"/>
+            </Grid.RowDefinitions>
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="Auto"/>
+            </Grid.ColumnDefinitions>
+            
+            <TextBox x:Name="GlobalPttKeybindDisplay" 
+                     Text="Ctrl+T" 
+                     IsReadOnly="True" 
+                     VerticalContentAlignment="Center"
+                     Padding="5"
+                     Grid.Column="0"
+                     Grid.Row="0"
+                     Margin="0,0,10,0"/>
+            
+            <Button x:Name="RecordGlobalPttButton" 
+                    Click="RecordGlobalPtt_Click" 
+                    Content="Record" 
+                    Width="80" 
+                    Margin="0,0,10,0"
+                    Grid.Column="1"
+                    Grid.Row="0"/>
+            
+            <Button x:Name="ClearGlobalPttButton" 
+                    Click="ClearGlobalPtt_Click" 
+                    Content="Clear" 
+                    Width="80"
+                    Grid.Column="2"
+                    Grid.Row="0"/>
+            
+            <!-- Hotkeys work when unfocused checkbox -->
+            <CheckBox x:Name="HotkeysWorkWhenUnfocusedCheckbox"
+                      Content="Allow hotkeys to work when application is not focused (tabbed out)"
+                      Grid.Column="0"
+                      Grid.ColumnSpan="3"
+                      Grid.Row="1"
+                      Margin="0,10,0,0"
+                      VerticalAlignment="Center"
+                      IsChecked="True"/>
+        </Grid>
+
+        <!-- Tabbed Section for Per-Channel Keybindings -->
+        <TabControl Grid.Row="2" Margin="0,5,0,0">
+            <!-- PTT Keybindings Tab -->
+            <TabItem Header="PTT Keybindings">
+                <Grid Margin="10">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="*"/>
+                    </Grid.RowDefinitions>
+                    
+                    <TextBlock x:Name="CodeplugIdentifierText" 
+                               Text="No codeplug loaded" 
+                               FontSize="10" 
+                               Foreground="Gray" 
+                               Margin="0,0,0,10"
+                               Grid.Row="0"/>
+                    
+                    <ScrollViewer Grid.Row="1">
+                        <StackPanel x:Name="ChannelKeybindingsPanel"/>
+                    </ScrollViewer>
+                </Grid>
+            </TabItem>
+            
+            <!-- Channel Toggle Keybindings Tab -->
+            <TabItem Header="Channel Toggle">
+                <Grid Margin="10">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="*"/>
+                    </Grid.RowDefinitions>
+                    
+                    <TextBlock x:Name="CodeplugIdentifierTextToggle" 
+                               Text="No codeplug loaded" 
+                               FontSize="10" 
+                               Foreground="Gray" 
+                               Margin="0,0,0,10"
+                               Grid.Row="0"/>
+                    
+                    <ScrollViewer Grid.Row="1">
+                        <StackPanel x:Name="ChannelToggleKeybindingsPanel"/>
+                    </ScrollViewer>
+                </Grid>
+            </TabItem>
+        </TabControl>
+
+        <!-- Footer Buttons -->
+        <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Grid.Row="3" Margin="0,20,0,0">
+            <Button x:Name="ApplyButton" 
+                    Click="Apply_Click" 
+                    Content="Apply" 
+                    Width="100" 
+                    Margin="0,0,10,0"/>
+            <Button x:Name="CloseButton" 
+                    Click="Close_Click" 
+                    Content="Close" 
+                    Width="100"/>
+        </StackPanel>
+    </Grid>
+</Window>
diff --git a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
new file mode 100644
index 0000000..24630c2
--- /dev/null
+++ b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
@@ -0,0 +1,615 @@
+/*
+* WhackerLink - WhackerLinkConsoleV2
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* 
+* Copyright (C) 2024-2025 Caleb, K4PHP
+* Copyright (C) 2025 Firav (firavdev@gmail.com)
+* 
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using WhackerLinkLib.Models.Radio;
+
+namespace WhackerLinkConsoleV2
+{
+    public partial class KeybindingConfigWindow : Window
+    {
+        private SettingsManager _settingsManager;
+        private ChannelKeybindingManager _channelKeybindingManager;
+        private Codeplug _codeplug;
+        private string _codeplugIdentifier;
+        private MainWindow _mainWindow;
+
+        private bool _recordingGlobalPtt = false;
+        private Dictionary<string, TextBox> _channelKeybindingControls = new Dictionary<string, TextBox>();
+        private Dictionary<string, TextBox> _channelToggleKeybindingControls = new Dictionary<string, TextBox>();
+        
+        // Key recording state tracking
+        private bool _isRecording = false;
+        private ModifierKeys _recordedModifiers = ModifierKeys.None;
+        private Key _recordedKey = Key.None;
+        private string _pendingKeybinding = "";
+        private readonly HashSet<Key> _pressedKeys = new HashSet<Key>();
+
+        /// <summary>
+        /// Gets whether keybindings were successfully applied and should take immediate effect
+        /// </summary>
+        public bool KeybindingsApplied { get; private set; } = false;
+
+        public KeybindingConfigWindow(SettingsManager settingsManager, ChannelKeybindingManager channelKeybindingManager, Codeplug codeplug, string codeplugFilePath, MainWindow mainWindow = null)
+        {
+            InitializeComponent();
+            _settingsManager = settingsManager;
+            _channelKeybindingManager = channelKeybindingManager;
+            _codeplug = codeplug;
+            _codeplugIdentifier = ChannelKeybindingManager.GenerateCodeplugIdentifier(codeplugFilePath);
+            _mainWindow = mainWindow;
+
+            LoadSettings();
+            GenerateChannelControls();
+            
+            // Suspend all hotkeys while this window is open to prevent background activation
+            SuspendMainWindowHotkeys();
+        }
+
+        private void LoadSettings()
+        {
+            // Load global keybinding
+            GlobalPttKeybindDisplay.Text = _settingsManager.GlobalPttKeybind;
+            
+            // Load hotkeys work when unfocused setting
+            HotkeysWorkWhenUnfocusedCheckbox.IsChecked = _settingsManager.HotkeysWorkWhenUnfocused;
+
+            // Load codeplug identifier for both tabs
+            CodeplugIdentifierText.Text = _codeplugIdentifier;
+            CodeplugIdentifierTextToggle.Text = _codeplugIdentifier;
+        }
+
+        private void GenerateChannelControls()
+        {
+            GeneratePttChannelControls();
+            GenerateToggleChannelControls();
+        }
+
+        private void GeneratePttChannelControls()
+        {
+            ChannelKeybindingsPanel.Children.Clear();
+            _channelKeybindingControls.Clear();
+
+            if (_codeplug == null || _codeplug.Zones == null || _codeplug.Zones.Count == 0)
+            {
+                var noChannelsText = new TextBlock
+                {
+                    Text = "No channels available",
+                    Foreground = System.Windows.Media.Brushes.Gray,
+                    FontSize = 11,
+                    Margin = new Thickness(0, 10, 0, 0)
+                };
+                ChannelKeybindingsPanel.Children.Add(noChannelsText);
+                return;
+            }
+
+            var allChannels = _codeplug.Zones.SelectMany(z => z.Channels).Distinct().OrderBy(c => c.Name).ToList();
+
+            if (allChannels.Count == 0)
+            {
+                var noChannelsText = new TextBlock
+                {
+                    Text = "No channels in codeplug",
+                    Foreground = System.Windows.Media.Brushes.Gray,
+                    FontSize = 11,
+                    Margin = new Thickness(0, 10, 0, 0)
+                };
+                ChannelKeybindingsPanel.Children.Add(noChannelsText);
+                return;
+            }
+
+            foreach (var channel in allChannels)
+            {
+                var existingKeybind = _channelKeybindingManager.GetChannelKeybinding(_codeplugIdentifier, channel.Name) ?? "";
+
+                var grid = new Grid
+                {
+                    Margin = new Thickness(0, 0, 0, 10)
+                };
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(150) });
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+
+                // Channel name
+                var channelNameText = new TextBlock
+                {
+                    Text = channel.Name,
+                    VerticalAlignment = VerticalAlignment.Center,
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                Grid.SetColumn(channelNameText, 0);
+                grid.Children.Add(channelNameText);
+
+                // Keybinding textbox
+                var keybindTextBox = new TextBox
+                {
+                    Text = existingKeybind,
+                    IsReadOnly = true,
+                    VerticalContentAlignment = VerticalAlignment.Center,
+                    Padding = new Thickness(5),
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                Grid.SetColumn(keybindTextBox, 1);
+                grid.Children.Add(keybindTextBox);
+
+                _channelKeybindingControls[channel.Name] = keybindTextBox;
+
+                // Record button
+                var recordButton = new Button
+                {
+                    Content = "Record",
+                    Width = 80,
+                    Tag = channel.Name,
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                recordButton.Click += (s, e) => RecordChannelKeybind_Click(channel.Name);
+                Grid.SetColumn(recordButton, 2);
+                grid.Children.Add(recordButton);
+
+                // Clear button
+                var clearButton = new Button
+                {
+                    Content = "Clear",
+                    Width = 80,
+                    Tag = channel.Name
+                };
+                clearButton.Click += (s, e) => ClearChannelKeybind_Click(channel.Name);
+                Grid.SetColumn(clearButton, 3);
+                grid.Children.Add(clearButton);
+
+                ChannelKeybindingsPanel.Children.Add(grid);
+            }
+        }
+
+        private void GenerateToggleChannelControls()
+        {
+            ChannelToggleKeybindingsPanel.Children.Clear();
+            _channelToggleKeybindingControls.Clear();
+
+            if (_codeplug == null || _codeplug.Zones == null || _codeplug.Zones.Count == 0)
+            {
+                var noChannelsText = new TextBlock
+                {
+                    Text = "No channels available",
+                    Foreground = System.Windows.Media.Brushes.Gray,
+                    FontSize = 11,
+                    Margin = new Thickness(0, 10, 0, 0)
+                };
+                ChannelToggleKeybindingsPanel.Children.Add(noChannelsText);
+                return;
+            }
+
+            var allChannels = _codeplug.Zones.SelectMany(z => z.Channels).Distinct().OrderBy(c => c.Name).ToList();
+
+            if (allChannels.Count == 0)
+            {
+                var noChannelsText = new TextBlock
+                {
+                    Text = "No channels in codeplug",
+                    Foreground = System.Windows.Media.Brushes.Gray,
+                    FontSize = 11,
+                    Margin = new Thickness(0, 10, 0, 0)
+                };
+                ChannelToggleKeybindingsPanel.Children.Add(noChannelsText);
+                return;
+            }
+
+            foreach (var channel in allChannels)
+            {
+                var existingKeybind = _channelKeybindingManager.GetChannelToggleKeybinding(_codeplugIdentifier, channel.Name) ?? "";
+
+                var grid = new Grid
+                {
+                    Margin = new Thickness(0, 0, 0, 10)
+                };
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(150) });
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+
+                // Channel name
+                var channelNameText = new TextBlock
+                {
+                    Text = channel.Name,
+                    VerticalAlignment = VerticalAlignment.Center,
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                Grid.SetColumn(channelNameText, 0);
+                grid.Children.Add(channelNameText);
+
+                // Keybinding textbox
+                var keybindTextBox = new TextBox
+                {
+                    Text = existingKeybind,
+                    IsReadOnly = true,
+                    VerticalContentAlignment = VerticalAlignment.Center,
+                    Padding = new Thickness(5),
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                Grid.SetColumn(keybindTextBox, 1);
+                grid.Children.Add(keybindTextBox);
+
+                _channelToggleKeybindingControls[channel.Name] = keybindTextBox;
+
+                // Record button
+                var recordButton = new Button
+                {
+                    Content = "Record",
+                    Width = 80,
+                    Tag = channel.Name,
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                recordButton.Click += (s, e) => RecordChannelToggleKeybind_Click(channel.Name);
+                Grid.SetColumn(recordButton, 2);
+                grid.Children.Add(recordButton);
+
+                // Clear button
+                var clearButton = new Button
+                {
+                    Content = "Clear",
+                    Width = 80,
+                    Tag = channel.Name
+                };
+                clearButton.Click += (s, e) => ClearChannelToggleKeybind_Click(channel.Name);
+                Grid.SetColumn(clearButton, 3);
+                grid.Children.Add(clearButton);
+
+                ChannelToggleKeybindingsPanel.Children.Add(grid);
+            }
+        }
+
+        private void RecordGlobalPtt_Click(object sender, RoutedEventArgs e)
+        {
+            StartRecording();
+            _recordingGlobalPtt = true;
+            RecordGlobalPttButton.Content = "Press keys...";
+            RecordGlobalPttButton.IsEnabled = false;
+            Focus();
+        }
+
+        private void RecordChannelKeybind_Click(string channelName)
+        {
+            if (!_channelKeybindingControls.TryGetValue(channelName, out var textBox))
+                return;
+
+            StartRecording();
+            var recordingTag = $"recording_ptt_{channelName}";
+            Tag = recordingTag;
+            textBox.Text = "Press keys...";
+            Focus();
+        }
+
+        private void RecordChannelToggleKeybind_Click(string channelName)
+        {
+            if (!_channelToggleKeybindingControls.TryGetValue(channelName, out var textBox))
+                return;
+
+            StartRecording();
+            var recordingTag = $"recording_toggle_{channelName}";
+            Tag = recordingTag;
+            textBox.Text = "Press keys...";
+            Focus();
+        }
+
+        private void ClearChannelKeybind_Click(string channelName)
+        {
+            if (!_channelKeybindingControls.TryGetValue(channelName, out var textBox))
+                return;
+
+            textBox.Text = "";
+            _channelKeybindingManager.SetChannelKeybinding(_codeplugIdentifier, channelName, "");
+        }
+
+        private void ClearChannelToggleKeybind_Click(string channelName)
+        {
+            if (!_channelToggleKeybindingControls.TryGetValue(channelName, out var textBox))
+                return;
+
+            textBox.Text = "";
+            _channelKeybindingManager.SetChannelToggleKeybinding(_codeplugIdentifier, channelName, "");
+        }
+
+        private void ClearGlobalPtt_Click(object sender, RoutedEventArgs e)
+        {
+            GlobalPttKeybindDisplay.Text = "";
+            // Reset global PTT recording state if active
+            if (_recordingGlobalPtt)
+            {
+                StopRecording();
+                _recordingGlobalPtt = false;
+                RecordGlobalPttButton.Content = "Record";
+                RecordGlobalPttButton.IsEnabled = true;
+            }
+        }
+
+        private void StartRecording()
+        {
+            _isRecording = true;
+            _recordedModifiers = ModifierKeys.None;
+            _recordedKey = Key.None;
+            _pendingKeybinding = "";
+            _pressedKeys.Clear();
+        }
+        
+        private void StopRecording()
+        {
+            _isRecording = false;
+            _recordedModifiers = ModifierKeys.None;
+            _recordedKey = Key.None;
+            _pendingKeybinding = "";
+            _pressedKeys.Clear();
+        }
+
+        protected override void OnPreviewKeyDown(KeyEventArgs e)
+        {
+            if (!_isRecording)
+            {
+                base.OnPreviewKeyDown(e);
+                return;
+            }
+
+            var key = e.Key;
+            var modifiers = Keyboard.Modifiers;
+            
+            // Track all pressed keys
+            _pressedKeys.Add(key);
+            
+            // If this is a modifier key, just track it
+            if (key == Key.LeftCtrl || key == Key.RightCtrl ||
+                key == Key.LeftShift || key == Key.RightShift ||
+                key == Key.LeftAlt || key == Key.RightAlt ||
+                key == Key.LWin || key == Key.RWin ||
+                key == Key.System)
+            {
+                e.Handled = true;
+                UpdateRecordingDisplay(modifiers, Key.None);
+                return;
+            }
+            
+            // This is a non-modifier key - capture the combination
+            _recordedModifiers = modifiers;
+            _recordedKey = key;
+            _pendingKeybinding = KeybindingParser.KeybindingToString(modifiers, key);
+            
+            UpdateRecordingDisplay(modifiers, key);
+            e.Handled = true;
+        }
+        
+        protected override void OnPreviewKeyUp(KeyEventArgs e)
+        {
+            if (!_isRecording)
+            {
+                base.OnPreviewKeyUp(e);
+                return;
+            }
+            
+            var key = e.Key;
+            _pressedKeys.Remove(key);
+            
+            // If all keys have been released and we have a pending keybinding, finalize it
+            if (_pressedKeys.Count == 0 && !string.IsNullOrEmpty(_pendingKeybinding))
+            {
+                FinalizeRecording();
+            }
+            
+            e.Handled = true;
+        }
+        
+        private void UpdateRecordingDisplay(ModifierKeys modifiers, Key key)
+        {
+            string displayText;
+            if (key == Key.None)
+            {
+                // Show just the modifiers being held
+                displayText = KeybindingParser.ModifiersToString(modifiers);
+                if (string.IsNullOrEmpty(displayText))
+                {
+                    displayText = "Press keys...";
+                }
+                else
+                {
+                    displayText += "+...";
+                }
+            }
+            else
+            {
+                displayText = KeybindingParser.KeybindingToString(modifiers, key);
+            }
+            
+            // Update the appropriate display
+            if (_recordingGlobalPtt)
+            {
+                GlobalPttKeybindDisplay.Text = displayText;
+            }
+            else if (Tag is string tag && tag.StartsWith("recording_"))
+            {
+                if (tag.StartsWith("recording_ptt_"))
+                {
+                    var channelName = tag.Substring("recording_ptt_".Length);
+                    if (_channelKeybindingControls.TryGetValue(channelName, out var textBox))
+                    {
+                        textBox.Text = displayText;
+                    }
+                }
+                else if (tag.StartsWith("recording_toggle_"))
+                {
+                    var channelName = tag.Substring("recording_toggle_".Length);
+                    if (_channelToggleKeybindingControls.TryGetValue(channelName, out var textBox))
+                    {
+                        textBox.Text = displayText;
+                    }
+                }
+            }
+        }
+        
+        private void FinalizeRecording()
+        {
+            // Complete the recording with the captured keybinding
+            if (_recordingGlobalPtt)
+            {
+                GlobalPttKeybindDisplay.Text = _pendingKeybinding;
+                _recordingGlobalPtt = false;
+                RecordGlobalPttButton.Content = "Record";
+                RecordGlobalPttButton.IsEnabled = true;
+            }
+            else if (Tag is string tag && tag.StartsWith("recording_"))
+            {
+                if (tag.StartsWith("recording_ptt_"))
+                {
+                    var channelName = tag.Substring("recording_ptt_".Length);
+                    if (_channelKeybindingControls.TryGetValue(channelName, out var textBox))
+                    {
+                        textBox.Text = _pendingKeybinding;
+                    }
+                }
+                else if (tag.StartsWith("recording_toggle_"))
+                {
+                    var channelName = tag.Substring("recording_toggle_".Length);
+                    if (_channelToggleKeybindingControls.TryGetValue(channelName, out var textBox))
+                    {
+                        textBox.Text = _pendingKeybinding;
+                    }
+                }
+                Tag = null;
+            }
+            
+            StopRecording();
+        }
+
+        private void Apply_Click(object sender, RoutedEventArgs e)
+        {
+            // Validate and save global keybinding
+            if (string.IsNullOrWhiteSpace(GlobalPttKeybindDisplay.Text))
+            {
+                // Clear the global PTT keybinding
+                _settingsManager.GlobalPttKeybind = "";
+            }
+            else
+            {
+                if (!KeybindingParser.TryParseKeybinding(GlobalPttKeybindDisplay.Text, out _, out _))
+                {
+                    MessageBox.Show("Invalid Global PTT keybinding format.", "Validation Error", MessageBoxButton.OK, MessageBoxImage.Warning);
+                    return;
+                }
+                
+                _settingsManager.GlobalPttKeybind = GlobalPttKeybindDisplay.Text;
+            }
+            
+            // Save the hotkeys work when unfocused setting
+            _settingsManager.HotkeysWorkWhenUnfocused = HotkeysWorkWhenUnfocusedCheckbox.IsChecked ?? true;
+
+            _settingsManager.SaveSettings();
+
+            // Validate and save per-channel keybindings
+            foreach (var kvp in _channelKeybindingControls)
+            {
+                var channelName = kvp.Key;
+                var textBox = kvp.Value;
+                var keybinding = textBox.Text;
+
+                if (string.IsNullOrWhiteSpace(keybinding))
+                {
+                    _channelKeybindingManager.RemoveChannelKeybinding(_codeplugIdentifier, channelName);
+                }
+                else
+                {
+                    if (!KeybindingParser.TryParseKeybinding(keybinding, out _, out _))
+                    {
+                        MessageBox.Show($"Invalid PTT keybinding for channel '{channelName}': {keybinding}", "Validation Error", MessageBoxButton.OK, MessageBoxImage.Warning);
+                        return;
+                    }
+                    
+                    _channelKeybindingManager.SetChannelKeybinding(_codeplugIdentifier, channelName, keybinding);
+                }
+            }
+
+            // Validate and save per-channel toggle keybindings
+            foreach (var kvp in _channelToggleKeybindingControls)
+            {
+                var channelName = kvp.Key;
+                var textBox = kvp.Value;
+                var keybinding = textBox.Text;
+
+                if (string.IsNullOrWhiteSpace(keybinding))
+                {
+                    _channelKeybindingManager.RemoveChannelToggleKeybinding(_codeplugIdentifier, channelName);
+                }
+                else
+                {
+                    if (!KeybindingParser.TryParseKeybinding(keybinding, out _, out _))
+                    {
+                        MessageBox.Show($"Invalid toggle keybinding for channel '{channelName}': {keybinding}", "Validation Error", MessageBoxButton.OK, MessageBoxImage.Warning);
+                        return;
+                    }
+                    
+                    _channelKeybindingManager.SetChannelToggleKeybinding(_codeplugIdentifier, channelName, keybinding);
+                }
+            }
+
+            KeybindingsApplied = true;
+
+            MessageBox.Show("Keybindings saved and applied successfully!", "Success", MessageBoxButton.OK, MessageBoxImage.Information);
+            Close();
+        }
+
+        private void Close_Click(object sender, RoutedEventArgs e)
+        {
+            Close();
+        }
+
+        private void SuspendMainWindowHotkeys()
+        {
+            try
+            {
+                _mainWindow?.SuspendHotkeys();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"WARNING: Failed to suspend main window hotkeys: {ex.Message}");
+            }
+        }
+
+        private void ResumeMainWindowHotkeys()
+        {
+            try
+            {
+                _mainWindow?.ResumeHotkeys();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"WARNING: Failed to resume main window hotkeys: {ex.Message}");
+            }
+        }
+
+        protected override void OnClosed(EventArgs e)
+        {
+            // Always resume hotkeys when the window is closed, regardless of how it was closed
+            ResumeMainWindowHotkeys();
+            base.OnClosed(e);
+        }
+    }
+}
diff --git a/WhackerLinkConsoleV2/KeybindingParser.cs b/WhackerLinkConsoleV2/KeybindingParser.cs
new file mode 100644
index 0000000..a9eb66b
--- /dev/null
+++ b/WhackerLinkConsoleV2/KeybindingParser.cs
@@ -0,0 +1,160 @@
+/*
+* WhackerLink - WhackerLinkConsoleV2
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* 
+* Copyright (C) 2024-2025 Caleb, K4PHP
+* Copyright (C) 2025 Firav (firavdev@gmail.com)
+* 
+*/
+
+using System;
+using System.Windows.Input;
+
+namespace WhackerLinkConsoleV2
+{
+    /// <summary>
+    /// Helper class to parse and convert keybinding strings.
+    /// Supports both single-key (e.g., "T", "F1") and multi-key (e.g., "Ctrl+T", "Ctrl+Alt+P")
+    /// </summary>
+    public static class KeybindingParser
+    {
+        /// <summary>
+        /// Parses a keybinding string like "Ctrl+Alt+P" into ModifierKeys and Key
+        /// </summary>
+        /// <returns>Returns true if parsing was successful</returns>
+        public static bool TryParseKeybinding(string keybindingString, out ModifierKeys modifiers, out Key key)
+        {
+            modifiers = ModifierKeys.None;
+            key = Key.None;
+
+            if (string.IsNullOrWhiteSpace(keybindingString))
+            {
+                Console.WriteLine("ERROR: Keybinding string is null or empty");
+                return false;
+            }
+
+            try
+            {
+                var parts = keybindingString.Split('+');
+
+                if (parts.Length == 0)
+                {
+                    Console.WriteLine($"ERROR: Invalid keybinding format: '{keybindingString}'");
+                    return false;
+                }
+
+                // Handle single-key keybindings (e.g., "T", "P", "F1")
+                if (parts.Length == 1)
+                {
+                    string keyString = parts[0].Trim();
+                    if (!Enum.TryParse<Key>(keyString, true, out key))
+                    {
+                        Console.WriteLine($"ERROR: Unknown key: '{keyString}'");
+                        return false;
+                    }
+
+                    if (key == Key.None)
+                    {
+                        Console.WriteLine($"ERROR: Key cannot be None");
+                        return false;
+                    }
+
+                    return true;
+                }
+
+                // Handle multi-key keybindings (e.g., "Ctrl+T", "Ctrl+Alt+P")
+                // Parse modifiers from all but the last part
+                for (int i = 0; i < parts.Length - 1; i++)
+                {
+                    string part = parts[i].Trim().ToLower();
+
+                    switch (part)
+                    {
+                        case "ctrl":
+                        case "control":
+                            modifiers |= ModifierKeys.Control;
+                            break;
+                        case "alt":
+                            modifiers |= ModifierKeys.Alt;
+                            break;
+                        case "shift":
+                            modifiers |= ModifierKeys.Shift;
+                            break;
+                        case "win":
+                        case "windows":
+                            modifiers |= ModifierKeys.Windows;
+                            break;
+                        default:
+                            Console.WriteLine($"ERROR: Unknown modifier key: '{part}'");
+                            return false;
+                    }
+                }
+
+                // Parse the main key from the last part
+                string keyStr = parts[parts.Length - 1].Trim();
+                if (!Enum.TryParse<Key>(keyStr, true, out key))
+                {
+                    Console.WriteLine($"ERROR: Unknown key: '{keyStr}'");
+                    return false;
+                }
+
+                if (key == Key.None)
+                {
+                    Console.WriteLine($"ERROR: Key cannot be None");
+                    return false;
+                }
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Exception parsing keybinding '{keybindingString}': {ex.Message}");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Converts ModifierKeys and Key back to a keybinding string
+        /// </summary>
+        public static string KeybindingToString(ModifierKeys modifiers, Key key)
+        {
+            var result = ModifiersToString(modifiers);
+            if (!string.IsNullOrEmpty(result))
+                result += "+";
+            result += key.ToString();
+
+            return result;
+        }
+
+        /// <summary>
+        /// Converts ModifierKeys to a string representation (without the final key)
+        /// </summary>
+        public static string ModifiersToString(ModifierKeys modifiers)
+        {
+            var result = "";
+
+            if ((modifiers & ModifierKeys.Control) == ModifierKeys.Control)
+                result += "Ctrl+";
+            if ((modifiers & ModifierKeys.Alt) == ModifierKeys.Alt)
+                result += "Alt+";
+            if ((modifiers & ModifierKeys.Shift) == ModifierKeys.Shift)
+                result += "Shift+";
+            if ((modifiers & ModifierKeys.Windows) == ModifierKeys.Windows)
+                result += "Win+";
+
+            return result.TrimEnd('+');
+        }
+    }
+}
diff --git a/WhackerLinkConsoleV2/MainWindow.xaml b/WhackerLinkConsoleV2/MainWindow.xaml
index 3cc66f8..fb490ac 100644
--- a/WhackerLinkConsoleV2/MainWindow.xaml
+++ b/WhackerLinkConsoleV2/MainWindow.xaml
@@ -2,7 +2,9 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:local="clr-namespace:WhackerLinkConsoleV2.Controls"
-        Title="WhackerLinkConsoleV2" Height="600" Width="1000" Background="#FFF2F2F2">
+        Title="WhackerLinkConsoleV2" Height="600" Width="1000" Background="#FFF2F2F2"
+        Icon="/Assets/whackerlink-logo-icon.png"
+        Closed="MainWindow_OnClosed">
     <Grid Background="#FFF2F2F2">
         <Grid.ColumnDefinitions>
             <ColumnDefinition Width="497*"/>
@@ -29,6 +31,7 @@
             </MenuItem>
             <MenuItem Header="Edit">
                 <MenuItem Header="Audio Settings" Click="AudioSettings_Click" />
+                <MenuItem Header="Configure Keybindings" Click="ConfigurePttKeybindings_Click"/>
                 <MenuItem Header="Enable Edit Mode" Click="ToggleEditMode_Click"/>
                 <MenuItem Header="Select Widgets to Display" Click="SelectWidgets_Click"/>
                 <MenuItem Header="Reset Settings" Click="ResetSettings_Click"/>
diff --git a/WhackerLinkConsoleV2/MainWindow.xaml.cs b/WhackerLinkConsoleV2/MainWindow.xaml.cs
index d9098ad..4a35082 100644
--- a/WhackerLinkConsoleV2/MainWindow.xaml.cs
+++ b/WhackerLinkConsoleV2/MainWindow.xaml.cs
@@ -1,2318 +1,2734 @@
-/*
-* WhackerLink - WhackerLinkConsoleV2
-*
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-* 
-* Copyright (C) 2024-2025 Caleb, K4PHP
-* Copyright (C) 2025 J. Dean
-* 
-*/
-
-using Microsoft.Win32;
-using System;
-using System.Timers;
-using System.IO;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Input;
-using WhackerLinkLib.Models.Radio;
-using YamlDotNet.Serialization;
-using YamlDotNet.Serialization.NamingConventions;
-using WhackerLinkConsoleV2.Controls;
-using WebSocketManager = WhackerLinkLib.Managers.WebSocketManager;
-using System.Windows.Media;
-using WhackerLinkLib.Utils;
-using WhackerLinkLib.Models;
-using System.Net;
-using NAudio.Wave;
-using WhackerLinkLib.Interfaces;
-using WhackerLinkLib.Models.IOSP;
-using fnecore.P25;
-using fnecore;
-using Microsoft.VisualBasic;
-using System.Text;
-using Constants = fnecore.Constants;
-using System.Security.Cryptography;
-using fnecore.P25.LC.TSBK;
-using WebSocketSharp;
-using NWaves.Signals;
-using static WhackerLinkConsoleV2.P25Crypto;
-using static WhackerLinkLib.Models.Radio.Codeplug;
-
-namespace WhackerLinkConsoleV2
-{
-    public partial class MainWindow : Window
-    {
-        public Codeplug Codeplug { get; set; }
-        private bool isEditMode = false;
-
-        private bool globalPttState = false;
-
-        private UIElement _draggedElement;
-        private Point _startPoint;
-        private double _offsetX;
-        private double _offsetY;
-        private bool _isDragging;
-
-        private SettingsManager _settingsManager = new SettingsManager();
-        private SelectedChannelsManager _selectedChannelsManager;
-        private FlashingBackgroundManager _flashingManager;
-        private WaveFilePlaybackManager _emergencyAlertPlayback;
-        private WebSocketManager _webSocketManager = new WebSocketManager();
-
-        private ChannelBox playbackChannelBox;
-
-        CallHistoryWindow callHistoryWindow = new CallHistoryWindow();
-
-        public static string PLAYBACKTG = "LOCPLAYBACK";
-        public static string PLAYBACKSYS = "LOCPLAYBACKSYS";
-        public static string PLAYBACKCHNAME = "PLAYBACK";
-
-        private readonly WaveInEvent _waveIn;
-        private readonly AudioManager _audioManager;
-
-        private static System.Timers.Timer _channelHoldTimer;
-
-        private Dictionary<string, SlotStatus> systemStatuses = new Dictionary<string, SlotStatus>();
-        private FneSystemManager _fneSystemManager = new FneSystemManager();
-
-        private bool cryptodev = true;
-
-        private static HashSet<uint> usedRids = new HashSet<uint>();
-
-        List<Tuple<uint, uint>> fneAffs = new List<Tuple<uint, uint>>();
-
-        public MainWindow()
-        {
-#if !DEBUG
-            ConsoleNative.ShowConsole();
-#endif
-            InitializeComponent();
-            _settingsManager.LoadSettings();
-            _selectedChannelsManager = new SelectedChannelsManager();
-            _flashingManager = new FlashingBackgroundManager(null, ChannelsCanvas, null, this);
-            _emergencyAlertPlayback = new WaveFilePlaybackManager(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "emergency.wav"));
-
-            _channelHoldTimer = new System.Timers.Timer(10000);
-            _channelHoldTimer.Elapsed += OnHoldTimerElapsed;
-            _channelHoldTimer.AutoReset = true;
-            _channelHoldTimer.Enabled = true;
-
-            _waveIn = new WaveInEvent
-            {
-                WaveFormat = new WaveFormat(8000, 16, 1)
-            };
-            _waveIn.DataAvailable += WaveIn_DataAvailable;
-            _waveIn.RecordingStopped += WaveIn_RecordingStopped;
-
-            _waveIn.StartRecording();
-
-            _audioManager = new AudioManager(_settingsManager);
-
-            _selectedChannelsManager.SelectedChannelsChanged += SelectedChannelsChanged;
-            Loaded += MainWindow_Loaded;
-        }
-
-        private void OpenCodeplug_Click(object sender, RoutedEventArgs e)
-        {
-            OpenFileDialog openFileDialog = new OpenFileDialog
-            {
-                Filter = "Codeplug Files (*.yml)|*.yml|All Files (*.*)|*.*",
-                Title = "Open Codeplug"
-            };
-            if (openFileDialog.ShowDialog() == true)
-            {
-                LoadCodeplug(openFileDialog.FileName);
-
-                _settingsManager.LastCodeplugPath = openFileDialog.FileName;
-                _settingsManager.SaveSettings();
-            }
-        }
-
-        private void ResetSettings_Click(object sender, RoutedEventArgs e)
-        {
-            if (File.Exists("UserSettings.json"))
-                File.Delete("UserSettings.json");
-        }
-
-        private void LoadCodeplug(string filePath)
-        {
-            try
-            {
-                var deserializer = new DeserializerBuilder()
-                    .WithNamingConvention(CamelCaseNamingConvention.Instance)
-                    .IgnoreUnmatchedProperties()
-                    .Build();
-
-                var yaml = File.ReadAllText(filePath);
-                Codeplug = deserializer.Deserialize<Codeplug>(yaml);
-
-                GenerateChannelWidgets();
-            }
-            catch (Exception ex)
-            {
-                MessageBox.Show($"Error loading codeplug: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
-            }
-        }
-
-        private void GenerateChannelWidgets()
-        {
-            ChannelsCanvas.Children.Clear();
-            double offsetX = 20;
-            double offsetY = 20;
-
-            if (Codeplug != null)
-            {
-                foreach (var system in Codeplug.Systems)
-                {
-                    var systemStatusBox = new SystemStatusBox(system.Name, system.Address, system.Port);
-
-                    if (_settingsManager.SystemStatusPositions.TryGetValue(system.Name, out var position))
-                    {
-                        Canvas.SetLeft(systemStatusBox, position.X);
-                        Canvas.SetTop(systemStatusBox, position.Y);
-                    }
-                    else
-                    {
-                        Canvas.SetLeft(systemStatusBox, offsetX);
-                        Canvas.SetTop(systemStatusBox, offsetY);
-                    }
-
-                    systemStatusBox.MouseLeftButtonDown += SystemStatusBox_MouseLeftButtonDown;
-                    systemStatusBox.MouseMove += SystemStatusBox_MouseMove;
-                    systemStatusBox.MouseRightButtonDown += SystemStatusBox_MouseRightButtonDown;
-
-                    ChannelsCanvas.Children.Add(systemStatusBox);
-
-                    offsetX += 225;
-                    if (offsetX + 220 > ChannelsCanvas.ActualWidth)
-                    {
-                        offsetX = 20;
-                        offsetY += 106;
-                    }
-
-                    if (File.Exists(system.AliasPath))
-                        system.RidAlias = AliasTools.LoadAliases(system.AliasPath);
-
-                    if (!system.IsDvm)
-                    {
-                        _webSocketManager.AddWebSocketHandler(system.Name);
-
-                        IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-                        handler.OnVoiceChannelResponse += HandleVoiceResponse;
-                        handler.OnVoiceChannelRelease += HandleVoiceRelease;
-                        handler.OnEmergencyAlarmResponse += HandleEmergencyAlarmResponse;
-                        handler.OnAudioData += HandleReceivedAudio;
-                        handler.OnAffiliationUpdate += HandleAffiliationUpdate;
-                        handler.OnCallAlert += HandleCallAlert;
-
-                        handler.OnUnitRegistrationResponse += (response) =>
-                        {
-                            Dispatcher.Invoke(() =>
-                            {
-                                if (response.Status == (int)ResponseType.GRANT)
-                                {
-                                    systemStatusBox.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
-                                    systemStatusBox.ConnectionState = "Connected";
-
-                                    foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-                                    {
-                                        if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                                            continue;
-
-                                        Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                                        Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                                        if (!system.IsDvm)
-                                        {
-                                            IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                                            if (channel.IsSelected && handler.IsConnected)
-                                            {
-                                                Console.WriteLine("sending WLINK master aff");
-
-                                                Task.Run(() =>
-                                                {
-                                                    GRP_AFF_REQ release = new GRP_AFF_REQ
-                                                    {
-                                                        SrcId = system.Rid,
-                                                        DstId = cpgChannel.Tgid,
-                                                        Site = system.Site
-                                                    };
-
-                                                    handler.SendMessage(release.GetData());
-                                                });
-                                            }
-                                        }
-                                    }
-                                }
-                                else
-                                {
-                                    systemStatusBox.Background = new SolidColorBrush(Colors.Red);
-                                    systemStatusBox.ConnectionState = "Disconnected";
-                                }
-                            });
-                        };
-
-                        handler.OnClose += () =>
-                        {
-                            Dispatcher.Invoke(() =>
-                            {
-                                systemStatusBox.Background = new SolidColorBrush(Colors.Red);
-                                systemStatusBox.ConnectionState = "Disconnected";
-                            });
-                        };
-
-                        handler.OnOpen += () =>
-                        {
-                            Console.WriteLine("Peer connected");
-                            U_REG_REQ release = new U_REG_REQ
-                            {
-                                SrcId = system.Rid,
-                                Site = system.Site
-                            };
-
-                            handler.SendMessage(release.GetData());
-                        };
-
-                        handler.OnReconnecting += () =>
-                        {
-                            Console.WriteLine("Peer reconnecting");
-                        };
-
-                        Task.Run(() =>
-                        {
-                            handler.Connect(system.Address, system.Port, system.AuthKey);
-
-                            handler.OnGroupAffiliationResponse += (response) => { /* TODO */ };
-
-                            if (!handler.IsConnected)
-                            {
-                                systemStatusBox.Background = new SolidColorBrush(Colors.Red);
-                                systemStatusBox.ConnectionState = "Disconnected";
-                            }
-                        });
-                    } else
-                    {
-                        _fneSystemManager.AddFneSystem(system.Name, system, this);
-
-                        PeerSystem peer = _fneSystemManager.GetFneSystem(system.Name);
-
-                        peer.peer.PeerConnected += (sender, response) =>
-                        {
-                            Console.WriteLine("FNE Peer connected");
-
-                            Dispatcher.Invoke(() =>
-                            {
-                                systemStatusBox.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
-                                systemStatusBox.ConnectionState = "Connected";
-                            });
-                        };
-
-
-                        peer.peer.PeerDisconnected += (response) =>
-                        {
-                            Console.WriteLine("FNE Peer disconnected");
-
-                            Dispatcher.Invoke(() =>
-                            {
-                                systemStatusBox.Background = new SolidColorBrush(Colors.Red);
-                                systemStatusBox.ConnectionState = "Disconnected";
-                            });
-                        };
-
-                        Task.Run(() =>
-                        {
-                            peer.Start();
-                        });
-                    }
-
-                    if (!_settingsManager.ShowSystemStatus)
-                        systemStatusBox.Visibility = Visibility.Collapsed;
-
-                }
-            }
-
-            if (_settingsManager.ShowChannels && Codeplug != null)
-            {
-                foreach (var zone in Codeplug.Zones)
-                {
-                    foreach (var channel in zone.Channels)
-                    {
-                        var channelBox = new ChannelBox(_selectedChannelsManager, _audioManager, channel.Name, channel.System, channel.Tgid);
-
-                        //channelBox.crypter.AddKey(channel.GetKeyId(), channel.GetAlgoId(), channel.GetEncryptionKey());
-
-                        systemStatuses.Add(channel.Name, new SlotStatus());
-
-                        if (_settingsManager.ChannelPositions.TryGetValue(channel.Name, out var position))
-                        {
-                            Canvas.SetLeft(channelBox, position.X);
-                            Canvas.SetTop(channelBox, position.Y);
-                        }
-                        else
-                        {
-                            Canvas.SetLeft(channelBox, offsetX);
-                            Canvas.SetTop(channelBox, offsetY);
-                        }
-
-                        channelBox.PTTButtonClicked += ChannelBox_PTTButtonClicked;
-                        channelBox.PageButtonClicked += ChannelBox_PageButtonClicked;
-                        channelBox.HoldChannelButtonClicked += ChannelBox_HoldChannelButtonClicked;
-
-                        channelBox.MouseLeftButtonDown += ChannelBox_MouseLeftButtonDown;
-                        channelBox.MouseMove += ChannelBox_MouseMove;
-                        channelBox.MouseRightButtonDown += ChannelBox_MouseRightButtonDown;
-                        ChannelsCanvas.Children.Add(channelBox);
-
-                        offsetX += 225;
-
-                        if (offsetX + 220 > ChannelsCanvas.ActualWidth)
-                        {
-                            offsetX = 20;
-                            offsetY += 106;
-                        }
-                    }
-                }
-            }
-
-            if (_settingsManager.ShowAlertTones && Codeplug != null)
-            {
-                foreach (var alertPath in _settingsManager.AlertToneFilePaths)
-                {
-                    var alertTone = new AlertTone(alertPath)
-                    {
-                        IsEditMode = isEditMode
-                    };
-
-                    alertTone.OnAlertTone += SendAlertTone;
-
-                    if (_settingsManager.AlertTonePositions.TryGetValue(alertPath, out var position))
-                    {
-                        Canvas.SetLeft(alertTone, position.X);
-                        Canvas.SetTop(alertTone, position.Y);
-                    }
-                    else
-                    {
-                        Canvas.SetLeft(alertTone, 20);
-                        Canvas.SetTop(alertTone, 20);
-                    }
-
-                    alertTone.MouseRightButtonUp += AlertTone_MouseRightButtonUp;
-
-                    ChannelsCanvas.Children.Add(alertTone);
-                }
-            }
-
-            playbackChannelBox = new ChannelBox(_selectedChannelsManager, _audioManager, PLAYBACKCHNAME, PLAYBACKSYS, PLAYBACKTG);
-
-            if (_settingsManager.ChannelPositions.TryGetValue(PLAYBACKCHNAME, out var pos))
-            {
-                Canvas.SetLeft(playbackChannelBox, pos.X);
-                Canvas.SetTop(playbackChannelBox, pos.Y);
-            }
-            else
-            {
-                Canvas.SetLeft(playbackChannelBox, offsetX);
-                Canvas.SetTop(playbackChannelBox, offsetY);
-            }
-
-            playbackChannelBox.PTTButtonClicked += ChannelBox_PTTButtonClicked;
-            playbackChannelBox.PageButtonClicked += ChannelBox_PageButtonClicked;
-            playbackChannelBox.HoldChannelButtonClicked += ChannelBox_HoldChannelButtonClicked;
-
-            playbackChannelBox.MouseLeftButtonDown += ChannelBox_MouseLeftButtonDown;
-            playbackChannelBox.MouseMove += ChannelBox_MouseMove;
-            playbackChannelBox.MouseRightButtonDown += ChannelBox_MouseRightButtonDown;
-            ChannelsCanvas.Children.Add(playbackChannelBox);
-
-            //offsetX += 225;
-
-            //if (offsetX + 220 > ChannelsCanvas.ActualWidth)
-            //{
-            //    offsetX = 20;
-            //    offsetY += 106;
-            //}
-
-            AdjustCanvasHeight();
-        }
-
-        private void WaveIn_RecordingStopped(object sender, EventArgs e)
-        {
-            /* stub */
-        }
-
-        private void WaveIn_DataAvailable(object sender, WaveInEventArgs e)
-        {
-            bool isAnyTgOn = false;
-
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                {
-                    playbackChannelBox.IsReceiving = true;
-                    continue;
-                }
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                Task.Run(() =>
-                {
-
-                    if (!system.IsDvm)
-                    {
-                        IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                        if (channel.IsSelected && channel.VoiceChannel != null && channel.PttState)
-                        {
-                            isAnyTgOn = true;
-
-                            object voicePaket = new
-                            {
-                                type = PacketType.AUDIO_DATA,
-                                data = new
-                                {
-                                    Data = e.Buffer,
-                                    VoiceChannel = new VoiceChannel
-                                    {
-                                        Frequency = channel.VoiceChannel,
-                                        DstId = cpgChannel.Tgid,
-                                        SrcId = system.Rid,
-                                        Site = system.Site
-                                    },
-                                    Site = system.Site
-                                }
-                            };
-
-#if DEBUG
-                            Console.WriteLine($"WLINK AUDIO_DATA SrcId: {system.Rid}; DstId: {cpgChannel.Tgid}; Freq: {channel.VoiceChannel}");
-#endif
-
-                            handler.SendMessage(voicePaket);
-                        }
-                    }
-                    else
-                    {
-                        PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                        if (channel.IsSelected && channel.PttState)
-                        {
-                            isAnyTgOn = true;
-
-                            int samples = 320;
-
-                            channel.chunkedPcm = AudioConverter.SplitToChunks(e.Buffer);
-
-                            foreach (byte[] chunk in channel.chunkedPcm)
-                            {
-                                if (chunk.Length == samples)
-                                {
-                                    P25EncodeAudioFrame(chunk, handler, channel, cpgChannel, system);
-                                }
-                                else
-                                {
-                                    Console.WriteLine("bad sample length: " + chunk.Length);
-                                }
-                            }
-                        }
-                    }
-                });
-            }
-
-            if (isAnyTgOn && playbackChannelBox.IsSelected)
-                _audioManager.AddTalkgroupStream(PLAYBACKTG, e.Buffer);
-        }
-
-        private void SelectedChannelsChanged()
-        {
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-         
-                if (!system.IsDvm) {
-                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                    if (channel.IsSelected && handler.IsConnected)
-                    {
-                        Console.WriteLine("sending WLINK master aff");
-
-                        Task.Run(() =>
-                        {
-                            GRP_AFF_REQ release = new GRP_AFF_REQ
-                            {
-                                SrcId = system.Rid,
-                                DstId = cpgChannel.Tgid,
-                                Site = system.Site
-                            };
-
-                            handler.SendMessage(release.GetData());
-                        });
-                    }
-                } else
-                {
-                    PeerSystem fne = _fneSystemManager.GetFneSystem(system.Name);
-
-                    if (channel.IsSelected)
-                    {
-                        uint newTgid = UInt32.Parse(cpgChannel.Tgid);
-                        bool exists = fneAffs.Any(aff => aff.Item2 == newTgid);
-
-                        if (cpgChannel.GetAlgoId() != 0 && cpgChannel.GetKeyId() != 0)
-                            fne.peer.SendMasterKeyRequest(cpgChannel.GetAlgoId(), cpgChannel.GetKeyId());
-
-                        if (!exists)
-                            fneAffs.Add(new Tuple<uint, uint>(GetUniqueRid(system.Rid), newTgid));
-
-                        //Console.WriteLine("FNE Affiliations:");
-                        //foreach (var aff in fneAffs)
-                        //{
-                        //    Console.WriteLine($"  RID: {aff.Item1}, TGID: {aff.Item2}");
-                        //}
-                    }
-                }
-            }
-
-            foreach (Codeplug.System system in Codeplug.Systems)
-            {
-                if (system.IsDvm)
-                {
-                    PeerSystem fne = _fneSystemManager.GetFneSystem(system.Name);
-                    //fne.peer.SendMasterAffiliationUpdate(fneAffs);
-                }
-            }
-        }
-
-        private void AudioSettings_Click(object sender, RoutedEventArgs e)
-        {
-            List<Codeplug.Channel> channels = Codeplug?.Zones.SelectMany(z => z.Channels).ToList() ?? new List<Codeplug.Channel>();
-
-            AudioSettingsWindow audioSettingsWindow = new AudioSettingsWindow(_settingsManager, _audioManager, channels);
-            audioSettingsWindow.ShowDialog();
-        }
-
-        private void P25Page_Click(object sender, RoutedEventArgs e)
-        {
-            DigitalPageWindow pageWindow = new DigitalPageWindow(Codeplug.Systems);
-            pageWindow.Owner = this;
-            if (pageWindow.ShowDialog() == true)
-            {
-                if (!pageWindow.RadioSystem.IsDvm)
-                {
-                    IPeer handler = _webSocketManager.GetWebSocketHandler(pageWindow.RadioSystem.Name);
-
-                    CALL_ALRT_REQ callAlert = new CALL_ALRT_REQ
-                    {
-                        SrcId = pageWindow.RadioSystem.Rid,
-                        DstId = pageWindow.DstId
-                    };
-
-                    handler.SendMessage(callAlert.GetData());
-                }
-                else
-                {
-                    PeerSystem handler = _fneSystemManager.GetFneSystem(pageWindow.RadioSystem.Name);
-                    IOSP_CALL_ALRT callAlert = new IOSP_CALL_ALRT(UInt32.Parse(pageWindow.DstId), UInt32.Parse(pageWindow.RadioSystem.Rid));
-
-                    RemoteCallData callData = new RemoteCallData
-                    {
-                        SrcId = UInt32.Parse(pageWindow.RadioSystem.Rid),
-                        DstId = UInt32.Parse(pageWindow.DstId),
-                        LCO = P25Defines.TSBK_IOSP_CALL_ALRT
-                    };
-
-                    byte[] tsbk = new byte[P25Defines.P25_TSBK_LENGTH_BYTES];
-
-                    callAlert.Encode(ref tsbk, true, true);
-
-                    handler.SendP25TSBK(callData, tsbk);
-
-                    Console.WriteLine("sent page");
-                }
-            }
-        }
-
-        private async void ManualPage_Click(object sender, RoutedEventArgs e)
-        {
-            QuickCallPage pageWindow = new QuickCallPage();
-            pageWindow.Owner = this;
-            if (pageWindow.ShowDialog() == true)
-            {
-                foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-                {
-                    Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                    Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                    if (channel.PageState)
-                    {
-                        ToneGenerator generator = new ToneGenerator();
-
-                        double toneADuration = 1.0;
-                        double toneBDuration = 3.0;
-
-                        byte[] toneA = generator.GenerateTone(Double.Parse(pageWindow.ToneA), toneADuration);
-                        byte[] toneB = generator.GenerateTone(Double.Parse(pageWindow.ToneB), toneBDuration);
-
-                        byte[] combinedAudio = new byte[toneA.Length + toneB.Length];
-                        Buffer.BlockCopy(toneA, 0, combinedAudio, 0, toneA.Length);
-                        Buffer.BlockCopy(toneB, 0, combinedAudio, toneA.Length, toneB.Length);
-
-                        int chunkSize = 1600;
-
-                        if (system.IsDvm)
-                            chunkSize = 320;
-
-                        int totalChunks = (combinedAudio.Length + chunkSize - 1) / chunkSize;
-
-                        Task.Run(() =>
-                        {
-                            //_waveProvider.ClearBuffer();
-                            _audioManager.AddTalkgroupStream(cpgChannel.Tgid, combinedAudio);
-                        });
-
-                        await Task.Run(() =>
-                        {
-                            for (int i = 0; i < totalChunks; i++)
-                            {
-                                int offset = i * chunkSize;
-                                int size = Math.Min(chunkSize, combinedAudio.Length - offset);
-
-                                byte[] chunk = new byte[chunkSize];
-                                Buffer.BlockCopy(combinedAudio, offset, chunk, 0, size);
-
-                                if (!system.IsDvm)
-                                {
-                                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                                    AudioPacket voicePacket = new AudioPacket
-                                    {
-                                        Data = chunk,
-                                        VoiceChannel = new VoiceChannel
-                                        {
-                                            Frequency = channel.VoiceChannel,
-                                            DstId = cpgChannel.Tgid,
-                                            SrcId = system.Rid,
-                                            Site = system.Site
-                                        },
-                                        Site = system.Site,
-                                        LopServerVocode = true
-                                    };
-
-                                    handler.SendMessage(voicePacket.GetData());
-                                } else
-                                {
-                                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                                    if (chunk.Length == 320)
-                                    {
-                                        P25EncodeAudioFrame(chunk, handler, channel, cpgChannel, system);
-                                    }
-                                }
-                            }
-                        });
-
-                        double totalDurationMs = (toneADuration + toneBDuration) * 1000 + 750;
-                        await Task.Delay((int)totalDurationMs);
-
-                        if (!system.IsDvm)
-                        {
-                            IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                            GRP_VCH_RLS release = new GRP_VCH_RLS
-                            {
-                                SrcId = system.Rid,
-                                DstId = cpgChannel.Tgid,
-                                Channel = channel.VoiceChannel,
-                                Site = system.Site
-                            };
-
-                            handler.SendMessage(release.GetData());
-                        } else
-                        {
-                            PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                            await Task.Delay(4000);
-
-                            handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
-                        }
-
-                        Dispatcher.Invoke(() =>
-                        {
-                            //channel.PageState = false; // TODO: Investigate
-                            channel.PageSelectButton.Background = channel.grayGradient;
-                        });
-                    }
-                }
-            }
-        }
-
-        private void SendAlertTone(AlertTone e)
-        {
-            Task.Run(() => SendAlertTone(e.AlertFilePath));
-        }
-
-        private void SendAlertTone(string filePath, bool forHold = false)
-        {
-            if (!string.IsNullOrEmpty(filePath) && File.Exists(filePath))
-            {
-                try
-                {
-                    foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-                    {
-                        if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                            continue;
-
-                        Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                        Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                        if (channel.PageState || (forHold && channel.HoldState))
-                        {
-                            byte[] pcmData;
-
-                            Task.Run(async () => {
-                                using (var waveReader = new WaveFileReader(filePath))
-                                {
-                                    if (waveReader.WaveFormat.Encoding != WaveFormatEncoding.Pcm ||
-                                        waveReader.WaveFormat.SampleRate != 8000 ||
-                                        waveReader.WaveFormat.BitsPerSample != 16 ||
-                                        waveReader.WaveFormat.Channels != 1)
-                                    {
-                                        MessageBox.Show("The alert tone must be PCM 16-bit, Mono, 8000Hz format.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
-                                        return;
-                                    }
-
-                                    using (MemoryStream ms = new MemoryStream())
-                                    {
-                                        waveReader.CopyTo(ms);
-                                        pcmData = ms.ToArray();
-                                    }
-                                }
-
-                                int chunkSize = 1600;
-                                int totalChunks = (pcmData.Length + chunkSize - 1) / chunkSize;
-
-                                if (pcmData.Length % chunkSize != 0)
-                                {
-                                    byte[] paddedData = new byte[totalChunks * chunkSize];
-                                    Buffer.BlockCopy(pcmData, 0, paddedData, 0, pcmData.Length);
-                                    pcmData = paddedData;
-                                }
-
-                                Task.Run(() =>
-                                {
-                                    _audioManager.AddTalkgroupStream(cpgChannel.Tgid, pcmData);
-                                });
-
-                                DateTime startTime = DateTime.UtcNow;
-
-                                for (int i = 0; i < totalChunks; i++)
-                                {
-                                    int offset = i * chunkSize;
-                                    byte[] chunk = new byte[chunkSize];
-                                    Buffer.BlockCopy(pcmData, offset, chunk, 0, chunkSize);
-
-                                    if (!system.IsDvm)
-                                    {
-                                        IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                                        AudioPacket voicePacket = new AudioPacket
-                                        {
-                                            Data = chunk,
-                                            VoiceChannel = new VoiceChannel
-                                            {
-                                                Frequency = channel.VoiceChannel,
-                                                DstId = cpgChannel.Tgid,
-                                                SrcId = system.Rid,
-                                                Site = system.Site
-                                            },
-                                            Site = system.Site,
-                                            LopServerVocode = true
-                                        };
-
-                                        handler.SendMessage(voicePacket.GetData());
-                                    }
-                                    else
-                                    {
-                                        PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                                        channel.chunkedPcm = AudioConverter.SplitToChunks(chunk);
-
-                                        foreach (byte[] smallchunk in channel.chunkedPcm)
-                                        {
-                                            if (smallchunk.Length == 320)
-                                            {
-                                                P25EncodeAudioFrame(smallchunk, handler, channel, cpgChannel, system);
-                                            }
-                                        }
-                                    }
-
-                                    DateTime nextPacketTime = startTime.AddMilliseconds((i + 1) * 100);
-                                    TimeSpan waitTime = nextPacketTime - DateTime.UtcNow;
-
-                                    if (waitTime.TotalMilliseconds > 0)
-                                    {
-                                        await Task.Delay(waitTime);
-                                    }
-                                }
-
-                                double totalDurationMs = ((double)pcmData.Length / 16000) + 250;
-                                await Task.Delay((int)totalDurationMs);
-
-                                if (!system.IsDvm)
-                                {
-                                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                                    GRP_VCH_RLS release = new GRP_VCH_RLS
-                                    {
-                                        SrcId = system.Rid,
-                                        DstId = cpgChannel.Tgid,
-                                        Channel = channel.VoiceChannel,
-                                        Site = system.Site
-                                    };
-
-                                    Dispatcher.Invoke(() =>
-                                    {
-                                        handler.SendMessage(release.GetData());
-
-                                        if (forHold)
-                                            channel.PttButton.Background = channel.grayGradient;
-                                        else
-                                            channel.PageState = false;
-                                    });
-                                } else
-                                {
-                                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                                    await Task.Delay(3000);
-
-                                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
-
-                                    Dispatcher.Invoke(() =>
-                                    {
-                                        if (forHold)
-                                            channel.PttButton.Background = channel.grayGradient;
-                                        else
-                                            channel.PageState = false;
-                                    });
-                                }
-                            });
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    MessageBox.Show($"Failed to process alert tone: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
-                }
-            }
-            else
-            {
-                MessageBox.Show("Alert file not set or file not found.", "Alert", MessageBoxButton.OK, MessageBoxImage.Warning);
-            }
-        }
-
-        private void SelectWidgets_Click(object sender, RoutedEventArgs e)
-        {
-            WidgetSelectionWindow widgetSelectionWindow = new WidgetSelectionWindow();
-            widgetSelectionWindow.Owner = this;
-            if (widgetSelectionWindow.ShowDialog() == true)
-            {
-                _settingsManager.ShowSystemStatus = widgetSelectionWindow.ShowSystemStatus;
-                _settingsManager.ShowChannels = widgetSelectionWindow.ShowChannels;
-                _settingsManager.ShowAlertTones = widgetSelectionWindow.ShowAlertTones;
-
-                GenerateChannelWidgets();
-                _settingsManager.SaveSettings();
-            }
-        }
-
-        private void HandleEmergencyAlarmResponse(EMRG_ALRM_RSP response)
-        {
-            bool forUs = false;
-
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (response.DstId == cpgChannel.Tgid)
-                {
-                    forUs = true;
-                    channel.Emergency = true;
-                    channel.LastSrcId = response.SrcId;
-                }
-            }
-
-            if (forUs)
-            {
-                Dispatcher.Invoke(() =>
-                {
-                    _flashingManager.Start();
-                    _emergencyAlertPlayback.Start();
-                });
-            }
-        }
-
-        private void HandleCallAlert(CALL_ALRT request)
-        {
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (system.IsDvm)
-                    continue;
-
-                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                if (request.DstId == system.Rid)
-                {
-
-                    ACK_RSP ack = new ACK_RSP
-                    {
-                        SrcId = request.SrcId,
-                        DstId = request.DstId,
-                        Service = PacketType.CALL_ALRT
-                    };
-
-                    handler.SendMessage(ack.GetData());
-                }
-            }
-        }
-
-        private void HandleReceivedAudio(AudioPacket audioPacket)
-        {
-            bool shouldReceive = false;
-            string talkgroupId = audioPacket.VoiceChannel.DstId;
-
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (system.IsDvm)
-                    continue;
-
-                if (audioPacket.VoiceChannel.SrcId != system.Rid && audioPacket.VoiceChannel.Frequency == channel.VoiceChannel && audioPacket.VoiceChannel.DstId == cpgChannel.Tgid)
-                    shouldReceive = true;
-            }
-
-            if (shouldReceive)
-                _audioManager.AddTalkgroupStream(talkgroupId, audioPacket.Data);
-        }
-
-        private void HandleAffiliationUpdate(AFF_UPDATE affUpdate)
-        {
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (system.IsDvm)
-                    continue;
-
-                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                bool ridExists = affUpdate.Affiliations.Any(aff => aff.SrcId == system.Rid);
-                bool tgidExists = affUpdate.Affiliations.Any(aff => aff.DstId == cpgChannel.Tgid);
-
-                if (ridExists && tgidExists)
-                {
-                    //Console.WriteLine("rid aff'ed");
-                }
-                else
-                {
-                    //Console.WriteLine("rid not aff'ed");
-                    Task.Run(() =>
-                    {
-                        GRP_AFF_REQ affReq = new GRP_AFF_REQ
-                        {
-                            SrcId = system.Rid,
-                            DstId = cpgChannel.Tgid,
-                            Site = system.Site
-                        };
-
-                        handler.SendMessage(affReq.GetData());
-                    });
-                }
-            }
-        }
-
-        private void HandleVoiceRelease(GRP_VCH_RLS response)
-        {
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (system.IsDvm)
-                    continue;
-
-                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                if (response.DstId == cpgChannel.Tgid && response.SrcId != system.Rid)
-                {
-                    Dispatcher.Invoke(() =>
-                    {
-                        if (channel.IsSelected)
-                        {
-                            channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF0B004B");
-                            channel.IsReceiving = false;
-                        }
-                        else
-                        {
-                            channel.Background = new SolidColorBrush(Colors.DarkGray);
-                            channel.IsReceiving = false;
-                        }
-                    });
-
-                    channel.VoiceChannel = null;
-                }
-            }
-        }
-
-        private void HandleVoiceResponse(GRP_VCH_RSP response)
-        {
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (system.IsDvm)
-                    continue;
-
-                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                if (channel.PttState && response.Status == (int)ResponseType.GRANT && response.Channel != null && response.SrcId == system.Rid && response.DstId == cpgChannel.Tgid)
-                {
-                    channel.VoiceChannel = response.Channel;
-                }
-                else if (response.Status == (int)ResponseType.GRANT && response.SrcId != system.Rid && response.DstId == cpgChannel.Tgid)
-                {
-                    channel.VoiceChannel = response.Channel;
-
-                    string alias = string.Empty;
-
-                    try
-                    {
-                        alias = AliasTools.GetAliasByRid(system.RidAlias, int.Parse(response.SrcId));
-                    }
-                    catch (Exception) { }
-
-                    if (alias.IsNullOrEmpty())
-                        channel.LastSrcId = "Last SRC: " + response.SrcId;
-                    else
-                        channel.LastSrcId = "Last: " + alias;
-
-                    Dispatcher.Invoke(() =>
-                    {
-                        channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
-                        channel.IsReceiving = true;
-                    });
-                }
-                else if ((channel.HoldState || channel.PageState) && response.Status == (int)ResponseType.GRANT && response.Channel != null && response.SrcId == system.Rid && response.DstId == cpgChannel.Tgid)
-                {
-                    channel.VoiceChannel = response.Channel;
-                }
-                else
-                {
-                    //Dispatcher.Invoke(() =>
-                    //{
-                    //    if (channel.IsSelected)
-                    //        channel.Background = new SolidColorBrush(Colors.DodgerBlue);
-                    //    else
-                    //        channel.Background = new SolidColorBrush(Colors.Gray);
-                    //});
-
-                    //channel.VoiceChannel = null;
-                    //_stopSending = true;
-                }
-            }
-        }
-
-        private void ChannelBox_HoldChannelButtonClicked(object sender, ChannelBox e)
-        {
-            if (e.SystemName == PLAYBACKSYS || e.ChannelName == PLAYBACKCHNAME || e.DstId == PLAYBACKTG)
-                return;
-
-            Codeplug.System system = Codeplug.GetSystemForChannel(e.ChannelName);
-            Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(e.ChannelName);
-
-            if (system.IsDvm)
-                return;
-
-            IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-        }
-
-        private void ChannelBox_PageButtonClicked(object sender, ChannelBox e)
-        {
-            if (e.SystemName == PLAYBACKSYS || e.ChannelName == PLAYBACKCHNAME || e.DstId == PLAYBACKTG)
-                return;
-
-            Codeplug.System system = Codeplug.GetSystemForChannel(e.ChannelName);
-            Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(e.ChannelName);
-
-            if (!system.IsDvm)
-            {
-
-                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                if (e.PageState)
-                {
-                    GRP_VCH_REQ request = new GRP_VCH_REQ
-                    {
-                        SrcId = system.Rid,
-                        DstId = cpgChannel.Tgid,
-                        Site = system.Site
-                    };
-
-                    handler.SendMessage(request.GetData());
-                }
-                else
-                {
-                    GRP_VCH_RLS release = new GRP_VCH_RLS
-                    {
-                        SrcId = system.Rid,
-                        DstId = cpgChannel.Tgid,
-                        Channel = e.VoiceChannel,
-                        Site = system.Site
-                    };
-
-                    handler.SendMessage(release.GetData());
-                    e.VoiceChannel = null;
-                }
-            }
-            else
-            {
-                PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-                if (e.PageState)
-                {
-                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
-                }
-                else
-                {
-                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
-                }
-            }
-        }
-
-        private void ChannelBox_PTTButtonClicked(object sender, ChannelBox e)
-        {
-            if (e.SystemName == PLAYBACKSYS || e.ChannelName == PLAYBACKCHNAME || e.DstId == PLAYBACKTG)
-                return;
-
-            Codeplug.System system = Codeplug.GetSystemForChannel(e.ChannelName);
-            Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(e.ChannelName);
-
-            if (!system.IsDvm)
-            {
-                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                if (!e.IsSelected)
-                    return;
-
-                if (e.PttState)
-                {
-                    GRP_VCH_REQ request = new GRP_VCH_REQ
-                    {
-                        SrcId = system.Rid,
-                        DstId = cpgChannel.Tgid,
-                        Site = system.Site
-                    };
-
-                    handler.SendMessage(request.GetData());
-                }
-                else
-                {
-                    GRP_VCH_RLS release = new GRP_VCH_RLS
-                    {
-                        SrcId = system.Rid,
-                        DstId = cpgChannel.Tgid,
-                        Channel = e.VoiceChannel,
-                        Site = system.Site
-                    };
-
-                    handler.SendMessage(release.GetData());
-                    e.VoiceChannel = null;
-                }
-            } else
-            {
-                PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                if (!e.IsSelected)
-                    return;
-
-                FneUtils.Memset(e.mi, 0x00, P25Defines.P25_MI_LENGTH);
-
-                uint srcId = UInt32.Parse(system.Rid);
-                uint dstId = UInt32.Parse(cpgChannel.Tgid);
-
-                if (e.PttState)
-                {
-                    e.txStreamId = handler.NewStreamId();
-
-                    Console.WriteLine("sending grant demand " + dstId);
-                    handler.SendP25TDU(srcId, dstId, true);
-                }
-                else
-                {
-                    Console.WriteLine("sending terminator " + dstId);
-                    handler.SendP25TDU(srcId, dstId, false);
-                }
-            }
-        }
-
-        private void ChannelBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
-        {
-            if (!isEditMode || !(sender is UIElement element)) return;
-
-            _draggedElement = element;
-            _startPoint = e.GetPosition(ChannelsCanvas);
-            _offsetX = _startPoint.X - Canvas.GetLeft(_draggedElement);
-            _offsetY = _startPoint.Y - Canvas.GetTop(_draggedElement);
-            _isDragging = true;
-
-            element.CaptureMouse();
-        }
-
-        private const int GridSize = 5;
-
-        private void ChannelBox_MouseMove(object sender, MouseEventArgs e)
-        {
-            if (!isEditMode || !_isDragging || _draggedElement == null) return;
-
-            Point currentPosition = e.GetPosition(ChannelsCanvas);
-
-            // Calculate the new position with snapping to the grid
-            double newLeft = Math.Round((currentPosition.X - _offsetX) / GridSize) * GridSize;
-            double newTop = Math.Round((currentPosition.Y - _offsetY) / GridSize) * GridSize;
-
-            // Ensure the box stays within canvas bounds
-            newLeft = Math.Max(0, Math.Min(newLeft, ChannelsCanvas.ActualWidth - _draggedElement.RenderSize.Width));
-            newTop = Math.Max(0, Math.Min(newTop, ChannelsCanvas.ActualHeight - _draggedElement.RenderSize.Height));
-
-            // Apply snapped position
-            Canvas.SetLeft(_draggedElement, newLeft);
-            Canvas.SetTop(_draggedElement, newTop);
-
-            // Save the new position if it's a ChannelBox
-            if (_draggedElement is ChannelBox channelBox)
-            {
-                _settingsManager.UpdateChannelPosition(channelBox.ChannelName, newLeft, newTop);
-            }
-
-            AdjustCanvasHeight();
-        }
-
-        private void ChannelBox_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
-        {
-            if (!isEditMode || !_isDragging || _draggedElement == null) return;
-
-            _isDragging = false;
-            _draggedElement.ReleaseMouseCapture();
-            _draggedElement = null;
-        }
-
-        private void SystemStatusBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) => ChannelBox_MouseLeftButtonDown(sender, e);
-        private void SystemStatusBox_MouseMove(object sender, MouseEventArgs e) => ChannelBox_MouseMove(sender, e);
-
-        private void SystemStatusBox_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
-        {
-            if (!isEditMode) return;
-
-            if (sender is SystemStatusBox systemStatusBox)
-            {
-                double x = Canvas.GetLeft(systemStatusBox);
-                double y = Canvas.GetTop(systemStatusBox);
-                _settingsManager.SystemStatusPositions[systemStatusBox.SystemName] = new ChannelPosition { X = x, Y = y };
-
-                ChannelBox_MouseRightButtonDown(sender, e);
-
-                AdjustCanvasHeight();
-            }
-        }
-
-        private void ToggleEditMode_Click(object sender, RoutedEventArgs e)
-        {
-            isEditMode = !isEditMode;
-            var menuItem = (MenuItem)sender;
-            menuItem.Header = isEditMode ? "Disable Edit Mode" : "Enable Edit Mode";
-            UpdateEditModeForWidgets();
-        }
-
-        private void UpdateEditModeForWidgets()
-        {
-            foreach (var child in ChannelsCanvas.Children)
-            {
-                if (child is AlertTone alertTone)
-                {
-                    alertTone.IsEditMode = isEditMode;
-                }
-
-                if (child is ChannelBox channelBox)
-                {
-                    channelBox.IsEditMode = isEditMode;
-                }
-            }
-        }
-
-        private void AddAlertTone_Click(object sender, RoutedEventArgs e)
-        {
-            OpenFileDialog openFileDialog = new OpenFileDialog
-            {
-                Filter = "WAV Files (*.wav)|*.wav|All Files (*.*)|*.*",
-                Title = "Select Alert Tone"
-            };
-
-            if (openFileDialog.ShowDialog() == true)
-            {
-                string alertFilePath = openFileDialog.FileName;
-                var alertTone = new AlertTone(alertFilePath)
-                {
-                    IsEditMode = isEditMode
-                };
-
-                alertTone.OnAlertTone += SendAlertTone;
-
-                if (_settingsManager.AlertTonePositions.TryGetValue(alertFilePath, out var position))
-                {
-                    Canvas.SetLeft(alertTone, position.X);
-                    Canvas.SetTop(alertTone, position.Y);
-                }
-                else
-                {
-                    Canvas.SetLeft(alertTone, 20);
-                    Canvas.SetTop(alertTone, 20);
-                }
-
-                alertTone.MouseRightButtonUp += AlertTone_MouseRightButtonUp;
-
-                ChannelsCanvas.Children.Add(alertTone);
-                _settingsManager.UpdateAlertTonePaths(alertFilePath);
-
-                AdjustCanvasHeight();
-            }
-        }
-
-        private void AlertTone_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
-        {
-            if (!isEditMode) return;
-
-            if (sender is AlertTone alertTone)
-            {
-                double x = Canvas.GetLeft(alertTone);
-                double y = Canvas.GetTop(alertTone);
-                _settingsManager.UpdateAlertTonePosition(alertTone.AlertFilePath, x, y);
-
-                AdjustCanvasHeight();
-            }
-        }
-
-        private void AdjustCanvasHeight()
-        {
-            double maxBottom = 0;
-
-            foreach (UIElement child in ChannelsCanvas.Children)
-            {
-                double childBottom = Canvas.GetTop(child) + child.RenderSize.Height;
-                if (childBottom > maxBottom)
-                {
-                    maxBottom = childBottom;
-                }
-            }
-
-            ChannelsCanvas.Height = maxBottom + 150;
-        }
-
-        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
-        {
-            if (!string.IsNullOrEmpty(_settingsManager.LastCodeplugPath) && File.Exists(_settingsManager.LastCodeplugPath))
-            {
-                LoadCodeplug(_settingsManager.LastCodeplugPath);
-            }
-            else
-            {
-                GenerateChannelWidgets();
-            }
-        }
-
-        private async void OnHoldTimerElapsed(object sender, ElapsedEventArgs e)
-        {
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (!system.IsDvm)
-                {
-
-                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                    if (channel.HoldState && !channel.IsReceiving && !channel.PttState && !channel.PageState)
-                    {
-                        //Task.Factory.StartNew(async () =>
-                        //{
-                        Console.WriteLine("Sending channel hold beep");
-
-                        Dispatcher.Invoke(() => { channel.PttButton.Background = channel.redGradient; });
-
-                        GRP_VCH_REQ req = new GRP_VCH_REQ
-                        {
-                            SrcId = system.Rid,
-                            DstId = cpgChannel.Tgid,
-                            Site = system.Site
-                        };
-
-                        handler.SendMessage(req.GetData());
-
-                        await Task.Delay(1000);
-
-                        SendAlertTone("hold.wav", true);
-                        // });
-                    }
-                } else
-                {
-                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                    if (channel.HoldState && !channel.IsReceiving && !channel.PttState && !channel.PageState)
-                    {
-                        handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
-                        await Task.Delay(1000);
-
-                        SendAlertTone("hold.wav", true);
-                    }
-                }
-            }
-        }
-
-        protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
-        {
-            _settingsManager.SaveSettings();
-            base.OnClosing(e);
-            Application.Current.Shutdown();
-        }
-
-        private void ClearEmergency_Click(object sender, RoutedEventArgs e)
-        {
-            _emergencyAlertPlayback.Stop();
-            _flashingManager.Stop();
-
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                channel.Emergency = false;
-            }
-        }
-
-        private void btnAlert1_Click(object sender, RoutedEventArgs e)
-        {
-            Dispatcher.Invoke(() => {
-                SendAlertTone("alert1.wav");
-            });
-        }
-
-        private void btnAlert2_Click(object sender, RoutedEventArgs e)
-        {
-            Dispatcher.Invoke(() =>
-            {
-                SendAlertTone("alert2.wav");
-            });
-        }
-
-        private void btnAlert3_Click(object sender, RoutedEventArgs e)
-        {
-            Dispatcher.Invoke(() =>
-            {
-                SendAlertTone("alert3.wav");
-            });
-        }
-
-        private async void btnGlobalPtt_Click(object sender, RoutedEventArgs e)
-        {
-            if (globalPttState)
-                await Task.Delay(500);
-
-            globalPttState = !globalPttState;
-
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (!system.IsDvm)
-                {
-                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                    if (!channel.IsSelected)
-                        continue;
-
-                    if (globalPttState)
-                    {
-                        Dispatcher.Invoke(() =>
-                        {
-                            btnGlobalPtt.Background = channel.redGradient;
-                        });
-
-
-                        GRP_VCH_REQ request = new GRP_VCH_REQ
-                        {
-                            SrcId = system.Rid,
-                            DstId = cpgChannel.Tgid,
-                            Site = system.Site
-                        };
-
-                        channel.PttState = true;
-
-                        handler.SendMessage(request.GetData());
-                    }
-                    else
-                    {
-                        Dispatcher.Invoke(() =>
-                        {
-                            btnGlobalPtt.Background = channel.grayGradient;
-                        });
-
-                        GRP_VCH_RLS release = new GRP_VCH_RLS
-                        {
-                            SrcId = system.Rid,
-                            DstId = cpgChannel.Tgid,
-                            Site = system.Site
-                        };
-
-                        channel.PttState = false;
-
-                        handler.SendMessage(release.GetData());
-                    }
-                } else
-                {
-                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                    channel.txStreamId = handler.NewStreamId();
-
-                    if (globalPttState)
-                    {
-                        Dispatcher.Invoke(() =>
-                        {
-                            btnGlobalPtt.Background = channel.redGradient;
-                            channel.PttState = true;
-                        });
-
-                        handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
-                    }
-                    else
-                    {
-                        Dispatcher.Invoke(() =>
-                        {
-                            btnGlobalPtt.Background = channel.grayGradient;
-                            channel.PttState = false;
-                        });
-
-                        handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
-                    }
-                }
-            }
-        }
-
-        private void Button_Click(object sender, RoutedEventArgs e) { /* sub */ }
-
-        private void SelectAll_Click(object sender, RoutedEventArgs e)
-        {
-            foreach (ChannelBox channel in ChannelsCanvas.Children.OfType<ChannelBox>())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (!channel.IsSelected)
-                {
-                    channel.IsSelected = true;
-
-                    channel.Background = channel.IsSelected ? (Brush)new BrushConverter().ConvertFrom("#FF0B004B") : Brushes.Gray;
-
-                    if (channel.IsSelected)
-                    {
-                        _selectedChannelsManager.AddSelectedChannel(channel);
-                    }
-                    else
-                    {
-                        _selectedChannelsManager.RemoveSelectedChannel(channel);
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// Helper to encode and transmit PCM audio as P25 IMBE frames.
-        /// </summary>
-        private void P25EncodeAudioFrame(byte[] pcm, PeerSystem handler, ChannelBox channel, Codeplug.Channel cpgChannel, Codeplug.System system)
-        {
-            bool encryptCall = true; // TODO: make this dynamic somewhere?
-
-            if (channel.p25N > 17)
-                channel.p25N = 0;
-            if (channel.p25N == 0)
-                FneUtils.Memset(channel.netLDU1, 0, 9 * 25);
-            if (channel.p25N == 9)
-                FneUtils.Memset(channel.netLDU2, 0, 9 * 25);
-
-            // Log.Logger.Debug($"BYTE BUFFER {FneUtils.HexDump(pcm)}");
-
-            //// pre-process: apply gain to PCM audio frames
-            //if (Program.Configuration.TxAudioGain != 1.0f)
-            //{
-            //    BufferedWaveProvider buffer = new BufferedWaveProvider(waveFormat);
-            //    buffer.AddSamples(pcm, 0, pcm.Length);
-
-            //    VolumeWaveProvider16 gainControl = new VolumeWaveProvider16(buffer);
-            //    gainControl.Volume = Program.Configuration.TxAudioGain;
-            //    gainControl.Read(pcm, 0, pcm.Length);
-            //}
-
-            int smpIdx = 0;
-            short[] samples = new short[FneSystemBase.MBE_SAMPLES_LENGTH];
-            for (int pcmIdx = 0; pcmIdx < pcm.Length; pcmIdx += 2)
-            {
-                samples[smpIdx] = (short)((pcm[pcmIdx + 1] << 8) + pcm[pcmIdx + 0]);
-                smpIdx++;
-            }
-
-            // Convert to floats
-            float[] fSamples = AudioConverter.PcmToFloat(samples);
-
-            // Convert to signal
-            DiscreteSignal signal = new DiscreteSignal(8000, fSamples, true);
-
-            // Log.Logger.Debug($"SAMPLE BUFFER {FneUtils.HexDump(samples)}");
-
-            // encode PCM samples into IMBE codewords
-            byte[] imbe = new byte[FneSystemBase.IMBE_BUF_LEN];
-
-
-            int tone = 0;
-
-            if (true) // TODO: Disable/enable detection
-            {
-                tone = channel.toneDetector.Detect(signal);
-            }
-            if (tone > 0)
-            {
-                MBEToneGenerator.IMBEEncodeSingleTone((ushort)tone, imbe);
-                Console.WriteLine($"({system.Name}) P25D: {tone} HZ TONE DETECT");
-            }
-            else
-            {
-#if WIN32
-                if (channel.extFullRateVocoder == null)
-                    channel.extFullRateVocoder = new AmbeVocoder(true);
-
-                channel.extFullRateVocoder.encode(samples, out imbe);
-#else
-                if (channel.encoder == null)
-                    channel.encoder = new MBEEncoder(MBE_MODE.IMBE_88BIT);
-
-                channel.encoder.encode(samples, imbe);
-#endif
-            }
-            // Log.Logger.Debug($"IMBE {FneUtils.HexDump(imbe)}");
-
-            if (encryptCall && cpgChannel.GetAlgoId() != 0 && cpgChannel.GetKeyId() != 0)
-            {
-                // initial HDU MI
-                if (channel.p25N == 0)
-                {
-                    if (channel.mi.All(b => b == 0))
-                    {
-                        Random random = new Random();
-
-                        for (int i = 0; i < P25Defines.P25_MI_LENGTH; i++)
-                        {
-                            channel.mi[i] = (byte)random.Next(0x00, 0x100);
-                        }
-                    }
-
-                    channel.crypter.Prepare(cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), ProtocolType.P25Phase1, channel.mi);
-                }
-
-                // crypto time
-                channel.crypter.Process(imbe, channel.p25N < 9U ? P25Crypto.FrameType.LDU1 : P25Crypto.FrameType.LDU2, 0);
-
-                // last block of LDU2, prepare a new MI
-                if (channel.p25N == 17U)
-                {
-                    P25Crypto.CycleP25Lfsr(channel.mi);
-                    channel.crypter.Prepare(cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), ProtocolType.P25Phase1, channel.mi);
-                }
-            }
-
-            // fill the LDU buffers appropriately
-            switch (channel.p25N)
-            {
-                // LDU1
-                case 0:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 10, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 1:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 26, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 2:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 55, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 3:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 80, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 4:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 105, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 5:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 130, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 6:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 155, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 7:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 180, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 8:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 204, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-
-                // LDU2
-                case 9:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 10, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 10:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 26, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 11:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 55, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 12:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 80, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 13:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 105, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 14:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 130, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 15:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 155, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 16:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 180, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 17:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 204, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-            }
-
-            uint srcId = UInt32.Parse(system.Rid);
-            uint dstId = UInt32.Parse(cpgChannel.Tgid);
-
-            FnePeer peer = handler.peer;
-            RemoteCallData callData = new RemoteCallData()
-            {
-                SrcId = srcId,
-                DstId = dstId,
-                LCO = P25Defines.LC_GROUP
-            };
-
-            // send P25 LDU1
-            if (channel.p25N == 8U)
-            {
-                ushort pktSeq = 0;
-                if (channel.p25SeqNo == 0U)
-                    pktSeq = peer.pktSeq(true);
-                else
-                    pktSeq = peer.pktSeq();
-
-                //Console.WriteLine($"({channel.SystemName}) P25D: Traffic *VOICE FRAME    * PEER {handler.PeerId} SRC_ID {srcId} TGID {dstId} [STREAM ID {channel.txStreamId}]");
-
-                byte[] payload = new byte[200];
-                handler.CreateNewP25MessageHdr((byte)P25DUID.LDU1, callData, ref payload, cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), channel.mi);
-                handler.CreateP25LDU1Message(channel.netLDU1, ref payload, srcId, dstId);
-
-                peer.SendMaster(new Tuple<byte, byte>(Constants.NET_FUNC_PROTOCOL, Constants.NET_PROTOCOL_SUBFUNC_P25), payload, pktSeq, channel.txStreamId);
-            }
-
-            // send P25 LDU2
-            if (channel.p25N == 17U)
-            {
-                ushort pktSeq = 0;
-                if (channel.p25SeqNo == 0U)
-                    pktSeq = peer.pktSeq(true);
-                else
-                    pktSeq = peer.pktSeq();
-
-                //Console.WriteLine($"({channel.SystemName}) P25D: Traffic *VOICE FRAME    * PEER {handler.PeerId} SRC_ID {srcId} TGID {dstId} [STREAM ID {channel.txStreamId}]");
-
-                byte[] payload = new byte[200];
-                handler.CreateNewP25MessageHdr((byte)P25DUID.LDU2, callData, ref payload, cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), channel.mi);
-                handler.CreateP25LDU2Message(channel.netLDU2, ref payload, new CryptoParams { AlgId = cpgChannel.GetAlgoId(), KeyId = cpgChannel.GetKeyId(), Mi = channel.mi });
-
-                peer.SendMaster(new Tuple<byte, byte>(Constants.NET_FUNC_PROTOCOL, Constants.NET_PROTOCOL_SUBFUNC_P25), payload, pktSeq, channel.txStreamId);
-            }
-
-            channel.p25SeqNo++;
-            channel.p25N++;
-        }
-
-        /// <summary>
-        /// Helper to decode and playback P25 IMBE frames as PCM audio.
-        /// </summary>
-        /// <param name="ldu"></param>
-        /// <param name="e"></param>
-        private void P25DecodeAudioFrame(byte[] ldu, P25DataReceivedEvent e, PeerSystem system, ChannelBox channel, bool emergency = false, P25Crypto.FrameType frameType = P25Crypto.FrameType.LDU1)
-        {
-            try
-            {
-                // decode 9 IMBE codewords into PCM samples
-                for (int n = 0; n < 9; n++)
-                {
-                    byte[] imbe = new byte[FneSystemBase.IMBE_BUF_LEN];
-                    switch (n)
-                    {
-                        case 0:
-                            Buffer.BlockCopy(ldu, 10, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 1:
-                            Buffer.BlockCopy(ldu, 26, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 2:
-                            Buffer.BlockCopy(ldu, 55, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 3:
-                            Buffer.BlockCopy(ldu, 80, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 4:
-                            Buffer.BlockCopy(ldu, 105, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 5:
-                            Buffer.BlockCopy(ldu, 130, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 6:
-                            Buffer.BlockCopy(ldu, 155, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 7:
-                            Buffer.BlockCopy(ldu, 180, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 8:
-                            Buffer.BlockCopy(ldu, 204, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                    }
-
-                    //Log.Logger.Debug($"Decoding IMBE buffer: {FneUtils.HexDump(imbe)}");
-
-                    short[] samples = new short[FneSystemBase.MBE_SAMPLES_LENGTH];
-
-                    channel.crypter.Process(imbe, frameType, n);
-
-#if WIN32
-                    if (channel.extFullRateVocoder == null)
-                        channel.extFullRateVocoder = new AmbeVocoder(true);
-
-                    channel.p25Errs = channel.extFullRateVocoder.decode(imbe, out samples);
-#else
-
-                    channel.p25Errs = channel.decoder.decode(imbe, samples);
-#endif
-
-                    if (emergency)
-                    {
-                        if (!channel.Emergency)
-                        {
-                            Task.Run(() =>
-                            {
-                                HandleEmergencyAlarmResponse(new EMRG_ALRM_RSP
-                                {
-                                    SrcId = e.SrcId.ToString(),
-                                    DstId = e.DstId.ToString()
-                                });
-                            });
-                        }
-                    }
-
-                    if (samples != null)
-                    {
-                        //Log.Logger.Debug($"({Config.Name}) P25D: Traffic *VOICE FRAME    * PEER {e.PeerId} SRC_ID {e.SrcId} TGID {e.DstId} VC{n} ERRS {errs} [STREAM ID {e.StreamId}]");
-                        //Log.Logger.Debug($"IMBE {FneUtils.HexDump(imbe)}");
-                        //Console.WriteLine($"SAMPLE BUFFER {FneUtils.HexDump(samples)}");
-
-                        int pcmIdx = 0;
-                        byte[] pcmData = new byte[samples.Length * 2];
-                        for (int i = 0; i < samples.Length; i++)
-                        {
-                            pcmData[pcmIdx] = (byte)(samples[i] & 0xFF);
-                            pcmData[pcmIdx + 1] = (byte)((samples[i] >> 8) & 0xFF);
-                            pcmIdx += 2;
-                        }
-
-                        _audioManager.AddTalkgroupStream(e.DstId.ToString(), pcmData);
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"Audio Decode Exception: {ex.Message}");
-            }
-        }
-
-        private uint GetUniqueRid(string ridString)
-        {
-            uint rid;
-
-            // Try to parse the RID, default to 1000 if parsing fails
-            if (!UInt32.TryParse(ridString, out rid))
-            {
-                rid = 1000;
-            }
-
-            // Ensure uniqueness by incrementing if needed
-            while (usedRids.Contains(rid))
-            {
-                rid++;
-            }
-
-            // Store the new unique RID
-            usedRids.Add(rid);
-
-            return rid;
-        }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="e"></param>
-        public void KeyResponseReceived(KeyResponseEvent e)
-        {
-            //Console.WriteLine($"Message ID: {e.KmmKey.MessageId}");
-            //Console.WriteLine($"Decrypt Info Format: {e.KmmKey.DecryptInfoFmt}");
-            //Console.WriteLine($"Algorithm ID: {e.KmmKey.AlgId}");
-            //Console.WriteLine($"Key ID: {e.KmmKey.KeyId}");
-            //Console.WriteLine($"Keyset ID: {e.KmmKey.KeysetItem.KeysetId}");
-            //Console.WriteLine($"Keyset Alg ID: {e.KmmKey.KeysetItem.AlgId}");
-            //Console.WriteLine($"Keyset Key Length: {e.KmmKey.KeysetItem.KeyLength}");
-            //Console.WriteLine($"Number of Keys: {e.KmmKey.KeysetItem.Keys.Count}");
-
-            foreach (var key in e.KmmKey.KeysetItem.Keys)
-            {
-                //Console.WriteLine($"  Key Format: {key.KeyFormat}");
-                //Console.WriteLine($"  SLN: {key.Sln}");
-                //Console.WriteLine($"  Key ID: {key.KeyId}");
-                //Console.WriteLine($"  Key Data: {BitConverter.ToString(key.GetKey())}");
-
-                Dispatcher.Invoke(() =>
-                {
-                    foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-                    {
-                        Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                        Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                        if (!system.IsDvm)
-                            continue;
-
-                        PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                        if (cpgChannel.GetKeyId() != 0 && cpgChannel.GetAlgoId() != 0)
-                            channel.crypter.AddKey(key.KeyId, e.KmmKey.KeysetItem.AlgId, key.GetKey());
-                    }
-                });
-            }
-        }
-
-        private void KeyStatus_Click(object sender, RoutedEventArgs e)
-        {
-            KeyStatusWindow keyStatus = new KeyStatusWindow(Codeplug, this);
-            keyStatus.Show();
-        }
-
-        /// <summary>
-        /// Event handler used to process incoming P25 data.
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        public void P25DataReceived(P25DataReceivedEvent e, DateTime pktTime)
-        {
-            uint sysId = (uint)((e.Data[11U] << 8) | (e.Data[12U] << 0));
-            uint netId = FneUtils.Bytes3ToUInt32(e.Data, 16);
-            byte control = e.Data[14U];
-
-            byte len = e.Data[23];
-            byte[] data = new byte[len];
-            for (int i = 24; i < len; i++)
-                data[i - 24] = e.Data[i];
-
-            Dispatcher.Invoke(() =>
-            {
-                foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-                {
-                    Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                    Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                    bool isEmergency = false;
-                    bool encrypted = false;
-
-                    if (!system.IsDvm)
-                        continue;
-
-                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                    if (!channel.IsEnabled)
-                        continue;
-
-                    if (cpgChannel.Tgid != e.DstId.ToString())
-                        continue;
-
-                    if (!systemStatuses.ContainsKey(cpgChannel.Name))
-                    {
-                        systemStatuses[cpgChannel.Name] = new SlotStatus();
-                    }
-
-                    if (channel.decoder == null)
-                    {
-                        channel.decoder = new MBEDecoder(MBE_MODE.IMBE_88BIT);
-                    }
-
-                    SlotStatus slot = systemStatuses[cpgChannel.Name];
-
-                    // if this is an LDU1 see if this is the first LDU with HDU encryption data
-                    if (e.DUID == P25DUID.LDU1)
-                    {
-                        byte frameType = e.Data[180];
-
-                        // get the initial MI and other enc info (bug found by the screeeeeeeeech on initial tx...)
-                        if (frameType == P25Defines.P25_FT_HDU_VALID)
-                        {
-                            channel.algId = e.Data[181];
-                            channel.kId = (ushort)((e.Data[182] << 8) | e.Data[183]);
-                            Array.Copy(e.Data, 184, channel.mi, 0, P25Defines.P25_MI_LENGTH);
-
-                            channel.crypter.Prepare(channel.algId, channel.kId, P25Crypto.ProtocolType.P25Phase1, channel.mi);
-
-                            encrypted = true;
-                        }
-                    }
-
-                    // is this a new call stream?
-                    if (e.StreamId != slot.RxStreamId && ((e.DUID != P25DUID.TDU) && (e.DUID != P25DUID.TDULC)))
-                    {
-                        channel.IsReceiving = true;
-                        slot.RxStart = pktTime;
-                        Console.WriteLine($"({system.Name}) P25D: Traffic *CALL START     * PEER {e.PeerId} SRC_ID {e.SrcId} TGID {e.DstId} [STREAM ID {e.StreamId}]");
-
-                        FneUtils.Memset(channel.mi, 0x00, P25Defines.P25_MI_LENGTH);
-
-                        callHistoryWindow.AddCall(cpgChannel.Name, (int)e.SrcId, (int)e.DstId);
-                        callHistoryWindow.ChannelKeyed(cpgChannel.Name, (int)e.SrcId, encrypted);
-
-                        string alias = string.Empty;
-
-                        try
-                        {
-                            alias = AliasTools.GetAliasByRid(system.RidAlias, (int)e.SrcId);
-                        }
-                        catch (Exception) { }
-
-                        if (alias.IsNullOrEmpty())
-                            channel.LastSrcId = "Last SRC: " + e.SrcId;
-                        else
-                            channel.LastSrcId = "Last: " + alias;
-
-                        if (channel.algId != P25Defines.P25_ALGO_UNENCRYPT)
-                            channel.Background = (Brush)new BrushConverter().ConvertFrom("#ffdeaf0a");
-                        else
-                            channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
-                    }
-
-                    // Is the call over?
-                    if (((e.DUID == P25DUID.TDU) || (e.DUID == P25DUID.TDULC)) && (slot.RxType != fnecore.FrameType.TERMINATOR))
-                    {
-                        channel.IsReceiving = false;
-                        TimeSpan callDuration = pktTime - slot.RxStart;
-                        Console.WriteLine($"({system.Name}) P25D: Traffic *CALL END       * PEER {e.PeerId} SRC_ID {e.SrcId} TGID {e.DstId} DUR {callDuration} [STREAM ID {e.StreamId}]");
-                        channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF0B004B");
-                        callHistoryWindow.ChannelUnkeyed(cpgChannel.Name, (int)e.SrcId);
-                        return;
-                    }
-
-                    if ((channel.algId != cpgChannel.GetAlgoId() || channel.kId != cpgChannel.GetKeyId()) && channel.algId != P25Defines.P25_ALGO_UNENCRYPT)
-                        continue;
-
-                    byte[] newMI = new byte[P25Defines.P25_MI_LENGTH];
-
-                    int count = 0;
-
-                    switch (e.DUID)
-                    {
-                        case P25DUID.LDU1:
-                            {
-                                // The '62', '63', '64', '65', '66', '67', '68', '69', '6A' records are LDU1
-                                if ((data[0U] == 0x62U) && (data[22U] == 0x63U) &&
-                                    (data[36U] == 0x64U) && (data[53U] == 0x65U) &&
-                                    (data[70U] == 0x66U) && (data[87U] == 0x67U) &&
-                                    (data[104U] == 0x68U) && (data[121U] == 0x69U) &&
-                                    (data[138U] == 0x6AU))
-                                {
-                                    // The '62' record - IMBE Voice 1
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 0, 22);
-                                    count += 22;
-
-                                    // The '63' record - IMBE Voice 2
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 25, 14);
-                                    count += 14;
-
-                                    // The '64' record - IMBE Voice 3 + Link Control
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 50, 17);
-                                    byte serviceOptions = data[count + 3];
-                                    isEmergency = (serviceOptions & 0x80) == 0x80;
-                                    count += 17;
-
-                                    // The '65' record - IMBE Voice 4 + Link Control
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 75, 17);
-                                    count += 17;
-
-                                    // The '66' record - IMBE Voice 5 + Link Control
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 100, 17);
-                                    count += 17;
-
-                                    // The '67' record - IMBE Voice 6 + Link Control
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 125, 17);
-                                    count += 17;
-
-                                    // The '68' record - IMBE Voice 7 + Link Control
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 150, 17);
-                                    count += 17;
-
-                                    // The '69' record - IMBE Voice 8 + Link Control
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 175, 17);
-                                    count += 17;
-
-                                    // The '6A' record - IMBE Voice 9 + Low Speed Data
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 200, 16);
-                                    count += 16;
-
-                                    // decode 9 IMBE codewords into PCM samples
-                                    P25DecodeAudioFrame(channel.netLDU1, e, handler, channel, isEmergency);
-                                }
-                            }
-                            break;
-                        case P25DUID.LDU2:
-                            {
-                                // The '6B', '6C', '6D', '6E', '6F', '70', '71', '72', '73' records are LDU2
-                                if ((data[0U] == 0x6BU) && (data[22U] == 0x6CU) &&
-                                    (data[36U] == 0x6DU) && (data[53U] == 0x6EU) &&
-                                    (data[70U] == 0x6FU) && (data[87U] == 0x70U) &&
-                                    (data[104U] == 0x71U) && (data[121U] == 0x72U) &&
-                                    (data[138U] == 0x73U))
-                                {
-                                    // The '6B' record - IMBE Voice 10
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 0, 22);
-                                    count += 22;
-
-                                    // The '6C' record - IMBE Voice 11
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 25, 14);
-                                    count += 14;
-
-                                    // The '6D' record - IMBE Voice 12 + Encryption Sync
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 50, 17);
-                                    newMI[0] = data[count + 1];
-                                    newMI[1] = data[count + 2];
-                                    newMI[2] = data[count + 3];
-                                    count += 17;
-
-                                    // The '6E' record - IMBE Voice 13 + Encryption Sync
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 75, 17);
-                                    newMI[3] = data[count + 1];
-                                    newMI[4] = data[count + 2];
-                                    newMI[5] = data[count + 3];
-                                    count += 17;
-
-                                    // The '6F' record - IMBE Voice 14 + Encryption Sync
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 100, 17);
-                                    newMI[6] = data[count + 1];
-                                    newMI[7] = data[count + 2];
-                                    newMI[8] = data[count + 3];
-                                    count += 17;
-
-                                    // The '70' record - IMBE Voice 15 + Encryption Sync
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 125, 17);
-                                    channel.algId = data[count + 1];                                    // Algorithm ID
-                                    channel.kId = (ushort)((data[count + 2] << 8) | data[count + 3]);   // Key ID
-                                    count += 17;
-
-                                    // The '71' record - IMBE Voice 16 + Encryption Sync
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 150, 17);
-                                    count += 17;
-
-                                    // The '72' record - IMBE Voice 17 + Encryption Sync
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 175, 17);
-                                    count += 17;
-
-                                    // The '73' record - IMBE Voice 18 + Low Speed Data
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 200, 16);
-                                    count += 16;
-
-                                    if (channel.p25Errs > 0) // temp, need to actually get errors I guess
-                                        P25Crypto.CycleP25Lfsr(channel.mi);
-                                    else
-                                        Array.Copy(newMI, channel.mi, P25Defines.P25_MI_LENGTH);
-
-                                    // decode 9 IMBE codewords into PCM samples
-                                    P25DecodeAudioFrame(channel.netLDU2, e, handler, channel, isEmergency, P25Crypto.FrameType.LDU2);
-                                }
-                            }
-                            break;
-                    }
-
-                    if (channel.mi != null)
-                        channel.crypter.Prepare(channel.algId, channel.kId, P25Crypto.ProtocolType.P25Phase1, channel.mi);
-
-                    slot.RxRFS = e.SrcId;
-                    slot.RxType = e.FrameType;
-                    slot.RxTGId = e.DstId;
-                    slot.RxTime = pktTime;
-                    slot.RxStreamId = e.StreamId;
-
-                }
-            });
-        }
-
-        private void CallHist_Click(object sender, RoutedEventArgs e)
-        {
-            callHistoryWindow.Show();
-        }
-    }
-}
+/*
+* WhackerLink - WhackerLinkConsoleV2
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* 
+* Copyright (C) 2024-2025 Caleb, K4PHP
+* Copyright (C) 2025 J. Dean
+* Copyright (C) 2025 Firav (firavdev@gmail.com)
+* 
+*/
+
+using Microsoft.Win32;
+using System;
+using System.Timers;
+using System.IO;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using WhackerLinkLib.Models.Radio;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+using WhackerLinkConsoleV2.Controls;
+using WebSocketManager = WhackerLinkLib.Managers.WebSocketManager;
+using System.Windows.Media;
+using WhackerLinkLib.Utils;
+using WhackerLinkLib.Models;
+using System.Net;
+using NAudio.Wave;
+using WhackerLinkLib.Interfaces;
+using WhackerLinkLib.Models.IOSP;
+using fnecore.P25;
+using fnecore;
+using Microsoft.VisualBasic;
+using System.Text;
+using Constants = fnecore.Constants;
+using System.Security.Cryptography;
+using fnecore.P25.LC.TSBK;
+using WebSocketSharp;
+using NWaves.Signals;
+using static WhackerLinkConsoleV2.P25Crypto;
+using static WhackerLinkLib.Models.Radio.Codeplug;
+
+namespace WhackerLinkConsoleV2
+{
+    public partial class MainWindow : Window
+    {
+        public Codeplug Codeplug { get; set; }
+        private bool isEditMode = false;
+
+        private bool globalPttState = false;
+
+        private UIElement _draggedElement;
+        private Point _startPoint;
+        private double _offsetX;
+        private double _offsetY;
+        private bool _isDragging;
+
+        private SettingsManager _settingsManager = new SettingsManager();
+        private SelectedChannelsManager _selectedChannelsManager;
+        private FlashingBackgroundManager _flashingManager;
+        private WaveFilePlaybackManager _emergencyAlertPlayback;
+        private WebSocketManager _webSocketManager = new WebSocketManager();
+        private ChannelKeybindingManager _channelKeybindingManager = new ChannelKeybindingManager();
+        private GlobalHotKeyManager _globalHotKeyManager;
+        private ChannelHotKeyManager _channelHotKeyManager;
+        private int _globalPttHotKeyId = -1;
+        private string _currentCodeplugIdentifier;
+
+        private ChannelBox playbackChannelBox;
+
+        CallHistoryWindow callHistoryWindow = new CallHistoryWindow();
+
+        public static string PLAYBACKTG = "LOCPLAYBACK";
+        public static string PLAYBACKSYS = "LOCPLAYBACKSYS";
+        public static string PLAYBACKCHNAME = "PLAYBACK";
+
+        private readonly WaveInEvent _waveIn;
+        private readonly AudioManager _audioManager;
+
+        private System.Timers.Timer _channelHoldTimer;
+
+        private Dictionary<string, SlotStatus> systemStatuses = new Dictionary<string, SlotStatus>();
+        private FneSystemManager _fneSystemManager = new FneSystemManager();
+
+        private bool cryptodev = true;
+
+        private static HashSet<uint> usedRids = new HashSet<uint>();
+
+        List<Tuple<uint, uint>> fneAffs = new List<Tuple<uint, uint>>();
+
+        public MainWindow()
+        {
+            // Check command-line arguments for console flag
+            var args = Environment.GetCommandLineArgs();
+            bool showConsole = args.Any(arg => arg.Equals("--console", StringComparison.OrdinalIgnoreCase) || 
+                                               arg.Equals("-console", StringComparison.OrdinalIgnoreCase) ||
+                                               arg.Equals("/console", StringComparison.OrdinalIgnoreCase));
+
+#if DEBUG
+            showConsole = true; // Always show console in debug builds
+#endif
+
+            if (showConsole)
+            {
+                ConsoleNative.ShowConsole();
+            }
+
+            InitializeComponent();
+            _settingsManager.LoadSettings();
+            _channelKeybindingManager.LoadKeybindings();
+            _selectedChannelsManager = new SelectedChannelsManager();
+            _flashingManager = new FlashingBackgroundManager(null, ChannelsCanvas, null, this);
+            _emergencyAlertPlayback = new WaveFilePlaybackManager(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "emergency.wav"));
+
+            _channelHoldTimer = new System.Timers.Timer(10000);
+            _channelHoldTimer.Elapsed += OnHoldTimerElapsed;
+            _channelHoldTimer.AutoReset = true;
+            _channelHoldTimer.Enabled = true;
+
+            _waveIn = new WaveInEvent
+            {
+                WaveFormat = new WaveFormat(8000, 16, 1)
+            };
+            _waveIn.DataAvailable += WaveIn_DataAvailable;
+            _waveIn.RecordingStopped += WaveIn_RecordingStopped;
+
+            _waveIn.StartRecording();
+
+            _audioManager = new AudioManager(_settingsManager);
+
+            _selectedChannelsManager.SelectedChannelsChanged += SelectedChannelsChanged;
+            Loaded += MainWindow_Loaded;
+            Loaded += (s, e) => InitializeGlobalHotkeys();
+        }
+
+        private void OpenCodeplug_Click(object sender, RoutedEventArgs e)
+        {
+            OpenFileDialog openFileDialog = new OpenFileDialog
+            {
+                Filter = "Codeplug Files (*.yml)|*.yml|All Files (*.*)|*.*",
+                Title = "Open Codeplug"
+            };
+            if (openFileDialog.ShowDialog() == true)
+            {
+                LoadCodeplug(openFileDialog.FileName);
+
+                _settingsManager.LastCodeplugPath = openFileDialog.FileName;
+                _settingsManager.SaveSettings();
+            }
+        }
+
+        private void ResetSettings_Click(object sender, RoutedEventArgs e)
+        {
+            if (File.Exists("UserSettings.json"))
+                File.Delete("UserSettings.json");
+        }
+
+        private void LoadCodeplug(string filePath)
+        {
+            try
+            {
+                var deserializer = new DeserializerBuilder()
+                    .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                    .IgnoreUnmatchedProperties()
+                    .Build();
+
+                var yaml = File.ReadAllText(filePath);
+                Codeplug = deserializer.Deserialize<Codeplug>(yaml);
+
+                GenerateChannelWidgets();
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show($"Error loading codeplug: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+            }
+        }
+
+        private void GenerateChannelWidgets()
+        {
+            ChannelsCanvas.Children.Clear();
+            double offsetX = 20;
+            double offsetY = 20;
+
+            if (Codeplug != null)
+            {
+                foreach (var system in Codeplug.Systems)
+                {
+                    var systemStatusBox = new SystemStatusBox(system.Name, system.Address, system.Port);
+
+                    if (_settingsManager.SystemStatusPositions.TryGetValue(system.Name, out var position))
+                    {
+                        Canvas.SetLeft(systemStatusBox, position.X);
+                        Canvas.SetTop(systemStatusBox, position.Y);
+                    }
+                    else
+                    {
+                        Canvas.SetLeft(systemStatusBox, offsetX);
+                        Canvas.SetTop(systemStatusBox, offsetY);
+                    }
+
+                    systemStatusBox.MouseLeftButtonDown += SystemStatusBox_MouseLeftButtonDown;
+                    systemStatusBox.MouseMove += SystemStatusBox_MouseMove;
+                    systemStatusBox.MouseRightButtonDown += SystemStatusBox_MouseRightButtonDown;
+
+                    ChannelsCanvas.Children.Add(systemStatusBox);
+
+                    offsetX += 225;
+                    if (offsetX + 220 > ChannelsCanvas.ActualWidth)
+                    {
+                        offsetX = 20;
+                        offsetY += 106;
+                    }
+
+                    if (File.Exists(system.AliasPath))
+                        system.RidAlias = AliasTools.LoadAliases(system.AliasPath);
+
+                    if (!system.IsDvm)
+                    {
+                        _webSocketManager.AddWebSocketHandler(system.Name);
+
+                        IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+                        handler.OnVoiceChannelResponse += HandleVoiceResponse;
+                        handler.OnVoiceChannelRelease += HandleVoiceRelease;
+                        handler.OnEmergencyAlarmResponse += HandleEmergencyAlarmResponse;
+                        handler.OnAudioData += HandleReceivedAudio;
+                        handler.OnAffiliationUpdate += HandleAffiliationUpdate;
+                        handler.OnCallAlert += HandleCallAlert;
+
+                        handler.OnUnitRegistrationResponse += (response) =>
+                        {
+                            Dispatcher.Invoke(() =>
+                            {
+                                if (response.Status == (int)ResponseType.GRANT)
+                                {
+                                    systemStatusBox.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
+                                    systemStatusBox.ConnectionState = "Connected";
+
+                                    foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+                                    {
+                                        if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                                            continue;
+
+                                        Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                                        Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                                        if (!system.IsDvm)
+                                        {
+                                            IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                                            if (channel.IsSelected && handler.IsConnected)
+                                            {
+                                                Console.WriteLine("sending WLINK master aff");
+
+                                                Task.Run(() =>
+                                                {
+                                                    GRP_AFF_REQ release = new GRP_AFF_REQ
+                                                    {
+                                                        SrcId = system.Rid,
+                                                        DstId = cpgChannel.Tgid,
+                                                        Site = system.Site
+                                                    };
+
+                                                    handler.SendMessage(release.GetData());
+                                                });
+                                            }
+                                        }
+                                    }
+                                }
+                                else
+                                {
+                                    systemStatusBox.Background = new SolidColorBrush(Colors.Red);
+                                    systemStatusBox.ConnectionState = "Disconnected";
+                                }
+                            });
+                        };
+
+                        handler.OnClose += () =>
+                        {
+                            Dispatcher.Invoke(() =>
+                            {
+                                systemStatusBox.Background = new SolidColorBrush(Colors.Red);
+                                systemStatusBox.ConnectionState = "Disconnected";
+                            });
+                        };
+
+                        handler.OnOpen += () =>
+                        {
+                            Console.WriteLine("Peer connected");
+                            U_REG_REQ release = new U_REG_REQ
+                            {
+                                SrcId = system.Rid,
+                                Site = system.Site
+                            };
+
+                            handler.SendMessage(release.GetData());
+                        };
+
+                        handler.OnReconnecting += () =>
+                        {
+                            Console.WriteLine("Peer reconnecting");
+                        };
+
+                        Task.Run(() =>
+                        {
+                            handler.Connect(system.Address, system.Port, system.AuthKey);
+
+                            handler.OnGroupAffiliationResponse += (response) => { /* TODO */ };
+
+                            if (!handler.IsConnected)
+                            {
+                                systemStatusBox.Background = new SolidColorBrush(Colors.Red);
+                                systemStatusBox.ConnectionState = "Disconnected";
+                            }
+                        });
+                    } else
+                    {
+                        _fneSystemManager.AddFneSystem(system.Name, system, this);
+
+                        PeerSystem peer = _fneSystemManager.GetFneSystem(system.Name);
+
+                        peer.peer.PeerConnected += (sender, response) =>
+                        {
+                            Console.WriteLine("FNE Peer connected");
+
+                            Dispatcher.Invoke(() =>
+                            {
+                                systemStatusBox.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
+                                systemStatusBox.ConnectionState = "Connected";
+                            });
+                        };
+
+
+                        peer.peer.PeerDisconnected += (response) =>
+                        {
+                            Console.WriteLine("FNE Peer disconnected");
+
+                            Dispatcher.Invoke(() =>
+                            {
+                                systemStatusBox.Background = new SolidColorBrush(Colors.Red);
+                                systemStatusBox.ConnectionState = "Disconnected";
+                            });
+                        };
+
+                        Task.Run(() =>
+                        {
+                            peer.Start();
+                        });
+                    }
+
+                    if (!_settingsManager.ShowSystemStatus)
+                        systemStatusBox.Visibility = Visibility.Collapsed;
+
+                }
+            }
+
+            if (_settingsManager.ShowChannels && Codeplug != null)
+            {
+                foreach (var zone in Codeplug.Zones)
+                {
+                    foreach (var channel in zone.Channels)
+                    {
+                        var channelBox = new ChannelBox(_selectedChannelsManager, _audioManager, channel.Name, channel.System, channel.Tgid);
+
+                        //channelBox.crypter.AddKey(channel.GetKeyId(), channel.GetAlgoId(), channel.GetEncryptionKey());
+
+                        systemStatuses.Add(channel.Name, new SlotStatus());
+
+                        if (_settingsManager.ChannelPositions.TryGetValue(channel.Name, out var position))
+                        {
+                            Canvas.SetLeft(channelBox, position.X);
+                            Canvas.SetTop(channelBox, position.Y);
+                        }
+                        else
+                        {
+                            Canvas.SetLeft(channelBox, offsetX);
+                            Canvas.SetTop(channelBox, offsetY);
+                        }
+
+                        channelBox.PTTButtonClicked += ChannelBox_PTTButtonClicked;
+                        channelBox.PageButtonClicked += ChannelBox_PageButtonClicked;
+                        channelBox.HoldChannelButtonClicked += ChannelBox_HoldChannelButtonClicked;
+
+                        channelBox.MouseLeftButtonDown += ChannelBox_MouseLeftButtonDown;
+                        channelBox.MouseMove += ChannelBox_MouseMove;
+                        channelBox.MouseRightButtonDown += ChannelBox_MouseRightButtonDown;
+                        ChannelsCanvas.Children.Add(channelBox);
+
+                        offsetX += 225;
+
+                        if (offsetX + 220 > ChannelsCanvas.ActualWidth)
+                        {
+                            offsetX = 20;
+                            offsetY += 106;
+                        }
+                    }
+                }
+            }
+
+            if (_settingsManager.ShowAlertTones && Codeplug != null)
+            {
+                foreach (var alertPath in _settingsManager.AlertToneFilePaths)
+                {
+                    var alertTone = new AlertTone(alertPath)
+                    {
+                        IsEditMode = isEditMode
+                    };
+
+                    alertTone.OnAlertTone += SendAlertTone;
+
+                    if (_settingsManager.AlertTonePositions.TryGetValue(alertPath, out var position))
+                    {
+                        Canvas.SetLeft(alertTone, position.X);
+                        Canvas.SetTop(alertTone, position.Y);
+                    }
+                    else
+                    {
+                        Canvas.SetLeft(alertTone, 20);
+                        Canvas.SetTop(alertTone, 20);
+                    }
+
+                    alertTone.MouseRightButtonUp += AlertTone_MouseRightButtonUp;
+
+                    ChannelsCanvas.Children.Add(alertTone);
+                }
+            }
+
+            playbackChannelBox = new ChannelBox(_selectedChannelsManager, _audioManager, PLAYBACKCHNAME, PLAYBACKSYS, PLAYBACKTG);
+
+            if (_settingsManager.ChannelPositions.TryGetValue(PLAYBACKCHNAME, out var pos))
+            {
+                Canvas.SetLeft(playbackChannelBox, pos.X);
+                Canvas.SetTop(playbackChannelBox, pos.Y);
+            }
+            else
+            {
+                Canvas.SetLeft(playbackChannelBox, offsetX);
+                Canvas.SetTop(playbackChannelBox, offsetY);
+            }
+
+            playbackChannelBox.PTTButtonClicked += ChannelBox_PTTButtonClicked;
+            playbackChannelBox.PageButtonClicked += ChannelBox_PageButtonClicked;
+            playbackChannelBox.HoldChannelButtonClicked += ChannelBox_HoldChannelButtonClicked;
+
+            playbackChannelBox.MouseLeftButtonDown += ChannelBox_MouseLeftButtonDown;
+            playbackChannelBox.MouseMove += ChannelBox_MouseMove;
+            playbackChannelBox.MouseRightButtonDown += ChannelBox_MouseRightButtonDown;
+            ChannelsCanvas.Children.Add(playbackChannelBox);
+
+            //offsetX += 225;
+
+            //if (offsetX + 220 > ChannelsCanvas.ActualWidth)
+            //{
+            //    offsetX = 20;
+            //    offsetY += 106;
+            //}
+
+            // Initialize channel hotkeys after channels are created
+            InitializeChannelHotkeys();
+
+            AdjustCanvasHeight();
+        }
+
+        private void WaveIn_RecordingStopped(object sender, EventArgs e)
+        {
+            /* stub */
+        }
+
+        private void WaveIn_DataAvailable(object sender, WaveInEventArgs e)
+        {
+            bool isAnyTgOn = false;
+
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                {
+                    playbackChannelBox.IsReceiving = true;
+                    continue;
+                }
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                Task.Run(() =>
+                {
+
+                    if (!system.IsDvm)
+                    {
+                        IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                        if (channel.IsSelected && channel.VoiceChannel != null && channel.PttState)
+                        {
+                            isAnyTgOn = true;
+
+                            object voicePaket = new
+                            {
+                                type = PacketType.AUDIO_DATA,
+                                data = new
+                                {
+                                    Data = e.Buffer,
+                                    VoiceChannel = new VoiceChannel
+                                    {
+                                        Frequency = channel.VoiceChannel,
+                                        DstId = cpgChannel.Tgid,
+                                        SrcId = system.Rid,
+                                        Site = system.Site
+                                    },
+                                    Site = system.Site
+                                }
+                            };
+
+#if DEBUG
+                            Console.WriteLine($"WLINK AUDIO_DATA SrcId: {system.Rid}; DstId: {cpgChannel.Tgid}; Freq: {channel.VoiceChannel}");
+#endif
+
+                            handler.SendMessage(voicePaket);
+                        }
+                    }
+                    else
+                    {
+                        PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                        if (channel.IsSelected && channel.PttState)
+                        {
+                            isAnyTgOn = true;
+
+                            int samples = 320;
+
+                            channel.chunkedPcm = AudioConverter.SplitToChunks(e.Buffer);
+
+                            foreach (byte[] chunk in channel.chunkedPcm)
+                            {
+                                if (chunk.Length == samples)
+                                {
+                                    P25EncodeAudioFrame(chunk, handler, channel, cpgChannel, system);
+                                }
+                                else
+                                {
+                                    Console.WriteLine("bad sample length: " + chunk.Length);
+                                }
+                            }
+                        }
+                    }
+                });
+            }
+
+            if (isAnyTgOn && playbackChannelBox.IsSelected)
+                _audioManager.AddTalkgroupStream(PLAYBACKTG, e.Buffer);
+        }
+
+        private void SelectedChannelsChanged()
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+         
+                if (!system.IsDvm) {
+                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                    if (channel.IsSelected && handler.IsConnected)
+                    {
+                        Console.WriteLine("sending WLINK master aff");
+
+                        Task.Run(() =>
+                        {
+                            GRP_AFF_REQ release = new GRP_AFF_REQ
+                            {
+                                SrcId = system.Rid,
+                                DstId = cpgChannel.Tgid,
+                                Site = system.Site
+                            };
+
+                            handler.SendMessage(release.GetData());
+                        });
+                    }
+                } else
+                {
+                    PeerSystem fne = _fneSystemManager.GetFneSystem(system.Name);
+
+                    if (channel.IsSelected)
+                    {
+                        uint newTgid = UInt32.Parse(cpgChannel.Tgid);
+                        bool exists = fneAffs.Any(aff => aff.Item2 == newTgid);
+
+                        if (cpgChannel.GetAlgoId() != 0 && cpgChannel.GetKeyId() != 0)
+                            fne.peer.SendMasterKeyRequest(cpgChannel.GetAlgoId(), cpgChannel.GetKeyId());
+
+                        if (!exists)
+                            fneAffs.Add(new Tuple<uint, uint>(GetUniqueRid(system.Rid), newTgid));
+
+                        //Console.WriteLine("FNE Affiliations:");
+                        //foreach (var aff in fneAffs)
+                        //{
+                        //    Console.WriteLine($"  RID: {aff.Item1}, TGID: {aff.Item2}");
+                        //}
+                    }
+                }
+            }
+
+            foreach (Codeplug.System system in Codeplug.Systems)
+            {
+                if (system.IsDvm)
+                {
+                    PeerSystem fne = _fneSystemManager.GetFneSystem(system.Name);
+                    //fne.peer.SendMasterAffiliationUpdate(fneAffs);
+                }
+            }
+        }
+
+        private void AudioSettings_Click(object sender, RoutedEventArgs e)
+        {
+            List<Codeplug.Channel> channels = Codeplug?.Zones.SelectMany(z => z.Channels).ToList() ?? new List<Codeplug.Channel>();
+
+            AudioSettingsWindow audioSettingsWindow = new AudioSettingsWindow(_settingsManager, _audioManager, channels);
+            audioSettingsWindow.ShowDialog();
+        }
+
+        private void ConfigurePttKeybindings_Click(object sender, RoutedEventArgs e)
+        {
+            if (Codeplug == null)
+            {
+                MessageBox.Show("Please load a codeplug first before configuring PTT keybindings.", "No Codeplug Loaded", MessageBoxButton.OK, MessageBoxImage.Information);
+                return;
+            }
+
+            var configWindow = new KeybindingConfigWindow(
+                _settingsManager,
+                _channelKeybindingManager,
+                Codeplug,
+                _settingsManager.LastCodeplugPath,
+                this
+            );
+
+            configWindow.Owner = this;
+            configWindow.ShowDialog();
+
+            // Reinitialize hotkeys only if configuration changes were applied
+            if (configWindow.KeybindingsApplied)
+            {
+                InitializeGlobalHotkeys();
+                if (Codeplug != null)
+                {
+                    InitializeChannelHotkeys();
+                }
+            }
+        }
+
+        private void InitializeGlobalHotkeys()
+        {
+            try
+            {
+                // Initialize the hotkey manager if not already done
+                if (_globalHotKeyManager == null)
+                {
+                    _globalHotKeyManager = new GlobalHotKeyManager();
+                    _globalHotKeyManager.Initialize(this);
+                }
+                
+                // Update the WorkWhenUnfocused setting
+                _globalHotKeyManager.WorkWhenUnfocused = _settingsManager.HotkeysWorkWhenUnfocused;
+
+                // Unregister old hotkey
+                if (_globalPttHotKeyId != -1)
+                {
+                    _globalHotKeyManager.UnregisterHotKey(_globalPttHotKeyId);
+                    _globalPttHotKeyId = -1;
+                }
+
+                // Register Global PTT hotkey
+                if (_settingsManager.EnableGlobalPttHotkey && !string.IsNullOrWhiteSpace(_settingsManager.GlobalPttKeybind))
+                {
+                    if (KeybindingParser.TryParseKeybinding(_settingsManager.GlobalPttKeybind, out var globalModifiers, out var globalKey))
+                    {
+                        _globalPttHotKeyId = _globalHotKeyManager.RegisterHotKey(
+                            globalModifiers,
+                            globalKey,
+                            OnGlobalPttHotKeyDown,
+                            OnGlobalPttHotKeyUp
+                        );
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Failed to initialize global hotkeys: {ex.Message}");
+            }
+        }
+
+        private void InitializeChannelHotkeys()
+        {
+            try
+            {
+                _currentCodeplugIdentifier = ChannelKeybindingManager.GenerateCodeplugIdentifier(_settingsManager.LastCodeplugPath);
+
+                // Make sure global hotkey manager is initialized first
+                if (_globalHotKeyManager == null)
+                {
+                    InitializeGlobalHotkeys();
+                }
+
+                if (_channelHotKeyManager == null)
+                {
+                    _channelHotKeyManager = new ChannelHotKeyManager(
+                        _globalHotKeyManager,
+                        _channelKeybindingManager,
+                        OnChannelHotKeyTriggered,
+                        OnChannelToggleTriggered
+                    );
+                }
+
+                var allChannels = ChannelsCanvas.Children.OfType<ChannelBox>().ToList();
+                _channelHotKeyManager.InitializeChannelHotkeys(_currentCodeplugIdentifier, allChannels);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Failed to initialize channel hotkeys: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Temporarily suspends all hotkeys (used when configuration window is open)
+        /// </summary>
+        public void SuspendHotkeys()
+        {
+            try
+            {
+                _globalHotKeyManager?.UnregisterAllHotKeys();
+                _channelHotKeyManager?.UnregisterAllChannelHotkeys();
+                Console.WriteLine("Hotkeys suspended");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Failed to suspend hotkeys: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Resumes all hotkeys after suspension
+        /// </summary>
+        public void ResumeHotkeys()
+        {
+            try
+            {
+                InitializeGlobalHotkeys();
+                if (Codeplug != null)
+                {
+                    InitializeChannelHotkeys();
+                }
+                Console.WriteLine("Hotkeys resumed");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Failed to resume hotkeys: {ex.Message}");
+            }
+        }
+
+        private void OnGlobalPttHotKeyDown()
+        {
+            Dispatcher.Invoke(() =>
+            {
+                if (!globalPttState)
+                {
+                    globalPttState = true;
+                    ActivateGlobalPtt();
+                }
+            });
+        }
+
+        private void OnGlobalPttHotKeyUp()
+        {
+            Dispatcher.Invoke(() =>
+            {
+                if (globalPttState)
+                {
+                    globalPttState = false;
+                    ReleaseGlobalPtt();
+                }
+            });
+        }
+
+        private void OnChannelHotKeyTriggered(ChannelBox channel, bool isPressed)
+        {
+            Dispatcher.Invoke(() =>
+            {
+                if (channel != null)
+                {
+                    if (isPressed && !channel.PttState)
+                    {
+                        channel.PttState = true;
+                        ChannelBox_PTTButtonClicked(channel, channel);
+                    }
+                    else if (!isPressed && channel.PttState)
+                    {
+                        channel.PttState = false;
+                        ChannelBox_PTTButtonClicked(channel, channel);
+                    }
+                }
+            });
+        }
+
+        private void OnChannelToggleTriggered(ChannelBox channel)
+        {
+            Dispatcher.Invoke(() =>
+            {
+                if (channel != null)
+                {
+                    // Toggle the channel's selection state (like clicking on it)
+                    channel.ToggleSelection();
+                    
+                    // Optionally log the toggle action
+                    Console.WriteLine($"Channel '{channel.ChannelName}' toggled to {(channel.IsSelected ? "selected" : "unselected")}");
+                }
+            });
+        }
+
+        private async void ActivateGlobalPtt()
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (!system.IsDvm)
+                {
+                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                    if (!channel.IsSelected)
+                        continue;
+
+                    Dispatcher.Invoke(() =>
+                    {
+                        btnGlobalPtt.Background = channel.redGradient;
+                    });
+
+                    GRP_VCH_REQ request = new GRP_VCH_REQ
+                    {
+                        SrcId = system.Rid,
+                        DstId = cpgChannel.Tgid,
+                        Site = system.Site
+                    };
+
+                    channel.PttState = true;
+
+                    handler.SendMessage(request.GetData());
+                }
+                else
+                {
+                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                    channel.txStreamId = handler.NewStreamId();
+
+                    Dispatcher.Invoke(() =>
+                    {
+                        btnGlobalPtt.Background = channel.redGradient;
+                        channel.PttState = true;
+                    });
+
+                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
+                }
+            }
+        }
+
+        private async void ReleaseGlobalPtt()
+        {
+            await Task.Delay(500);
+
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (!system.IsDvm)
+                {
+                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                    if (!channel.IsSelected)
+                        continue;
+
+                    Dispatcher.Invoke(() =>
+                    {
+                        btnGlobalPtt.Background = channel.grayGradient;
+                    });
+
+                    GRP_VCH_RLS release = new GRP_VCH_RLS
+                    {
+                        SrcId = system.Rid,
+                        DstId = cpgChannel.Tgid,
+                        Site = system.Site
+                    };
+
+                    channel.PttState = false;
+
+                    handler.SendMessage(release.GetData());
+                }
+                else
+                {
+                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                    Dispatcher.Invoke(() =>
+                    {
+                        btnGlobalPtt.Background = channel.grayGradient;
+                        channel.PttState = false;
+                    });
+
+                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
+                }
+            }
+        }
+
+        private void P25Page_Click(object sender, RoutedEventArgs e)
+        {
+            DigitalPageWindow pageWindow = new DigitalPageWindow(Codeplug.Systems);
+            pageWindow.Owner = this;
+            if (pageWindow.ShowDialog() == true)
+            {
+                if (!pageWindow.RadioSystem.IsDvm)
+                {
+                    IPeer handler = _webSocketManager.GetWebSocketHandler(pageWindow.RadioSystem.Name);
+
+                    CALL_ALRT_REQ callAlert = new CALL_ALRT_REQ
+                    {
+                        SrcId = pageWindow.RadioSystem.Rid,
+                        DstId = pageWindow.DstId
+                    };
+
+                    handler.SendMessage(callAlert.GetData());
+                }
+                else
+                {
+                    PeerSystem handler = _fneSystemManager.GetFneSystem(pageWindow.RadioSystem.Name);
+                    IOSP_CALL_ALRT callAlert = new IOSP_CALL_ALRT(UInt32.Parse(pageWindow.DstId), UInt32.Parse(pageWindow.RadioSystem.Rid));
+
+                    RemoteCallData callData = new RemoteCallData
+                    {
+                        SrcId = UInt32.Parse(pageWindow.RadioSystem.Rid),
+                        DstId = UInt32.Parse(pageWindow.DstId),
+                        LCO = P25Defines.TSBK_IOSP_CALL_ALRT
+                    };
+
+                    byte[] tsbk = new byte[P25Defines.P25_TSBK_LENGTH_BYTES];
+
+                    callAlert.Encode(ref tsbk, true, true);
+
+                    handler.SendP25TSBK(callData, tsbk);
+
+                    Console.WriteLine("sent page");
+                }
+            }
+        }
+
+        private async void ManualPage_Click(object sender, RoutedEventArgs e)
+        {
+            QuickCallPage pageWindow = new QuickCallPage();
+            pageWindow.Owner = this;
+            if (pageWindow.ShowDialog() == true)
+            {
+                foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+                {
+                    Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                    Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                    if (channel.PageState)
+                    {
+                        ToneGenerator generator = new ToneGenerator();
+
+                        double toneADuration = 1.0;
+                        double toneBDuration = 3.0;
+
+                        byte[] toneA = generator.GenerateTone(Double.Parse(pageWindow.ToneA), toneADuration);
+                        byte[] toneB = generator.GenerateTone(Double.Parse(pageWindow.ToneB), toneBDuration);
+
+                        byte[] combinedAudio = new byte[toneA.Length + toneB.Length];
+                        Buffer.BlockCopy(toneA, 0, combinedAudio, 0, toneA.Length);
+                        Buffer.BlockCopy(toneB, 0, combinedAudio, toneA.Length, toneB.Length);
+
+                        int chunkSize = 1600;
+
+                        if (system.IsDvm)
+                            chunkSize = 320;
+
+                        int totalChunks = (combinedAudio.Length + chunkSize - 1) / chunkSize;
+
+                        Task.Run(() =>
+                        {
+                            //_waveProvider.ClearBuffer();
+                            _audioManager.AddTalkgroupStream(cpgChannel.Tgid, combinedAudio);
+                        });
+
+                        await Task.Run(() =>
+                        {
+                            for (int i = 0; i < totalChunks; i++)
+                            {
+                                int offset = i * chunkSize;
+                                int size = Math.Min(chunkSize, combinedAudio.Length - offset);
+
+                                byte[] chunk = new byte[chunkSize];
+                                Buffer.BlockCopy(combinedAudio, offset, chunk, 0, size);
+
+                                if (!system.IsDvm)
+                                {
+                                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                                    AudioPacket voicePacket = new AudioPacket
+                                    {
+                                        Data = chunk,
+                                        VoiceChannel = new VoiceChannel
+                                        {
+                                            Frequency = channel.VoiceChannel,
+                                            DstId = cpgChannel.Tgid,
+                                            SrcId = system.Rid,
+                                            Site = system.Site
+                                        },
+                                        Site = system.Site,
+                                        LopServerVocode = true
+                                    };
+
+                                    handler.SendMessage(voicePacket.GetData());
+                                } else
+                                {
+                                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                                    if (chunk.Length == 320)
+                                    {
+                                        P25EncodeAudioFrame(chunk, handler, channel, cpgChannel, system);
+                                    }
+                                }
+                            }
+                        });
+
+                        double totalDurationMs = (toneADuration + toneBDuration) * 1000 + 750;
+                        await Task.Delay((int)totalDurationMs);
+
+                        if (!system.IsDvm)
+                        {
+                            IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                            GRP_VCH_RLS release = new GRP_VCH_RLS
+                            {
+                                SrcId = system.Rid,
+                                DstId = cpgChannel.Tgid,
+                                Channel = channel.VoiceChannel,
+                                Site = system.Site
+                            };
+
+                            handler.SendMessage(release.GetData());
+                        } else
+                        {
+                            PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                            await Task.Delay(4000);
+
+                            handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
+                        }
+
+                        Dispatcher.Invoke(() =>
+                        {
+                            //channel.PageState = false; // TODO: Investigate
+                            channel.PageSelectButton.Background = channel.grayGradient;
+                        });
+                    }
+                }
+            }
+        }
+
+        private void SendAlertTone(AlertTone e)
+        {
+            Task.Run(() => SendAlertTone(e.AlertFilePath));
+        }
+
+        private void SendAlertTone(string filePath, bool forHold = false)
+        {
+            if (!string.IsNullOrEmpty(filePath) && File.Exists(filePath))
+            {
+                try
+                {
+                    foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+                    {
+                        if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                            continue;
+
+                        Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                        Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                        if (channel.PageState || (forHold && channel.HoldState))
+                        {
+                            byte[] pcmData;
+
+                            Task.Run(async () => {
+                                using (var waveReader = new WaveFileReader(filePath))
+                                {
+                                    if (waveReader.WaveFormat.Encoding != WaveFormatEncoding.Pcm ||
+                                        waveReader.WaveFormat.SampleRate != 8000 ||
+                                        waveReader.WaveFormat.BitsPerSample != 16 ||
+                                        waveReader.WaveFormat.Channels != 1)
+                                    {
+                                        MessageBox.Show("The alert tone must be PCM 16-bit, Mono, 8000Hz format.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                                        return;
+                                    }
+
+                                    using (MemoryStream ms = new MemoryStream())
+                                    {
+                                        waveReader.CopyTo(ms);
+                                        pcmData = ms.ToArray();
+                                    }
+                                }
+
+                                int chunkSize = 1600;
+                                int totalChunks = (pcmData.Length + chunkSize - 1) / chunkSize;
+
+                                if (pcmData.Length % chunkSize != 0)
+                                {
+                                    byte[] paddedData = new byte[totalChunks * chunkSize];
+                                    Buffer.BlockCopy(pcmData, 0, paddedData, 0, pcmData.Length);
+                                    pcmData = paddedData;
+                                }
+
+                                Task.Run(() =>
+                                {
+                                    _audioManager.AddTalkgroupStream(cpgChannel.Tgid, pcmData);
+                                });
+
+                                DateTime startTime = DateTime.UtcNow;
+
+                                for (int i = 0; i < totalChunks; i++)
+                                {
+                                    int offset = i * chunkSize;
+                                    byte[] chunk = new byte[chunkSize];
+                                    Buffer.BlockCopy(pcmData, offset, chunk, 0, chunkSize);
+
+                                    if (!system.IsDvm)
+                                    {
+                                        IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                                        AudioPacket voicePacket = new AudioPacket
+                                        {
+                                            Data = chunk,
+                                            VoiceChannel = new VoiceChannel
+                                            {
+                                                Frequency = channel.VoiceChannel,
+                                                DstId = cpgChannel.Tgid,
+                                                SrcId = system.Rid,
+                                                Site = system.Site
+                                            },
+                                            Site = system.Site,
+                                            LopServerVocode = true
+                                        };
+
+                                        handler.SendMessage(voicePacket.GetData());
+                                    }
+                                    else
+                                    {
+                                        PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                                        channel.chunkedPcm = AudioConverter.SplitToChunks(chunk);
+
+                                        foreach (byte[] smallchunk in channel.chunkedPcm)
+                                        {
+                                            if (smallchunk.Length == 320)
+                                            {
+                                                P25EncodeAudioFrame(smallchunk, handler, channel, cpgChannel, system);
+                                            }
+                                        }
+                                    }
+
+                                    DateTime nextPacketTime = startTime.AddMilliseconds((i + 1) * 100);
+                                    TimeSpan waitTime = nextPacketTime - DateTime.UtcNow;
+
+                                    if (waitTime.TotalMilliseconds > 0)
+                                    {
+                                        await Task.Delay(waitTime);
+                                    }
+                                }
+
+                                double totalDurationMs = ((double)pcmData.Length / 16000) + 250;
+                                await Task.Delay((int)totalDurationMs);
+
+                                if (!system.IsDvm)
+                                {
+                                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                                    GRP_VCH_RLS release = new GRP_VCH_RLS
+                                    {
+                                        SrcId = system.Rid,
+                                        DstId = cpgChannel.Tgid,
+                                        Channel = channel.VoiceChannel,
+                                        Site = system.Site
+                                    };
+
+                                    Dispatcher.Invoke(() =>
+                                    {
+                                        handler.SendMessage(release.GetData());
+
+                                        if (forHold)
+                                            channel.PttButton.Background = channel.grayGradient;
+                                        else
+                                            channel.PageState = false;
+                                    });
+                                } else
+                                {
+                                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                                    await Task.Delay(3000);
+
+                                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
+
+                                    Dispatcher.Invoke(() =>
+                                    {
+                                        if (forHold)
+                                            channel.PttButton.Background = channel.grayGradient;
+                                        else
+                                            channel.PageState = false;
+                                    });
+                                }
+                            });
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    MessageBox.Show($"Failed to process alert tone: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                }
+            }
+            else
+            {
+                MessageBox.Show("Alert file not set or file not found.", "Alert", MessageBoxButton.OK, MessageBoxImage.Warning);
+            }
+        }
+
+        private void SelectWidgets_Click(object sender, RoutedEventArgs e)
+        {
+            WidgetSelectionWindow widgetSelectionWindow = new WidgetSelectionWindow();
+            widgetSelectionWindow.Owner = this;
+            if (widgetSelectionWindow.ShowDialog() == true)
+            {
+                _settingsManager.ShowSystemStatus = widgetSelectionWindow.ShowSystemStatus;
+                _settingsManager.ShowChannels = widgetSelectionWindow.ShowChannels;
+                _settingsManager.ShowAlertTones = widgetSelectionWindow.ShowAlertTones;
+
+                GenerateChannelWidgets();
+                _settingsManager.SaveSettings();
+            }
+        }
+
+        private void HandleEmergencyAlarmResponse(EMRG_ALRM_RSP response)
+        {
+            bool forUs = false;
+
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (response.DstId == cpgChannel.Tgid)
+                {
+                    forUs = true;
+                    channel.Emergency = true;
+                    channel.LastSrcId = response.SrcId;
+                }
+            }
+
+            if (forUs)
+            {
+                Dispatcher.Invoke(() =>
+                {
+                    _flashingManager.Start();
+                    _emergencyAlertPlayback.Start();
+                });
+            }
+        }
+
+        private void HandleCallAlert(CALL_ALRT request)
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (system.IsDvm)
+                    continue;
+
+                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                if (request.DstId == system.Rid)
+                {
+
+                    ACK_RSP ack = new ACK_RSP
+                    {
+                        SrcId = request.SrcId,
+                        DstId = request.DstId,
+                        Service = PacketType.CALL_ALRT
+                    };
+
+                    handler.SendMessage(ack.GetData());
+                }
+            }
+        }
+
+        private void HandleReceivedAudio(AudioPacket audioPacket)
+        {
+            bool shouldReceive = false;
+            string talkgroupId = audioPacket.VoiceChannel.DstId;
+
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (system.IsDvm)
+                    continue;
+
+                if (audioPacket.VoiceChannel.SrcId != system.Rid && audioPacket.VoiceChannel.Frequency == channel.VoiceChannel && audioPacket.VoiceChannel.DstId == cpgChannel.Tgid)
+                    shouldReceive = true;
+            }
+
+            if (shouldReceive)
+                _audioManager.AddTalkgroupStream(talkgroupId, audioPacket.Data);
+        }
+
+        private void HandleAffiliationUpdate(AFF_UPDATE affUpdate)
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (system.IsDvm)
+                    continue;
+
+                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                bool ridExists = affUpdate.Affiliations.Any(aff => aff.SrcId == system.Rid);
+                bool tgidExists = affUpdate.Affiliations.Any(aff => aff.DstId == cpgChannel.Tgid);
+
+                if (ridExists && tgidExists)
+                {
+                    //Console.WriteLine("rid aff'ed");
+                }
+                else
+                {
+                    //Console.WriteLine("rid not aff'ed");
+                    Task.Run(() =>
+                    {
+                        GRP_AFF_REQ affReq = new GRP_AFF_REQ
+                        {
+                            SrcId = system.Rid,
+                            DstId = cpgChannel.Tgid,
+                            Site = system.Site
+                        };
+
+                        handler.SendMessage(affReq.GetData());
+                    });
+                }
+            }
+        }
+
+        private void HandleVoiceRelease(GRP_VCH_RLS response)
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (system.IsDvm)
+                    continue;
+
+                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                if (response.DstId == cpgChannel.Tgid && response.SrcId != system.Rid)
+                {
+                    Dispatcher.Invoke(() =>
+                    {
+                        if (channel.IsSelected)
+                        {
+                            channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF0B004B");
+                            channel.IsReceiving = false;
+                        }
+                        else
+                        {
+                            channel.Background = new SolidColorBrush(Colors.DarkGray);
+                            channel.IsReceiving = false;
+                        }
+                    });
+
+                    channel.VoiceChannel = null;
+                }
+            }
+        }
+
+        private void HandleVoiceResponse(GRP_VCH_RSP response)
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (system.IsDvm)
+                    continue;
+
+                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                if (channel.PttState && response.Status == (int)ResponseType.GRANT && response.Channel != null && response.SrcId == system.Rid && response.DstId == cpgChannel.Tgid)
+                {
+                    channel.VoiceChannel = response.Channel;
+                }
+                else if (response.Status == (int)ResponseType.GRANT && response.SrcId != system.Rid && response.DstId == cpgChannel.Tgid)
+                {
+                    channel.VoiceChannel = response.Channel;
+
+                    string alias = string.Empty;
+
+                    try
+                    {
+                        alias = AliasTools.GetAliasByRid(system.RidAlias, int.Parse(response.SrcId));
+                    }
+                    catch (Exception) { }
+
+                    if (alias.IsNullOrEmpty())
+                        channel.LastSrcId = "Last SRC: " + response.SrcId;
+                    else
+                        channel.LastSrcId = "Last: " + alias;
+
+                    Dispatcher.Invoke(() =>
+                    {
+                        channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
+                        channel.IsReceiving = true;
+                    });
+                }
+                else if ((channel.HoldState || channel.PageState) && response.Status == (int)ResponseType.GRANT && response.Channel != null && response.SrcId == system.Rid && response.DstId == cpgChannel.Tgid)
+                {
+                    channel.VoiceChannel = response.Channel;
+                }
+                else
+                {
+                    //Dispatcher.Invoke(() =>
+                    //{
+                    //    if (channel.IsSelected)
+                    //        channel.Background = new SolidColorBrush(Colors.DodgerBlue);
+                    //    else
+                    //        channel.Background = new SolidColorBrush(Colors.Gray);
+                    //});
+
+                    //channel.VoiceChannel = null;
+                    //_stopSending = true;
+                }
+            }
+        }
+
+        private void ChannelBox_HoldChannelButtonClicked(object sender, ChannelBox e)
+        {
+            if (e.SystemName == PLAYBACKSYS || e.ChannelName == PLAYBACKCHNAME || e.DstId == PLAYBACKTG)
+                return;
+
+            Codeplug.System system = Codeplug.GetSystemForChannel(e.ChannelName);
+            Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(e.ChannelName);
+
+            if (system.IsDvm)
+                return;
+
+            IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+        }
+
+        private void ChannelBox_PageButtonClicked(object sender, ChannelBox e)
+        {
+            if (e.SystemName == PLAYBACKSYS || e.ChannelName == PLAYBACKCHNAME || e.DstId == PLAYBACKTG)
+                return;
+
+            Codeplug.System system = Codeplug.GetSystemForChannel(e.ChannelName);
+            Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(e.ChannelName);
+
+            if (!system.IsDvm)
+            {
+
+                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                if (e.PageState)
+                {
+                    GRP_VCH_REQ request = new GRP_VCH_REQ
+                    {
+                        SrcId = system.Rid,
+                        DstId = cpgChannel.Tgid,
+                        Site = system.Site
+                    };
+
+                    handler.SendMessage(request.GetData());
+                }
+                else
+                {
+                    GRP_VCH_RLS release = new GRP_VCH_RLS
+                    {
+                        SrcId = system.Rid,
+                        DstId = cpgChannel.Tgid,
+                        Channel = e.VoiceChannel,
+                        Site = system.Site
+                    };
+
+                    handler.SendMessage(release.GetData());
+                    e.VoiceChannel = null;
+                }
+            }
+            else
+            {
+                PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+                if (e.PageState)
+                {
+                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
+                }
+                else
+                {
+                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
+                }
+            }
+        }
+
+        private void ChannelBox_PTTButtonClicked(object sender, ChannelBox e)
+        {
+            if (e.SystemName == PLAYBACKSYS || e.ChannelName == PLAYBACKCHNAME || e.DstId == PLAYBACKTG)
+                return;
+
+            Codeplug.System system = Codeplug.GetSystemForChannel(e.ChannelName);
+            Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(e.ChannelName);
+
+            if (!system.IsDvm)
+            {
+                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                if (!e.IsSelected)
+                    return;
+
+                if (e.PttState)
+                {
+                    GRP_VCH_REQ request = new GRP_VCH_REQ
+                    {
+                        SrcId = system.Rid,
+                        DstId = cpgChannel.Tgid,
+                        Site = system.Site
+                    };
+
+                    handler.SendMessage(request.GetData());
+                }
+                else
+                {
+                    GRP_VCH_RLS release = new GRP_VCH_RLS
+                    {
+                        SrcId = system.Rid,
+                        DstId = cpgChannel.Tgid,
+                        Channel = e.VoiceChannel,
+                        Site = system.Site
+                    };
+
+                    handler.SendMessage(release.GetData());
+                    e.VoiceChannel = null;
+                }
+            } else
+            {
+                PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                if (!e.IsSelected)
+                    return;
+
+                FneUtils.Memset(e.mi, 0x00, P25Defines.P25_MI_LENGTH);
+
+                uint srcId = UInt32.Parse(system.Rid);
+                uint dstId = UInt32.Parse(cpgChannel.Tgid);
+
+                if (e.PttState)
+                {
+                    e.txStreamId = handler.NewStreamId();
+
+                    Console.WriteLine("sending grant demand " + dstId);
+                    handler.SendP25TDU(srcId, dstId, true);
+                }
+                else
+                {
+                    Console.WriteLine("sending terminator " + dstId);
+                    handler.SendP25TDU(srcId, dstId, false);
+                }
+            }
+        }
+
+        private void ChannelBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            if (!isEditMode || !(sender is UIElement element)) return;
+
+            _draggedElement = element;
+            _startPoint = e.GetPosition(ChannelsCanvas);
+            _offsetX = _startPoint.X - Canvas.GetLeft(_draggedElement);
+            _offsetY = _startPoint.Y - Canvas.GetTop(_draggedElement);
+            _isDragging = true;
+
+            element.CaptureMouse();
+        }
+
+        private const int GridSize = 5;
+
+        private void ChannelBox_MouseMove(object sender, MouseEventArgs e)
+        {
+            if (!isEditMode || !_isDragging || _draggedElement == null) return;
+
+            Point currentPosition = e.GetPosition(ChannelsCanvas);
+
+            // Calculate the new position with snapping to the grid
+            double newLeft = Math.Round((currentPosition.X - _offsetX) / GridSize) * GridSize;
+            double newTop = Math.Round((currentPosition.Y - _offsetY) / GridSize) * GridSize;
+
+            // Ensure the box stays within canvas bounds
+            newLeft = Math.Max(0, Math.Min(newLeft, ChannelsCanvas.ActualWidth - _draggedElement.RenderSize.Width));
+            newTop = Math.Max(0, Math.Min(newTop, ChannelsCanvas.ActualHeight - _draggedElement.RenderSize.Height));
+
+            // Apply snapped position
+            Canvas.SetLeft(_draggedElement, newLeft);
+            Canvas.SetTop(_draggedElement, newTop);
+
+            // Save the new position if it's a ChannelBox
+            if (_draggedElement is ChannelBox channelBox)
+            {
+                _settingsManager.UpdateChannelPosition(channelBox.ChannelName, newLeft, newTop);
+            }
+
+            AdjustCanvasHeight();
+        }
+
+        private void ChannelBox_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            if (!isEditMode || !_isDragging || _draggedElement == null) return;
+
+            _isDragging = false;
+            _draggedElement.ReleaseMouseCapture();
+            _draggedElement = null;
+        }
+
+        private void SystemStatusBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) => ChannelBox_MouseLeftButtonDown(sender, e);
+        private void SystemStatusBox_MouseMove(object sender, MouseEventArgs e) => ChannelBox_MouseMove(sender, e);
+
+        private void SystemStatusBox_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            if (!isEditMode) return;
+
+            if (sender is SystemStatusBox systemStatusBox)
+            {
+                double x = Canvas.GetLeft(systemStatusBox);
+                double y = Canvas.GetTop(systemStatusBox);
+                _settingsManager.SystemStatusPositions[systemStatusBox.SystemName] = new ChannelPosition { X = x, Y = y };
+
+                ChannelBox_MouseRightButtonDown(sender, e);
+
+                AdjustCanvasHeight();
+            }
+        }
+
+        private void ToggleEditMode_Click(object sender, RoutedEventArgs e)
+        {
+            isEditMode = !isEditMode;
+            var menuItem = (MenuItem)sender;
+            menuItem.Header = isEditMode ? "Disable Edit Mode" : "Enable Edit Mode";
+            UpdateEditModeForWidgets();
+        }
+
+        private void UpdateEditModeForWidgets()
+        {
+            foreach (var child in ChannelsCanvas.Children)
+            {
+                if (child is AlertTone alertTone)
+                {
+                    alertTone.IsEditMode = isEditMode;
+                }
+
+                if (child is ChannelBox channelBox)
+                {
+                    channelBox.IsEditMode = isEditMode;
+                }
+            }
+        }
+
+        private void AddAlertTone_Click(object sender, RoutedEventArgs e)
+        {
+            OpenFileDialog openFileDialog = new OpenFileDialog
+            {
+                Filter = "WAV Files (*.wav)|*.wav|All Files (*.*)|*.*",
+                Title = "Select Alert Tone"
+            };
+
+            if (openFileDialog.ShowDialog() == true)
+            {
+                string alertFilePath = openFileDialog.FileName;
+                var alertTone = new AlertTone(alertFilePath)
+                {
+                    IsEditMode = isEditMode
+                };
+
+                alertTone.OnAlertTone += SendAlertTone;
+
+                if (_settingsManager.AlertTonePositions.TryGetValue(alertFilePath, out var position))
+                {
+                    Canvas.SetLeft(alertTone, position.X);
+                    Canvas.SetTop(alertTone, position.Y);
+                }
+                else
+                {
+                    Canvas.SetLeft(alertTone, 20);
+                    Canvas.SetTop(alertTone, 20);
+                }
+
+                alertTone.MouseRightButtonUp += AlertTone_MouseRightButtonUp;
+
+                ChannelsCanvas.Children.Add(alertTone);
+                _settingsManager.UpdateAlertTonePaths(alertFilePath);
+
+                AdjustCanvasHeight();
+            }
+        }
+
+        private void AlertTone_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
+        {
+            if (!isEditMode) return;
+
+            if (sender is AlertTone alertTone)
+            {
+                double x = Canvas.GetLeft(alertTone);
+                double y = Canvas.GetTop(alertTone);
+                _settingsManager.UpdateAlertTonePosition(alertTone.AlertFilePath, x, y);
+
+                AdjustCanvasHeight();
+            }
+        }
+
+        private void AdjustCanvasHeight()
+        {
+            double maxBottom = 0;
+
+            foreach (UIElement child in ChannelsCanvas.Children)
+            {
+                double childBottom = Canvas.GetTop(child) + child.RenderSize.Height;
+                if (childBottom > maxBottom)
+                {
+                    maxBottom = childBottom;
+                }
+            }
+
+            ChannelsCanvas.Height = maxBottom + 150;
+        }
+
+        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
+        {
+            if (!string.IsNullOrEmpty(_settingsManager.LastCodeplugPath) && File.Exists(_settingsManager.LastCodeplugPath))
+            {
+                LoadCodeplug(_settingsManager.LastCodeplugPath);
+            }
+            else
+            {
+                GenerateChannelWidgets();
+            }
+        }
+
+        private async void OnHoldTimerElapsed(object sender, ElapsedEventArgs e)
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (!system.IsDvm)
+                {
+
+                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                    if (channel.HoldState && !channel.IsReceiving && !channel.PttState && !channel.PageState)
+                    {
+                        //Task.Factory.StartNew(async () =>
+                        //{
+                        Console.WriteLine("Sending channel hold beep");
+
+                        Dispatcher.Invoke(() => { channel.PttButton.Background = channel.redGradient; });
+
+                        GRP_VCH_REQ req = new GRP_VCH_REQ
+                        {
+                            SrcId = system.Rid,
+                            DstId = cpgChannel.Tgid,
+                            Site = system.Site
+                        };
+
+                        handler.SendMessage(req.GetData());
+
+                        await Task.Delay(1000);
+
+                        SendAlertTone(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Audio", "hold.wav"), true);
+                        // });
+                    }
+                } else
+                {
+                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                    if (channel.HoldState && !channel.IsReceiving && !channel.PttState && !channel.PageState)
+                    {
+                        handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
+                        await Task.Delay(1000);
+
+                        SendAlertTone(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Audio", "hold.wav"), true);
+                    }
+                }
+            }
+        }
+
+        protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
+        {
+            _settingsManager.SaveSettings();
+            base.OnClosing(e);
+        }
+
+        private void ClearEmergency_Click(object sender, RoutedEventArgs e)
+        {
+            _emergencyAlertPlayback.Stop();
+            _flashingManager.Stop();
+
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                channel.Emergency = false;
+            }
+        }
+
+        private void btnAlert1_Click(object sender, RoutedEventArgs e)
+        {
+            Dispatcher.Invoke(() => {
+                string alertPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Audio", "alert1.wav");
+                SendAlertTone(alertPath);
+            });
+        }
+
+        private void btnAlert2_Click(object sender, RoutedEventArgs e)
+        {
+            Dispatcher.Invoke(() =>
+            {
+                string alertPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Audio", "alert2.wav");
+                SendAlertTone(alertPath);
+            });
+        }
+
+        private void btnAlert3_Click(object sender, RoutedEventArgs e)
+        {
+            Dispatcher.Invoke(() =>
+            {
+                string alertPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Audio", "alert3.wav");
+                SendAlertTone(alertPath);
+            });
+        }
+
+        private async void btnGlobalPtt_Click(object sender, RoutedEventArgs e)
+        {
+            if (globalPttState)
+                await Task.Delay(500);
+
+            globalPttState = !globalPttState;
+
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (!system.IsDvm)
+                {
+                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                    if (!channel.IsSelected)
+                        continue;
+
+                    if (globalPttState)
+                    {
+                        Dispatcher.Invoke(() =>
+                        {
+                            btnGlobalPtt.Background = channel.redGradient;
+                        });
+
+
+                        GRP_VCH_REQ request = new GRP_VCH_REQ
+                        {
+                            SrcId = system.Rid,
+                            DstId = cpgChannel.Tgid,
+                            Site = system.Site
+                        };
+
+                        channel.PttState = true;
+
+                        handler.SendMessage(request.GetData());
+                    }
+                    else
+                    {
+                        Dispatcher.Invoke(() =>
+                        {
+                            btnGlobalPtt.Background = channel.grayGradient;
+                        });
+
+                        GRP_VCH_RLS release = new GRP_VCH_RLS
+                        {
+                            SrcId = system.Rid,
+                            DstId = cpgChannel.Tgid,
+                            Site = system.Site
+                        };
+
+                        channel.PttState = false;
+
+                        handler.SendMessage(release.GetData());
+                    }
+                } else
+                {
+                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                    channel.txStreamId = handler.NewStreamId();
+
+                    if (globalPttState)
+                    {
+                        Dispatcher.Invoke(() =>
+                        {
+                            btnGlobalPtt.Background = channel.redGradient;
+                            channel.PttState = true;
+                        });
+
+                        handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
+                    }
+                    else
+                    {
+                        Dispatcher.Invoke(() =>
+                        {
+                            btnGlobalPtt.Background = channel.grayGradient;
+                            channel.PttState = false;
+                        });
+
+                        handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
+                    }
+                }
+            }
+        }
+
+        private void Button_Click(object sender, RoutedEventArgs e) { /* sub */ }
+
+        private void SelectAll_Click(object sender, RoutedEventArgs e)
+        {
+            foreach (ChannelBox channel in ChannelsCanvas.Children.OfType<ChannelBox>())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (!channel.IsSelected)
+                {
+                    channel.IsSelected = true;
+
+                    channel.Background = channel.IsSelected ? (Brush)new BrushConverter().ConvertFrom("#FF0B004B") : Brushes.Gray;
+
+                    if (channel.IsSelected)
+                    {
+                        _selectedChannelsManager.AddSelectedChannel(channel);
+                    }
+                    else
+                    {
+                        _selectedChannelsManager.RemoveSelectedChannel(channel);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Helper to encode and transmit PCM audio as P25 IMBE frames.
+        /// </summary>
+        private void P25EncodeAudioFrame(byte[] pcm, PeerSystem handler, ChannelBox channel, Codeplug.Channel cpgChannel, Codeplug.System system)
+        {
+            bool encryptCall = true; // TODO: make this dynamic somewhere?
+
+            if (channel.p25N > 17)
+                channel.p25N = 0;
+            if (channel.p25N == 0)
+                FneUtils.Memset(channel.netLDU1, 0, 9 * 25);
+            if (channel.p25N == 9)
+                FneUtils.Memset(channel.netLDU2, 0, 9 * 25);
+
+            // Log.Logger.Debug($"BYTE BUFFER {FneUtils.HexDump(pcm)}");
+
+            //// pre-process: apply gain to PCM audio frames
+            //if (Program.Configuration.TxAudioGain != 1.0f)
+            //{
+            //    BufferedWaveProvider buffer = new BufferedWaveProvider(waveFormat);
+            //    buffer.AddSamples(pcm, 0, pcm.Length);
+
+            //    VolumeWaveProvider16 gainControl = new VolumeWaveProvider16(buffer);
+            //    gainControl.Volume = Program.Configuration.TxAudioGain;
+            //    gainControl.Read(pcm, 0, pcm.Length);
+            //}
+
+            int smpIdx = 0;
+            short[] samples = new short[FneSystemBase.MBE_SAMPLES_LENGTH];
+            for (int pcmIdx = 0; pcmIdx < pcm.Length; pcmIdx += 2)
+            {
+                samples[smpIdx] = (short)((pcm[pcmIdx + 1] << 8) + pcm[pcmIdx + 0]);
+                smpIdx++;
+            }
+
+            // Convert to floats
+            float[] fSamples = AudioConverter.PcmToFloat(samples);
+
+            // Convert to signal
+            DiscreteSignal signal = new DiscreteSignal(8000, fSamples, true);
+
+            // Log.Logger.Debug($"SAMPLE BUFFER {FneUtils.HexDump(samples)}");
+
+            // encode PCM samples into IMBE codewords
+            byte[] imbe = new byte[FneSystemBase.IMBE_BUF_LEN];
+
+
+            int tone = 0;
+
+            if (true) // TODO: Disable/enable detection
+            {
+                tone = channel.toneDetector.Detect(signal);
+            }
+            if (tone > 0)
+            {
+                MBEToneGenerator.IMBEEncodeSingleTone((ushort)tone, imbe);
+                Console.WriteLine($"({system.Name}) P25D: {tone} HZ TONE DETECT");
+            }
+            else
+            {
+#if WIN32
+                if (channel.extFullRateVocoder == null)
+                    channel.extFullRateVocoder = new AmbeVocoder(true);
+
+                channel.extFullRateVocoder.encode(samples, out imbe);
+#else
+                if (channel.encoder == null)
+                    channel.encoder = new MBEEncoder(MBE_MODE.IMBE_88BIT);
+
+                channel.encoder.encode(samples, imbe);
+#endif
+            }
+            // Log.Logger.Debug($"IMBE {FneUtils.HexDump(imbe)}");
+
+            if (encryptCall && cpgChannel.GetAlgoId() != 0 && cpgChannel.GetKeyId() != 0)
+            {
+                // initial HDU MI
+                if (channel.p25N == 0)
+                {
+                    if (channel.mi.All(b => b == 0))
+                    {
+                        Random random = new Random();
+
+                        for (int i = 0; i < P25Defines.P25_MI_LENGTH; i++)
+                        {
+                            channel.mi[i] = (byte)random.Next(0x00, 0x100);
+                        }
+                    }
+
+                    channel.crypter.Prepare(cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), ProtocolType.P25Phase1, channel.mi);
+                }
+
+                // crypto time
+                channel.crypter.Process(imbe, channel.p25N < 9U ? P25Crypto.FrameType.LDU1 : P25Crypto.FrameType.LDU2, 0);
+
+                // last block of LDU2, prepare a new MI
+                if (channel.p25N == 17U)
+                {
+                    P25Crypto.CycleP25Lfsr(channel.mi);
+                    channel.crypter.Prepare(cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), ProtocolType.P25Phase1, channel.mi);
+                }
+            }
+
+            // fill the LDU buffers appropriately
+            switch (channel.p25N)
+            {
+                // LDU1
+                case 0:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 10, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 1:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 26, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 2:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 55, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 3:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 80, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 4:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 105, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 5:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 130, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 6:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 155, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 7:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 180, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 8:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 204, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+
+                // LDU2
+                case 9:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 10, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 10:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 26, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 11:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 55, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 12:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 80, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 13:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 105, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 14:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 130, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 15:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 155, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 16:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 180, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 17:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 204, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+            }
+
+            uint srcId = UInt32.Parse(system.Rid);
+            uint dstId = UInt32.Parse(cpgChannel.Tgid);
+
+            FnePeer peer = handler.peer;
+            RemoteCallData callData = new RemoteCallData()
+            {
+                SrcId = srcId,
+                DstId = dstId,
+                LCO = P25Defines.LC_GROUP
+            };
+
+            // send P25 LDU1
+            if (channel.p25N == 8U)
+            {
+                ushort pktSeq = 0;
+                if (channel.p25SeqNo == 0U)
+                    pktSeq = peer.pktSeq(true);
+                else
+                    pktSeq = peer.pktSeq();
+
+                //Console.WriteLine($"({channel.SystemName}) P25D: Traffic *VOICE FRAME    * PEER {handler.PeerId} SRC_ID {srcId} TGID {dstId} [STREAM ID {channel.txStreamId}]");
+
+                byte[] payload = new byte[200];
+                handler.CreateNewP25MessageHdr((byte)P25DUID.LDU1, callData, ref payload, cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), channel.mi);
+                handler.CreateP25LDU1Message(channel.netLDU1, ref payload, srcId, dstId);
+
+                peer.SendMaster(new Tuple<byte, byte>(Constants.NET_FUNC_PROTOCOL, Constants.NET_PROTOCOL_SUBFUNC_P25), payload, pktSeq, channel.txStreamId);
+            }
+
+            // send P25 LDU2
+            if (channel.p25N == 17U)
+            {
+                ushort pktSeq = 0;
+                if (channel.p25SeqNo == 0U)
+                    pktSeq = peer.pktSeq(true);
+                else
+                    pktSeq = peer.pktSeq();
+
+                //Console.WriteLine($"({channel.SystemName}) P25D: Traffic *VOICE FRAME    * PEER {handler.PeerId} SRC_ID {srcId} TGID {dstId} [STREAM ID {channel.txStreamId}]");
+
+                byte[] payload = new byte[200];
+                handler.CreateNewP25MessageHdr((byte)P25DUID.LDU2, callData, ref payload, cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), channel.mi);
+                handler.CreateP25LDU2Message(channel.netLDU2, ref payload, new CryptoParams { AlgId = cpgChannel.GetAlgoId(), KeyId = cpgChannel.GetKeyId(), Mi = channel.mi });
+
+                peer.SendMaster(new Tuple<byte, byte>(Constants.NET_FUNC_PROTOCOL, Constants.NET_PROTOCOL_SUBFUNC_P25), payload, pktSeq, channel.txStreamId);
+            }
+
+            channel.p25SeqNo++;
+            channel.p25N++;
+        }
+
+        /// <summary>
+        /// Helper to decode and playback P25 IMBE frames as PCM audio.
+        /// </summary>
+        /// <param name="ldu"></param>
+        /// <param name="e"></param>
+        private void P25DecodeAudioFrame(byte[] ldu, P25DataReceivedEvent e, PeerSystem system, ChannelBox channel, bool emergency = false, P25Crypto.FrameType frameType = P25Crypto.FrameType.LDU1)
+        {
+            try
+            {
+                // decode 9 IMBE codewords into PCM samples
+                for (int n = 0; n < 9; n++)
+                {
+                    byte[] imbe = new byte[FneSystemBase.IMBE_BUF_LEN];
+                    switch (n)
+                    {
+                        case 0:
+                            Buffer.BlockCopy(ldu, 10, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 1:
+                            Buffer.BlockCopy(ldu, 26, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 2:
+                            Buffer.BlockCopy(ldu, 55, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 3:
+                            Buffer.BlockCopy(ldu, 80, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 4:
+                            Buffer.BlockCopy(ldu, 105, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 5:
+                            Buffer.BlockCopy(ldu, 130, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 6:
+                            Buffer.BlockCopy(ldu, 155, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 7:
+                            Buffer.BlockCopy(ldu, 180, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 8:
+                            Buffer.BlockCopy(ldu, 204, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                    }
+
+                    //Log.Logger.Debug($"Decoding IMBE buffer: {FneUtils.HexDump(imbe)}");
+
+                    short[] samples = new short[FneSystemBase.MBE_SAMPLES_LENGTH];
+
+                    channel.crypter.Process(imbe, frameType, n);
+
+#if WIN32
+                    if (channel.extFullRateVocoder == null)
+                        channel.extFullRateVocoder = new AmbeVocoder(true);
+
+                    channel.p25Errs = channel.extFullRateVocoder.decode(imbe, out samples);
+#else
+
+                    channel.p25Errs = channel.decoder.decode(imbe, samples);
+#endif
+
+                    if (emergency)
+                    {
+                        if (!channel.Emergency)
+                        {
+                            Task.Run(() =>
+                            {
+                                HandleEmergencyAlarmResponse(new EMRG_ALRM_RSP
+                                {
+                                    SrcId = e.SrcId.ToString(),
+                                    DstId = e.DstId.ToString()
+                                });
+                            });
+                        }
+                    }
+
+                    if (samples != null)
+                    {
+                        //Log.Logger.Debug($"({Config.Name}) P25D: Traffic *VOICE FRAME    * PEER {e.PeerId} SRC_ID {e.SrcId} TGID {e.DstId} VC{n} ERRS {errs} [STREAM ID {e.StreamId}]");
+                        //Log.Logger.Debug($"IMBE {FneUtils.HexDump(imbe)}");
+                        //Console.WriteLine($"SAMPLE BUFFER {FneUtils.HexDump(samples)}");
+
+                        int pcmIdx = 0;
+                        byte[] pcmData = new byte[samples.Length * 2];
+                        for (int i = 0; i < samples.Length; i++)
+                        {
+                            pcmData[pcmIdx] = (byte)(samples[i] & 0xFF);
+                            pcmData[pcmIdx + 1] = (byte)((samples[i] >> 8) & 0xFF);
+                            pcmIdx += 2;
+                        }
+
+                        _audioManager.AddTalkgroupStream(e.DstId.ToString(), pcmData);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Audio Decode Exception: {ex.Message}");
+            }
+        }
+
+        private uint GetUniqueRid(string ridString)
+        {
+            uint rid;
+
+            // Try to parse the RID, default to 1000 if parsing fails
+            if (!UInt32.TryParse(ridString, out rid))
+            {
+                rid = 1000;
+            }
+
+            // Ensure uniqueness by incrementing if needed
+            while (usedRids.Contains(rid))
+            {
+                rid++;
+            }
+
+            // Store the new unique RID
+            usedRids.Add(rid);
+
+            return rid;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="e"></param>
+        public void KeyResponseReceived(KeyResponseEvent e)
+        {
+            //Console.WriteLine($"Message ID: {e.KmmKey.MessageId}");
+            //Console.WriteLine($"Decrypt Info Format: {e.KmmKey.DecryptInfoFmt}");
+            //Console.WriteLine($"Algorithm ID: {e.KmmKey.AlgId}");
+            //Console.WriteLine($"Key ID: {e.KmmKey.KeyId}");
+            //Console.WriteLine($"Keyset ID: {e.KmmKey.KeysetItem.KeysetId}");
+            //Console.WriteLine($"Keyset Alg ID: {e.KmmKey.KeysetItem.AlgId}");
+            //Console.WriteLine($"Keyset Key Length: {e.KmmKey.KeysetItem.KeyLength}");
+            //Console.WriteLine($"Number of Keys: {e.KmmKey.KeysetItem.Keys.Count}");
+
+            foreach (var key in e.KmmKey.KeysetItem.Keys)
+            {
+                //Console.WriteLine($"  Key Format: {key.KeyFormat}");
+                //Console.WriteLine($"  SLN: {key.Sln}");
+                //Console.WriteLine($"  Key ID: {key.KeyId}");
+                //Console.WriteLine($"  Key Data: {BitConverter.ToString(key.GetKey())}");
+
+                Dispatcher.Invoke(() =>
+                {
+                    foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+                    {
+                        Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                        Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                        if (!system.IsDvm)
+                            continue;
+
+                        PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                        if (cpgChannel.GetKeyId() != 0 && cpgChannel.GetAlgoId() != 0)
+                            channel.crypter.AddKey(key.KeyId, e.KmmKey.KeysetItem.AlgId, key.GetKey());
+                    }
+                });
+            }
+        }
+
+        private void KeyStatus_Click(object sender, RoutedEventArgs e)
+        {
+            KeyStatusWindow keyStatus = new KeyStatusWindow(Codeplug, this);
+            keyStatus.Show();
+        }
+
+        /// <summary>
+        /// Event handler used to process incoming P25 data.
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        public void P25DataReceived(P25DataReceivedEvent e, DateTime pktTime)
+        {
+            uint sysId = (uint)((e.Data[11U] << 8) | (e.Data[12U] << 0));
+            uint netId = FneUtils.Bytes3ToUInt32(e.Data, 16);
+            byte control = e.Data[14U];
+
+            byte len = e.Data[23];
+            byte[] data = new byte[len];
+            for (int i = 24; i < len; i++)
+                data[i - 24] = e.Data[i];
+
+            Dispatcher.Invoke(() =>
+            {
+                foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+                {
+                    Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                    Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                    bool isEmergency = false;
+                    bool encrypted = false;
+
+                    if (!system.IsDvm)
+                        continue;
+
+                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                    if (!channel.IsEnabled)
+                        continue;
+
+                    if (cpgChannel.Tgid != e.DstId.ToString())
+                        continue;
+
+                    if (!systemStatuses.ContainsKey(cpgChannel.Name))
+                    {
+                        systemStatuses[cpgChannel.Name] = new SlotStatus();
+                    }
+
+                    if (channel.decoder == null)
+                    {
+                        channel.decoder = new MBEDecoder(MBE_MODE.IMBE_88BIT);
+                    }
+
+                    SlotStatus slot = systemStatuses[cpgChannel.Name];
+
+                    // if this is an LDU1 see if this is the first LDU with HDU encryption data
+                    if (e.DUID == P25DUID.LDU1)
+                    {
+                        byte frameType = e.Data[180];
+
+                        // get the initial MI and other enc info (bug found by the screeeeeeeeech on initial tx...)
+                        if (frameType == P25Defines.P25_FT_HDU_VALID)
+                        {
+                            channel.algId = e.Data[181];
+                            channel.kId = (ushort)((e.Data[182] << 8) | e.Data[183]);
+                            Array.Copy(e.Data, 184, channel.mi, 0, P25Defines.P25_MI_LENGTH);
+
+                            channel.crypter.Prepare(channel.algId, channel.kId, P25Crypto.ProtocolType.P25Phase1, channel.mi);
+
+                            encrypted = true;
+                        }
+                    }
+
+                    // is this a new call stream?
+                    if (e.StreamId != slot.RxStreamId && ((e.DUID != P25DUID.TDU) && (e.DUID != P25DUID.TDULC)))
+                    {
+                        channel.IsReceiving = true;
+                        slot.RxStart = pktTime;
+                        Console.WriteLine($"({system.Name}) P25D: Traffic *CALL START     * PEER {e.PeerId} SRC_ID {e.SrcId} TGID {e.DstId} [STREAM ID {e.StreamId}]");
+
+                        FneUtils.Memset(channel.mi, 0x00, P25Defines.P25_MI_LENGTH);
+
+                        callHistoryWindow.AddCall(cpgChannel.Name, (int)e.SrcId, (int)e.DstId);
+                        callHistoryWindow.ChannelKeyed(cpgChannel.Name, (int)e.SrcId, encrypted);
+
+                        string alias = string.Empty;
+
+                        try
+                        {
+                            alias = AliasTools.GetAliasByRid(system.RidAlias, (int)e.SrcId);
+                        }
+                        catch (Exception) { }
+
+                        if (alias.IsNullOrEmpty())
+                            channel.LastSrcId = "Last SRC: " + e.SrcId;
+                        else
+                            channel.LastSrcId = "Last: " + alias;
+
+                        if (channel.algId != P25Defines.P25_ALGO_UNENCRYPT)
+                            channel.Background = (Brush)new BrushConverter().ConvertFrom("#ffdeaf0a");
+                        else
+                            channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
+                    }
+
+                    // Is the call over?
+                    if (((e.DUID == P25DUID.TDU) || (e.DUID == P25DUID.TDULC)) && (slot.RxType != fnecore.FrameType.TERMINATOR))
+                    {
+                        channel.IsReceiving = false;
+                        TimeSpan callDuration = pktTime - slot.RxStart;
+                        Console.WriteLine($"({system.Name}) P25D: Traffic *CALL END       * PEER {e.PeerId} SRC_ID {e.SrcId} TGID {e.DstId} DUR {callDuration} [STREAM ID {e.StreamId}]");
+                        channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF0B004B");
+                        callHistoryWindow.ChannelUnkeyed(cpgChannel.Name, (int)e.SrcId);
+                        return;
+                    }
+
+                    if ((channel.algId != cpgChannel.GetAlgoId() || channel.kId != cpgChannel.GetKeyId()) && channel.algId != P25Defines.P25_ALGO_UNENCRYPT)
+                        continue;
+
+                    byte[] newMI = new byte[P25Defines.P25_MI_LENGTH];
+
+                    int count = 0;
+
+                    switch (e.DUID)
+                    {
+                        case P25DUID.LDU1:
+                            {
+                                // The '62', '63', '64', '65', '66', '67', '68', '69', '6A' records are LDU1
+                                if ((data[0U] == 0x62U) && (data[22U] == 0x63U) &&
+                                    (data[36U] == 0x64U) && (data[53U] == 0x65U) &&
+                                    (data[70U] == 0x66U) && (data[87U] == 0x67U) &&
+                                    (data[104U] == 0x68U) && (data[121U] == 0x69U) &&
+                                    (data[138U] == 0x6AU))
+                                {
+                                    // The '62' record - IMBE Voice 1
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 0, 22);
+                                    count += 22;
+
+                                    // The '63' record - IMBE Voice 2
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 25, 14);
+                                    count += 14;
+
+                                    // The '64' record - IMBE Voice 3 + Link Control
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 50, 17);
+                                    byte serviceOptions = data[count + 3];
+                                    isEmergency = (serviceOptions & 0x80) == 0x80;
+                                    count += 17;
+
+                                    // The '65' record - IMBE Voice 4 + Link Control
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 75, 17);
+                                    count += 17;
+
+                                    // The '66' record - IMBE Voice 5 + Link Control
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 100, 17);
+                                    count += 17;
+
+                                    // The '67' record - IMBE Voice 6 + Link Control
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 125, 17);
+                                    count += 17;
+
+                                    // The '68' record - IMBE Voice 7 + Link Control
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 150, 17);
+                                    count += 17;
+
+                                    // The '69' record - IMBE Voice 8 + Link Control
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 175, 17);
+                                    count += 17;
+
+                                    // The '6A' record - IMBE Voice 9 + Low Speed Data
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 200, 16);
+                                    count += 16;
+
+                                    // decode 9 IMBE codewords into PCM samples
+                                    P25DecodeAudioFrame(channel.netLDU1, e, handler, channel, isEmergency);
+                                }
+                            }
+                            break;
+                        case P25DUID.LDU2:
+                            {
+                                // The '6B', '6C', '6D', '6E', '6F', '70', '71', '72', '73' records are LDU2
+                                if ((data[0U] == 0x6BU) && (data[22U] == 0x6CU) &&
+                                    (data[36U] == 0x6DU) && (data[53U] == 0x6EU) &&
+                                    (data[70U] == 0x6FU) && (data[87U] == 0x70U) &&
+                                    (data[104U] == 0x71U) && (data[121U] == 0x72U) &&
+                                    (data[138U] == 0x73U))
+                                {
+                                    // The '6B' record - IMBE Voice 10
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 0, 22);
+                                    count += 22;
+
+                                    // The '6C' record - IMBE Voice 11
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 25, 14);
+                                    count += 14;
+
+                                    // The '6D' record - IMBE Voice 12 + Encryption Sync
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 50, 17);
+                                    newMI[0] = data[count + 1];
+                                    newMI[1] = data[count + 2];
+                                    newMI[2] = data[count + 3];
+                                    count += 17;
+
+                                    // The '6E' record - IMBE Voice 13 + Encryption Sync
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 75, 17);
+                                    newMI[3] = data[count + 1];
+                                    newMI[4] = data[count + 2];
+                                    newMI[5] = data[count + 3];
+                                    count += 17;
+
+                                    // The '6F' record - IMBE Voice 14 + Encryption Sync
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 100, 17);
+                                    newMI[6] = data[count + 1];
+                                    newMI[7] = data[count + 2];
+                                    newMI[8] = data[count + 3];
+                                    count += 17;
+
+                                    // The '70' record - IMBE Voice 15 + Encryption Sync
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 125, 17);
+                                    channel.algId = data[count + 1];                                    // Algorithm ID
+                                    channel.kId = (ushort)((data[count + 2] << 8) | data[count + 3]);   // Key ID
+                                    count += 17;
+
+                                    // The '71' record - IMBE Voice 16 + Encryption Sync
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 150, 17);
+                                    count += 17;
+
+                                    // The '72' record - IMBE Voice 17 + Encryption Sync
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 175, 17);
+                                    count += 17;
+
+                                    // The '73' record - IMBE Voice 18 + Low Speed Data
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 200, 16);
+                                    count += 16;
+
+                                    if (channel.p25Errs > 0) // temp, need to actually get errors I guess
+                                        P25Crypto.CycleP25Lfsr(channel.mi);
+                                    else
+                                        Array.Copy(newMI, channel.mi, P25Defines.P25_MI_LENGTH);
+
+                                    // decode 9 IMBE codewords into PCM samples
+                                    P25DecodeAudioFrame(channel.netLDU2, e, handler, channel, isEmergency, P25Crypto.FrameType.LDU2);
+                                }
+                            }
+                            break;
+                    }
+
+                    if (channel.mi != null)
+                        channel.crypter.Prepare(channel.algId, channel.kId, P25Crypto.ProtocolType.P25Phase1, channel.mi);
+
+                    slot.RxRFS = e.SrcId;
+                    slot.RxType = e.FrameType;
+                    slot.RxTGId = e.DstId;
+                    slot.RxTime = pktTime;
+                    slot.RxStreamId = e.StreamId;
+
+                }
+            });
+        }
+
+        private void CallHist_Click(object sender, RoutedEventArgs e)
+        {
+            callHistoryWindow.Show();
+        }
+
+        private void MainWindow_OnClosed(object sender, EventArgs e)
+        {
+            Console.WriteLine("=== Application Shutdown Started ===");
+
+            // Stop and dispose timers FIRST to prevent any new operations
+            try
+            {
+                Console.WriteLine("Stopping timers...");
+                _channelHoldTimer?.Stop();
+                _channelHoldTimer?.Dispose();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error disposing timer: {ex.Message}");
+            }
+
+            // Cleanup hotkeys early
+            try
+            {
+                _globalHotKeyManager?.UnregisterAllHotKeys();
+                _channelHotKeyManager?.UnregisterAllChannelHotkeys();
+                _globalHotKeyManager?.Dispose();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error disposing hotkeys: {ex.Message}");
+            }
+
+            // Disconnect all WebSocket connections
+            try
+            {
+                Console.WriteLine("Disconnecting WebSocket connections...");
+                _webSocketManager?.ClearAllWebSocketHandlers();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error disconnecting websockets: {ex.Message}");
+            }
+
+            // Stop all FNE systems
+            try
+            {
+                Console.WriteLine("Stopping FNE systems...");
+                _fneSystemManager?.ClearAll();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error stopping FNE systems: {ex.Message}");
+            }
+
+            // Give connections a moment to close gracefully
+            Console.WriteLine("Waiting for connections to close...");
+            System.Threading.Thread.Sleep(1000);
+
+            // Stop and dispose audio recording
+            try
+            {
+                Console.WriteLine("Stopping audio recording...");
+                _waveIn?.StopRecording();
+                _waveIn?.Dispose();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error disposing audio: {ex.Message}");
+            }
+
+            // Stop emergency alert playback
+            try
+            {
+                _emergencyAlertPlayback?.Stop();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error stopping emergency playback: {ex.Message}");
+            }
+
+            // Save settings
+            try
+            {
+                _settingsManager?.SaveSettings();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error saving settings: {ex.Message}");
+            }
+
+            Console.WriteLine("Cleanup complete. Terminating process...");
+            
+            // Force immediate process termination
+            // This is necessary because background threads from WebSocket/FNE may not terminate cleanly
+            Environment.Exit(0);
+        }
+    }
+}
diff --git a/WhackerLinkConsoleV2/SettingsManager.cs b/WhackerLinkConsoleV2/SettingsManager.cs
index 96690b9..765703e 100644
--- a/WhackerLinkConsoleV2/SettingsManager.cs
+++ b/WhackerLinkConsoleV2/SettingsManager.cs
@@ -39,6 +39,14 @@ public class SettingsManager
         public Dictionary<string, ChannelPosition> AlertTonePositions { get; set; } = new Dictionary<string, ChannelPosition>();
         public Dictionary<string, int> ChannelOutputDevices { get; set; } = new Dictionary<string, int>();
 
+        // Hotkey bindings for global PTT
+        // Supports both single-key (e.g., "T", "P") and dual-key (e.g., "Ctrl+T", "Ctrl+P")
+        public string GlobalPttKeybind { get; set; } = "Ctrl+T";          // Global PTT across all selected channels
+        public bool EnableGlobalPttHotkey { get; set; } = true;
+        
+        // Controls whether hotkeys work when the application is not focused/tabbed out
+        public bool HotkeysWorkWhenUnfocused { get; set; } = true;
+
         public void LoadSettings()
         {
             if (!File.Exists(SettingsFilePath)) return;
@@ -59,6 +67,9 @@ public void LoadSettings()
                     AlertToneFilePaths = loadedSettings.AlertToneFilePaths ?? new List<string>();
                     AlertTonePositions = loadedSettings.AlertTonePositions ?? new Dictionary<string, ChannelPosition>();
                     ChannelOutputDevices = loadedSettings.ChannelOutputDevices ?? new Dictionary<string, int>();
+                    GlobalPttKeybind = loadedSettings.GlobalPttKeybind ?? "Ctrl+T";
+                    EnableGlobalPttHotkey = loadedSettings.EnableGlobalPttHotkey;
+                    HotkeysWorkWhenUnfocused = loadedSettings.HotkeysWorkWhenUnfocused;
                 }
             }
             catch (Exception ex)
diff --git a/WhackerLinkConsoleV2/WhackerLinkConsoleV2.csproj b/WhackerLinkConsoleV2/WhackerLinkConsoleV2.csproj
index 5441dd9..adbe062 100644
--- a/WhackerLinkConsoleV2/WhackerLinkConsoleV2.csproj
+++ b/WhackerLinkConsoleV2/WhackerLinkConsoleV2.csproj
@@ -9,6 +9,7 @@
     <Platforms>AnyCPU;x64;x86</Platforms>
     <Configurations>Debug;Release;WIN32</Configurations>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <ApplicationIcon>Assets\app-icon.ico</ApplicationIcon>
   </PropertyGroup>
 
   <ItemGroup>
@@ -38,6 +39,7 @@
     <Resource Include="Assets\alerttone.png" />
     <Resource Include="Assets\alerttone2.png" />
     <Resource Include="Assets\audio.png" />
+    <Resource Include="Assets\app-icon.ico" />
   </ItemGroup>
 
   <ItemGroup>
@@ -69,6 +71,7 @@
     <Resource Include="Assets\pageselect.png" />
     <Resource Include="Assets\pttselect.png" />
     <Resource Include="Assets\whackerlink-logo.png" />
+    <Resource Include="Assets\whackerlink-logo-icon.png" />
     <Resource Include="Assets\WhackerLinkLogoV2.png" />
     <Resource Include="Assets\WhackerLinkLogoV4.png" />
   </ItemGroup>