RemoteModule.cs

using System.ComponentModel;
using System.Threading.Channels;

using Repl;

using Results = Repl.Results;

namespace HostingRemoteSample;

/// <summary>
/// REPL module demonstrating shared settings, messaging, and session tracking.
/// </summary>
internal sealed class RemoteModule(
	ISettingsService settings,
	IMessageBus bus,
	SessionTracker tracker) : IReplModule
{
	public void Map(IReplMap map)
	{
		map.Context(
			"settings",
			[Description("Read and write shared settings")]
			(IReplMap m) =>
			{
				m.Map(
					"show {key}",
					[Description("Read a setting value")]
					(string key) =>
						settings.Get(key) is { } value
							? Results.Ok($"{key} = {value}")
							: Results.NotFound($"Setting '{key}' not found."));

				m.Map(
					"set {key} {value}",
					[Description("Write a setting value")]
					(string key, string value) =>
					{
						settings.Set(key, value);
						return Results.Success($"Setting '{key}' updated to '{value}'.");
					});
			});

		map.Map(
			"send {message}",
			[Description("Publish a message to all watching sessions")]
			(
				[Description("Message to send")]
				string message) =>
			{
				var sender = $"session-{Environment.CurrentManagedThreadId}";
				bus.Publish(sender, message);
				return Results.Ok("Message sent.");
			});

		map.Map(
			"watch",
			[Description("Subscribe to messages (press Enter to stop)")]
			async (IReplInteractionChannel channel, CancellationToken ct) =>
			{
				var messages = Channel.CreateUnbounded<string>();

				void Handler(string sender, string msg) =>
					messages.Writer.TryWrite($"[{sender}] {msg}");

				bus.OnMessage += Handler;
				try
				{
					using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
					var displayTask = DisplayMessagesAsync(messages.Reader, channel, cts.Token);
					await channel.AskTextAsync("watch-stop", "Watching... press Enter to stop");
					await cts.CancelAsync();
					await displayTask.ConfigureAwait(false);
				}
				finally
				{
					bus.OnMessage -= Handler;
					messages.Writer.Complete();
				}

				return Results.Ok("Stopped watching.");
			});

		map.Map(
			"who",
			[Description("List connected sessions")]
			() =>
			{
				var sessions = tracker.GetAllNames();
				return sessions.Count == 0
					? Results.Ok("No active sessions.")
					: Results.Ok(string.Join('\n', sessions));
			});

		map.Map(
			"configure",
			[Description("Configure server features (interactive multi-choice)")]
			async (IReplInteractionChannel channel, CancellationToken ct) =>
			{
				string[] featureNames = ["Authentication", "Logging", "Caching", "Metrics"];
				var selected = await channel.AskMultiChoiceAsync(
					"features",
					"Enable features:",
					["_Authentication", "_Logging", "_Caching", "_Metrics"],
					defaultIndices: [0, 1]);
				var labels = selected.Select(i => featureNames[i]);
				return Results.Ok($"Enabled: {string.Join(", ", labels)}.");
			});

		map.Map(
			"maintenance",
			[Description("Toggle maintenance mode (interactive choice with mnemonics)")]
			async (IReplInteractionChannel channel, CancellationToken ct) =>
			{
				var current = settings.Get("maintenance") ?? "off";
				await channel.WriteStatusAsync($"Maintenance is currently: {current}", ct);

				var action = await channel.AskChoiceAsync(
					"action",
					"What would you like to do?",
					["_Enable maintenance", "_Disable maintenance", "_Cancel"],
					defaultIndex: 2);

				if (action is 0 or 1)
				{
					var value = action == 0 ? "on" : "off";
					settings.Set("maintenance", value);
					return Results.Success($"Maintenance set to '{value}'.");
				}

				return Results.Ok("Cancelled.");
			});

		map.Context(
			"feedback",
			[Description("Demonstrate hosted user feedback states")]
			(IReplMap m) =>
			{
				m.Map(
					"demo",
					[Description("Run a successful feedback sequence with progress, warning, and indeterminate states")]
					async (IReplInteractionChannel channel, IReplSessionInfo session, CancellationToken ct) =>
					{
						await channel.WriteNoticeAsync(
							session.TerminalCapabilities.HasFlag(TerminalCapabilities.ProgressReporting)
								? "Advanced progress reporting is available for this hosted session."
								: "This client is using the text fallback for progress updates.",
							ct).ConfigureAwait(false);
						await BeginFeedbackDemoAsync(
							channel,
							"Press Enter to run a smooth feedback demo. You will see normal progress, a waiting phase, a warning phase, and a clean finish to 100%.",
							"feedback-demo-start",
							ct).ConfigureAwait(false);
						await AnimateProgressAsync(
							channel,
							"Preparing session",
							startPercent: 0,
							endPercent: 30,
							FeedbackStepDuration.InitialProgress,
							ct).ConfigureAwait(false);
						await channel.WriteIndeterminateProgressAsync(
							"Waiting for remote worker",
							"Negotiating with upstream services",
							ct).ConfigureAwait(false);
						await DelayFeedbackStepAsync(FeedbackStepDuration.Indeterminate, ct).ConfigureAwait(false);
						await AnimateWarningProgressAsync(
							channel,
							"Retrying sync",
							startPercent: 44,
							endPercent: 72,
							"Transient network jitter",
							FeedbackStepDuration.Warning,
							ct).ConfigureAwait(false);
						await AnimateProgressAsync(
							channel,
							"Finalizing",
							startPercent: 73,
							endPercent: 96,
							FeedbackStepDuration.NormalProgress,
							ct).ConfigureAwait(false);
						await AnimateProgressAsync(
							channel,
							"Completed",
							startPercent: 97,
							endPercent: 100,
							FeedbackStepDuration.CompletedRamp,
							ct).ConfigureAwait(false);
						await DelayFeedbackStepAsync(FeedbackStepDuration.Completed, ct).ConfigureAwait(false);
						await channel.WriteNoticeAsync("Feedback demo completed.", ct).ConfigureAwait(false);
						return Results.Success("Feedback demo completed.");
					});

				m.Map(
					"fail",
					[Description("Run a failing feedback sequence with warning, error, and problem output")]
					async (IReplInteractionChannel channel, CancellationToken ct) =>
					{
						await channel.WriteNoticeAsync(
							"Starting an error-state demo. This run is expected to end in a simulated failure state.",
							ct).ConfigureAwait(false);
						await BeginFeedbackDemoAsync(
							channel,
							"Press Enter to run a demo that intentionally ends in an error state. You will see normal progress, then a warning, then a final simulated failure.",
							"feedback-fail-start",
							ct).ConfigureAwait(false);
						await AnimateProgressAsync(
							channel,
							"Preparing session",
							startPercent: 0,
							endPercent: 28,
							FeedbackStepDuration.InitialProgress,
							ct).ConfigureAwait(false);
						await AnimateWarningProgressAsync(
							channel,
							"Retrying sync",
							startPercent: 36,
							endPercent: 58,
							"Remote worker timed out",
							FeedbackStepDuration.Warning,
							ct).ConfigureAwait(false);
						await AnimateErrorProgressAsync(
							channel,
							"Remote job failed",
							startPercent: 66,
							endPercent: 82,
							"Final retry exhausted",
							FeedbackStepDuration.Error,
							ct).ConfigureAwait(false);
						await channel.WriteProblemAsync(
							"Remote feedback demo failed",
							"The remote worker stayed unavailable after several retries.",
							"remote_feedback_failed",
							ct).ConfigureAwait(false);
						await channel.WriteNoticeAsync(
							"Error-state demo complete. The failure shown above was intentional.",
							ct).ConfigureAwait(false);
						return Results.Success("Error-state demo completed. The failure shown above was intentional.");
					});
			});

		map.Map(
			"debug",
			[Description("Show terminal capabilities for this session")]
			(IReplSessionInfo session) => new StatusRow[]
			{
				new("AnsiSupported", session.AnsiSupported.ToString(), session.AnsiSupported ? "ok" : "warning"),
				new(
					"ProgressReporting",
					session.TerminalCapabilities.HasFlag(TerminalCapabilities.ProgressReporting) ? "supported" : "text fallback",
					session.TerminalCapabilities.HasFlag(TerminalCapabilities.ProgressReporting) ? "ok" : "idle"),
				new("Capabilities", session.TerminalCapabilities.ToString(), "ok"),
				new("WindowSize", session.WindowSize is { } sz ? $"{sz.Width}x{sz.Height}" : "unknown", "ok"),
				new("Terminal", session.TerminalIdentity ?? "unknown", "ok"),
				new("Transport", session.TransportName ?? "local", "ok"),
			});

		map.Map(
			"sessions",
			[Description("List active sessions with transport and activity details")]
			(IReplSessionInfo session) =>
			{
				tracker.UpdateFromSession(session);
				var sessions = tracker.GetAll();
				return sessions.Count == 0
					? (object)Results.Ok("No active sessions.")
					: sessions.Select(ToSessionRow).ToArray();
			});

		map.Map(
			"status",
			[Description("Show system status (adapts to terminal width)")]
			(IReplSessionInfo session) =>
			{
				tracker.UpdateFromSession(session);
				var sessions = tracker.GetAll();
				return new StatusRow[]
				{
					new("Sessions", $"{sessions.Count} active", sessions.Count > 0 ? "ok" : "idle"),
					new("Settings", $"{settings.Count} keys", "ok"),
					new("Maintenance", settings.Get("maintenance") ?? "unknown", settings.Get("maintenance") == "on" ? "warning" : "ok"),
					new("Uptime", FormatUptime(), "ok"),
					new("Screen", session.WindowSize is { } sz ? $"{sz.Width}x{sz.Height}" : "unknown", "ok"),
					new(
						"Feedback",
						session.TerminalCapabilities.HasFlag(TerminalCapabilities.ProgressReporting)
							? "advanced VT progress"
							: "text fallback",
						session.TerminalCapabilities.HasFlag(TerminalCapabilities.ProgressReporting) ? "ok" : "idle"),
					new("Transport", FormatTransport(session), "ok"),
					new("Terminal", FormatTerminal(session), "ok"),
					new("Server", Environment.MachineName, "ok"),
					new("Runtime", $".NET {Environment.Version}", "ok"),
				};
			});
	}

	private static SessionRow ToSessionRow(SessionSnapshot session)
	{
		var now = DateTimeOffset.UtcNow;
		var connectedFor = now - session.ConnectedAtUtc;
		var idleFor = now - session.LastSeenUtc;
		return new SessionRow(
			Name: session.Name,
			Transport: session.Transport,
			Remote: string.IsNullOrWhiteSpace(session.RemotePeer) ? "unknown" : session.RemotePeer!,
			Screen: session.Screen ?? "unknown",
			Terminal: FormatTerminal(session),
			ConnectedFor: FormatDuration(connectedFor),
			IdleFor: FormatDuration(idleFor));
	}

	private static string FormatUptime()
	{
		var uptime = TimeSpan.FromMilliseconds(Environment.TickCount64);
		return FormatDuration(uptime);
	}

	private static string FormatTerminal(IReplSessionInfo session)
	{
		var caps = session.TerminalCapabilities;
		var identity = session.TerminalIdentity;
		if (!string.IsNullOrWhiteSpace(identity))
		{
			return caps == TerminalCapabilities.None
				? identity
				: $"{identity} ({caps})";
		}

		return caps == TerminalCapabilities.None ? "unknown" : caps.ToString();
	}

	private static string FormatTransport(IReplSessionInfo session)
	{
		var transport = session.TransportName ?? "console";
		if (string.IsNullOrWhiteSpace(session.RemotePeer))
		{
			return transport;
		}

		return $"{transport} ({session.RemotePeer})";
	}

	private static string FormatDuration(TimeSpan value)
	{
		if (value.TotalHours >= 1)
		{
			return $"{(int)value.TotalHours}h {value.Minutes}m";
		}

		if (value.TotalMinutes >= 1)
		{
			return $"{value.Minutes}m {value.Seconds}s";
		}

		return $"{Math.Max(0, value.Seconds)}s";
	}

	private static string FormatTerminal(SessionSnapshot session)
	{
		if (!string.IsNullOrWhiteSpace(session.Terminal))
		{
			return session.Capabilities == TerminalCapabilities.None
				? session.Terminal
				: $"{session.Terminal} ({session.Capabilities})";
		}

		return session.Capabilities == TerminalCapabilities.None
			? "unknown"
			: session.Capabilities.ToString();
	}

	private sealed record SessionRow(
		[property: System.ComponentModel.DataAnnotations.Display(Name = "Session")] string Name,
		[property: System.ComponentModel.DataAnnotations.Display(Name = "Transport")] string Transport,
		[property: System.ComponentModel.DataAnnotations.Display(Name = "Remote")] string Remote,
		[property: System.ComponentModel.DataAnnotations.Display(Name = "Screen")] string Screen,
		[property: System.ComponentModel.DataAnnotations.Display(Name = "Terminal")] string Terminal,
		[property: System.ComponentModel.DataAnnotations.Display(Name = "Connected")] string ConnectedFor,
		[property: System.ComponentModel.DataAnnotations.Display(Name = "Idle")] string IdleFor);

	private sealed record StatusRow(
		[property: System.ComponentModel.DataAnnotations.Display(Name = "Component")] string Component,
		[property: System.ComponentModel.DataAnnotations.Display(Name = "Value")] string Value,
		[property: System.ComponentModel.DataAnnotations.Display(Name = "State")] string State);

	private static async Task DisplayMessagesAsync(
		ChannelReader<string> reader,
		IReplInteractionChannel channel,
		CancellationToken cancellationToken)
	{
		try
		{
			await foreach (var msg in reader.ReadAllAsync(cancellationToken).ConfigureAwait(false))
			{
				await channel.WriteStatusAsync(msg, cancellationToken).ConfigureAwait(false);
			}
		}
		catch (OperationCanceledException)
		{
			// Expected when user presses Enter.
		}
	}

	private static Task DelayFeedbackStepAsync(TimeSpan duration, CancellationToken cancellationToken) =>
		Task.Delay(duration, cancellationToken);

	private static async Task AnimateProgressAsync(
		IReplInteractionChannel channel,
		string label,
		double startPercent,
		double endPercent,
		TimeSpan duration,
		CancellationToken cancellationToken)
	{
		await AnimateProgressCoreAsync(
			startPercent,
			endPercent,
			duration,
			static (progressChannel, progressLabel, percent, _, ct) => progressChannel.WriteProgressAsync(progressLabel, percent, ct),
			channel,
			label,
			details: null,
			cancellationToken).ConfigureAwait(false);
	}

	private static async Task AnimateWarningProgressAsync(
		IReplInteractionChannel channel,
		string label,
		double startPercent,
		double endPercent,
		string details,
		TimeSpan duration,
		CancellationToken cancellationToken)
	{
		await AnimateProgressCoreAsync(
			startPercent,
			endPercent,
			duration,
			static (progressChannel, progressLabel, percent, progressDetails, ct) =>
				progressChannel.WriteWarningProgressAsync(progressLabel, percent, progressDetails!, ct),
			channel,
			label,
			details,
			cancellationToken).ConfigureAwait(false);
	}

	private static async Task AnimateErrorProgressAsync(
		IReplInteractionChannel channel,
		string label,
		double startPercent,
		double endPercent,
		string details,
		TimeSpan duration,
		CancellationToken cancellationToken)
	{
		await AnimateProgressCoreAsync(
			startPercent,
			endPercent,
			duration,
			static (progressChannel, progressLabel, percent, progressDetails, ct) =>
				progressChannel.WriteErrorProgressAsync(progressLabel, percent, progressDetails!, ct),
			channel,
			label,
			details,
			cancellationToken).ConfigureAwait(false);
	}

	private static async Task BeginFeedbackDemoAsync(
		IReplInteractionChannel channel,
		string instructions,
		string promptName,
		CancellationToken cancellationToken)
	{
		await channel.WriteStatusAsync(instructions, cancellationToken).ConfigureAwait(false);
		await channel.AskTextAsync(promptName, "Press Enter to start").ConfigureAwait(false);
	}

	private static async Task AnimateProgressCoreAsync(
		double startPercent,
		double endPercent,
		TimeSpan duration,
		Func<IReplInteractionChannel, string, double, string?, CancellationToken, ValueTask> writer,
		IReplInteractionChannel channel,
		string label,
		string? details,
		CancellationToken cancellationToken)
	{
		var clampedStart = Math.Clamp(startPercent, 0d, 100d);
		var clampedEnd = Math.Clamp(endPercent, 0d, 100d);
		var direction = clampedEnd >= clampedStart ? 1 : -1;
		var range = Math.Abs(clampedEnd - clampedStart);
		var stepCount = Math.Max(1, (int)Math.Ceiling(range / 1.5d));
		var interval = TimeSpan.FromMilliseconds(Math.Max(45d, duration.TotalMilliseconds / stepCount));
		var stepSize = stepCount == 0 ? range : range / stepCount;
		var percent = clampedStart;

		while (true)
		{
			await writer(channel, label, percent, details, cancellationToken).ConfigureAwait(false);
			if (Math.Abs(percent - clampedEnd) < double.Epsilon)
			{
				break;
			}

			await Task.Delay(interval, cancellationToken).ConfigureAwait(false);
			var nextPercent = percent + (stepSize * direction);
			percent = direction > 0
				? Math.Min(clampedEnd, nextPercent)
				: Math.Max(clampedEnd, nextPercent);
		}
	}

	private static class FeedbackStepDuration
	{
		public static readonly TimeSpan InitialProgress = TimeSpan.FromSeconds(1.4);
		public static readonly TimeSpan Indeterminate = TimeSpan.FromSeconds(1.4);
		public static readonly TimeSpan Warning = TimeSpan.FromSeconds(1.4);
		public static readonly TimeSpan NormalProgress = TimeSpan.FromSeconds(1.2);
		public static readonly TimeSpan CompletedRamp = TimeSpan.FromSeconds(0.4);
		public static readonly TimeSpan Completed = TimeSpan.FromSeconds(1.2);
		public static readonly TimeSpan Error = TimeSpan.FromSeconds(1.2);
	}
}