using System.Globalization; using System.Runtime.CompilerServices; using System.Text.Json; using AutoForge.Application.Features.Vehicles.Diagnostics; using AutoForge.Diagnostics; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection.Extensions; namespace AutoForge.Application.Features.Vehicles.Telemetry.LiveDashboard; public interface ILiveDashboardPollScheduler { Task WaitAsync(TimeSpan interval, CancellationToken cancellationToken); } public sealed class SystemLiveDashboardPollScheduler : ILiveDashboardPollScheduler { public Task WaitAsync(TimeSpan interval, CancellationToken cancellationToken) => Task.Delay(interval, cancellationToken); } public interface ILiveDashboardFeedFactory { LiveDashboardFeed Create(DiagnosticSession session); } public sealed class LiveDashboardFeedFactory(ILiveDashboardPollScheduler scheduler) : ILiveDashboardFeedFactory { private readonly object _gate = new(); private readonly ConditionalWeakTable _feeds = new(); public LiveDashboardFeed Create(DiagnosticSession session) { ArgumentNullException.ThrowIfNull(session); lock (_gate) { ObjectDisposedException.ThrowIf(session.IsClosed, session); return _feeds.GetValue(session, source => new LiveDashboardFeed(source, scheduler)); } } } public sealed class LiveDashboardFeed : IAsyncDisposable { public static readonly TimeSpan PollInterval = TimeSpan.FromMilliseconds(250); private readonly DiagnosticSession _session; private readonly ILiveDashboardPollScheduler _scheduler; private readonly object _gate = new(); private readonly Dictionary _eligibleEndpoints = new(StringComparer.OrdinalIgnoreCase); private readonly Dictionary> _lastSignals = new(StringComparer.OrdinalIgnoreCase); private readonly Dictionary _moduleStatuses = new(StringComparer.OrdinalIgnoreCase); private readonly Dictionary<(string Module, string Signal), DashboardSignalBinding> _knownBindings = new(new SignalKeyComparer()); private readonly Dictionary<(string Module, string Signal), DiagnosticSignal> _lastFiniteSignals = new(new SignalKeyComparer()); private IReadOnlyList _definitions = []; private DashboardFeedState _state = DashboardFeedState.Stopped; private LiveDashboardSnapshot _snapshot; private CancellationTokenSource? _ownerCancellation; private Task? _ownerTask; private Task? _initializationTask; private Task? _stopTask; private long _cycle; private string? _error; private bool _disposed; private Task? _disposeTask; internal LiveDashboardFeed( DiagnosticSession session, ILiveDashboardPollScheduler scheduler) { _session = session ?? throw new ArgumentNullException(nameof(session)); _scheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler)); _snapshot = CreateSnapshotLocked(); _session.RegisterLifetimeResource(this); } public event Action? Changed; public LiveDashboardSnapshot Snapshot { get { lock (_gate) { return _snapshot; } } } public void ReplaceDefinitions(IEnumerable definitions) { ArgumentNullException.ThrowIfNull(definitions); var proposed = definitions.ToArray(); lock (_gate) { EnsureNotDisposed(); ValidateDefinitions(proposed); _definitions = Array.AsReadOnly(proposed.ToArray()); _snapshot = CreateSnapshotLocked(); } Changed?.Invoke(); } public async Task StartAsync(CancellationToken cancellationToken = default) { Task initialization; var changed = false; lock (_gate) { EnsureNotDisposed(); if (_state == DashboardFeedState.Running) { return; } if (_state == DashboardFeedState.Starting && _initializationTask is not null) { initialization = _initializationTask; } else { if (_state == DashboardFeedState.Stopping || _ownerTask is { IsCompleted: false }) { throw new InvalidOperationException( "The previous dashboard acquisition owner is still stopping; retry after cleanup completes."); } _ownerCancellation?.Dispose(); _ownerCancellation = new CancellationTokenSource(); var initializationSource = new TaskCompletionSource( TaskCreationOptions.RunContinuationsAsynchronously); initialization = initializationSource.Task; _initializationTask = initialization; _stopTask = null; _error = null; _state = DashboardFeedState.Starting; _snapshot = CreateSnapshotLocked(); _ownerTask = Task.Run(() => RunOwnerAsync(_ownerCancellation, initializationSource)); changed = true; } } if (changed) { Changed?.Invoke(); } await initialization.WaitAsync(cancellationToken).ConfigureAwait(false); } public Task StopAsync() { Task stop; var changed = false; lock (_gate) { EnsureNotDisposed(); if (_state == DashboardFeedState.Stopping && _stopTask is not null) { return _stopTask; } if (_ownerTask is not { } owner) { _state = DashboardFeedState.Stopped; _initializationTask = null; _snapshot = CreateSnapshotLocked(); stop = Task.CompletedTask; changed = true; } else { _state = DashboardFeedState.Stopping; _snapshot = CreateSnapshotLocked(); _ownerCancellation!.Cancel(); stop = StopOwnerAsync(owner, _ownerCancellation); _stopTask = stop; changed = true; } } if (changed) { Changed?.Invoke(); } return stop; } public ValueTask DisposeAsync() { lock (_gate) { if (_disposeTask is not null) { return new ValueTask(_disposeTask); } _disposeTask = DisposeCoreAsync(); return new ValueTask(_disposeTask); } } private async Task DisposeCoreAsync() { try { await StopAsync().ConfigureAwait(false); } finally { lock (_gate) { _disposed = true; _ownerCancellation?.Dispose(); _ownerCancellation = null; _initializationTask = null; Changed = null; } } } private async Task RunOwnerAsync( CancellationTokenSource cancellation, TaskCompletionSource initialization) { try { var token = cancellation.Token; var discovery = await _session.DiscoverAsync(token).ConfigureAwait(false); token.ThrowIfCancellationRequested(); var endpoints = discovery.Endpoints .Where(entry => entry.Identity is not null && entry.ImplementedServices.Contains(DiagnosticServices.ReadSignals, StringComparer.Ordinal)) .Select(entry => entry.Endpoint) .ToArray(); if (endpoints.Length == 0) { throw new InvalidOperationException( "No identity-verified endpoint in this session advertises read.signals; monitoring cannot start."); } lock (_gate) { if (ReferenceEquals(_ownerCancellation, cancellation)) { _eligibleEndpoints.Clear(); foreach (var endpoint in endpoints) { _eligibleEndpoints.Add(endpoint.ModuleIdentifier, endpoint); } } } await AcquireCycleAsync(token).ConfigureAwait(false); token.ThrowIfCancellationRequested(); lock (_gate) { if (ReferenceEquals(_ownerCancellation, cancellation) && !token.IsCancellationRequested) { _state = DashboardFeedState.Running; _snapshot = CreateSnapshotLocked(); } } token.ThrowIfCancellationRequested(); initialization.TrySetResult(); Changed?.Invoke(); while (true) { await _scheduler.WaitAsync(PollInterval, token).ConfigureAwait(false); token.ThrowIfCancellationRequested(); await AcquireCycleAsync(token).ConfigureAwait(false); token.ThrowIfCancellationRequested(); Changed?.Invoke(); } } catch (OperationCanceledException) when (cancellation.IsCancellationRequested) { initialization.TrySetCanceled(cancellation.Token); } catch (Exception exception) { lock (_gate) { if (ReferenceEquals(_ownerCancellation, cancellation)) { _error = exception.Message; _state = DashboardFeedState.Error; _snapshot = CreateSnapshotLocked(); } } initialization.TrySetException(exception); Changed?.Invoke(); } } private async Task AcquireCycleAsync(CancellationToken cancellationToken) { KeyValuePair[] endpoints; lock (_gate) { endpoints = _eligibleEndpoints.ToArray(); } foreach (var (moduleIdentifier, endpoint) in endpoints) { cancellationToken.ThrowIfCancellationRequested(); var result = await _session.ReadSignalsAsync(endpoint, cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); if (result.IsSuccess) { var snapshot = result.Value!; try { ValidateSnapshot(moduleIdentifier, snapshot); lock (_gate) { var signals = snapshot.Signals.ToDictionary( signal => signal.SignalIdentifier, signal => signal, StringComparer.Ordinal); var bindings = new List(snapshot.Signals.Count); foreach (var signal in snapshot.Signals) { var key = (moduleIdentifier, signal.SignalIdentifier); var binding = new DashboardSignalBinding( signal.ModuleIdentifier, signal.SignalIdentifier, signal.Unit, signal.Origin); if (_knownBindings.TryGetValue(key, out var previous) && (!StringComparer.Ordinal.Equals(previous.Unit, binding.Unit) || !StringComparer.Ordinal.Equals(previous.Origin, binding.Origin))) { throw new InvalidOperationException( $"Signal '{signal.SignalIdentifier}' on '{moduleIdentifier}' changed its verified unit or origin."); } bindings.Add(binding); } _lastSignals[moduleIdentifier] = signals; foreach (var signal in bindings) { var key = (moduleIdentifier, signal.SignalIdentifier); _knownBindings.TryAdd(key, signal); } foreach (var signal in snapshot.Signals) { if (signal.Quality == SignalQuality.Good && TryGetFiniteNumber(signal, out _)) { _lastFiniteSignals[(moduleIdentifier, signal.SignalIdentifier)] = signal; } } _moduleStatuses[moduleIdentifier] = new DashboardModuleStatus(moduleIdentifier, result.Outcome, null); } } catch (InvalidOperationException exception) { lock (_gate) { _moduleStatuses[moduleIdentifier] = new DashboardModuleStatus(moduleIdentifier, DiagnosticOutcome.ProtocolError, exception.Message); } } } else { lock (_gate) { _moduleStatuses[moduleIdentifier] = new DashboardModuleStatus(moduleIdentifier, result.Outcome, result.Error); } } } lock (_gate) { _cycle++; _snapshot = CreateSnapshotLocked(); } } private void ValidateSnapshot(string requestedModule, SignalSnapshot snapshot) { if (!StringComparer.OrdinalIgnoreCase.Equals(snapshot.ModuleIdentifier, requestedModule)) { throw new InvalidOperationException( $"Signal response module '{snapshot.ModuleIdentifier}' did not match requested module '{requestedModule}'."); } foreach (var signal in snapshot.Signals) { if (!StringComparer.OrdinalIgnoreCase.Equals(signal.ModuleIdentifier, requestedModule)) { throw new InvalidOperationException( $"Signal '{signal.SignalIdentifier}' reported source module '{signal.ModuleIdentifier}' instead of '{requestedModule}'."); } var identity = _session.Identity; if (!StringComparer.Ordinal.Equals( signal.ModelConfigurationIdentifier, identity.DynamicsConfigurationIdentifier) || !StringComparer.Ordinal.Equals(signal.ModelRunIdentifier, identity.DynamicsRunIdentifier)) { throw new InvalidOperationException( $"Signal '{signal.SignalIdentifier}' does not match the selected dynamics configuration/run context."); } } } private void ValidateDefinitions(IReadOnlyList definitions) { if (definitions.Count > 8) { throw new DashboardConfigurationException("A live dashboard supports no more than eight gauges."); } var identifiers = new HashSet(StringComparer.OrdinalIgnoreCase); foreach (var definition in definitions) { if (definition is null) { throw new DashboardConfigurationException("Dashboard gauge definitions cannot contain null."); } if (string.IsNullOrWhiteSpace(definition.GaugeIdentifier) || !StringComparer.Ordinal.Equals(definition.GaugeIdentifier, definition.GaugeIdentifier.Trim()) || !identifiers.Add(definition.GaugeIdentifier)) { throw new DashboardConfigurationException( "Gauge identifiers must be nonblank, trimmed and unique ignoring case."); } if (string.IsNullOrWhiteSpace(definition.Label) || !StringComparer.Ordinal.Equals(definition.Label, definition.Label.Trim())) { throw new DashboardConfigurationException("Gauge labels must be nonblank and contain no surrounding whitespace."); } if (!Enum.IsDefined(definition.Kind)) { throw new DashboardConfigurationException("The selected gauge kind is undefined."); } if (string.IsNullOrWhiteSpace(definition.ModuleIdentifier) || string.IsNullOrWhiteSpace(definition.SignalIdentifier) || string.IsNullOrWhiteSpace(definition.Unit)) { throw new DashboardConfigurationException("Gauge module, signal and unit bindings must be explicit."); } if (!double.IsFinite(definition.Minimum) || !double.IsFinite(definition.Maximum) || !double.IsFinite(definition.Maximum - definition.Minimum) || definition.Maximum <= definition.Minimum) { throw new DashboardConfigurationException( "Gauge range must have finite minimum, maximum and positive finite span."); } if (definition.DecimalPrecision is < 0 or > 3) { throw new DashboardConfigurationException("Gauge decimal precision must be an integer from 0 through 3."); } if (!_knownBindings.TryGetValue( (definition.ModuleIdentifier, definition.SignalIdentifier), out var binding)) { throw new DashboardConfigurationException( $"Signal '{definition.SignalIdentifier}' on module '{definition.ModuleIdentifier}' has not been read from an identity-verified endpoint in this session."); } if (!StringComparer.Ordinal.Equals(definition.Unit, binding.Unit)) { throw new DashboardConfigurationException( $"Gauge unit '{definition.Unit}' does not exactly match source unit '{binding.Unit}'; unit conversion is not supported."); } } } private LiveDashboardSnapshot CreateSnapshotLocked() { var available = Array.AsReadOnly(_knownBindings.Values .OrderBy(item => item.ModuleIdentifier, StringComparer.OrdinalIgnoreCase) .ThenBy(item => item.SignalIdentifier, StringComparer.Ordinal) .ToArray()); var values = Array.AsReadOnly(_definitions.Select(CreateGaugeValueLocked).ToArray()); var modules = Array.AsReadOnly(_moduleStatuses.Values .OrderBy(item => item.ModuleIdentifier, StringComparer.OrdinalIgnoreCase) .ToArray()); return new LiveDashboardSnapshot( _session.Identity, _state, available, Array.AsReadOnly(_definitions.ToArray()), values, modules, _cycle, _error); } private DashboardGaugeValue CreateGaugeValueLocked(DashboardGaugeDefinition definition) { if (_state is DashboardFeedState.Stopped or DashboardFeedState.Stopping) { if (_lastFiniteSignals.TryGetValue( (definition.ModuleIdentifier, definition.SignalIdentifier), out var stoppedSignal) && TryGetFiniteNumber(stoppedSignal, out var stoppedNumber)) { var stoppedState = GetRangeState(stoppedNumber, definition); return CreateValue(definition, DashboardReadingState.Stopped, stoppedNumber, stoppedSignal, $"Monitoring stopped; last source sample was at logical tick {stoppedSignal.LogicalTimeTicks}.", stoppedState); } return new DashboardGaugeValue( definition, DashboardReadingState.Stopped, "--", null, null, "Monitoring stopped; no numeric source sample is available.", null); } if (_state == DashboardFeedState.Starting) { return new DashboardGaugeValue( definition, DashboardReadingState.Pending, "--", null, null, "Waiting for the first verified source sample.", null); } if (_state == DashboardFeedState.Error) { return LastOrError(definition, _error ?? "Dashboard acquisition stopped after an unexpected source error."); } DiagnosticSignal? signal = null; _lastSignals.TryGetValue(definition.ModuleIdentifier, out var moduleSignals); moduleSignals?.TryGetValue(definition.SignalIdentifier, out signal); if (_moduleStatuses.TryGetValue(definition.ModuleIdentifier, out var moduleStatus) && moduleStatus.Outcome != DiagnosticOutcome.PositiveResponse) { return LastOrError(definition, moduleStatus.Error ?? $"Source read outcome: {moduleStatus.Outcome}."); } if (signal is null) { return LastOrError( definition, "The previously bound signal is missing from the latest source response.", DashboardReadingState.Unavailable); } if (signal.Quality == SignalQuality.Unknown || !TryGetFiniteNumber(signal, out var value)) { return new DashboardGaugeValue( definition, DashboardReadingState.Unknown, "--", null, null, signal.Quality == SignalQuality.Unknown ? "The source quality is Unknown." : "The source value is null, non-numeric or non-finite.", signal); } if (signal.Quality == SignalQuality.Uncertain) { return CreateValue( definition, DashboardReadingState.Uncertain, value, signal, "The source marked this finite value Uncertain.", GetRangeState(value, definition)); } if (signal.Quality != SignalQuality.Good) { return new DashboardGaugeValue( definition, DashboardReadingState.Unknown, "--", null, null, "The source quality is undefined.", signal); } _lastFiniteSignals[(definition.ModuleIdentifier, definition.SignalIdentifier)] = signal; return CreateValue(definition, GetRangeState(value, definition), value, signal, null); } private DashboardGaugeValue LastOrError( DashboardGaugeDefinition definition, string error, DashboardReadingState missingState = DashboardReadingState.Error) { if (_lastFiniteSignals.TryGetValue((definition.ModuleIdentifier, definition.SignalIdentifier), out var last) && TryGetFiniteNumber(last, out var lastValue)) { var rangeState = GetRangeState(lastValue, definition); return CreateValue( definition, DashboardReadingState.Stale, lastValue, last, $"{error} Retaining last-known sample from logical tick {last.LogicalTimeTicks}.", rangeState); } return new DashboardGaugeValue( definition, missingState, "--", null, null, error, null); } private static DashboardGaugeValue CreateValue( DashboardGaugeDefinition definition, DashboardReadingState state, double value, DiagnosticSignal signal, string? reason, DashboardReadingState? rangeState = null) { var outOfRangeState = rangeState ?? (state is DashboardReadingState.OutOfRangeLow or DashboardReadingState.OutOfRangeHigh ? state : null); var displayState = state is DashboardReadingState.OutOfRangeLow or DashboardReadingState.OutOfRangeHigh ? DashboardReadingState.Good : state; var barPercent = Math.Clamp((value - definition.Minimum) / (definition.Maximum - definition.Minimum) * 100, 0, 100); return new DashboardGaugeValue( definition, displayState, value.ToString($"F{definition.DecimalPrecision}", CultureInfo.InvariantCulture), value, barPercent, reason, signal, outOfRangeState); } private static DashboardReadingState GetRangeState(double value, DashboardGaugeDefinition definition) => value < definition.Minimum ? DashboardReadingState.OutOfRangeLow : value > definition.Maximum ? DashboardReadingState.OutOfRangeHigh : DashboardReadingState.Good; private static bool TryGetFiniteNumber(DiagnosticSignal signal, out double value) { value = default; return signal.Value.ValueKind == JsonValueKind.Number && signal.Value.TryGetDouble(out value) && double.IsFinite(value); } private void EnsureNotDisposed() { ObjectDisposedException.ThrowIf(_disposed, this); } private async Task StopOwnerAsync(Task owner, CancellationTokenSource cancellation) { try { await owner.ConfigureAwait(false); } catch (Exception exception) { lock (_gate) { if (ReferenceEquals(_ownerCancellation, cancellation)) { _error ??= exception.Message; } } } finally { lock (_gate) { if (ReferenceEquals(_ownerCancellation, cancellation)) { _ownerTask = null; _ownerCancellation = null; _initializationTask = null; _stopTask = null; _state = DashboardFeedState.Stopped; _snapshot = CreateSnapshotLocked(); cancellation.Dispose(); } } Changed?.Invoke(); } } private sealed class SignalKeyComparer : IEqualityComparer<(string Module, string Signal)> { public bool Equals((string Module, string Signal) x, (string Module, string Signal) y) => StringComparer.OrdinalIgnoreCase.Equals(x.Module, y.Module) && StringComparer.Ordinal.Equals(x.Signal, y.Signal); public int GetHashCode((string Module, string Signal) key) => HashCode.Combine( StringComparer.OrdinalIgnoreCase.GetHashCode(key.Module), StringComparer.Ordinal.GetHashCode(key.Signal)); } } public static class LiveDashboardServiceCollectionExtensions { public static IServiceCollection AddAutoForgeLiveDashboard(this IServiceCollection services) { ArgumentNullException.ThrowIfNull(services); services.TryAddSingleton(); services.TryAddSingleton(); return services; } }