using AutoForge.Application.ExecutionTargets; using AutoForge.Application.Features.Vehicles.Profiles; using AutoForge.Core.ExecutionTargets; using AutoForge.Core.Simulation; using AutoForge.Core.Vehicles; using AutoForge.Diagnostics; using Microsoft.Extensions.DependencyInjection; namespace AutoForge.Application.Features.Vehicles.Diagnostics; public enum DiagnosticSessionFailure { ProviderNotRegistered, UnsupportedTargetKind, DefinitionNotFound, InvalidDefinition, SessionConflict, DynamicsCapabilityUnavailable } public sealed class DiagnosticSessionException( DiagnosticSessionFailure failure, string message, Exception? innerException = null) : Exception(message, innerException) { public DiagnosticSessionFailure Failure { get; } = failure; } public sealed class DiagnosticClearVerificationResult { internal DiagnosticClearVerificationResult( DiagnosticOperationResult acknowledgement, DiagnosticOperationResult? readback, bool isVerified, string? verificationError) { Acknowledgement = acknowledgement; Readback = readback; IsVerified = isVerified; VerificationError = verificationError; } public DiagnosticOperationResult Acknowledgement { get; } public DiagnosticOperationResult? Readback { get; } public bool IsVerified { get; } public string? VerificationError { get; } } public interface IDiagnosticSessionService { IReadOnlyList Providers { get; } Task OpenAsync( string profileIdentifier, int profileRevision, string providerIdentifier, ExecutionTargetKind targetKind, CancellationToken cancellationToken = default); Task OpenDynamicsAsync( string profileIdentifier, int profileRevision, string providerIdentifier, ExecutionTargetKind targetKind, DynamicsConfiguration configuration, CancellationToken cancellationToken = default); Task ResetAsync(DiagnosticSession session, CancellationToken cancellationToken = default); } public sealed class DiagnosticSession( VehicleProfile profile, DiagnosticSessionIdentity identity, IDiagnosticProtocolClient protocol, IDiagnosticTransport transport, CancellationTokenSource lifetime, DynamicsConfiguration? dynamicsConfiguration = null, IDynamicsControl? dynamicsControl = null) : IAsyncDisposable { private int _closed; public VehicleProfile Profile { get; } = profile; public DiagnosticSessionIdentity Identity { get; } = identity; public DynamicsConfiguration? DynamicsConfiguration { get; } = dynamicsConfiguration; public IDynamicsControl? DynamicsControl { get; } = dynamicsControl; public IReadOnlyList ExpectedEndpoints => protocol.ExpectedEndpoints; public DiagnosticTraceSnapshot Trace => protocol.Trace; public bool IsClosed => Volatile.Read(ref _closed) != 0; public Task DiscoverAsync(CancellationToken cancellationToken = default) => InvokeAsync(protocol.DiscoverAsync, cancellationToken); public Task> ReadIdentityAsync( DiagnosticEndpoint endpoint, CancellationToken cancellationToken = default) => InvokeAsync(token => protocol.ReadIdentityAsync(endpoint, token), cancellationToken); public Task> ReadTroubleCodesAsync( DiagnosticEndpoint endpoint, CancellationToken cancellationToken = default) => InvokeAsync(token => protocol.ReadTroubleCodesAsync(endpoint, token), cancellationToken); public Task> ClearTroubleCodesAsync( DiagnosticEndpoint endpoint, CancellationToken cancellationToken = default) => InvokeAsync(token => protocol.ClearTroubleCodesAsync(endpoint, token), cancellationToken); public Task ClearTroubleCodesAndVerifyAsync( DiagnosticEndpoint endpoint, CancellationToken cancellationToken = default) => InvokeAsync(async token => { var acknowledgement = await protocol.ClearTroubleCodesAsync(endpoint, token).ConfigureAwait(false); if (!acknowledgement.IsSuccess) { return new DiagnosticClearVerificationResult( acknowledgement, null, false, $"Virtual clear was not acknowledged ({acknowledgement.Outcome}): {acknowledgement.Error}"); } var readback = await protocol.ReadTroubleCodesAsync(endpoint, token).ConfigureAwait(false); if (!readback.IsSuccess) { return new DiagnosticClearVerificationResult( acknowledgement, readback, false, $"Virtual clear was acknowledged, but fresh readback could not verify the state ({readback.Outcome}): {readback.Error}"); } if (readback.Value!.Codes.Count != 0) { return new DiagnosticClearVerificationResult( acknowledgement, readback, false, $"Virtual clear was acknowledged, but fresh readback still contains {readback.Value.Codes.Count} DTC(s)."); } return new DiagnosticClearVerificationResult(acknowledgement, readback, true, null); }, cancellationToken); public Task> ReadSignalsAsync( DiagnosticEndpoint endpoint, CancellationToken cancellationToken = default) => InvokeAsync(token => protocol.ReadSignalsAsync(endpoint, token), cancellationToken); public async ValueTask DisposeAsync() { if (Interlocked.Exchange(ref _closed, 1) == 0) { lifetime.Cancel(); if (DynamicsControl is not null) { await DynamicsControl.DisposeAsync().ConfigureAwait(false); } await transport.DisposeAsync().ConfigureAwait(false); lifetime.Dispose(); } } private async Task InvokeAsync(Func> operation, CancellationToken cancellationToken) { if (IsClosed) { return await operation(new CancellationToken(canceled: true)).ConfigureAwait(false); } if (!cancellationToken.CanBeCanceled) { return await operation(lifetime.Token).ConfigureAwait(false); } using var linked = CancellationTokenSource.CreateLinkedTokenSource(lifetime.Token, cancellationToken); return await operation(linked.Token).ConfigureAwait(false); } } public sealed class DiagnosticSessionService : IDiagnosticSessionService { private readonly IVehicleProfileService _profiles; private readonly IExecutionTargetResolver _targets; private readonly IReadOnlyList _factories; private readonly Func _logicalClockFactory; private long _sessionSequence; private long _runSequence; public DiagnosticSessionService( IVehicleProfileService profiles, IExecutionTargetResolver targets, IEnumerable factories, Func logicalClockFactory) { _profiles = profiles; _targets = targets; _factories = Array.AsReadOnly(factories.ToArray()); _logicalClockFactory = logicalClockFactory ?? throw new ArgumentNullException(nameof(logicalClockFactory)); Providers = Array.AsReadOnly(_factories.Select(factory => factory.Descriptor).ToArray()); } public IReadOnlyList Providers { get; } public Task OpenAsync( string profileIdentifier, int profileRevision, string providerIdentifier, ExecutionTargetKind targetKind, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); var profile = _profiles.Select(profileIdentifier, profileRevision); var target = _targets.Resolve(new ExecutionTargetDescriptor(providerIdentifier, targetKind)); if (target.Kind != ExecutionTargetKind.Simulation) { throw new DiagnosticSessionException( DiagnosticSessionFailure.UnsupportedTargetKind, $"{target.Kind} operational sessions are unavailable; no provider substitution is performed."); } var factory = _factories.FirstOrDefault(item => StringComparer.OrdinalIgnoreCase.Equals(item.Descriptor.Target.ProviderIdentifier, target.ProviderIdentifier)); if (factory is null) { throw new DiagnosticSessionException( DiagnosticSessionFailure.ProviderNotRegistered, $"No diagnostic transport is registered for provider '{target.ProviderIdentifier}'."); } if (factory is IDynamicsDiagnosticTransportFactory) { throw new DiagnosticSessionException( DiagnosticSessionFailure.DynamicsCapabilityUnavailable, $"Provider '{target.ProviderIdentifier}' requires an explicit dynamics configuration; use the dynamics session workflow instead of opening a static session."); } var sequence = Interlocked.Increment(ref _sessionSequence); var identity = new DiagnosticSessionIdentity( $"diagnostic-session-{sequence:D6}", profile.ProfileIdentifier, profile.Revision, profile.Vehicle.VehicleIdentifier, target); var logicalClock = _logicalClockFactory() ?? throw new InvalidOperationException("The logical clock factory returned null."); IDiagnosticTransport transport; try { transport = factory.OpenTransport(profile, identity); } catch (DiagnosticProviderException exception) { throw new DiagnosticSessionException( exception.Failure switch { DiagnosticProviderFailure.ConfigurationNotFound => DiagnosticSessionFailure.DefinitionNotFound, DiagnosticProviderFailure.SessionConflict => DiagnosticSessionFailure.SessionConflict, _ => throw new ArgumentOutOfRangeException(nameof(exception), "The provider returned an undefined failure.") }, exception.Message, exception); } catch (ArgumentException exception) { throw new DiagnosticSessionException( DiagnosticSessionFailure.InvalidDefinition, exception.Message, exception); } var lifetime = new CancellationTokenSource(); var protocol = new SyntheticDiagnosticProtocolClient( profile, identity, transport, logicalClock); return Task.FromResult(new DiagnosticSession(profile, identity, protocol, transport, lifetime)); } public Task OpenDynamicsAsync( string profileIdentifier, int profileRevision, string providerIdentifier, ExecutionTargetKind targetKind, DynamicsConfiguration configuration, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); ArgumentNullException.ThrowIfNull(configuration); var profile = _profiles.Select(profileIdentifier, profileRevision); configuration.ValidateAgainst(profile); var target = _targets.Resolve(new ExecutionTargetDescriptor(providerIdentifier, targetKind)); if (target.Kind != ExecutionTargetKind.Simulation) { throw new DiagnosticSessionException( DiagnosticSessionFailure.UnsupportedTargetKind, $"{target.Kind} operational sessions are unavailable; no provider substitution is performed."); } var factory = _factories.FirstOrDefault(item => StringComparer.OrdinalIgnoreCase.Equals(item.Descriptor.Target.ProviderIdentifier, target.ProviderIdentifier)); if (factory is not IDynamicsDiagnosticTransportFactory dynamicsFactory) { throw new DiagnosticSessionException( DiagnosticSessionFailure.DynamicsCapabilityUnavailable, $"Provider '{target.ProviderIdentifier}' does not offer dynamics control; no static or other-target fallback is performed."); } var sessionSequence = Interlocked.Increment(ref _sessionSequence); var runSequence = Interlocked.Increment(ref _runSequence); var identity = new DiagnosticSessionIdentity( $"diagnostic-session-{sessionSequence:D6}", profile.ProfileIdentifier, profile.Revision, profile.Vehicle.VehicleIdentifier, target, configuration.ConfigurationIdentifier, $"dynamics-run-{runSequence:D6}"); var binding = dynamicsFactory.OpenDynamicsTransport(profile, identity, configuration); var transport = binding.Transport ?? throw new InvalidOperationException("Dynamics provider returned a null transport."); var control = binding.Control ?? throw new InvalidOperationException("Dynamics provider returned a null control capability."); var protocol = new SyntheticDiagnosticProtocolClient( profile, identity, transport, _logicalClockFactory() ?? throw new InvalidOperationException("The logical clock factory returned null."), protocolVersion: 2, dynamicsConfiguration: configuration); return Task.FromResult(new DiagnosticSession( profile, identity, protocol, transport, new CancellationTokenSource(), configuration, control)); } public async Task ResetAsync( DiagnosticSession session, CancellationToken cancellationToken = default) { ArgumentNullException.ThrowIfNull(session); var identity = session.Identity; if (session.DynamicsConfiguration is { } configuration) { await session.DisposeAsync().ConfigureAwait(false); return await OpenDynamicsAsync( identity.ProfileIdentifier, identity.ProfileRevision, identity.Target.ProviderIdentifier, identity.Target.Kind, configuration, cancellationToken).ConfigureAwait(false); } await session.DisposeAsync().ConfigureAwait(false); return await OpenAsync( identity.ProfileIdentifier, identity.ProfileRevision, identity.Target.ProviderIdentifier, identity.Target.Kind, cancellationToken).ConfigureAwait(false); } } public static class DiagnosticSessionServiceCollectionExtensions { public static IServiceCollection AddAutoForgeDiagnostics( this IServiceCollection services, IEnumerable factories, Func? logicalClockFactory = null) { ArgumentNullException.ThrowIfNull(services); ArgumentNullException.ThrowIfNull(factories); if (services.Any(service => service.ServiceType == typeof(IDiagnosticSessionService))) { throw new InvalidOperationException("Diagnostic session services are already registered."); } var providerFactories = factories.ToArray(); if (providerFactories.Any(factory => factory is null)) { throw new ArgumentException("Diagnostic provider factories cannot contain null values.", nameof(factories)); } services.AddAutoForgeTargetSelection(providerFactories.Select(factory => factory.Descriptor.Target)); foreach (var factory in providerFactories) { services.AddSingleton(typeof(IDiagnosticTransportFactory), factory); services.AddSingleton(factory.GetType(), factory); } services.AddSingleton(provider => new DiagnosticSessionService( provider.GetRequiredService(), provider.GetRequiredService(), provider.GetServices(), logicalClockFactory ?? (() => new DiagnosticLogicalClock()))); return services; } }