423 lines
16 KiB
C#
423 lines
16 KiB
C#
using AutoForge.Application.Features.Vehicles.Diagnostics;
|
|
using AutoForge.Application.Features.Vehicles.Profiles;
|
|
using AutoForge.Application.ExecutionTargets;
|
|
using AutoForge.Components;
|
|
using AutoForge.Core.ExecutionTargets;
|
|
using AutoForge.Core.Vehicles;
|
|
using AutoForge.Diagnostics;
|
|
|
|
namespace AutoForge.UI.Features.Vehicles.Diagnostics;
|
|
|
|
public sealed class DiagnosticPageViewModel(
|
|
IVehicleProfileService profiles,
|
|
IDiagnosticSessionService sessions) : IDisposable
|
|
{
|
|
private CancellationTokenSource? _pending;
|
|
|
|
public IReadOnlyList<VehicleProfileReference> AvailableProfiles { get; private set; } = profiles.List();
|
|
public IReadOnlyList<DiagnosticProviderDescriptor> Providers => sessions.Providers;
|
|
public string? SelectedProfileIdentifier { get; set; }
|
|
public int? SelectedProfileRevision { get; set; }
|
|
public string? SelectedProviderIdentifier { get; set; }
|
|
public ExecutionTargetKind? SelectedTargetKind { get; set; }
|
|
public DiagnosticSession? ActiveSession { get; private set; }
|
|
public IReadOnlyList<DiscoveryEntry> DiscoveredModules { get; private set; } = [];
|
|
public string? DiscoverySummary { get; private set; }
|
|
public IReadOnlyDictionary<string, TroubleCodeReadResult> TroubleCodes { get; private set; } =
|
|
new Dictionary<string, TroubleCodeReadResult>(StringComparer.OrdinalIgnoreCase);
|
|
public IReadOnlyDictionary<string, SignalSnapshot> Signals { get; private set; } =
|
|
new Dictionary<string, SignalSnapshot>(StringComparer.OrdinalIgnoreCase);
|
|
public IReadOnlyList<string> OperationMessages { get; private set; } = [];
|
|
public bool IsBusy => _pending is not null;
|
|
public StatusNoticeTone StatusTone { get; private set; } = StatusNoticeTone.Information;
|
|
|
|
public string StatusMessage { get; private set; } =
|
|
sessions.Providers.Count == 0
|
|
? "No diagnostic providers are available. No session is open."
|
|
: "Select an exact saved profile revision and provider, then explicitly open a simulation session. Metadata selection alone does not connect.";
|
|
|
|
public void LoadSyntheticExample()
|
|
{
|
|
try
|
|
{
|
|
var imported = profiles.Import(ReadSyntheticProfile());
|
|
AvailableProfiles = profiles.List();
|
|
StatusTone = StatusNoticeTone.Success;
|
|
StatusMessage =
|
|
$"Loaded synthetic profile '{imported.ProfileIdentifier}' revision {imported.Revision}. Select it explicitly; no session was opened.";
|
|
}
|
|
catch (VehicleProfileInterchangeException exception)
|
|
{
|
|
SetFailure(exception.Message);
|
|
}
|
|
catch (VehicleProfileCatalogException exception)
|
|
{
|
|
SetFailure(exception.Message);
|
|
}
|
|
}
|
|
|
|
public async Task OpenSessionAsync()
|
|
{
|
|
if (ActiveSession is not null)
|
|
{
|
|
SetFailure("Close the current session before opening another explicit session.");
|
|
return;
|
|
}
|
|
|
|
if (SelectedProfileIdentifier is null || SelectedProfileRevision is null ||
|
|
SelectedProviderIdentifier is null || SelectedTargetKind is null)
|
|
{
|
|
SetFailure("Select an exact saved profile revision, provider identifier and target kind before opening a session.");
|
|
return;
|
|
}
|
|
|
|
var cancellation = BeginPending();
|
|
try
|
|
{
|
|
var session = await sessions.OpenAsync(
|
|
SelectedProfileIdentifier,
|
|
SelectedProfileRevision.Value,
|
|
SelectedProviderIdentifier,
|
|
SelectedTargetKind.Value,
|
|
cancellation.Token);
|
|
ActiveSession = session;
|
|
ResetSessionResults();
|
|
SetInformation(
|
|
$"Simulation session {session.Identity.SessionIdentifier} opened for profile '{session.Identity.ProfileIdentifier}' revision {session.Identity.ProfileRevision}. No physical connection was attempted.");
|
|
}
|
|
catch (DiagnosticSessionException exception)
|
|
{
|
|
SetFailure(exception.Message);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
SetFailure("Opening the simulation session was cancelled.");
|
|
}
|
|
catch (VehicleProfileCatalogException exception)
|
|
{
|
|
SetFailure(exception.Message);
|
|
}
|
|
catch (TargetSelectionException exception)
|
|
{
|
|
SetFailure(exception.Message);
|
|
}
|
|
catch (ArgumentException exception)
|
|
{
|
|
SetFailure(exception.Message);
|
|
}
|
|
finally
|
|
{
|
|
EndPending(cancellation);
|
|
}
|
|
}
|
|
|
|
public async Task DiscoverAsync()
|
|
{
|
|
var session = ActiveSession;
|
|
if (session is null)
|
|
{
|
|
SetFailure("Open an explicit simulation session before discovery.");
|
|
return;
|
|
}
|
|
|
|
var cancellation = BeginPending();
|
|
try
|
|
{
|
|
var result = await session.DiscoverAsync(cancellation.Token);
|
|
if (!IsCurrent(session))
|
|
{
|
|
return;
|
|
}
|
|
|
|
DiscoveredModules = result.Endpoints;
|
|
DiscoverySummary =
|
|
$"Expected endpoints: {result.ExpectedEndpointCount}; validated positive probes: {result.ValidatedProbeCount}; profile-verified identities: {result.IdentifiedModuleCount}.";
|
|
SetInformation($"Discovery completed. {DiscoverySummary}");
|
|
OperationMessages = result.Endpoints
|
|
.SelectMany(endpoint => new[]
|
|
{
|
|
endpoint.ProbeError is null
|
|
? null
|
|
: $"{endpoint.Endpoint.ModuleIdentifier} probe: {endpoint.ProbeOutcome} — {endpoint.ProbeError}",
|
|
endpoint.IdentityError is null
|
|
? null
|
|
: $"{endpoint.Endpoint.ModuleIdentifier} identity ({endpoint.IdentityStatus}{(endpoint.IdentityOutcome is { } outcome ? $", {outcome}" : string.Empty)}): {endpoint.IdentityError}"
|
|
})
|
|
.Where(message => message is not null)
|
|
.Select(message => message!)
|
|
.ToArray();
|
|
if (result.Endpoints.Any(endpoint =>
|
|
endpoint.ProbeOutcome == DiagnosticOutcome.Cancelled ||
|
|
endpoint.IdentityOutcome == DiagnosticOutcome.Cancelled))
|
|
{
|
|
SetFailure($"Module discovery was cancelled; completed probe evidence is retained without treating any unavailable identity as verified. {DiscoverySummary}");
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
EndPending(cancellation);
|
|
}
|
|
}
|
|
|
|
public async Task ReadModuleAsync(string moduleIdentifier)
|
|
{
|
|
var session = ActiveSession;
|
|
var discovered = DiscoveredModules.FirstOrDefault(entry =>
|
|
entry.Identity is not null &&
|
|
StringComparer.OrdinalIgnoreCase.Equals(entry.Endpoint.ModuleIdentifier, moduleIdentifier));
|
|
if (session is null || discovered?.Identity is null)
|
|
{
|
|
SetFailure("Read requests require a profile-verified identity from the current session's discovery results.");
|
|
return;
|
|
}
|
|
|
|
var cancellation = BeginPending();
|
|
try
|
|
{
|
|
var dtcResult = discovered.ImplementedServices.Contains(DiagnosticServices.ReadTroubleCodes, StringComparer.Ordinal)
|
|
? await session.ReadTroubleCodesAsync(discovered.Endpoint, cancellation.Token)
|
|
: DiagnosticOperationResult<TroubleCodeReadResult>.Failure(
|
|
DiagnosticOutcome.NegativeResponse,
|
|
"UNSUPPORTED_SERVICE",
|
|
"This virtual endpoint does not implement DTC retrieval.");
|
|
var signalResult = discovered.ImplementedServices.Contains(DiagnosticServices.ReadSignals, StringComparer.Ordinal)
|
|
? await session.ReadSignalsAsync(discovered.Endpoint, cancellation.Token)
|
|
: DiagnosticOperationResult<SignalSnapshot>.Failure(
|
|
DiagnosticOutcome.NegativeResponse,
|
|
"UNSUPPORTED_SERVICE",
|
|
"This virtual endpoint does not implement static signal retrieval.");
|
|
|
|
if (!IsCurrent(session))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var dtcs = TroubleCodes.ToDictionary(pair => pair.Key, pair => pair.Value, StringComparer.OrdinalIgnoreCase);
|
|
var signals = Signals.ToDictionary(pair => pair.Key, pair => pair.Value, StringComparer.OrdinalIgnoreCase);
|
|
if (dtcResult.IsSuccess)
|
|
{
|
|
dtcs[moduleIdentifier] = dtcResult.Value!;
|
|
}
|
|
if (signalResult.IsSuccess)
|
|
{
|
|
signals[moduleIdentifier] = signalResult.Value!;
|
|
}
|
|
|
|
TroubleCodes = dtcs;
|
|
Signals = signals;
|
|
OperationMessages = new[]
|
|
{
|
|
FormatResult("DTC read", dtcResult.Outcome, dtcResult.Error),
|
|
FormatResult("Static signal read", signalResult.Outcome, signalResult.Error)
|
|
}
|
|
.Where(message => message is not null)
|
|
.Select(message => message!)
|
|
.ToArray();
|
|
if (dtcResult.Outcome == DiagnosticOutcome.Cancelled || signalResult.Outcome == DiagnosticOutcome.Cancelled)
|
|
{
|
|
SetFailure($"Diagnostic reads for '{moduleIdentifier}' were cancelled; no cancelled response is presented as data.");
|
|
}
|
|
else if (!dtcResult.IsSuccess || !signalResult.IsSuccess)
|
|
{
|
|
SetFailure($"One or more diagnostic reads for '{moduleIdentifier}' failed. See the explicit operation outcomes.");
|
|
}
|
|
else
|
|
{
|
|
SetInformation($"Diagnostic reads completed for '{moduleIdentifier}'. Empty DTC results are valid only when explicitly returned by the module.");
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
EndPending(cancellation);
|
|
}
|
|
}
|
|
|
|
public async Task ClearTroubleCodesAsync(string moduleIdentifier)
|
|
{
|
|
var session = ActiveSession;
|
|
var discovered = DiscoveredModules.FirstOrDefault(entry =>
|
|
entry.Identity is not null &&
|
|
StringComparer.OrdinalIgnoreCase.Equals(entry.Endpoint.ModuleIdentifier, moduleIdentifier));
|
|
if (session is null || discovered?.Identity is null)
|
|
{
|
|
SetFailure("Virtual DTC clear requires a profile-verified identity from the current simulation session.");
|
|
return;
|
|
}
|
|
|
|
if (!discovered.ImplementedServices.Contains(DiagnosticServices.ClearTroubleCodes, StringComparer.Ordinal))
|
|
{
|
|
SetFailure("This virtual module does not support DTC clearing.");
|
|
return;
|
|
}
|
|
|
|
var cancellation = BeginPending();
|
|
try
|
|
{
|
|
var clear = await session.ClearTroubleCodesAndVerifyAsync(discovered.Endpoint, cancellation.Token);
|
|
if (!IsCurrent(session))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (clear.Readback?.IsSuccess == true)
|
|
{
|
|
var dtcs = TroubleCodes.ToDictionary(pair => pair.Key, pair => pair.Value, StringComparer.OrdinalIgnoreCase);
|
|
dtcs[moduleIdentifier] = clear.Readback.Value!;
|
|
TroubleCodes = dtcs;
|
|
}
|
|
|
|
if (!clear.IsVerified)
|
|
{
|
|
var acknowledgementMessage = clear.Acknowledgement.IsSuccess
|
|
? $"Virtual clear acknowledgement received ({clear.Acknowledgement.Value!.ClearedCount} item(s))."
|
|
: $"Virtual clear acknowledgement: {clear.Acknowledgement.Outcome}.";
|
|
OperationMessages =
|
|
[
|
|
acknowledgementMessage,
|
|
$"Verification failed or is uncertain: {clear.VerificationError} No physical write was performed."
|
|
];
|
|
SetFailure(OperationMessages[1]);
|
|
return;
|
|
}
|
|
|
|
OperationMessages =
|
|
[
|
|
$"Virtual clear acknowledgement received ({clear.Acknowledgement.Value!.ClearedCount} item(s)).",
|
|
"Fresh readback verified that no DTCs remain."
|
|
];
|
|
SetInformation($"Fresh readback verified an empty virtual DTC state for '{moduleIdentifier}'. No physical write was performed.");
|
|
}
|
|
finally
|
|
{
|
|
EndPending(cancellation);
|
|
}
|
|
}
|
|
|
|
public async Task ResetSessionAsync()
|
|
{
|
|
var session = ActiveSession;
|
|
if (session is null)
|
|
{
|
|
SetFailure("There is no session to reset.");
|
|
return;
|
|
}
|
|
|
|
var cancellation = BeginPending();
|
|
try
|
|
{
|
|
var reset = await sessions.ResetAsync(session, cancellation.Token);
|
|
ActiveSession = reset;
|
|
ResetSessionResults();
|
|
SetInformation($"Session state reset to its configured synthetic initial values. New session: {reset.Identity.SessionIdentifier}.");
|
|
}
|
|
catch (DiagnosticSessionException exception)
|
|
{
|
|
ActiveSession = null;
|
|
SetFailure(exception.Message);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
ActiveSession = null;
|
|
SetFailure("Session reset was cancelled after closing the previous session.");
|
|
}
|
|
finally
|
|
{
|
|
EndPending(cancellation);
|
|
}
|
|
}
|
|
|
|
public async Task CloseSessionAsync()
|
|
{
|
|
var session = ActiveSession;
|
|
if (session is null)
|
|
{
|
|
SetInformation("No diagnostic session is open.");
|
|
return;
|
|
}
|
|
|
|
_pending?.Cancel();
|
|
ActiveSession = null;
|
|
ResetSessionResults();
|
|
await session.DisposeAsync();
|
|
SetInformation($"Session {session.Identity.SessionIdentifier} closed; its isolated virtual state and trace are released.");
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_pending?.Cancel();
|
|
if (ActiveSession is { } session)
|
|
{
|
|
ActiveSession = null;
|
|
ResetSessionResults();
|
|
session.DisposeAsync().AsTask().GetAwaiter().GetResult();
|
|
}
|
|
}
|
|
|
|
public void CancelPending() => _pending?.Cancel();
|
|
|
|
private CancellationTokenSource BeginPending()
|
|
{
|
|
if (_pending is not null)
|
|
{
|
|
throw new InvalidOperationException("A diagnostic operation is already pending.");
|
|
}
|
|
|
|
_pending = new CancellationTokenSource();
|
|
StatusTone = StatusNoticeTone.Information;
|
|
StatusMessage = "Diagnostic operation is pending. Cancellation remains available.";
|
|
return _pending;
|
|
}
|
|
|
|
private void EndPending(CancellationTokenSource cancellation)
|
|
{
|
|
if (ReferenceEquals(_pending, cancellation))
|
|
{
|
|
_pending = null;
|
|
}
|
|
|
|
cancellation.Dispose();
|
|
}
|
|
|
|
private bool IsCurrent(DiagnosticSession session) =>
|
|
ReferenceEquals(ActiveSession, session) && !session.IsClosed;
|
|
|
|
private void ResetSessionResults()
|
|
{
|
|
DiscoveredModules = [];
|
|
DiscoverySummary = null;
|
|
TroubleCodes = new Dictionary<string, TroubleCodeReadResult>(StringComparer.OrdinalIgnoreCase);
|
|
Signals = new Dictionary<string, SignalSnapshot>(StringComparer.OrdinalIgnoreCase);
|
|
OperationMessages = [];
|
|
}
|
|
|
|
private void SetInformation(string message)
|
|
{
|
|
StatusTone = StatusNoticeTone.Information;
|
|
StatusMessage = message;
|
|
}
|
|
|
|
private void SetFailure(string message)
|
|
{
|
|
StatusTone = StatusNoticeTone.Error;
|
|
StatusMessage = message;
|
|
}
|
|
|
|
private void SetOperationFailure(string action, DiagnosticOutcome outcome, string? error)
|
|
{
|
|
OperationMessages = [$"{action}: {outcome} — {error ?? "No successful response was received."}"];
|
|
SetFailure(OperationMessages[0]);
|
|
}
|
|
|
|
private static string? FormatResult(string action, DiagnosticOutcome outcome, string? error) =>
|
|
outcome == DiagnosticOutcome.PositiveResponse ? null : $"{action}: {outcome} — {error}";
|
|
|
|
private static string ReadSyntheticProfile()
|
|
{
|
|
using var stream = typeof(DiagnosticPageViewModel).Assembly.GetManifestResourceStream(
|
|
"AutoForge.UI.SyntheticExamples.synthetic-truck-baseline.json")
|
|
?? throw new InvalidOperationException("The source-controlled synthetic profile example is unavailable.");
|
|
using var reader = new StreamReader(stream);
|
|
return reader.ReadToEnd();
|
|
}
|
|
}
|