...

Author: Decimation

SmartImage 3/CliMain.cs

@@ -2,17 +2,23 @@
 // 2023-01-30 @ 10:37 PM
 
 using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
+using JetBrains.Annotations;
 using SmartImage.Lib;
 using SmartImage.Lib.Engines;
 using SmartImage.Lib.Results;
+using SmartImage.Utilities;
 using Spectre.Console;
+using Spectre.Console.Rendering;
 
 // ReSharper disable InconsistentNaming
 
 namespace SmartImage;
 
-public class CliMain : IDisposable
+public sealed class CliMain : IDisposable, IMain
 {
+	#region
+
 	private const double COMPLETE = 100.0D;
 
 	private static readonly ProgressColumn[] PrgCol_1 =
@@ -26,95 +32,173 @@ public class CliMain : IDisposable
 		new ProgressBarColumn()
 	};
 
-	static CliMain() { }
-
 	private static readonly Progress Prg_1 = AnsiConsole.Progress()
 		.AutoClear(true)
 		.AutoRefresh(true)
-		.HideCompleted(false)
+		.HideCompleted(true)
 		.Columns(PrgCol_1);
 
-	public static async Task RunCliAsync(string c)
-	{
-		var q = await Prg_1.StartAsync(async ctx =>
-		{
-			var t = ctx.AddTask("Validating input");
-			t.IsIndeterminate = true;
-			var qInner = await SearchQuery.TryCreateAsync(c);
-			t.Increment(COMPLETE);
-			return qInner;
-		});
+	static CliMain() { }
 
-		AnsiConsole.WriteLine($"{q}");
+	#endregion
 
-		var url = await Prg_1.StartAsync(async (p) =>
-		{
-			var pt       = p.AddTask($"Upload");
-			pt.IsIndeterminate = true;
-			var urlInner = await q.UploadAsync();
-			pt.Increment(COMPLETE);
-			return urlInner;
+	private readonly ConcurrentBag<SearchResult> m_results = new();
+
+	private SearchResult[] m_results2;
+
+	private readonly SearchConfig m_cfg;
+
+	private SearchQuery m_query;
+
+	private readonly SearchClient m_client;
+
+	private readonly CancellationTokenSource m_cts;
+
+	public CliMain()
+	{
+		m_cfg    = new SearchConfig();
+		m_client = new SearchClient(m_cfg);
+		m_query  = SearchQuery.Null;
+		m_cts    = new CancellationTokenSource();
+	}
 
-		});
+	public async Task<object?> RunAsync(object? c)
+	{
+		await Prg_1.StartAsync(ctx => ValidateInputAsync(ctx, c as string));
 
-		AnsiConsole.MarkupLine($"[green]{q.Upload}[/]");
+		AnsiConsole.WriteLine($"{m_query}");
 
-		var cfg = new SearchConfig();
-		var sc  = new SearchClient(cfg);
+		var url = await Prg_1.StartAsync(UploadInputAsync);
 
-		AnsiConsole.WriteLine($"{cfg}");
+		AnsiConsole.MarkupLine($"[green]{m_query.Upload}[/]");
 
-		var cts = new CancellationTokenSource();
+		AnsiConsole.WriteLine($"{m_cfg}");
 
 		System.Console.CancelKeyPress += (sender, args) =>
 		{
 			args.Cancel = false;
-			cts.Cancel();
+			m_cts.Cancel();
 			AnsiConsole.MarkupLine($"[red]Cancellation requested {args}[/]");
 		};
 
-		var results = await Prg_1.StartAsync(async ctx =>
-		{
-			var ptMap = new Dictionary<BaseSearchEngine, ProgressTask>();
+		await Prg_1.StartAsync(RunSearchAsync);
+		return null;
+	}
 
-			foreach (var e in sc.Engines) {
-				var t = ctx.AddTask($"{e}");
-				t.IsIndeterminate = true;
-				ptMap.Add(e, t);
-			}
+	private async Task ValidateInputAsync(ProgressContext ctx, string c)
+	{
+		var t = ctx.AddTask("Validating input");
+		t.IsIndeterminate = true;
+		m_query           = await SearchQuery.TryCreateAsync(c);
+		t.Increment(COMPLETE);
+	}
 
-			var pt1 = ctx.AddTask("[yellow]Searching[/]");
-			pt1.IsIndeterminate = false;
-			var rg  = new ConcurrentBag<SearchResult>();
-
-			sc.OnComplete += (sender, searchResults) =>
-			{
-				pt1.Increment(COMPLETE);
-			};
-			pt1.MaxValue = sc.Engines.Length;
-
-			sc.OnResult += (sender, result) =>
-			{
-				rg.Add(result);
-				ptMap[result.Engine].Increment(COMPLETE);
-				pt1.Increment((1.0));
-				
-			};
+	private async Task<Url> UploadInputAsync(ProgressContext p)
+	{
+		var pt = p.AddTask($"Upload");
+		pt.IsIndeterminate = true;
+		var urlInner = await m_query.UploadAsync();
+		pt.Increment(COMPLETE);
+		return urlInner;
+
+	}
+
+	private async Task RunSearchAsync(ProgressContext ctx)
+	{
+		var ptMap = new Dictionary<BaseSearchEngine, (ProgressTask, Table)>();
+
+		foreach (var e in m_client.Engines) {
+			var t  = ctx.AddTask($"{e}");
+			var tt = get_table(e);
+			t.IsIndeterminate = true;
+			ptMap.Add(e, (t, tt));
+		}
+
+		var pt1 = ctx.AddTask("[yellow]Searching[/]");
+		pt1.IsIndeterminate = false;
+
+		void OnComplete(object sender, SearchResult[] searchResults)
+		{
+			pt1.Increment(COMPLETE);
+		}
 
-			var resultsInner = await sc.RunSearchAsync(q, cts.Token);
+		m_client.OnComplete += OnComplete;
 
-			return resultsInner;
-		});
+		pt1.MaxValue = m_client.Engines.Length;
 
-		foreach (SearchResult sr in results) {
-			AnsiConsole.MarkupLine($"[cyan][bold]{sr.Engine.Name}[/][/]");
+		void OnResult(object sender, SearchResult sr)
+		{
+			m_results.Add(sr);
+			ptMap[sr.Engine].Item1.Increment(COMPLETE);
+			pt1.Increment((1.0));
 			int i = 0;
+
+			var t = ptMap[sr.Engine].Item2;
+
 			foreach (SearchResultItem sri in sr.Results) {
-				AnsiConsole.MarkupLine($"[link={sri.Url}]{sr.Engine.Name} #{i+1}[/]");
+				t.Rows.Add(new IRenderable[]
+				{
+					new Text($"{i + 1}"),
+					Markup.FromInterpolated($"[link={sri.Url}]{sr.Engine.Name} #{i + 1}[/]")
+				});
+				
 				i++;
 			}
+
+			// AnsiConsole.Write(t);
+		}
+
+		m_client.OnResult += OnResult;
+
+		var ttt = m_client.RunSearchAsync(m_query, m_cts.Token);
+
+		/*
+		while (!pt1.IsFinished) { }*/
+
+		m_results2 = await ttt;
+
+		/*var ld = AnsiConsole.Live(new Table()
+			                          { });
+		ld.StartAsync(async (x) =>
+		{
+			return;
+		});*/
+		// pt1.StopTask();
+		
+		while (!pt1.IsFinished || ptMap.Any(s=>!s.Value.Item1.IsFinished)) {
+			await Task.Delay(TimeSpan.FromMilliseconds(100));
+		}
+
+		AnsiConsole.Clear();
+
+		foreach (var vt in ptMap.Values) {
+			// vt.Item1.StopTask();
+			AnsiConsole.Write(vt.Item2);
 		}
+
 	}
 
-	public void Dispose() { }
+	private static Table get_table(BaseSearchEngine bse)
+	{
+		var tt = new Table()
+		{
+			Border      = TableBorder.Heavy,
+			Title       = new($"{bse.Name}"),
+			ShowFooters = true,
+			ShowHeaders = true,
+		};
+
+		tt.AddColumns(new TableColumn("#"), new TableColumn("Link"));
+
+		return tt;
+	}
+
+	public void Dispose()
+	{
+		m_results.Clear();
+		Array.Clear(m_results2);
+		m_cts.Dispose();
+		m_query.Dispose();
+		m_client.Dispose();
+	}
 }

SmartImage 3/Program.cs

@@ -85,7 +85,7 @@ public static async Task<int> Main(string[] args)
 			rc.AddOption(arg);
 			rc.AddOption(opt2);
 
-			rc.SetHandler(CliMain.RunCliAsync, arg);
+			rc.SetHandler(main.RunAsync, arg);
 
 			var i = await rc.InvokeAsync(args);
 
@@ -98,8 +98,8 @@ public static async Task<int> Main(string[] args)
 			var main = new ShellMain(args);
 			object status;
 
-			var run = main.RunAsync(null);
-			status = await run;
+			var run =  main.RunAsync(null);
+			status = (bool?) await run;
 
 			if (status is bool { } and true) {
 				main.Dispose();

SmartImage 3/ShellMain.cs

@@ -26,7 +26,7 @@
 #pragma warning disable IDE0060
 namespace SmartImage;
 
-public sealed partial class ShellMain : IDisposable
+public sealed partial class ShellMain : IDisposable, IMain
 {
 	// NOTE: DO NOT REARRANGE FIELD ORDER
 	// NOTE: Static initialization order is nondeterminant with partial classes
@@ -366,10 +366,10 @@ public ShellMain(string[] args)
 		}
 	}
 
-	public Task<bool?> RunAsync(object? sender = null)
+	public Task<object?> RunAsync(object? sender = null)
 	{
 		Application.Run();
-		return Task.FromResult(Status);
+		return Task.FromResult<object?>(Status);
 	}
 
 	private void PreSearch()

SmartImage 3/Utilities/IMain.cs

@@ -0,0 +1,9 @@
+// Read Stanton SmartImage IMain.cs
+// 2023-01-31 @ 11:22 AM
+
+namespace SmartImage.Utilities;
+
+public interface IMain
+{
+	public Task<object?> RunAsync(object? sender);
+}