Catch SocketException when listing remote files

HyperbolicDownloader/GlobalSuppressions.cs

@@ -0,0 +1,8 @@
+// This file is used by Code Analysis to maintain SuppressMessage
+// attributes that are applied to this project.
+// Project-level suppressions either have no target or are given
+// a specific target and scoped to a namespace, type, member, etc.
+
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: SuppressMessage("Critical Code Smell", "S3998:Threads should not lock on objects with weak identity", Justification = "Not a problem in this case", Scope = "member", Target = "~M:HyperbolicDownloader.LogCommands.OnNotificationMessageRecived(System.Object,HyperbolicDownloaderApi.Managment.NotificationMessageEventArgs)")]

HyperbolicDownloader/HyperbolicDownloader.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
@@ -12,8 +12,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Console.Commander.NET" Version="1.0.1" />
+    <PackageReference Include="Console.Commander.NET" Version="1.0.2" />
-    <PackageReference Include="Stone_Red-C-Sharp-Utilities" Version="1.0.3.1" />
   </ItemGroup>
 
   <ItemGroup>

HyperbolicDownloader/InputHandler.cs

@@ -1,47 +1,62 @@
-using Commander_Net;
+using Commander;
+
+using CuteUtils.Misc;
 
 using HyperbolicDownloaderApi.Commands;
 using HyperbolicDownloaderApi.FileProcessing;
 using HyperbolicDownloaderApi.Networking;
 
-using Stone_Red_Utilities.ConsoleExtentions;
-
 namespace HyperbolicDownloader;
 
 internal class InputHandler
 {
-    private readonly Commander commander = new Commander();
+    private readonly Commander.Commander commander = new Commander.Commander();
     private bool exit = false;
 
-    public InputHandler(HostsManager hostsManager, FilesManager filesManager)
+    public InputHandler(HostsManager hostsManager, FilesManager filesManager, DirectoryWatcher directoryWatcher)
     {
         HostCommands hostCommands = new HostCommands(hostsManager);
         FileCommands fileCommands = new FileCommands(hostsManager, filesManager);
+        DirectoryCommands directoryCommands = new DirectoryCommands(directoryWatcher);
         DownloadCommands downloadCommands = new DownloadCommands(hostsManager, filesManager);
-        ClientCommands clientCommands = new ClientCommands();
+        StreamingCommands streamingCommands = new StreamingCommands(hostsManager);
 
-        _ = commander.Register(input => commander.PrintHelp(input), "help");
+        ClientCommands clientCommands = new ClientCommands();
+        LogCommands logCommands = new LogCommands();
+
+        _ = commander.Register(input => commander.PrintHelp(input), (HelpText)"Lists all commands.", "help", "h", "?");
         _ = commander.Register(_ => Console.Clear(), (HelpText)"Clears the console.", "clear", "cls");
         _ = commander.Register(_ => exit = true, (HelpText)"Exits the application.", "exit", "quit");
         _ = commander.Register(clientCommands.ShowInfo, (HelpText)"Displays the private and public IP address.", "info", "inf");
         _ = commander.Register(hostCommands.Discover, (HelpText)"Tries to find other active hosts on the local network.", "discover", "disc");
+        _ = commander.Register(hostCommands.Sync, (HelpText)"Syncs the host list", "sync");
+
+        Command logCommand = commander.Register((_) => logCommands.Log(false), (HelpText)"Displays live log.", "log");
+        _ = logCommand.Register((_) => logCommands.Log(true), (HelpText)"Displays live debug log.", "debug");
 
         Command getCommand = commander.Register(downloadCommands.GetFile, (HelpText)"Attempts to retrieve a file from another host using a hash.", "get");
         _ = getCommand.Register(downloadCommands.GetFileFrom, (HelpText)"Attempts to retrieve a file from another host using a .hyper file.", "from");
 
+        Command streamCommand = commander.Register(streamingCommands.StreamWav, (HelpText)"(EXPERIMENTAL) Attempts to stream a .wav file from another host using a hash.", "stream");
+        _ = streamCommand.Register(streamingCommands.GetWavStreamFrom, (HelpText)"(EXPERIMENTAL) Attempts to stream a .wav file from another host using a .hyper file.", "from");
+
         Command generateCommad = commander.Register(fileCommands.GenerateFileFull, (HelpText)"Generates a .hyper file from a file hash.", "generate", "gen");
         _ = generateCommad.Register(fileCommands.GenerateFileSingle, (HelpText)"Generates a .hyper file from a file hash without checking the known hosts. This adds only the local host to the file.", "noscan");
 
         Command addCommand = commander.Register(fileCommands.AddFile, (HelpText)"Adds a file to the tracking list.", "add");
         _ = addCommand.Register(fileCommands.AddFile, (HelpText)"Adds a file to the tracking list.", "file");
+        _ = addCommand.Register(directoryCommands.AddDirectory, (HelpText)"Adds a directory to the tracking list.", "directory", "dir");
         _ = addCommand.Register(hostCommands.AddHost, (HelpText)"Adds a host to the list of known hosts.", "host");
 
         Command removeCommand = commander.Register(fileCommands.RemoveFile, (HelpText)"Removes a file from the tracking list.", "remove", "rm");
         _ = removeCommand.Register(fileCommands.RemoveFile, (HelpText)"Removes a file from the tracking list.", "file");
+        _ = removeCommand.Register(directoryCommands.RemoveDirectory, (HelpText)"Removes a directory from the tracking list.", "directory", "dir");
         _ = removeCommand.Register(hostCommands.RemoveHost, (HelpText)"Removes a host from the list of known hosts.", "host");
 
         Command listCommand = commander.Register(fileCommands.ListFiles, (HelpText)"Lists all files.", "list", "ls");
-        _ = listCommand.Register(fileCommands.ListFiles, (HelpText)"Lists all files.", "files");
+        Command listFilesCommand = listCommand.Register(fileCommands.ListFiles, (HelpText)"Lists all files.", "files");
+        _ = listFilesCommand.Register(fileCommands.ListFilesRemote, (HelpText)"Lists all files of another host.", "remote");
+        _ = listCommand.Register(directoryCommands.ListDirectories, (HelpText)"Lists all directories.", "directories", "dirs");
         _ = listCommand.Register(hostCommands.ListHosts, (HelpText)"lists all hosts.", "hosts");
 
         _ = commander.Register(hostCommands.CheckActiveHosts, (HelpText)"Checks the status of known hosts.", "status", "check");
@@ -56,13 +71,18 @@ internal class InputHandler
             Console.CursorVisible = true;
 
             string input = Console.ReadLine()?.Trim() ?? string.Empty;
+            ExecuteInput(input);
+        }
+    }
 
+    public void ExecuteInput(string input)
+    {
         Console.CursorVisible = false;
         try
         {
             if (!commander.Execute(input, out _))
             {
-                    ConsoleExt.WriteLine("Unknown command!", ConsoleColor.Red);
+                ConsoleExt.WriteLine("Unknown command! Use `help` to list all commands.", ConsoleColor.Red);
             }
         }
         catch (Exception ex)
@@ -71,4 +91,3 @@ internal class InputHandler
         }
     }
 }
-}

HyperbolicDownloader/LogCommands.cs

@@ -0,0 +1,102 @@
+using CuteUtils.Misc;
+
+using HyperbolicDownloaderApi.Managment;
+
+using System.Net;
+
+namespace HyperbolicDownloader;
+
+internal class LogCommands
+{
+    private bool debug = false;
+
+    public void Log(bool debug)
+    {
+        this.debug = debug;
+
+        Console.Clear();
+
+        if (debug)
+        {
+            Console.WriteLine("Debug log opened");
+        }
+        else
+        {
+            Console.WriteLine("Log opened");
+        }
+
+        ApiManager.OnNotificationMessageRecived += OnNotificationMessageRecived;
+
+        char c = ' ';
+
+        do
+        {
+            if (c != '\0')
+            {
+                Console.WriteLine("Press 'q' to exit");
+            }
+            c = Console.ReadKey(true).KeyChar;
+        } while (c != 'q');
+
+        ApiManager.OnNotificationMessageRecived -= OnNotificationMessageRecived;
+
+        Console.Clear();
+        Console.ResetColor();
+
+        Console.WriteLine("Log closed");
+    }
+
+    private void OnNotificationMessageRecived(object? sender, NotificationMessageEventArgs e)
+    {
+        if (e.NotificationMessageType == NotificationMessageType.Log || (debug && e.NotificationMessageType == NotificationMessageType.Debug))
+        {
+            lock (Console.Out)
+            {
+                if (e.Message?.Contains('>') == true && IPAddress.TryParse(e.Message[..e.Message.IndexOf('>')].Trim(), out IPAddress? ipAddress))
+                {
+                    ConsoleExt.Write($"[{DateTime.Now}] ", ConsoleColor.Gray);
+
+                    if (e.NotificationMessageType == NotificationMessageType.Debug)
+                    {
+                        ConsoleExt.Write("[DEBUG] ", ConsoleColor.DarkYellow);
+                    }
+
+                    byte[] ipAddressBytes = ipAddress.GetAddressBytes();
+
+                    Array.Resize(ref ipAddressBytes, 8);
+
+                    ConsoleColor consoleColor = (BitConverter.ToInt64(ipAddressBytes) % 12) switch
+                    {
+                        0 => ConsoleColor.Red,
+                        1 => ConsoleColor.Green,
+                        2 => ConsoleColor.Yellow,
+                        3 => ConsoleColor.Blue,
+                        4 => ConsoleColor.Magenta,
+                        5 => ConsoleColor.Cyan,
+                        6 => ConsoleColor.DarkRed,
+                        7 => ConsoleColor.DarkGreen,
+                        8 => ConsoleColor.DarkYellow,
+                        9 => ConsoleColor.DarkBlue,
+                        10 => ConsoleColor.DarkMagenta,
+                        11 => ConsoleColor.DarkCyan,
+                        _ => ConsoleColor.White
+                    };
+
+                    ConsoleExt.Write(e.Message[..e.Message.IndexOf('>')], consoleColor);
+                    Console.Write(e.Message[e.Message.IndexOf('>')..]);
+                }
+                else
+                {
+                    ConsoleExt.Write($"[{DateTime.Now}] ", ConsoleColor.Gray);
+
+                    if (e.NotificationMessageType == NotificationMessageType.Debug)
+                    {
+                        ConsoleExt.Write("[DEBUG] ", ConsoleColor.DarkYellow);
+                    }
+
+                    Console.Write(e.Message);
+                }
+            }
+        }
+    }
+}

HyperbolicDownloader/Program.cs

@@ -1,9 +1,10 @@
-using HyperbolicDownloaderApi.FileProcessing;
+using CuteUtils.Misc;
+
+using HyperbolicDownloaderApi.FileProcessing;
 using HyperbolicDownloaderApi.Managment;
 using HyperbolicDownloaderApi.Networking;
 
-using Stone_Red_Utilities.ConsoleExtentions;
+using System.Reflection;
-
 using System.Text.Json;
 
 namespace HyperbolicDownloader;
@@ -19,30 +20,48 @@ internal static class Program
 
         ApiManager.OnNotificationMessageRecived += ApiManager_OnNotificationMessageRecived;
 
+        if (!Directory.Exists(ApiConfiguration.BasePath))
+        {
+            _ = Directory.CreateDirectory(ApiConfiguration.BasePath);
+        }
+
         if (File.Exists(ApiConfiguration.HostsFilePath))
         {
             string hostsJson = await File.ReadAllTextAsync(ApiConfiguration.HostsFilePath);
-            apiManager.HostsManager.AddRange(JsonSerializer.Deserialize<List<NetworkSocket>>(hostsJson) ?? new());
+            _ = apiManager.HostsManager.AddRange(JsonSerializer.Deserialize<List<NetworkSocket>>(hostsJson) ?? []);
         }
 
         if (File.Exists(ApiConfiguration.FilesInfoPath))
         {
             string filesJson = await File.ReadAllTextAsync(ApiConfiguration.FilesInfoPath);
-            apiManager.FilesManager.AddRange(JsonSerializer.Deserialize<List<PrivateHyperFileInfo>>(filesJson) ?? new());
+            apiManager.FilesManager.AddRange(JsonSerializer.Deserialize<List<PrivateHyperFileInfo>>(filesJson) ?? []);
         }
 
-        InputHandler inputHandler = new InputHandler(apiManager.HostsManager, apiManager.FilesManager);
+        if (File.Exists(ApiConfiguration.DirectoriesInfoPath))
+        {
+            string directoriesJson = await File.ReadAllTextAsync(ApiConfiguration.DirectoriesInfoPath);
+            apiManager.DirectoryWatcher.AddRange(JsonSerializer.Deserialize<List<string>>(directoriesJson) ?? []);
+        }
+
+        Console.WriteLine($"HyperbolicDownloader - {Assembly.GetExecutingAssembly().GetName().Version}");
+        ConsoleExt.WriteLine("https://github.com/Stone-Red-Code/HyperbolicDownloader", ConsoleColor.Blue);
+        Console.WriteLine();
+
+        InputHandler inputHandler = new InputHandler(apiManager.HostsManager, apiManager.FilesManager, apiManager.DirectoryWatcher);
 
         if (args.Length > 0 && File.Exists(args[0]))
         {
             HyperbolicDownloaderApi.Commands.DownloadCommands downloadCommands = new HyperbolicDownloaderApi.Commands.DownloadCommands(apiManager.HostsManager, apiManager.FilesManager);
             downloadCommands.GetFileFrom(args[0]);
-            Console.WriteLine("Do you want to continue using this instance? [y/N]");
+            _ = Console.ReadLine();
-            if (char.ToLower(Console.ReadKey().KeyChar) != 'y')
-            {
             return;
         }
+        else if (args.Length > 0)
+        {
+            ConsoleExt.WriteLine("Warning! You are using command line arguments, which can lead to unexpected behavior with some commands.", ConsoleColor.Yellow);
             Console.WriteLine();
+            inputHandler.ExecuteInput(string.Join(' ', args));
+            return;
         }
 
         await Initialize();
@@ -53,6 +72,8 @@ internal static class Program
 
     private static async Task Initialize()
     {
+        apiManager.DirectoryWatcher.Start();
+
         Console.WriteLine("Searching for a UPnP/NAT-PMP device...");
         _ = await ApiManager.OpenPorts();
 
@@ -63,10 +84,15 @@ internal static class Program
         if (!apiManager.StartTcpListener())
         {
             _ = Console.ReadLine();
+            Environment.Exit(-1);
         }
 
-        Console.WriteLine("Starting broadcast listener...");
+        Console.WriteLine("Starting UDP listener...");
-        apiManager.StartBroadcastListener();
+        if (!apiManager.StartBroadcastListener())
+        {
+            _ = Console.ReadLine();
+            Environment.Exit(-2);
+        }
 
         int activeHostsCount = 0;
         if (apiManager.HostsManager.Count > 0)
@@ -78,7 +104,7 @@ internal static class Program
         if (activeHostsCount == 0)
         {
             ConsoleExt.WriteLine("No active hosts found!", ConsoleColor.Red);
-            ConsoleExt.WriteLine("Use 'add host xxx.xxx.xxx.xxx:yyyy' to add a new host or use 'discover' to find hosts in the local network.", ConsoleColor.Red);
+            ConsoleExt.WriteLine("Use 'add host <ip address>:<port>' to add a new host or use 'discover' to find hosts in the local network.", ConsoleColor.Red);
         }
 
         Console.WriteLine($"{apiManager.HostsManager.Count} known host(s).");
@@ -102,5 +128,6 @@ internal static class Program
     {
         ApiManager.ClosePorts();
         apiManager.HostsManager.SaveHosts();
+        Environment.Exit(0);
     }
 }

HyperbolicDownloaderApi/Commands/DirectoryCommands.cs

@@ -0,0 +1,81 @@
+using HyperbolicDownloaderApi.FileProcessing;
+using HyperbolicDownloaderApi.Managment;
+
+namespace HyperbolicDownloaderApi.Commands;
+
+public class DirectoryCommands(DirectoryWatcher directoryWatcher)
+{
+    public void AddDirectory(string directoryPath)
+    {
+        if (directoryWatcher.TryAdd(directoryPath, out string? message))
+        {
+            ApiManager.SendNotificationMessageNewLine($"Added directory: {directoryPath}", NotificationMessageType.Success);
+        }
+        else
+        {
+            ApiManager.SendNotificationMessageNewLine(message!, NotificationMessageType.Error);
+        }
+    }
+
+    public void RemoveDirectory(string args)
+    {
+        if (int.TryParse(args, out int index))
+        {
+            List<string> fileInfos = directoryWatcher.ToList();
+
+            if (index < 1 || index > fileInfos.Count)
+            {
+                ApiManager.SendNotificationMessageNewLine("Invalid index!", NotificationMessageType.Error);
+                return;
+            }
+
+            args = fileInfos[index - 1];
+        }
+
+        if (directoryWatcher.TryRemove(args))
+        {
+            ApiManager.SendNotificationMessageNewLine($"Removed directory: {args}", NotificationMessageType.Success);
+        }
+        else
+        {
+            ApiManager.SendNotificationMessageNewLine("Directory is not tracked!", NotificationMessageType.Error);
+        }
+    }
+
+    public void ListDirectories(string searchString)
+    {
+        int index = 0;
+        int directoryCount = 0;
+        List<string> directoryInfos = directoryWatcher.ToList();
+
+        if (directoryInfos.Count == 0)
+        {
+            ApiManager.SendNotificationMessageNewLine("No tracked directories!", NotificationMessageType.Warning);
+            return;
+        }
+
+        foreach (string directoryInfo in directoryInfos)
+        {
+            index++;
+
+            if (!string.IsNullOrWhiteSpace(searchString) && !directoryInfo.Contains(searchString, StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            directoryCount++;
+
+            ApiManager.SendNotificationMessageNewLine($"{index}) {directoryInfo}");
+            ApiManager.SendNotificationMessageNewLine(string.Empty);
+        }
+
+        if (directoryCount == 0)
+        {
+            ApiManager.SendNotificationMessage($"No directories found containing \"{searchString}\".", NotificationMessageType.Warning);
+        }
+        else
+        {
+            Console.CursorTop--;
+        }
+    }
+}

HyperbolicDownloaderApi/Commands/DownloadCommands.cs

@@ -1,8 +1,9 @@
-using HyperbolicDownloaderApi.FileProcessing;
+using CuteUtils;
+
+using HyperbolicDownloaderApi.FileProcessing;
 using HyperbolicDownloaderApi.Managment;
 using HyperbolicDownloaderApi.Networking;
-
+using HyperbolicDownloaderApi.Utilities;
-using Stone_Red_Utilities.StringExtentions;
 
 using System.Diagnostics;
 using System.Net;
@@ -12,17 +13,8 @@ using System.Text.Json;
 
 namespace HyperbolicDownloaderApi.Commands;
 
-public class DownloadCommands
+public class DownloadCommands(HostsManager hostsManager, FilesManager filesManager)
 {
-    private readonly HostsManager hostsManager;
-    private readonly FilesManager filesManager;
-
-    public DownloadCommands(HostsManager hostsManager, FilesManager filesManager)
-    {
-        this.hostsManager = hostsManager;
-        this.filesManager = filesManager;
-    }
-
     public void GetFileFrom(string path)
     {
         if (string.IsNullOrWhiteSpace(path))
@@ -36,6 +28,7 @@ public class DownloadCommands
         if (!File.Exists(fullPath))
         {
             ApiManager.SendNotificationMessageNewLine("Invalid file path!", NotificationMessageType.Error);
+            return;
         }
 
         string json = File.ReadAllText(fullPath);
@@ -47,7 +40,7 @@ public class DownloadCommands
             return;
         }
 
-        hostsManager.AddRange(publicHyperFileInfo.Hosts);
+        _ = hostsManager.AddRange(publicHyperFileInfo.Hosts);
         GetFile(publicHyperFileInfo.Hash);
     }
 
@@ -109,7 +102,7 @@ public class DownloadCommands
 
             byte[] bytesToSend = Encoding.ASCII.GetBytes($"Download {hash}");
             nwStream.Write(bytesToSend);
-            nwStream.ReadTimeout = 30000;
+            nwStream.ReadTimeout = 5000;
 
             int bytesRead;
             try
@@ -148,8 +141,6 @@ public class DownloadCommands
             ApiManager.SendNotificationMessageNewLine($"File name: {fileName}");
             ApiManager.SendNotificationMessageNewLine($"Starting download...");
 
-            int totalBytesRead = 0;
-
             if (!Directory.Exists(directoryPath))
             {
                 _ = Directory.CreateDirectory(directoryPath);
@@ -157,12 +148,14 @@ public class DownloadCommands
 
             using FileStream? fileStream = new FileStream(filePath, FileMode.Create);
 
-            int bytesInOneSecond = 0;
+            int totalBytesRead = 0;
-            int unitsPerSecond = 0;
+            int bytesPerSecond = 0;
-            string unit = "Kb";
+            int transferRate = 0;
+            TimeSpan timeRemaining = TimeSpan.Zero;
 
             Stopwatch stopWatch = new Stopwatch();
             stopWatch.Start();
+
             while (totalBytesRead < fileSize)
             {
                 try
@@ -182,26 +175,18 @@ public class DownloadCommands
                 fileStream.Write(reciveBuffer, 0, bytesRead);
                 totalBytesRead += bytesRead;
 
-                bytesInOneSecond += bytesRead;
+                bytesPerSecond += bytesRead;
 
                 if (stopWatch.Elapsed.TotalSeconds >= 1)
                 {
-                    unitsPerSecond = (int)(bytesInOneSecond * stopWatch.Elapsed.TotalSeconds);
+                    transferRate = bytesPerSecond;
-                    if (unitsPerSecond > 125000)
+                    host.DownloadSpeed = (host.DownloadSpeed + bytesPerSecond) / 2;
-                    {
+                    timeRemaining = TimeSpan.FromSeconds((fileSize - totalBytesRead) / (double)host.DownloadSpeed);
-                        unitsPerSecond /= 125000;
+                    bytesPerSecond = 0;
-                        unit = "Mb";
-                    }
-                    else
-                    {
-                        unitsPerSecond /= 125;
-                        unit = "Kb";
-                    }
-                    bytesInOneSecond = 0;
                     stopWatch.Restart();
                 }
 
-                ApiManager.SendNotificationMessage($"\rDownloading: {Math.Clamp(Math.Ceiling(100d / fileSize * totalBytesRead), 0, 100)}% {totalBytesRead / 1000}/{fileSize / 1000}KB [{unitsPerSecond}{unit}/s]    ");
+                ApiManager.SendNotificationMessage($"\rDownloading: [{Math.Clamp(Math.Ceiling(100d / fileSize * totalBytesRead), 0, 100)}%] [{UnitFormatter.FileSize(totalBytesRead)}/{UnitFormatter.FileSize(fileSize)}] [{UnitFormatter.TransferRate(transferRate)}] [ETA: {timeRemaining:hh\\:mm\\:ss}]      ");
             }
 
             fileStream.Close();

HyperbolicDownloaderApi/Commands/FileCommands.cs

@@ -2,22 +2,16 @@
 using HyperbolicDownloaderApi.Managment;
 using HyperbolicDownloaderApi.Networking;
 
+using System.Diagnostics;
 using System.Net;
+using System.Net.Sockets;
 using System.Text.Json;
 
 namespace HyperbolicDownloaderApi.Commands;
 
-public class FileCommands
+public class FileCommands(HostsManager hostsManager, FilesManager filesManager)
 {
-    private readonly HostsManager hostsManager;
+    private readonly JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions { WriteIndented = true };
-
-    private readonly FilesManager filesManager;
-
-    public FileCommands(HostsManager hostsManager, FilesManager filesManager)
-    {
-        this.hostsManager = hostsManager;
-        this.filesManager = filesManager;
-    }
 
     public void AddFile(string path)
     {
@@ -32,11 +26,24 @@ public class FileCommands
         }
     }
 
-    public void RemoveFile(string hash)
+    public void RemoveFile(string args)
     {
-        hash = hash.Trim().ToLower();
+        args = args.Trim().ToLower();
 
-        if (filesManager.TryRemove(hash))
+        if (int.TryParse(args, out int index))
+        {
+            List<PrivateHyperFileInfo> fileInfos = filesManager.ToList();
+
+            if (index < 1 || index > fileInfos.Count)
+            {
+                ApiManager.SendNotificationMessageNewLine("Invalid index!", NotificationMessageType.Error);
+                return;
+            }
+
+            args = fileInfos[index - 1].Hash;
+        }
+
+        if (filesManager.TryRemove(args))
         {
             ApiManager.SendNotificationMessageNewLine($"Successfully removed file!", NotificationMessageType.Success);
         }
@@ -46,9 +53,10 @@ public class FileCommands
         }
     }
 
-    public void ListFiles(string _)
+    public void ListFiles(string searchString)
     {
         int index = 0;
+        int fileCount = 0;
         List<PrivateHyperFileInfo> fileInfos = filesManager.ToList();
 
         if (fileInfos.Count == 0)
@@ -60,14 +68,129 @@ public class FileCommands
         foreach (PrivateHyperFileInfo fileInfo in fileInfos)
         {
             index++;
+
+            if (!string.IsNullOrWhiteSpace(searchString) && !fileInfo.FilePath.Contains(searchString, StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            fileCount++;
+
             ApiManager.SendNotificationMessageNewLine($"{index}) {fileInfo.FilePath}");
             ApiManager.SendNotificationMessageNewLine($"Hash: {fileInfo.Hash}");
             ApiManager.SendNotificationMessageNewLine(string.Empty);
         }
+
+        if (fileCount == 0)
+        {
+            ApiManager.SendNotificationMessage($"No files found containing \"{searchString}\".", NotificationMessageType.Warning);
+        }
+        else
+        {
+            Console.CursorTop--;
+        }
+    }
+
+    public void ListFilesRemote(string args)
+    {
+        args = args.Trim();
+
+        string searchString = string.Empty;
+
+        if (args.Contains(' '))
+        {
+            searchString = args.Substring(args.IndexOf(' ') + 1, args.Length - args.IndexOf(' ') - 1);
+            args = args[..args.IndexOf(' ')];
+        }
+
+        if (int.TryParse(args, out int index))
+        {
+            List<NetworkSocket> hosts = hostsManager.ToList();
+
+            if (index < 1 || index > hosts.Count)
+            {
+                ApiManager.SendNotificationMessageNewLine("Invalid index!", NotificationMessageType.Error);
+                return;
+            }
+
+            args = $"{hosts[index - 1].IPAddress}:{hosts[index - 1].Port}";
+        }
+
+        string[] parts = args.Split(":");
+
+        if (parts.Length != 2)
+        {
+            ApiManager.SendNotificationMessageNewLine("Invalid format! Use this format: <ip address>:<port>", NotificationMessageType.Error);
+            return;
+        }
+
+        string ipAddressInput = parts[0];
+        string portInput = parts[1];
+        IPAddress? ipAddress;
+
+        _ = int.TryParse(portInput, out int port);
+
+        if (port is < 1000 or >= 6000)
+        {
+            ApiManager.SendNotificationMessageNewLine("Invalid port number!", NotificationMessageType.Error);
+            return;
+        }
+        else if (!IPAddress.TryParse(ipAddressInput, out ipAddress))
+        {
+            try
+            {
+                ipAddress = Dns.GetHostAddresses(ipAddressInput).FirstOrDefault();
+            }
+            catch (SocketException ex)
+            {
+                Debug.WriteLine(ex);
+            }
+        }
+
+        if (ipAddress is null)
+        {
+            ApiManager.SendNotificationMessageNewLine("Invalid IP address!", NotificationMessageType.Error);
+            return;
+        }
+
+        ApiManager.SendNotificationMessageNewLine($"Requesting file list from {ipAddress}:{port}...");
+
+        Task<List<HyperFileDto>?> sendTask = NetworkClient.SendAsync<List<HyperFileDto>>(ipAddress, port, "GetFilesList", searchString);
+
+        _ = sendTask.Wait(1000);
+
+        if (!sendTask.IsCompletedSuccessfully)
+        {
+            ApiManager.SendNotificationMessageNewLine("Invalid host!", NotificationMessageType.Error);
+            return;
+        }
+
+        List<HyperFileDto>? fileInfos = sendTask.Result;
+
+        if (fileInfos?.Count == 0 && !string.IsNullOrEmpty(searchString))
+        {
+            ApiManager.SendNotificationMessageNewLine($"No files found containing \"{searchString}\".", NotificationMessageType.Warning);
+        }
+        else if (fileInfos is null || fileInfos.Count == 0)
+        {
+            ApiManager.SendNotificationMessageNewLine("No tracked files!", NotificationMessageType.Warning);
+            return;
+        }
+
+        index = 0;
+
+        foreach (HyperFileDto fileInfo in fileInfos)
+        {
+            index++;
+
+            ApiManager.SendNotificationMessageNewLine($"{index}) {fileInfo.Name}");
+            ApiManager.SendNotificationMessageNewLine($"Hash: {fileInfo.Hash}");
+            ApiManager.SendNotificationMessageNewLine(string.Empty);
+        }
         Console.CursorTop--;
     }
 
-    public void GenerateFileSingle(string hash)
+    public void GenerateFileSingle(string args)
     {
         string directoryPath = Path.Combine(ApiConfiguration.BasePath, "GeneratedFiles");
         if (!Directory.Exists(directoryPath))
@@ -75,9 +198,23 @@ public class FileCommands
             _ = Directory.CreateDirectory(directoryPath);
         }
 
-        hash = hash.Trim().ToLower();
+        args = args.Trim().ToLower();
 
-        if (!filesManager.TryGet(hash, out PrivateHyperFileInfo? localHyperFileInfo))
+        PrivateHyperFileInfo? localHyperFileInfo;
+
+        if (int.TryParse(args, out int index))
+        {
+            List<PrivateHyperFileInfo> fileInfos = filesManager.ToList();
+
+            if (index < 1 || index > fileInfos.Count)
+            {
+                ApiManager.SendNotificationMessageNewLine("Invalid index!", NotificationMessageType.Error);
+                return;
+            }
+
+            localHyperFileInfo = fileInfos[index - 1];
+        }
+        else if (!filesManager.TryGet(args, out localHyperFileInfo))
         {
             ApiManager.SendNotificationMessageNewLine("The file is not being tracked!", NotificationMessageType.Error);
             return;
@@ -86,7 +223,7 @@ public class FileCommands
         string fileName = Path.GetFileName(localHyperFileInfo!.FilePath);
         string filePath = Path.Combine(directoryPath, $"{fileName}.hyper");
 
-        PublicHyperFileInfo publicHyperFileInfo = new PublicHyperFileInfo(hash);
+        PublicHyperFileInfo publicHyperFileInfo = new PublicHyperFileInfo(localHyperFileInfo.Hash);
 
         NetworkSocket? localHost = ApiManager.GetLocalSocket();
         if (localHost is null)
@@ -97,8 +234,7 @@ public class FileCommands
 
         publicHyperFileInfo.Hosts.Add(localHost);
 
-        JsonSerializerOptions options = new JsonSerializerOptions { WriteIndented = true };
+        string json = JsonSerializer.Serialize(publicHyperFileInfo, jsonSerializerOptions);
-        string json = JsonSerializer.Serialize(publicHyperFileInfo, options);
 
         File.WriteAllText(filePath, json);
 
@@ -106,7 +242,7 @@ public class FileCommands
         ApiManager.SendNotificationMessageNewLine($"File saved at: {Path.GetFullPath(filePath)}");
     }
 
-    public void GenerateFileFull(string hash)
+    public void GenerateFileFull(string args)
     {
         string directoryPath = Path.Combine(ApiConfiguration.BasePath, "GeneratedFiles");
         if (!Directory.Exists(directoryPath))
@@ -114,9 +250,23 @@ public class FileCommands
             _ = Directory.CreateDirectory(directoryPath);
         }
 
-        hash = hash.Trim().ToLower();
+        args = args.Trim().ToLower();
 
-        if (!filesManager.TryGet(hash, out PrivateHyperFileInfo? localHyperFileInfo))
+        PrivateHyperFileInfo? localHyperFileInfo;
+
+        if (int.TryParse(args, out int index))
+        {
+            List<PrivateHyperFileInfo> fileInfos = filesManager.ToList();
+
+            if (index < 1 || index > fileInfos.Count)
+            {
+                ApiManager.SendNotificationMessageNewLine("Invalid index!", NotificationMessageType.Error);
+                return;
+            }
+
+            localHyperFileInfo = fileInfos[index - 1];
+        }
+        else if (!filesManager.TryGet(args, out localHyperFileInfo))
         {
             ApiManager.SendNotificationMessageNewLine("The file is not being tracked!", NotificationMessageType.Error);
             return;
@@ -125,7 +275,7 @@ public class FileCommands
         string fileName = Path.GetFileName(localHyperFileInfo!.FilePath);
         string filePath = Path.Combine(directoryPath, $"{fileName}.hyper");
 
-        PublicHyperFileInfo publicHyperFileInfo = new PublicHyperFileInfo(hash);
+        PublicHyperFileInfo publicHyperFileInfo = new PublicHyperFileInfo(localHyperFileInfo.Hash);
 
         NetworkSocket? localHost = ApiManager.GetLocalSocket();
         if (localHost is null)
@@ -148,7 +298,7 @@ public class FileCommands
 
             Console.CursorLeft = 0;
 
-            Task<bool> sendTask = NetworkClient.SendAsync<bool>(ipAddress!, host.Port, "HasFile", hash);
+            Task<bool> sendTask = NetworkClient.SendAsync<bool>(ipAddress!, host.Port, "HasFile", localHyperFileInfo.Hash);
 
             _ = sendTask.Wait(1000);
 
@@ -175,8 +325,7 @@ public class FileCommands
 
         publicHyperFileInfo.Hosts.Add(localHost);
 
-        JsonSerializerOptions options = new JsonSerializerOptions { WriteIndented = true };
+        string json = JsonSerializer.Serialize(publicHyperFileInfo, jsonSerializerOptions);
-        string json = JsonSerializer.Serialize(publicHyperFileInfo, options);
 
         File.WriteAllText(filePath, json);
 

HyperbolicDownloaderApi/Commands/HostCommands.cs

@@ -1,5 +1,6 @@
 using HyperbolicDownloaderApi.Managment;
 using HyperbolicDownloaderApi.Networking;
+using HyperbolicDownloaderApi.Utilities;
 
 using System.Diagnostics;
 using System.Net;
@@ -7,15 +8,8 @@ using System.Net.Sockets;
 
 namespace HyperbolicDownloaderApi.Commands;
 
-public class HostCommands
+public class HostCommands(HostsManager hostsManager)
 {
-    private readonly HostsManager hostsManager;
-
-    public HostCommands(HostsManager hostsManager)
-    {
-        this.hostsManager = hostsManager;
-    }
-
     public void Discover(string _)
     {
         ApiManager.SendNotificationMessageNewLine("Running local discovery routine...", NotificationMessageType.Info);
@@ -25,7 +19,16 @@ public class HostCommands
         BroadcastClient.Send(ApiConfiguration.BroadcastPort, ApiConfiguration.PrivatePort.ToString());
         Thread.Sleep(3000);
 
-        ApiManager.SendNotificationMessageNewLine($"Found {hostsManager.Count - hostsCountBefore} host(s)", NotificationMessageType.Info);
+        int newHostsCount = hostsManager.Count - hostsCountBefore;
+
+        if (newHostsCount > 0)
+        {
+            ApiManager.SendNotificationMessageNewLine($"Found {newHostsCount} host(s).", NotificationMessageType.Info);
+        }
+        else
+        {
+            ApiManager.SendNotificationMessageNewLine($"No new hosts added.", NotificationMessageType.Warning);
+        }
     }
 
     public void CheckActiveHosts(string _)
@@ -34,7 +37,7 @@ public class HostCommands
         if (activeHostsCount == 0)
         {
             ApiManager.SendNotificationMessageNewLine("No active hosts found!", NotificationMessageType.Error);
-            ApiManager.SendNotificationMessageNewLine("Use 'add host xxx.xxx.xxx.xxx:yyyy' to add a new host.", NotificationMessageType.Error);
+            ApiManager.SendNotificationMessageNewLine("Use 'add host <ip address>:<port>' to add a new host.", NotificationMessageType.Error);
         }
 
         ApiManager.SendNotificationMessageNewLine(string.Empty, NotificationMessageType.Info);
@@ -49,7 +52,7 @@ public class HostCommands
 
         if (hosts.Count == 0)
         {
-            ApiManager.SendNotificationMessageNewLine("No known hosts", NotificationMessageType.Warning);
+            ApiManager.SendNotificationMessageNewLine("No known hosts.", NotificationMessageType.Warning);
             return;
         }
 
@@ -58,6 +61,7 @@ public class HostCommands
             index++;
             ApiManager.SendNotificationMessageNewLine($"{index}) {host.IPAddress}:{host.Port}", NotificationMessageType.Info);
             ApiManager.SendNotificationMessageNewLine($"Last active: {host.LastActive}", NotificationMessageType.Info);
+            ApiManager.SendNotificationMessageNewLine($"Download speed: {(host.DownloadSpeed <= 0 ? "N/A" : UnitFormatter.TransferRate(host.DownloadSpeed))}", NotificationMessageType.Info);
             ApiManager.SendNotificationMessageNewLine(string.Empty, NotificationMessageType.Info);
         }
         Console.CursorTop--;
@@ -67,9 +71,23 @@ public class HostCommands
     {
         string[] parts = args.Split(":");
 
+        if (int.TryParse(args, out int index))
+        {
+            if (hostsManager.Count < index || index < 1)
+            {
+                ApiManager.SendNotificationMessageNewLine("Invalid index!", NotificationMessageType.Error);
+                return;
+            }
+
+            hostsManager.Remove(hostsManager.ToList()[index - 1], true);
+            ApiManager.SendNotificationMessageNewLine($"Successfully Removed host!", NotificationMessageType.Success);
+
+            return;
+        }
+
         if (parts.Length != 2)
         {
-            ApiManager.SendNotificationMessageNewLine("Invalid format! Use this format: (xxx.xxx.xxx.xxx:yyyy)", NotificationMessageType.Error);
+            ApiManager.SendNotificationMessageNewLine("Invalid format! Use this format: <ip address>:<port>", NotificationMessageType.Error);
             return;
         }
 
@@ -93,7 +111,7 @@ public class HostCommands
 
         if (!hostsManager.Contains(hostToRemove))
         {
-            ApiManager.SendNotificationMessageNewLine("Host not in list", NotificationMessageType.Error);
+            ApiManager.SendNotificationMessageNewLine("Host not in list!", NotificationMessageType.Error);
             return;
         }
 
@@ -107,7 +125,7 @@ public class HostCommands
 
         if (parts.Length != 2)
         {
-            ApiManager.SendNotificationMessageNewLine("Invalid format! Use this format: (xxx.xxx.xxx.xxx:yyyy)", NotificationMessageType.Error);
+            ApiManager.SendNotificationMessageNewLine("Invalid format! Use this format: <ip address>:<port>", NotificationMessageType.Error);
             return;
         }
 
@@ -144,25 +162,60 @@ public class HostCommands
         {
             ApiManager.SendNotificationMessageNewLine("Waiting for response...", NotificationMessageType.Info);
             NetworkSocket? localSocket = ApiManager.GetLocalSocket() ?? new NetworkSocket("0.0.0.0", 0, DateTime.MinValue);
-            List<NetworkSocket>? recivedHosts = NetworkClient.Send<List<NetworkSocket>>(ipAddress, port, "GetHostsList", localSocket);
+            Task<List<NetworkSocket>?> sendTask = NetworkClient.SendAsync<List<NetworkSocket>>(ipAddress, port, "GetHostsList", localSocket);
+
+            _ = sendTask.Wait(5000);
+
+            if (!sendTask.IsCompletedSuccessfully)
+            {
+                ApiManager.SendNotificationMessageNewLine($"No response from {ipAddress}:{port}", NotificationMessageType.Error);
+                return;
+            }
+
+            List<NetworkSocket>? recivedHosts = sendTask.Result;
 
             if (recivedHosts is not null)
             {
-                ApiManager.SendNotificationMessageNewLine($"Success! Added {recivedHosts.Count} new host(s).", NotificationMessageType.Success);
+                int newHosts = hostsManager.AddRange(recivedHosts);
-                hostsManager.AddRange(recivedHosts);
+
+                if (hostsManager.Add(new NetworkSocket(ipAddress.ToString(), port, DateTime.Now)))
+                {
+                    newHosts++;
+                }
+
+                if (newHosts > 0)
+                {
+                    ApiManager.SendNotificationMessageNewLine($"Added {newHosts} new host(s).", NotificationMessageType.Success);
+                }
+                else
+                {
+                    ApiManager.SendNotificationMessageNewLine($"No new hosts added.", NotificationMessageType.Warning);
+                }
             }
             else
             {
                 ApiManager.SendNotificationMessageNewLine($"Invalid response!", NotificationMessageType.Error);
             }
         }
-        catch (SocketException ex)
+        catch (Exception ex) when (ex is SocketException or IOException or AggregateException)
-        {
-            ApiManager.SendNotificationMessageNewLine($"Invalid host! Error message: {ex.Message}", NotificationMessageType.Error);
-        }
-        catch (IOException ex)
         {
             ApiManager.SendNotificationMessageNewLine($"Invalid host! Error message: {ex.Message}", NotificationMessageType.Error);
         }
     }
+
+    public void Sync(string _)
+    {
+        int newHostsCount = hostsManager.Sync();
+
+        ApiManager.SendNotificationMessageNewLine(string.Empty, NotificationMessageType.Info);
+
+        if (newHostsCount > 0)
+        {
+            ApiManager.SendNotificationMessage($"Added {newHostsCount} new host(s).");
+        }
+        else
+        {
+            ApiManager.SendNotificationMessage($"No new hosts added.", NotificationMessageType.Warning);
+        }
+    }
 }

HyperbolicDownloaderApi/Commands/StreamingCommands.cs

@@ -0,0 +1,247 @@
+using CuteUtils;
+
+using HyperbolicDownloaderApi.FileProcessing;
+using HyperbolicDownloaderApi.Managment;
+using HyperbolicDownloaderApi.Networking;
+
+using NAudio.Utils;
+using NAudio.Wave;
+
+using System.Diagnostics;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Text.Json;
+
+namespace HyperbolicDownloaderApi.Commands;
+
+public class StreamingCommands(HostsManager hostsManager)
+{
+    public void GetWavStreamFrom(string path)
+    {
+        if (string.IsNullOrWhiteSpace(path))
+        {
+            ApiManager.SendNotificationMessageNewLine("Path is empty!", NotificationMessageType.Error);
+            return;
+        }
+
+        string fullPath = Path.GetFullPath(path);
+
+        if (!File.Exists(fullPath))
+        {
+            ApiManager.SendNotificationMessageNewLine("Invalid file path!", NotificationMessageType.Error);
+            return;
+        }
+
+        string json = File.ReadAllText(fullPath);
+
+        PublicHyperFileInfo? publicHyperFileInfo = JsonSerializer.Deserialize<PublicHyperFileInfo>(json);
+        if (publicHyperFileInfo == null)
+        {
+            ApiManager.SendNotificationMessageNewLine("Parsing file failed!", NotificationMessageType.Error);
+            return;
+        }
+
+        _ = hostsManager.AddRange(publicHyperFileInfo.Hosts);
+        StreamWav(publicHyperFileInfo.Hash);
+    }
+
+    public void StreamWav(string hash)
+    {
+        if (string.IsNullOrEmpty(hash))
+        {
+            ApiManager.SendNotificationMessageNewLine("No hash value specified!", NotificationMessageType.Error);
+            return;
+        }
+
+        hash = hash.Trim().ToLower();
+
+        foreach (NetworkSocket host in hostsManager.ToList())
+        {
+            bool validIpAdress = IPAddress.TryParse(host.IPAddress, out IPAddress? ipAddress);
+
+            if (!validIpAdress)
+            {
+                hostsManager.Remove(host, true);
+                continue;
+            }
+
+            ApiManager.SendNotificationMessage($"{host.IPAddress}:{host.Port} > ???", NotificationMessageType.Warning);
+
+            Console.CursorLeft = 0;
+
+            Task<bool> sendTask = NetworkClient.SendAsync<bool>(ipAddress!, host.Port, "HasFile", hash);
+
+            _ = sendTask.Wait(1000);
+
+            if (!sendTask.IsCompletedSuccessfully)
+            {
+                Console.CursorLeft = 0;
+                ApiManager.SendNotificationMessageNewLine($"{host.IPAddress}:{host.Port} > Inactive", NotificationMessageType.Error);
+
+                hostsManager.Remove(host);
+                continue;
+            }
+            else if (!sendTask.Result)
+            {
+                host.LastActive = DateTime.Now;
+                ApiManager.SendNotificationMessageNewLine($"{host.IPAddress}:{host.Port} > Does not have the requested file", NotificationMessageType.Error);
+                continue;
+            }
+
+            host.LastActive = DateTime.Now;
+
+            ApiManager.SendNotificationMessageNewLine($"{host.IPAddress}:{host.Port} > Has the requested file", NotificationMessageType.Success);
+            ApiManager.SendNotificationMessageNewLine("Requesting stream...");
+
+            using TcpClient tcpClient = new TcpClient();
+            tcpClient.Connect(ipAddress!, host.Port);
+            tcpClient.ReceiveBufferSize = 6400;
+
+            NetworkStream nwStream = tcpClient.GetStream();
+            byte[] buffer = new byte[tcpClient.ReceiveBufferSize];
+            byte[] reciveBuffer = new byte[6400];
+
+            byte[] bytesToSend = Encoding.ASCII.GetBytes($"StreamWav {hash}");
+            nwStream.Write(bytesToSend);
+            nwStream.ReadTimeout = 5000;
+
+            int bytesRead;
+            try
+            {
+                bytesRead = nwStream.Read(buffer, 0, 1000);
+            }
+            catch (IOException)
+            {
+                ApiManager.SendNotificationMessageNewLine(string.Empty);
+                ApiManager.SendNotificationMessageNewLine("Lost connection to other host!", NotificationMessageType.Error);
+                continue;
+            }
+
+            string dataReceived = Encoding.ASCII.GetString(buffer, 0, bytesRead);
+
+            string[] parts = dataReceived.Split('/');
+
+            if (parts.Length != 5) //If received data does not contain 5 parts -> error
+            {
+                ApiManager.SendNotificationMessageNewLine(dataReceived, NotificationMessageType.Error);
+                continue;
+            }
+
+            if (!int.TryParse(parts[0], out int dataLength) || dataLength <= 0)
+            {
+                ApiManager.SendNotificationMessageNewLine("Invalid data length!", NotificationMessageType.Error);
+                continue;
+            }
+
+            if (!int.TryParse(parts[2], out int sampleRate) || sampleRate <= 0)
+            {
+                ApiManager.SendNotificationMessageNewLine("Invalid sample rate!", NotificationMessageType.Error);
+                continue;
+            }
+
+            if (!int.TryParse(parts[3], out int bitsPerSample) || bitsPerSample <= 0)
+            {
+                ApiManager.SendNotificationMessageNewLine("Invalid bits per sample!", NotificationMessageType.Error);
+                continue;
+            }
+
+            if (!int.TryParse(parts[4], out int channels) || channels <= 0)
+            {
+                ApiManager.SendNotificationMessageNewLine("Invalid channels!", NotificationMessageType.Error);
+                continue;
+            }
+
+            string fileName = parts[1].ToFileName();
+
+            ApiManager.SendNotificationMessageNewLine($"File name: {fileName}");
+            ApiManager.SendNotificationMessageNewLine($"Starting stream...");
+            ApiManager.SendNotificationMessageNewLine("Controls: [p]lay, [s]top");
+
+            BufferedWaveProvider bufferedWaveProvider = new BufferedWaveProvider(new WaveFormat(sampleRate, bitsPerSample, channels));
+            using WaveOutEvent player = new WaveOutEvent();
+            player.Init(bufferedWaveProvider);
+            player.Play();
+
+            int totalBytesRead = 0;
+            TimeSpan totalTime = TimeSpan.FromSeconds(dataLength / (double)sampleRate / channels / (bitsPerSample / 8));
+
+            Task task = Task.Run(async () =>
+            {
+                while (player.GetPosition() < dataLength && player.PlaybackState != PlaybackState.Stopped)
+                {
+                    Console.Write($"\r[{player.PlaybackState,-7}] {player.GetPositionTimeSpan():hh\\:mm\\:ss}/{totalTime:hh\\:mm\\:ss}");
+
+                    if (IsBufferNearlyFull(bufferedWaveProvider))
+                    {
+                        await Task.Delay(100);
+                        continue;
+                    }
+
+                    try
+                    {
+                        bytesRead = nwStream.Read(reciveBuffer, 0, reciveBuffer.Length);
+
+                        if (bytesRead == 0 && bufferedWaveProvider.BufferedBytes == 0)
+                        {
+                            player.Stop();
+                            ApiManager.SendNotificationMessage($"\r[{player.PlaybackState,-7}]");
+                        }
+                    }
+                    catch (IOException ex)
+                    {
+                        Debug.WriteLine(ex);
+                        ApiManager.SendNotificationMessageNewLine(string.Empty);
+                        ApiManager.SendNotificationMessageNewLine("Lost connection to other host!", NotificationMessageType.Error);
+                        break;
+                    }
+
+                    bytesRead = Math.Min(bytesRead, dataLength - totalBytesRead);
+
+                    bufferedWaveProvider.AddSamples(reciveBuffer, 0, bytesRead);
+                    totalBytesRead += bytesRead;
+                }
+
+                ApiManager.SendNotificationMessageNewLine(string.Empty);
+                ApiManager.SendNotificationMessageNewLine("Stream ended!", NotificationMessageType.Warning);
+            });
+
+            while (!task.IsCompleted)
+            {
+                ApiManager.SendNotificationMessage($"\r[{player.PlaybackState,-7}]");
+
+                char c = Console.ReadKey(true).KeyChar;
+
+                if (c == 'p')
+                {
+                    if (player.PlaybackState == PlaybackState.Playing)
+                    {
+                        player.Pause();
+                    }
+                    else
+                    {
+                        player.Play();
+                    }
+                }
+                else if (c == 's')
+                {
+                    player.Stop();
+                    ApiManager.SendNotificationMessage($"\r[{player.PlaybackState,-7}]");
+                    break;
+                }
+            }
+
+            hostsManager.SaveHosts();
+            return;
+        }
+        ApiManager.SendNotificationMessageNewLine("None of the available hosts have the requested file!", NotificationMessageType.Error);
+        hostsManager.SaveHosts();
+    }
+
+    private static bool IsBufferNearlyFull(BufferedWaveProvider bufferedWaveProvider)
+    {
+        return bufferedWaveProvider is not null &&
+               bufferedWaveProvider.BufferLength - bufferedWaveProvider.BufferedBytes
+               < bufferedWaveProvider.WaveFormat.AverageBytesPerSecond / 4;
+    }
+}

HyperbolicDownloaderApi/FileProcessing/DirectoryWatcher.cs

@@ -0,0 +1,105 @@
+using HyperbolicDownloaderApi.Managment;
+
+using System.Text.Json;
+using System.Timers;
+
+namespace HyperbolicDownloaderApi.FileProcessing;
+
+public class DirectoryWatcher
+{
+    private readonly FilesManager filesManager;
+
+    private readonly List<string> directories = [];
+    private readonly System.Timers.Timer timer = new(1);
+
+    public DirectoryWatcher(FilesManager filesManager)
+    {
+        this.filesManager = filesManager;
+
+        timer.AutoReset = false;
+        timer.Elapsed += Timer_Elapsed;
+    }
+
+    public bool TryAdd(string path, out string? errorMessage)
+    {
+        if (directories.Contains(path))
+        {
+            errorMessage = "Directory already tracked";
+            return false;
+        }
+
+        directories.Add(path);
+        errorMessage = null;
+
+        SaveDirectories();
+        return true;
+    }
+
+    public void AddRange(IEnumerable<string> directoryInfos)
+    {
+        foreach (string directoryInfo in directoryInfos)
+        {
+            if (Directory.Exists(directoryInfo) && !directories.Contains(directoryInfo))
+            {
+                directories.Add(directoryInfo);
+            }
+        }
+
+        SaveDirectories();
+    }
+
+    public bool TryRemove(string path)
+    {
+        if (!directories.Contains(path))
+        {
+            return false;
+        }
+
+        _ = directories.Remove(path);
+
+        SaveDirectories();
+        return true;
+    }
+
+    public void SaveDirectories()
+    {
+        File.WriteAllText(ApiConfiguration.DirectoriesInfoPath, JsonSerializer.Serialize(directories));
+    }
+
+    public List<string> ToList()
+    {
+        return directories;
+    }
+
+    public void Start()
+    {
+        timer.Start();
+    }
+
+    private void Timer_Elapsed(object? sender, ElapsedEventArgs e)
+    {
+        ApiManager.SendNotificationMessageNewLine("Checking for new files...", NotificationMessageType.Log);
+
+        timer.Interval = TimeSpan.FromMinutes(1).TotalMilliseconds;
+
+        int newFilesCount = 0;
+
+        foreach (string directory in directories)
+        {
+            ApiManager.SendNotificationMessageNewLine($"Checking directory: {directory}", NotificationMessageType.Log);
+            string[] files = Directory.GetFiles(directory, "*", SearchOption.AllDirectories);
+
+            foreach (string file in files)
+            {
+                if (filesManager.TryAdd(file, out _, out _))
+                {
+                    newFilesCount++;
+                }
+            }
+        }
+
+        ApiManager.SendNotificationMessageNewLine($"Finished checking for new files. Found {newFilesCount} new file(s).", NotificationMessageType.Log);
+
+        filesManager.RemoveFilesThatDontExist();
+    }
+}

HyperbolicDownloaderApi/FileProcessing/FilesManager.cs

@@ -1,12 +1,13 @@
 using HyperbolicDownloaderApi.Managment;
 
+using System.Diagnostics;
 using System.Text.Json;
 
 namespace HyperbolicDownloaderApi.FileProcessing;
 
 public class FilesManager
 {
-    private readonly List<PrivateHyperFileInfo> files = new List<PrivateHyperFileInfo>();
+    private readonly List<PrivateHyperFileInfo> files = [];
 
     public bool TryAdd(string filePath, out PrivateHyperFileInfo? fileInfo, out string? errorMessage)
     {
@@ -31,10 +32,16 @@ public class FilesManager
         if (Contains(hash))
         {
             fileInfo = null;
+            Debug.WriteLine(filePath + "-.-" + hash);
             errorMessage = "File already tracked!";
             return false;
         }
 
+        if (files.Exists(f => f.FilePath == fullPath))
+        {
+            _ = files.RemoveAll(f => f.FilePath == fullPath);
+        }
+
         fileInfo = new PrivateHyperFileInfo(hash, fullPath);
 
         files.Add(fileInfo);
@@ -83,12 +90,26 @@ public class FilesManager
 
     public bool Contains(string? hash)
     {
-        return files.Any(f => f.Hash == hash);
+        return files.Exists(f => f.Hash == hash);
     }
 
     public List<PrivateHyperFileInfo> ToList()
     {
-        return files.ToList();
+        return [.. files];
+    }
+
+    internal void RemoveFilesThatDontExist()
+    {
+        List<PrivateHyperFileInfo> filesToRemove = files
+            .Where(f => !File.Exists(f.FilePath))
+            .ToList();
+
+        foreach (PrivateHyperFileInfo fileToRemove in filesToRemove)
+        {
+            _ = files.Remove(fileToRemove);
+        }
+
+        SaveFiles();
     }
 
     private void SaveFiles()

HyperbolicDownloaderApi/FileProcessing/HyperFileDto.cs

@@ -0,0 +1,23 @@
+using System.Text.Json.Serialization;
+
+namespace HyperbolicDownloaderApi.FileProcessing;
+
+internal class HyperFileDto
+{
+    public string Hash { get; set; }
+
+    public string Name { get; set; }
+
+    [JsonConstructor]
+    public HyperFileDto(string hash, string name)
+    {
+        Hash = hash;
+        Name = name;
+    }
+
+    public HyperFileDto(PrivateHyperFileInfo privateHyperFileInfo)
+    {
+        Hash = privateHyperFileInfo.Hash;
+        Name = Path.GetFileName(privateHyperFileInfo.FilePath);
+    }
+}

HyperbolicDownloaderApi/FileProcessing/PrivateHyperFileInfo.cs

@@ -1,13 +1,7 @@
 namespace HyperbolicDownloaderApi.FileProcessing;
 
-public class PrivateHyperFileInfo
+public class PrivateHyperFileInfo(string hash, string filePath)
 {
-    public string Hash { get; set; }
+    public string Hash { get; set; } = hash;
-    public string FilePath { get; set; }
+    public string FilePath { get; set; } = filePath;
-
-    public PrivateHyperFileInfo(string hash, string filePath)
-    {
-        Hash = hash;
-        FilePath = filePath;
-    }
 }

HyperbolicDownloaderApi/FileProcessing/PublicHyperFileInfo.cs

@@ -5,7 +5,7 @@ namespace HyperbolicDownloaderApi.FileProcessing;
 public class PublicHyperFileInfo
 {
     public string Hash { get; set; } = string.Empty;
-    public List<NetworkSocket> Hosts { get; set; } = new();
+    public List<NetworkSocket> Hosts { get; set; } = [];
 
     public PublicHyperFileInfo()
     {

HyperbolicDownloaderApi/GlobalSuppressions.cs

@@ -0,0 +1,9 @@
+// This file is used by Code Analysis to maintain SuppressMessage
+// attributes that are applied to this project.
+// Project-level suppressions either have no target or are given
+// a specific target and scoped to a namespace, type, member, etc.
+
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: SuppressMessage("Major Code Smell", "S6561:Avoid using \"DateTime.Now\" for benchmarking or timing operations", Justification = "Stop")]
+[assembly: SuppressMessage("Minor Code Smell", "S3604:Member initializer values should not be redundant", Justification = "False positive")]

HyperbolicDownloaderApi/HyperbolicDownloaderApi.csproj

@@ -1,14 +1,15 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Open.Nat" Version="2.1.0" />
+    <PackageReference Include="CuteUtils" Version="1.0.0" />
-    <PackageReference Include="Stone_Red-C-Sharp-Utilities" Version="1.0.3.1" />
+    <PackageReference Include="NAudio" Version="2.2.1" />
+    <PackageReference Include="SharpOpenNat" Version="4.0.17" />
   </ItemGroup>
 
 </Project>

HyperbolicDownloaderApi/Managment/ApiConfiguration.cs

@@ -1,13 +1,12 @@
-using System.Reflection;
+namespace HyperbolicDownloaderApi.Managment;
-
-namespace HyperbolicDownloaderApi.Managment;
 
 public static class ApiConfiguration
 {
     public const int BroadcastPort = 2155;
     public const int PrivatePort = 3055;
     public static int PublicPort { get; set; }
-    public static string BasePath { get; } = Path.GetDirectoryName(Assembly.GetEntryAssembly()!.Location) ?? string.Empty;
+    public static string BasePath { get; } = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "StoneRed", "HyperbolicDownloader");
     public static string HostsFilePath { get; } = Path.Combine(BasePath, "Hosts.json");
     public static string FilesInfoPath { get; } = Path.Combine(BasePath, "Files.json");
+    public static string DirectoriesInfoPath { get; } = Path.Combine(BasePath, "Directories.json");
 }

HyperbolicDownloaderApi/Managment/ApiManager.cs

@@ -1,7 +1,7 @@
 using HyperbolicDownloaderApi.FileProcessing;
 using HyperbolicDownloaderApi.Networking;
 
-using Open.Nat;
+using SharpOpenNat;
 
 using System.Diagnostics;
 using System.Net;
@@ -13,19 +13,20 @@ public class ApiManager
 {
     public static event EventHandler<NotificationMessageEventArgs>? OnNotificationMessageRecived;
 
-    public static IPAddress? PublicIpAddress => device?.GetExternalIPAsync().GetAwaiter().GetResult();
-    public FilesManager FilesManager { get; } = new();
-    public HostsManager HostsManager { get; } = new();
-
     private static readonly Random random = new();
-    private static NatDevice? device;
+    private static INatDevice? device;
     private static Mapping? portMapping;
     private readonly BroadcastClient broadcastClient = new BroadcastClient();
     private readonly NetworkClient networkClient;
+    public static IPAddress? PublicIpAddress => device?.GetExternalIPAsync().GetAwaiter().GetResult();
+    public FilesManager FilesManager { get; } = new();
+    public HostsManager HostsManager { get; } = new();
+    public DirectoryWatcher DirectoryWatcher { get; }
 
     public ApiManager()
     {
         networkClient = new(FilesManager);
+        DirectoryWatcher = new(FilesManager);
     }
 
     public static NetworkSocket? GetLocalSocket()
@@ -58,8 +59,7 @@ public class ApiManager
         {
             ApiConfiguration.PublicPort = random.Next(1000, 6000);
 
-            NatDiscoverer? discoverer = new NatDiscoverer();
+            device = await OpenNat.Discoverer.DiscoverDeviceAsync();
-            device = await discoverer.DiscoverDeviceAsync();
 
             IPAddress? ip = await device.GetExternalIPAsync();
             SendNotificationMessageNewLine($"The public IP address is: {ip} ", NotificationMessageType.Success);
@@ -81,39 +81,46 @@ public class ApiManager
             SendNotificationMessageNewLine($"An error occurred while mapping the private port ({ApiConfiguration.PrivatePort}) to the public port ({ApiConfiguration.PublicPort})! Error message: {ex.Message}", NotificationMessageType.Error);
             return false;
         }
+        catch (SocketException ex)
+        {
+            SendNotificationMessageNewLine($"An error occurred while mapping the private port ({ApiConfiguration.PrivatePort}) to the public port ({ApiConfiguration.PublicPort})! Error message: {ex.Message}", NotificationMessageType.Error);
+            return false;
+        }
     }
 
     public static void ClosePorts()
     {
         SendNotificationMessageNewLine("Closing ports...", NotificationMessageType.Info);
-        if (device is not null)
+        if (device is not null && portMapping is not null)
         {
             try
             {
-                IEnumerable<Mapping>? mappings = device.GetAllMappingsAsync().GetAwaiter().GetResult();
+                device.DeletePortMapAsync(portMapping).GetAwaiter().GetResult();
-                foreach (Mapping? mapping in mappings)
-                {
-                    if (mapping.Description.Contains("HyperbolicDowloader") && mapping.PrivateIP.ToString() == portMapping?.PrivateIP.ToString())
-                    {
-                        device.DeletePortMapAsync(mapping).GetAwaiter().GetResult();
-                    }
-                }
             }
             catch (Exception ex)
             {
-                SendNotificationMessageNewLine(ex.ToString(), NotificationMessageType.Error);
+                SendNotificationMessageNewLine(ex.Message, NotificationMessageType.Error);
             }
         }
 
         SendNotificationMessageNewLine("Ports closed!", NotificationMessageType.Warning);
-        Environment.Exit(0);
     }
 
-    public void StartBroadcastListener()
+    public bool StartBroadcastListener()
+    {
+        try
         {
             broadcastClient.StartListening(ApiConfiguration.BroadcastPort);
             broadcastClient.OnBroadcastRecived += BroadcastClient_OnBroadcastRecived;
         }
+        catch (SocketException ex)
+        {
+            SendNotificationMessageNewLine($"An error occurred while starting the TCP listener! Error message: {ex.Message}", NotificationMessageType.Error); // net stop hens && net start hns
+            return false;
+        }
+
+        return true;
+    }
 
     public bool StartTcpListener()
     {
@@ -123,6 +130,7 @@ public class ApiManager
             networkClient.ListenTo<List<NetworkSocket>>("DiscoverAnswer", DiscoverAnswer);
             networkClient.ListenTo<string>("Message", ReciveMessage);
             networkClient.ListenTo<string>("HasFile", HasFile);
+            networkClient.ListenTo<string>("GetFilesList", GetFileList);
             networkClient.StartListening(ApiConfiguration.PrivatePort);
         }
         catch (SocketException ex)
@@ -134,6 +142,21 @@ public class ApiManager
         return true;
     }
 
+    internal static void SendNotificationMessage(string message, NotificationMessageType messageType = NotificationMessageType.Info)
+    {
+        OnNotificationMessageRecived?.Invoke(null, new NotificationMessageEventArgs(messageType, message));
+    }
+
+    internal static void SendNotificationMessageNewLine(string message, NotificationMessageType messageType = NotificationMessageType.Info)
+    {
+        OnNotificationMessageRecived?.Invoke(null, new NotificationMessageEventArgs(messageType, message + Environment.NewLine));
+    }
+
+    private static void ReciveMessage(object? sender, MessageRecivedEventArgs<string> recivedEventArgs)
+    {
+        SendNotificationMessageNewLine($"Received \"{recivedEventArgs.Data}\" from {recivedEventArgs.IpAddress}.", NotificationMessageType.Info);
+    }
+
     private async void BroadcastClient_OnBroadcastRecived(object? sender, BroadcastRecivedEventArgs recivedEventArgs)
     {
         IPAddress remoteIpAddress = recivedEventArgs.IPEndPoint.Address;
@@ -156,7 +179,7 @@ public class ApiManager
 
         if (success)
         {
-            HostsManager.Add(new NetworkSocket(remoteIpAddress.ToString(), remotePort, DateTime.Now));
+            _ = HostsManager.Add(new NetworkSocket(remoteIpAddress.ToString(), remotePort, DateTime.Now));
             try
             {
                 await NetworkClient.SendAsync(recivedEventArgs.IPEndPoint.Address, remotePort, "DiscoverAnswer", hostsToSend);
@@ -171,11 +194,14 @@ public class ApiManager
     private void DiscoverAnswer(object? sender, MessageRecivedEventArgs<List<NetworkSocket>> recivedEventArgs)
     {
         SendNotificationMessageNewLine($"Received answer from {recivedEventArgs.IpAddress}. Returned {recivedEventArgs.Data.Count} host(s).", NotificationMessageType.Info);
-        HostsManager.AddRange(recivedEventArgs.Data);
+        SendNotificationMessageNewLine($"{recivedEventArgs.IpAddress} > Discovery answer {string.Join(", ", recivedEventArgs.Data)}", NotificationMessageType.Log);
+        _ = HostsManager.AddRange(recivedEventArgs.Data);
     }
 
     private async void GetHostList(object? sender, MessageRecivedEventArgs<NetworkSocket> recivedEventArgs)
     {
+        SendNotificationMessageNewLine($"{recivedEventArgs.IpAddress} > Requesting host list", NotificationMessageType.Log);
+
         List<NetworkSocket> hostsToSend = HostsManager.ToList();
 
         NetworkSocket? localSocket = GetLocalSocket();
@@ -190,7 +216,7 @@ public class ApiManager
 
         if (recivedEventArgs.Data.Port != 0)
         {
-            HostsManager.Add(recivedEventArgs.Data);
+            _ = HostsManager.Add(recivedEventArgs.Data);
         }
 
         await recivedEventArgs.SendResponseAsync(hostsToSend);
@@ -198,21 +224,20 @@ public class ApiManager
 
     private async void HasFile(object? sender, MessageRecivedEventArgs<string> recivedEventArgs)
     {
+        SendNotificationMessageNewLine($"{recivedEventArgs.IpAddress} > Check if file exists [{recivedEventArgs.Data}]", NotificationMessageType.Log);
+
         await recivedEventArgs.SendResponseAsync(FilesManager.Contains(recivedEventArgs.Data));
     }
 
-    private void ReciveMessage(object? sender, MessageRecivedEventArgs<string> recivedEventArgs)
+    private async void GetFileList(object? sender, MessageRecivedEventArgs<string> recivedEventArgs)
     {
-        SendNotificationMessageNewLine($"Received \"{recivedEventArgs.Data}\" from {recivedEventArgs.IpAddress}.", NotificationMessageType.Info);
+        SendNotificationMessageNewLine($"{recivedEventArgs.IpAddress} > Requesting file list", NotificationMessageType.Log);
-    }
 
-    internal static void SendNotificationMessage(string message, NotificationMessageType messageType = NotificationMessageType.Info)
+        List<HyperFileDto> files = [.. FilesManager
-    {
+            .ToList()
-        OnNotificationMessageRecived?.Invoke(null, new NotificationMessageEventArgs(messageType, message));
+            .Select(f => new HyperFileDto(f))
-    }
+            .Where(f => f.Name.Contains(recivedEventArgs.Data))];
 
-    internal static void SendNotificationMessageNewLine(string message, NotificationMessageType messageType = NotificationMessageType.Info)
+        await recivedEventArgs.SendResponseAsync(files);
-    {
-        OnNotificationMessageRecived?.Invoke(null, new NotificationMessageEventArgs(messageType, message + Environment.NewLine));
     }
 }

HyperbolicDownloaderApi/Managment/NotificationMessageEventArgs.cs

@@ -1,20 +1,16 @@
 namespace HyperbolicDownloaderApi.Managment;
 
-public class NotificationMessageEventArgs : EventArgs
+public class NotificationMessageEventArgs(NotificationMessageType notificationMessageType, string? message) : EventArgs
 {
-    public NotificationMessageType NotificationMessageType { get; }
+    public NotificationMessageType NotificationMessageType { get; } = notificationMessageType;
-    public string? Message { get; }
+    public string? Message { get; } = message;
-
-    public NotificationMessageEventArgs(NotificationMessageType notificationMessageType, string? message)
-    {
-        NotificationMessageType = notificationMessageType;
-        Message = message;
-    }
 }
 
 public enum NotificationMessageType
 {
     Info,
+    Log,
+    Debug,
     Success,
     Warning,
     Error

HyperbolicDownloaderApi/Networking/BroadcastClient.cs

@@ -11,9 +11,8 @@ internal class BroadcastClient
 {
     public event EventHandler<BroadcastRecivedEventArgs>? OnBroadcastRecived;
 
-    public bool IsListening { get; private set; } = false;
-
     private UdpClient? udpListener;
+    public bool IsListening { get; private set; } = false;
 
     public static void Send(int port, string message)
     {
@@ -58,7 +57,7 @@ internal class BroadcastClient
         udpListener = new UdpClient(port);
         IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, port);
 
-        _ = Task.Run(() =>
+        _ = new TaskFactory().StartNew(() =>
         {
             while (IsListening)
             {
@@ -67,7 +66,7 @@ internal class BroadcastClient
 
                 OnBroadcastRecived?.Invoke(this, new BroadcastRecivedEventArgs(groupEP, message));
             }
-        });
+        }, TaskCreationOptions.LongRunning);
     }
 
     public void StopListening()

HyperbolicDownloaderApi/Networking/BroadcastRecivedEventArgs.cs

@@ -2,14 +2,8 @@
 
 namespace HyperbolicDownloaderApi.Networking;
 
-internal class BroadcastRecivedEventArgs : EventArgs
+internal class BroadcastRecivedEventArgs(IPEndPoint ipEndPoint, string message) : EventArgs
 {
-    public BroadcastRecivedEventArgs(IPEndPoint iPEndPoint, string message)
+    public IPEndPoint IPEndPoint { get; } = ipEndPoint;
-    {
+    public string Message { get; } = message;
-        IPEndPoint = iPEndPoint;
-        Message = message;
-    }
-
-    public IPEndPoint IPEndPoint { get; }
-    public string Message { get; }
 }

HyperbolicDownloaderApi/Networking/DataContainer.cs

@@ -1,13 +1,7 @@
 namespace HyperbolicDownloaderApi.Networking;
 
-internal class DataContainer
+internal class DataContainer(string eventName, string jsonData)
 {
-    public string EventName { get; set; }
+    public string EventName { get; set; } = eventName;
-    public string JsonData { get; set; }
+    public string JsonData { get; set; } = jsonData;
-
-    public DataContainer(string eventName, string jsonData)
-    {
-        JsonData = jsonData;
-        EventName = eventName;
-    }
 }

HyperbolicDownloaderApi/Networking/HostsManager.cs

@@ -1,5 +1,6 @@
 using HyperbolicDownloaderApi.Managment;
 
+using System.Net;
 using System.Net.Sockets;
 using System.Text.Json;
 
@@ -7,45 +8,47 @@ namespace HyperbolicDownloaderApi.Networking;
 
 public class HostsManager
 {
-    private List<NetworkSocket> hosts = new List<NetworkSocket>();
+    private List<NetworkSocket> hosts = [];
     public int Count => hosts.Count;
 
-    public void AddRange(IEnumerable<NetworkSocket> hosts)
+    public int AddRange(IEnumerable<NetworkSocket> hosts)
     {
-        foreach (NetworkSocket host in hosts)
+        int newHosts = hosts.Count(Add);
-        {
-            Add(host);
-        }
-
         SaveHosts();
+
+        return newHosts;
     }
 
-    public void Add(NetworkSocket host)
+    public bool Add(NetworkSocket host)
     {
-        if (!Contains(host))
+        if (!Contains(host) && !host.Equals(ApiManager.GetLocalSocket()))
         {
             hosts.Add(host);
+            return true;
         }
+
         SaveHosts();
+
+        return false;
     }
 
     public void Remove(NetworkSocket host, bool forceRemove = false)
     {
         if (DateTime.Now - host.LastActive >= new TimeSpan(24, 0, 0) || forceRemove)
         {
-            _ = hosts.RemoveAll(x => x.IPAddress == host.IPAddress && x.Port == host.Port);
+            _ = hosts.RemoveAll(x => x.Equals(host));
         }
         SaveHosts();
     }
 
     public bool Contains(NetworkSocket host)
     {
-        return hosts.Any(x => x.IPAddress == host.IPAddress && x.Port == host.Port);
+        return hosts.Exists(x => x.Equals(host));
     }
 
     public int CheckHostsActivity()
     {
-        List<NetworkSocket> hostsToRemove = new List<NetworkSocket>();
+        List<NetworkSocket> hostsToRemove = [];
         int activeHostsCount = 0;
         foreach (NetworkSocket host in hosts)
         {
@@ -54,7 +57,7 @@ public class HostsManager
 
             try
             {
-                _ = tcpClient.ConnectAsync(host.IPAddress, host.Port).Wait(500);
+                _ = tcpClient.ConnectAsync(host.IPAddress, host.Port).Wait(1000);
                 Console.CursorLeft = 0;
                 if (tcpClient.Connected)
                 {
@@ -91,14 +94,65 @@ public class HostsManager
         return activeHostsCount;
     }
 
+    public int Sync()
+    {
+        int newHostsCount = 0;
+
+        foreach (NetworkSocket host in hosts.ToArray())
+        {
+            ApiManager.SendNotificationMessage($"{host.IPAddress}:{host.Port} > ???", NotificationMessageType.Warning);
+
+            try
+            {
+                NetworkSocket? localSocket = ApiManager.GetLocalSocket() ?? new NetworkSocket("0.0.0.0", 0, DateTime.MinValue);
+
+                Task<List<NetworkSocket>?> sendTask = NetworkClient.SendAsync<List<NetworkSocket>>(IPAddress.Parse(host.IPAddress), host.Port, "GetHostsList", localSocket);
+
+                _ = sendTask.Wait(1000);
+
+                Console.CursorLeft = 0;
+                if (sendTask.IsCompletedSuccessfully)
+                {
+                    int newHosts = AddRange(sendTask.Result ?? []);
+                    newHostsCount += newHosts;
+
+                    if (newHosts > 0)
+                    {
+                        ApiManager.SendNotificationMessageNewLine($"{host.IPAddress}:{host.Port} > Found {newHosts} new hosts", NotificationMessageType.Success);
+                    }
+                    else
+                    {
+                        ApiManager.SendNotificationMessageNewLine($"{host.IPAddress}:{host.Port} > No new hosts found", NotificationMessageType.Warning);
+                    }
+
+                    host.LastActive = DateTime.Now;
+                }
+                else
+                {
+                    ApiManager.SendNotificationMessageNewLine($"{host.IPAddress}:{host.Port} > Inactive", NotificationMessageType.Error);
+                }
+            }
+            catch
+            {
+                Console.CursorLeft = 0;
+                ApiManager.SendNotificationMessageNewLine($"{host.IPAddress}:{host.Port} > Inactive", NotificationMessageType.Error);
+            }
+        }
+
+        SaveHosts();
+        return newHostsCount;
+    }
+
     public List<NetworkSocket> ToList()
     {
-        return hosts.ToList();
+        return [.. hosts];
     }
 
     public void SaveHosts()
     {
-        hosts = hosts.OrderByDescending(h => h.LastActive).ToList();
+        hosts = [.. hosts
+                .OrderByDescending(s => s.DownloadSpeed)
+                .ThenByDescending(s => s.LastActive)];
         File.WriteAllText(ApiConfiguration.HostsFilePath, JsonSerializer.Serialize(hosts));
     }
 }

HyperbolicDownloaderApi/Networking/MessageRecivedEventArgs.cs

@@ -5,20 +5,11 @@ using System.Text.Json;
 
 namespace HyperbolicDownloaderApi.Networking;
 
-internal class MessageRecivedEventArgs<T> : EventArgs
+internal class MessageRecivedEventArgs<T>(NetworkStream networkStream, IPAddress ipAddress, T data) : EventArgs
 {
-    private readonly NetworkStream networkStream;
+    public T Data { get; set; } = data;
 
-    public MessageRecivedEventArgs(NetworkStream networkStream, IPAddress ipAddress, T data)
+    public IPAddress IpAddress { get; set; } = ipAddress;
-    {
-        this.networkStream = networkStream;
-        Data = data;
-        IpAddress = ipAddress;
-    }
-
-    public T Data { get; set; }
-
-    public IPAddress IpAddress { get; set; }
 
     public async Task SendResponseAsync(object response)
     {

HyperbolicDownloaderApi/Networking/NetworkClient.cs

@@ -1,4 +1,7 @@
 using HyperbolicDownloaderApi.FileProcessing;
+using HyperbolicDownloaderApi.Managment;
+
+using NAudio.Wave;
 
 using System.Diagnostics;
 using System.Net;
@@ -8,25 +11,15 @@ using System.Text.Json;
 
 namespace HyperbolicDownloaderApi.Networking;
 
-internal class NetworkClient
+internal class NetworkClient(FilesManager filesManager)
 {
-    public bool IsListening { get; private set; } = false;
+    private readonly Dictionary<string, (Type type, Delegate method)> events = [];
-
     private TcpListener? tcpListener;
-    private readonly FilesManager filesManager;
+    public bool IsListening { get; private set; } = false;
-    private readonly Dictionary<string, (Type type, Delegate method)> events = new();
-
-    public NetworkClient(FilesManager filesManager)
-    {
-        this.filesManager = filesManager;
-    }
 
     public static async Task<T?> SendAsync<T>(IPAddress remoteIp, int remotePort, string eventName, object data)
     {
-        if (remoteIp is null)
+        ArgumentNullException.ThrowIfNull(remoteIp);
-        {
-            throw new ArgumentNullException(nameof(remoteIp));
-        }
 
         TcpClient client = new TcpClient();
 
@@ -39,9 +32,23 @@ internal class NetworkClient
 
         await nwStream.WriteAsync(bytesToSend);
 
+        List<byte> bytes = [];
+
         byte[] bytesToRead = new byte[client.ReceiveBufferSize];
+
+        while (nwStream.CanRead)
+        {
             int bytesRead = await nwStream.ReadAsync(bytesToRead.AsMemory(0, client.ReceiveBufferSize));
-        string response = Encoding.ASCII.GetString(bytesToRead, 0, bytesRead);
+
+            if (bytesRead == 0)
+            {
+                break;
+            }
+
+            bytes.AddRange(bytesToRead.AsMemory(0, bytesRead).ToArray());
+        }
+
+        string response = Encoding.ASCII.GetString(bytes.ToArray());
 
         client.Close();
 
@@ -57,10 +64,7 @@ internal class NetworkClient
 
     public static async Task SendAsync(IPAddress remoteIp, int remotePort, string eventName, object data)
     {
-        if (remoteIp is null)
+        ArgumentNullException.ThrowIfNull(remoteIp);
-        {
-            throw new ArgumentNullException(nameof(remoteIp));
-        }
 
         TcpClient client = new TcpClient();
 
@@ -98,98 +102,27 @@ internal class NetworkClient
         tcpListener.Start();
         IsListening = true;
 
-        _ = Task.Run(async () =>
+        _ = new TaskFactory().StartNew(() =>
         {
             while (IsListening)
             {
                 try
                 {
+                    ApiManager.SendNotificationMessageNewLine("Listening for connections...", NotificationMessageType.Debug);
+
                     TcpClient client = tcpListener.AcceptTcpClient();
-                    NetworkStream nwStream = client.GetStream();
-                    byte[] buffer = new byte[client.ReceiveBufferSize];
 
-                    int bytesRead = await nwStream.ReadAsync(buffer.AsMemory(0, client.ReceiveBufferSize));
+                    ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Connected", NotificationMessageType.Debug);
 
-                    string dataReceived = Encoding.ASCII.GetString(buffer, 0, bytesRead);
+                    _ = Task.Run(() => HandleRequest(client));
-
-                    if (dataReceived.StartsWith("Download"))
-                    {
-                        _ = Upload(client, dataReceived[8..]);
-                        continue;
-                    }
-                    if (string.IsNullOrWhiteSpace(dataReceived))
-                    {
-                        client.Close();
-                        continue;
-                    }
-
-                    DataContainer? dataContainer = JsonSerializer.Deserialize<DataContainer>(dataReceived);
-
-                    if (dataContainer is not null && events.ContainsKey(dataContainer.EventName))
-                    {
-                        (Type type, Delegate method) = events[dataContainer.EventName];
-
-                        Type eventArgsType = typeof(MessageRecivedEventArgs<>).MakeGenericType(type);
-
-                        object? eventArgs = Activator.CreateInstance(
-                            eventArgsType,
-                            nwStream,
-                            (client.Client.RemoteEndPoint as IPEndPoint)?.Address,
-                            JsonSerializer.Deserialize(dataContainer.JsonData, type));
-
-                        _ = (method?.DynamicInvoke(this, eventArgs));
-                    }
-
-                    client.Close();
                 }
                 catch (SocketException ex)
                 {
-                    if (ex.SocketErrorCode != SocketError.Interrupted)
+                    ApiManager.SendNotificationMessageNewLine(ex.Message, NotificationMessageType.Log);
-                    {
-                        throw;
-                    }
                 }
             }
             tcpListener.Stop();
-        });
+        }, TaskCreationOptions.LongRunning);
-    }
-
-    private async Task Upload(TcpClient client, string hash)
-    {
-        try
-        {
-            byte[] bytesToSend;
-            hash = hash.Trim();
-            NetworkStream nwStream = client.GetStream();
-            client.SendBufferSize = 64000;
-            if (filesManager.TryGet(hash, out PrivateHyperFileInfo? hyperFileInfo) && File.Exists(hyperFileInfo?.FilePath))
-            {
-                FileInfo fileInfo = new FileInfo(hyperFileInfo.FilePath);
-
-                bytesToSend = Encoding.ASCII.GetBytes($"{fileInfo.Length}/{Path.GetFileName(hyperFileInfo.FilePath)}");
-
-                Array.Resize(ref bytesToSend, 1000);
-
-                await nwStream.WriteAsync(bytesToSend);
-                foreach (byte[]? chunk in FileCompressor.ReadChunks(hyperFileInfo.FilePath, 64000).Where(chunk => chunk is not null))
-                {
-                    await nwStream.WriteAsync(chunk);
-                }
-            }
-            else
-            {
-                bytesToSend = Encoding.ASCII.GetBytes("File not found!");
-                await nwStream.WriteAsync(bytesToSend);
-            }
-        }
-        catch (Exception ex)
-        {
-            Debug.WriteLine(ex);
-        }
-        finally
-        {
-            client.Close();
-        }
     }
 
     public void StopListening()
@@ -202,4 +135,200 @@ internal class NetworkClient
     {
         events.Add(eventName, (typeof(T), eventHandler));
     }
+
+    private async Task HandleRequest(TcpClient client)
+    {
+        ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Handling request", NotificationMessageType.Debug);
+
+        NetworkStream nwStream = client.GetStream();
+        byte[] buffer = new byte[client.ReceiveBufferSize];
+
+        ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Reading data", NotificationMessageType.Debug);
+
+        int bytesRead = await nwStream.ReadAsync(buffer.AsMemory(0, client.ReceiveBufferSize));
+
+        ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Data read", NotificationMessageType.Debug);
+
+        string dataReceived = Encoding.ASCII.GetString(buffer, 0, bytesRead);
+
+        ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Data: {dataReceived}", NotificationMessageType.Debug);
+
+        if (dataReceived.StartsWith("Download"))
+        {
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Download request", NotificationMessageType.Debug);
+            _ = Upload(client, dataReceived[8..]);
+            return;
+        }
+
+        if (dataReceived.StartsWith("StreamWav"))
+        {
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Download request", NotificationMessageType.Debug);
+            _ = StreamWav(client, dataReceived[9..]);
+            return;
+        }
+
+        if (string.IsNullOrWhiteSpace(dataReceived))
+        {
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Disconnected", NotificationMessageType.Debug);
+            client.Close();
+            return;
+        }
+
+        ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Deserializing data", NotificationMessageType.Debug);
+
+        DataContainer? dataContainer = JsonSerializer.Deserialize<DataContainer>(dataReceived);
+
+        ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Data deserialized", NotificationMessageType.Debug);
+
+        if (dataContainer is not null && events.TryGetValue(dataContainer.EventName, out (Type type, Delegate method) value))
+        {
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Found event", NotificationMessageType.Debug);
+
+            (Type type, Delegate method) = value;
+
+            Type eventArgsType = typeof(MessageRecivedEventArgs<>).MakeGenericType(type);
+
+            object? eventArgs = Activator.CreateInstance(
+                eventArgsType,
+                nwStream,
+                (client.Client.RemoteEndPoint as IPEndPoint)?.Address,
+                JsonSerializer.Deserialize(dataContainer.JsonData, type));
+
+            _ = (method?.DynamicInvoke(this, eventArgs));
+        }
+        else
+        {
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Event not found", NotificationMessageType.Debug);
+        }
+
+        ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Closing connection", NotificationMessageType.Debug);
+
+        client.Close();
+
+        ApiManager.SendNotificationMessageNewLine($"{(client.Client?.RemoteEndPoint as IPEndPoint)?.Address} > Connection closed", NotificationMessageType.Debug);
+    }
+
+    private async Task Upload(TcpClient client, string hash)
+    {
+        try
+        {
+            byte[] bytesToSend;
+            hash = hash.Trim();
+
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Requesting file download [{hash}]", NotificationMessageType.Log);
+
+            NetworkStream nwStream = client.GetStream();
+            client.SendBufferSize = 64000;
+
+            if (filesManager.TryGet(hash, out PrivateHyperFileInfo? hyperFileInfo) && File.Exists(hyperFileInfo?.FilePath))
+            {
+                ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Accepting file download [{Path.GetFileName(hyperFileInfo.FilePath)}] [{hash}]", NotificationMessageType.Log);
+
+                FileInfo fileInfo = new FileInfo(hyperFileInfo.FilePath);
+
+                bytesToSend = Encoding.ASCII.GetBytes($"{fileInfo.Length}/{Path.GetFileName(hyperFileInfo.FilePath)}");
+
+                await nwStream.WriteAsync(bytesToSend);
+
+                ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Starting file download of file [{Path.GetFileName(hyperFileInfo.FilePath)}] [{hash}]", NotificationMessageType.Log);
+
+                foreach (byte[]? chunk in FileCompressor.ReadChunks(hyperFileInfo.FilePath, 64000).Where(chunk => chunk is not null))
+                {
+                    await nwStream.WriteAsync(chunk);
+                }
+
+                ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Completed download of file [{Path.GetFileName(hyperFileInfo.FilePath)}] [{hash}]", NotificationMessageType.Log);
+            }
+            else
+            {
+                bytesToSend = Encoding.ASCII.GetBytes("File not found!");
+                ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > File not found [{hash}]", NotificationMessageType.Log);
+                await nwStream.WriteAsync(bytesToSend);
+            }
+        }
+        catch (Exception ex)
+        {
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Error downloading file {ex.Message} [{hash}]", NotificationMessageType.Log);
+            Debug.WriteLine(ex);
+        }
+        finally
+        {
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Closing connection", NotificationMessageType.Debug);
+
+            client.Close();
+
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client?.RemoteEndPoint as IPEndPoint)?.Address} > Connection closed", NotificationMessageType.Debug);
+        }
+    }
+
+    private async Task StreamWav(TcpClient client, string hash)
+    {
+        try
+        {
+            byte[] bytesToSend;
+            hash = hash.Trim();
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Requesting file stream [{hash}]", NotificationMessageType.Log);
+
+            NetworkStream nwStream = client.GetStream();
+            client.SendBufferSize = 6400;
+
+            if (filesManager.TryGet(hash, out PrivateHyperFileInfo? hyperFileInfo) && File.Exists(hyperFileInfo?.FilePath))
+            {
+                ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Accepting file stream [{Path.GetFileName(hyperFileInfo.FilePath)}] [{hash}]", NotificationMessageType.Log);
+
+                WaveFileReader reader;
+
+                try
+                {
+                    reader = new WaveFileReader(hyperFileInfo.FilePath);
+                }
+                catch (FormatException ex)
+                {
+                    ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Error streaming file {ex.Message} [{hash}]", NotificationMessageType.Log);
+                    Debug.WriteLine(ex);
+                    bytesToSend = Encoding.ASCII.GetBytes("Invalid file format!");
+                    await nwStream.WriteAsync(bytesToSend);
+
+                    return;
+                }
+
+                bytesToSend = Encoding.ASCII.GetBytes($"{reader.Length}/{Path.GetFileName(hyperFileInfo.FilePath)}/{reader.WaveFormat.SampleRate}/{reader.WaveFormat.BitsPerSample}/{reader.WaveFormat.Channels}");
+
+                await nwStream.WriteAsync(bytesToSend);
+
+                ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Starting file stream of file [{Path.GetFileName(hyperFileInfo.FilePath)}] [{hash}]", NotificationMessageType.Log);
+
+                byte[]? buffer = new byte[64000];
+
+                while (reader.Position < reader.Length)
+                {
+                    int bytesRead = reader.Read(buffer, 0, 6400);
+                    await nwStream.WriteAsync(buffer.AsMemory(0, bytesRead));
+                }
+
+                ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Completed stream of file [{Path.GetFileName(hyperFileInfo.FilePath)}] [{hash}]", NotificationMessageType.Log);
+
+                reader.Close();
+            }
+            else
+            {
+                bytesToSend = Encoding.ASCII.GetBytes("File not found!");
+                ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > File not found [{hash}]", NotificationMessageType.Log);
+                await nwStream.WriteAsync(bytesToSend);
+            }
+        }
+        catch (Exception ex)
+        {
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Error streaming file {ex.Message} [{hash}]", NotificationMessageType.Log);
+            Debug.WriteLine(ex);
+        }
+        finally
+        {
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client.RemoteEndPoint as IPEndPoint)?.Address} > Closing connection", NotificationMessageType.Debug);
+
+            client.Close();
+
+            ApiManager.SendNotificationMessageNewLine($"{(client.Client?.RemoteEndPoint as IPEndPoint)?.Address} > Connection closed", NotificationMessageType.Debug);
+        }
+    }
 }

HyperbolicDownloaderApi/Networking/NetworkSocket.cs

@@ -1,15 +1,25 @@
 namespace HyperbolicDownloaderApi.Networking;
 
-public class NetworkSocket
+public class NetworkSocket(string ipAddress, int port, DateTime lastActive)
 {
-    public string IPAddress { get; set; }
+    public string IPAddress { get; set; } = ipAddress;
-    public int Port { get; set; }
+    public int Port { get; set; } = port;
-    public DateTime LastActive { get; set; }
+    public DateTime LastActive { get; set; } = lastActive;
 
-    public NetworkSocket(string ipAddress, int port, DateTime lastActive)
+    public long DownloadSpeed { get; set; }
+
+    public override bool Equals(object? obj)
     {
-        IPAddress = ipAddress;
+        if (obj is not NetworkSocket networkSocket)
-        Port = port;
+        {
-        LastActive = lastActive;
+            return false;
+        }
+
+        return networkSocket.IPAddress == IPAddress && networkSocket.Port == Port;
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(IPAddress, Port);
     }
 }

HyperbolicDownloaderApi/Utilities/UnitFormatter.cs

@@ -0,0 +1,38 @@
+namespace HyperbolicDownloaderApi.Utilities;
+
+internal static class UnitFormatter
+{
+    public static string TransferRate(long bytesPerSecond)
+    {
+        string[] ordinals = ["", "K", "M", "G", "T", "P", "E"];
+
+        decimal rate = bytesPerSecond * 8;
+
+        int ordinal = 0;
+
+        while (rate > 1000)
+        {
+            rate /= 1000;
+            ordinal++;
+        }
+
+        return $"{Math.Round(rate, 0, MidpointRounding.AwayFromZero)}{ordinals[ordinal]}bps";
+    }
+
+    public static string FileSize(long bytes)
+    {
+        string[] ordinals = ["", "K", "M", "G", "T", "P", "E"];
+
+        decimal rate = bytes;
+
+        int ordinal = 0;
+
+        while (rate > 1000)
+        {
+            rate /= 1000;
+            ordinal++;
+        }
+
+        return $"{Math.Round(rate, 0, MidpointRounding.AwayFromZero)}{ordinals[ordinal]}B";
+    }
+}

HyperbolicDownloaderGUI/.gitignore

@@ -1,454 +0,0 @@
-## Ignore Visual Studio temporary files, build results, and
-## files generated by popular Visual Studio add-ons.
-##
-## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
-
-# User-specific files
-*.rsuser
-*.suo
-*.user
-*.userosscache
-*.sln.docstates
-
-# User-specific files (MonoDevelop/Xamarin Studio)
-*.userprefs
-
-# Mono auto generated files
-mono_crash.*
-
-# Build results
-[Dd]ebug/
-[Dd]ebugPublic/
-[Rr]elease/
-[Rr]eleases/
-x64/
-x86/
-[Ww][Ii][Nn]32/
-[Aa][Rr][Mm]/
-[Aa][Rr][Mm]64/
-bld/
-[Bb]in/
-[Oo]bj/
-[Ll]og/
-[Ll]ogs/
-
-# Visual Studio 2015/2017 cache/options directory
-.vs/
-# Uncomment if you have tasks that create the project's static files in wwwroot
-#wwwroot/
-
-# Visual Studio 2017 auto generated files
-Generated\ Files/
-
-# MSTest test Results
-[Tt]est[Rr]esult*/
-[Bb]uild[Ll]og.*
-
-# NUnit
-*.VisualState.xml
-TestResult.xml
-nunit-*.xml
-
-# Build Results of an ATL Project
-[Dd]ebugPS/
-[Rr]eleasePS/
-dlldata.c
-
-# Benchmark Results
-BenchmarkDotNet.Artifacts/
-
-# .NET Core
-project.lock.json
-project.fragment.lock.json
-artifacts/
-
-# Tye
-.tye/
-
-# ASP.NET Scaffolding
-ScaffoldingReadMe.txt
-
-# StyleCop
-StyleCopReport.xml
-
-# Files built by Visual Studio
-*_i.c
-*_p.c
-*_h.h
-*.ilk
-*.meta
-*.obj
-*.iobj
-*.pch
-*.pdb
-*.ipdb
-*.pgc
-*.pgd
-*.rsp
-*.sbr
-*.tlb
-*.tli
-*.tlh
-*.tmp
-*.tmp_proj
-*_wpftmp.csproj
-*.log
-*.vspscc
-*.vssscc
-.builds
-*.pidb
-*.svclog
-*.scc
-
-# Chutzpah Test files
-_Chutzpah*
-
-# Visual C++ cache files
-ipch/
-*.aps
-*.ncb
-*.opendb
-*.opensdf
-*.sdf
-*.cachefile
-*.VC.db
-*.VC.VC.opendb
-
-# Visual Studio profiler
-*.psess
-*.vsp
-*.vspx
-*.sap
-
-# Visual Studio Trace Files
-*.e2e
-
-# TFS 2012 Local Workspace
-$tf/
-
-# Guidance Automation Toolkit
-*.gpState
-
-# ReSharper is a .NET coding add-in
-_ReSharper*/
-*.[Rr]e[Ss]harper
-*.DotSettings.user
-
-# TeamCity is a build add-in
-_TeamCity*
-
-# DotCover is a Code Coverage Tool
-*.dotCover
-
-# AxoCover is a Code Coverage Tool
-.axoCover/*
-!.axoCover/settings.json
-
-# Coverlet is a free, cross platform Code Coverage Tool
-coverage*.json
-coverage*.xml
-coverage*.info
-
-# Visual Studio code coverage results
-*.coverage
-*.coveragexml
-
-# NCrunch
-_NCrunch_*
-.*crunch*.local.xml
-nCrunchTemp_*
-
-# MightyMoose
-*.mm.*
-AutoTest.Net/
-
-# Web workbench (sass)
-.sass-cache/
-
-# Installshield output folder
-[Ee]xpress/
-
-# DocProject is a documentation generator add-in
-DocProject/buildhelp/
-DocProject/Help/*.HxT
-DocProject/Help/*.HxC
-DocProject/Help/*.hhc
-DocProject/Help/*.hhk
-DocProject/Help/*.hhp
-DocProject/Help/Html2
-DocProject/Help/html
-
-# Click-Once directory
-publish/
-
-# Publish Web Output
-*.[Pp]ublish.xml
-*.azurePubxml
-# Note: Comment the next line if you want to checkin your web deploy settings,
-# but database connection strings (with potential passwords) will be unencrypted
-*.pubxml
-*.publishproj
-
-# Microsoft Azure Web App publish settings. Comment the next line if you want to
-# checkin your Azure Web App publish settings, but sensitive information contained
-# in these scripts will be unencrypted
-PublishScripts/
-
-# NuGet Packages
-*.nupkg
-# NuGet Symbol Packages
-*.snupkg
-# The packages folder can be ignored because of Package Restore
-**/[Pp]ackages/*
-# except build/, which is used as an MSBuild target.
-!**/[Pp]ackages/build/
-# Uncomment if necessary however generally it will be regenerated when needed
-#!**/[Pp]ackages/repositories.config
-# NuGet v3's project.json files produces more ignorable files
-*.nuget.props
-*.nuget.targets
-
-# Microsoft Azure Build Output
-csx/
-*.build.csdef
-
-# Microsoft Azure Emulator
-ecf/
-rcf/
-
-# Windows Store app package directories and files
-AppPackages/
-BundleArtifacts/
-Package.StoreAssociation.xml
-_pkginfo.txt
-*.appx
-*.appxbundle
-*.appxupload
-
-# Visual Studio cache files
-# files ending in .cache can be ignored
-*.[Cc]ache
-# but keep track of directories ending in .cache
-!?*.[Cc]ache/
-
-# Others
-ClientBin/
-~$*
-*~
-*.dbmdl
-*.dbproj.schemaview
-*.jfm
-*.pfx
-*.publishsettings
-orleans.codegen.cs
-
-# Including strong name files can present a security risk
-# (https://github.com/github/gitignore/pull/2483#issue-259490424)
-#*.snk
-
-# Since there are multiple workflows, uncomment next line to ignore bower_components
-# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
-#bower_components/
-
-# RIA/Silverlight projects
-Generated_Code/
-
-# Backup & report files from converting an old project file
-# to a newer Visual Studio version. Backup files are not needed,
-# because we have git ;-)
-_UpgradeReport_Files/
-Backup*/
-UpgradeLog*.XML
-UpgradeLog*.htm
-ServiceFabricBackup/
-*.rptproj.bak
-
-# SQL Server files
-*.mdf
-*.ldf
-*.ndf
-
-# Business Intelligence projects
-*.rdl.data
-*.bim.layout
-*.bim_*.settings
-*.rptproj.rsuser
-*- [Bb]ackup.rdl
-*- [Bb]ackup ([0-9]).rdl
-*- [Bb]ackup ([0-9][0-9]).rdl
-
-# Microsoft Fakes
-FakesAssemblies/
-
-# GhostDoc plugin setting file
-*.GhostDoc.xml
-
-# Node.js Tools for Visual Studio
-.ntvs_analysis.dat
-node_modules/
-
-# Visual Studio 6 build log
-*.plg
-
-# Visual Studio 6 workspace options file
-*.opt
-
-# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
-*.vbw
-
-# Visual Studio LightSwitch build output
-**/*.HTMLClient/GeneratedArtifacts
-**/*.DesktopClient/GeneratedArtifacts
-**/*.DesktopClient/ModelManifest.xml
-**/*.Server/GeneratedArtifacts
-**/*.Server/ModelManifest.xml
-_Pvt_Extensions
-
-# Paket dependency manager
-.paket/paket.exe
-paket-files/
-
-# FAKE - F# Make
-.fake/
-
-# CodeRush personal settings
-.cr/personal
-
-# Python Tools for Visual Studio (PTVS)
-__pycache__/
-*.pyc
-
-# Cake - Uncomment if you are using it
-# tools/**
-# !tools/packages.config
-
-# Tabs Studio
-*.tss
-
-# Telerik's JustMock configuration file
-*.jmconfig
-
-# BizTalk build output
-*.btp.cs
-*.btm.cs
-*.odx.cs
-*.xsd.cs
-
-# OpenCover UI analysis results
-OpenCover/
-
-# Azure Stream Analytics local run output
-ASALocalRun/
-
-# MSBuild Binary and Structured Log
-*.binlog
-
-# NVidia Nsight GPU debugger configuration file
-*.nvuser
-
-# MFractors (Xamarin productivity tool) working folder
-.mfractor/
-
-# Local History for Visual Studio
-.localhistory/
-
-# BeatPulse healthcheck temp database
-healthchecksdb
-
-# Backup folder for Package Reference Convert tool in Visual Studio 2017
-MigrationBackup/
-
-# Ionide (cross platform F# VS Code tools) working folder
-.ionide/
-
-# Fody - auto-generated XML schema
-FodyWeavers.xsd
-
-##
-## Visual studio for Mac
-##
-
-
-# globs
-Makefile.in
-*.userprefs
-*.usertasks
-config.make
-config.status
-aclocal.m4
-install-sh
-autom4te.cache/
-*.tar.gz
-tarballs/
-test-results/
-
-# Mac bundle stuff
-*.dmg
-*.app
-
-# content below from: https://github.com/github/gitignore/blob/master/Global/macOS.gitignore
-# General
-.DS_Store
-.AppleDouble
-.LSOverride
-
-# Icon must end with two \r
-Icon
-
-
-# Thumbnails
-._*
-
-# Files that might appear in the root of a volume
-.DocumentRevisions-V100
-.fseventsd
-.Spotlight-V100
-.TemporaryItems
-.Trashes
-.VolumeIcon.icns
-.com.apple.timemachine.donotpresent
-
-# Directories potentially created on remote AFP share
-.AppleDB
-.AppleDesktop
-Network Trash Folder
-Temporary Items
-.apdisk
-
-# content below from: https://github.com/github/gitignore/blob/master/Global/Windows.gitignore
-# Windows thumbnail cache files
-Thumbs.db
-ehthumbs.db
-ehthumbs_vista.db
-
-# Dump file
-*.stackdump
-
-# Folder config file
-[Dd]esktop.ini
-
-# Recycle Bin used on file shares
-$RECYCLE.BIN/
-
-# Windows Installer files
-*.cab
-*.msi
-*.msix
-*.msm
-*.msp
-
-# Windows shortcuts
-*.lnk
-
-# JetBrains Rider
-.idea/
-*.sln.iml
-
-##
-## Visual Studio Code
-##
-.vscode/*
-!.vscode/settings.json
-!.vscode/tasks.json
-!.vscode/launch.json
-!.vscode/extensions.json

HyperbolicDownloaderGUI/App.axaml

@@ -1,12 +0,0 @@
-<Application xmlns="https://github.com/avaloniaui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:local="using:HyperbolicDownloaderGUI"
-             x:Class="HyperbolicDownloaderGUI.App">
-    <Application.DataTemplates>
-        <local:ViewLocator/>
-    </Application.DataTemplates>
-
-    <Application.Styles>
-        <FluentTheme Mode="Light"/>
-    </Application.Styles>
-</Application>

HyperbolicDownloaderGUI/App.axaml.cs

@@ -1,30 +0,0 @@
-using Avalonia;
-using Avalonia.Controls.ApplicationLifetimes;
-using Avalonia.Markup.Xaml;
-
-using HyperbolicDownloaderGUI.ViewModels;
-using HyperbolicDownloaderGUI.Views;
-
-namespace HyperbolicDownloaderGUI
-{
-    public class App : Application
-    {
-        public override void Initialize()
-        {
-            AvaloniaXamlLoader.Load(this);
-        }
-
-        public override void OnFrameworkInitializationCompleted()
-        {
-            if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
-            {
-                desktop.MainWindow = new MainWindow
-                {
-                    DataContext = new MainWindowViewModel(),
-                };
-            }
-
-            base.OnFrameworkInitializationCompleted();
-        }
-    }
-}

HyperbolicDownloaderGUI/HyperbolicDownloaderGUI.csproj

@@ -1,19 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-  <ItemGroup>
-    <Folder Include="Models\" />
-    <AvaloniaResource Include="Assets\**" />
-    <None Remove=".gitignore" />
-  </ItemGroup>
-  <ItemGroup>
-    <PackageReference Include="Avalonia" Version="0.10.10" />
-    <PackageReference Include="Avalonia.Desktop" Version="0.10.10" />
-    <!--Condition below is needed to remove Avalonia.Diagnostics package from build output in Release configuration.-->
-    <PackageReference Condition="'$(Configuration)' == 'Debug'" Include="Avalonia.Diagnostics" Version="0.10.10" />
-    <PackageReference Include="Avalonia.ReactiveUI" Version="0.10.10" />
-  </ItemGroup>
-</Project>

HyperbolicDownloaderGUI/Program.cs

@@ -1,28 +0,0 @@
-using Avalonia;
-using Avalonia.ReactiveUI;
-
-using System;
-
-namespace HyperbolicDownloaderGUI
-{
-    internal static class Program
-    {
-        // Initialization code. Don't use any Avalonia, third-party APIs or any
-        // SynchronizationContext-reliant code before AppMain is called: things aren't initialized
-        // yet and stuff might break.
-        [STAThread]
-        public static void Main(string[] args)
-        {
-            BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);
-        }
-
-        // Avalonia configuration, don't remove; also used by visual designer.
-        public static AppBuilder BuildAvaloniaApp()
-        {
-            return AppBuilder.Configure<App>()
-                           .UsePlatformDetect()
-                           .LogToTrace()
-                           .UseReactiveUI();
-        }
-    }
-}

HyperbolicDownloaderGUI/ViewLocator.cs

@@ -1,32 +0,0 @@
-using Avalonia.Controls;
-using Avalonia.Controls.Templates;
-
-using HyperbolicDownloaderGUI.ViewModels;
-
-using System;
-
-namespace HyperbolicDownloaderGUI
-{
-    public class ViewLocator : IDataTemplate
-    {
-        public IControl Build(object data)
-        {
-            var name = data.GetType().FullName!.Replace("ViewModel", "View");
-            var type = Type.GetType(name);
-
-            if (type != null)
-            {
-                return (Control)Activator.CreateInstance(type)!;
-            }
-            else
-            {
-                return new TextBlock { Text = "Not Found: " + name };
-            }
-        }
-
-        public bool Match(object data)
-        {
-            return data is ViewModelBase;
-        }
-    }
-}

HyperbolicDownloaderGUI/ViewModels/MainWindowViewModel.cs

@@ -1,11 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace HyperbolicDownloaderGUI.ViewModels
-{
-    public class MainWindowViewModel : ViewModelBase
-    {
-        public string Greeting => "Welcome to Avalonia!";
-    }
-}

HyperbolicDownloaderGUI/ViewModels/ViewModelBase.cs

@@ -1,12 +0,0 @@
-using ReactiveUI;
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace HyperbolicDownloaderGUI.ViewModels
-{
-    public class ViewModelBase : ReactiveObject
-    {
-    }
-}

HyperbolicDownloaderGUI/Views/MainWindow.axaml

@@ -1,17 +0,0 @@
-<Window xmlns="https://github.com/avaloniaui"
-        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        xmlns:vm="using:HyperbolicDownloaderGUI.ViewModels"
-        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-        mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
-        x:Class="HyperbolicDownloaderGUI.Views.MainWindow"
-        Icon="/Assets/avalonia-logo.ico"
-        Title="HyperbolicDownloaderGUI">
-
-    <Design.DataContext>
-        <vm:MainWindowViewModel/>
-    </Design.DataContext>
-
-    <TextBlock Text="{Binding Greeting}" HorizontalAlignment="Center" VerticalAlignment="Center"/>
-
-</Window>

HyperbolicDownloaderGUI/Views/MainWindow.axaml.cs

@@ -1,22 +0,0 @@
-using Avalonia;
-using Avalonia.Controls;
-using Avalonia.Markup.Xaml;
-
-namespace HyperbolicDownloaderGUI.Views
-{
-    public partial class MainWindow : Window
-    {
-        public MainWindow()
-        {
-            InitializeComponent();
-#if DEBUG
-            this.AttachDevTools();
-#endif
-        }
-
-        private void InitializeComponent()
-        {
-            AvaloniaXamlLoader.Load(this);
-        }
-    }
-}