MqttEventHandler.cs

using System.Collections.Concurrent;
using System.Diagnostics.Metrics;
using Api.Controllers.Models;
using Api.Database.Models;
using Api.Mqtt.MessageModels;
using Api.Services;
using Api.Services.ActionServices;
using Api.Services.Events;
using Api.Services.Models;
using Api.Utilities;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;

namespace Api.EventHandlers
{
    /// <summary>
    ///     A background service which listens to events and performs callback functions.
    /// </summary>
    public class MqttEventHandler : EventHandlerBase
    {
        private readonly ILogger<MqttEventHandler> _logger;

        private readonly IServiceScopeFactory _scopeFactory;

        private readonly IMemoryCache _cache;
        private EventAggregatorSingletonService _eventAggregatorSingletonService;

        private readonly ConcurrentDictionary<string, RobotMetricData> _batteryMetrics = new();
        private readonly ConcurrentDictionary<string, RobotMetricData> _pressureMetrics = new();

        private record RobotMetricData(
            float Value,
            string RobotId,
            string InstallationCode,
            DateTimeOffset Timestamp
        );

        public MqttEventHandler(
            ILogger<MqttEventHandler> logger,
            IServiceScopeFactory scopeFactory,
            IMemoryCache cache,
            Meter meter,
            EventAggregatorSingletonService eventAggregatorSingletonService
        )
        {
            _logger = logger;
            // Reason for using factory: https://www.thecodebuzz.com/using-dbcontext-instance-in-ihostedservice/
            _scopeFactory = scopeFactory;
            _cache = cache;
            _eventAggregatorSingletonService = eventAggregatorSingletonService;

            meter.CreateObservableGauge(
                "robot.battery.level",
                () =>
                {
                    return _batteryMetrics.Select(kvp => new Measurement<float>(
                        kvp.Value.Value,
                        new KeyValuePair<string, object?>("robot.id", kvp.Value.RobotId),
                        new KeyValuePair<string, object?>(
                            "installation.code",
                            kvp.Value.InstallationCode
                        )
                    ));
                },
                unit: "%",
                description: "Current battery level of the robot"
            );

            meter.CreateObservableGauge(
                "robot.pressure.level",
                () =>
                {
                    return _pressureMetrics.Select(kvp => new Measurement<float>(
                        kvp.Value.Value,
                        new KeyValuePair<string, object?>("robot.id", kvp.Value.RobotId),
                        new KeyValuePair<string, object?>(
                            "installation.code",
                            kvp.Value.InstallationCode
                        )
                    ));
                },
                unit: "bar",
                description: "Current pressure level of the robot"
            );

            Subscribe();
        }

        private IInspectionService InspectionService =>
            _scopeFactory.CreateScope().ServiceProvider.GetRequiredService<IInspectionService>();
        private IInstallationService InstallationService =>
            _scopeFactory.CreateScope().ServiceProvider.GetRequiredService<IInstallationService>();
        private ILastMissionRunService LastMissionRunService =>
            _scopeFactory
                .CreateScope()
                .ServiceProvider.GetRequiredService<ILastMissionRunService>();
        private IMissionRunService MissionRunService =>
            _scopeFactory.CreateScope().ServiceProvider.GetRequiredService<IMissionRunService>();
        private IMissionSchedulingService MissionScheduling =>
            _scopeFactory
                .CreateScope()
                .ServiceProvider.GetRequiredService<IMissionSchedulingService>();
        private IMissionTaskService MissionTaskService =>
            _scopeFactory.CreateScope().ServiceProvider.GetRequiredService<IMissionTaskService>();
        private IRobotService RobotService =>
            _scopeFactory.CreateScope().ServiceProvider.GetRequiredService<IRobotService>();
        private ISignalRService SignalRService =>
            _scopeFactory.CreateScope().ServiceProvider.GetRequiredService<ISignalRService>();
        private ITaskDurationService TaskDurationService =>
            _scopeFactory.CreateScope().ServiceProvider.GetRequiredService<ITaskDurationService>();

        public override void Subscribe()
        {
            _eventAggregatorSingletonService.Subscribe<IsarStatusMessage>(OnIsarStatus);
            _eventAggregatorSingletonService.Subscribe<IsarRobotInfoMessage>(OnIsarRobotInfo);
            _eventAggregatorSingletonService.Subscribe<IsarMissionMessage>(OnIsarMissionUpdate);
            _eventAggregatorSingletonService.Subscribe<IsarTaskMessage>(OnIsarTaskUpdate);
            _eventAggregatorSingletonService.Subscribe<IsarBatteryMessage>(OnIsarBatteryUpdate);
            _eventAggregatorSingletonService.Subscribe<IsarPressureMessage>(OnIsarPressureUpdate);
            _eventAggregatorSingletonService.Subscribe<IsarPoseMessage>(OnIsarPoseUpdate);
            _eventAggregatorSingletonService.Subscribe<IsarCloudHealthMessage>(
                OnIsarCloudHealthUpdate
            );
            _eventAggregatorSingletonService.Subscribe<IsarInterventionNeededMessage>(
                OnIsarInterventionNeededUpdate
            );
            _eventAggregatorSingletonService.Subscribe<IsarStartupMessage>(OnIsarStartup);
            _eventAggregatorSingletonService.Subscribe<IsarMissionAbortedMessage>(
                OnIsarMissionAborted
            );
            _eventAggregatorSingletonService.Subscribe<SaraInspectionResultMessage>(
                OnSaraInspectionResultUpdate
            );
            _eventAggregatorSingletonService.Subscribe<SaraAnalysisResultMessage>(
                OnSaraAnalysisResultMessage
            );
        }

        public override void Unsubscribe() { }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            await stoppingToken;
        }

        private async void OnIsarStatus(IsarStatusMessage isarStatus)
        {
            var robot = await RobotService.ReadByIsarId(isarStatus.IsarId, readOnly: true);

            if (robot == null)
            {
                _logger.LogInformation(
                    "Received message from unknown ISAR instance {Id} with robot name {Name}",
                    isarStatus.IsarId,
                    isarStatus.RobotName
                );
                return;
            }

            if (robot.Status == isarStatus.Status)
            {
                return;
            }

            _logger.LogInformation(
                "OnIsarStatus: Robot {robotName} has status {robotStatus} and current inspection area id {areaId}",
                robot.Name,
                robot.Status,
                robot.CurrentInspectionAreaId
            );

            await RobotService.UpdateRobotStatus(robot.Id, isarStatus.Status);
            robot.Status = isarStatus.Status;

            _logger.LogInformation(
                "Updated status for robot {Name} to {Status}",
                robot.Name,
                robot.Status
            );

            _logger.LogInformation(
                "OnIsarStatus: Robot {robotName} has status {robotStatus} and current inspection area id {areaId}",
                robot.Name,
                robot.Status,
                robot.CurrentInspectionAreaId
            );

            if (Robot.IsStatusThatCanReceiveMissions(isarStatus.Status))
            {
                _eventAggregatorSingletonService.Publish(new RobotReadyForMissionsEventArgs(robot));
            }
        }

        private async void CreateRobot(
            IsarRobotInfoMessage isarRobotInfo,
            Installation installation
        )
        {
            _logger.LogInformation(
                "Received message from new ISAR instance '{Id}' with robot name '{Name}'. Adding new robot to database",
                isarRobotInfo.IsarId,
                isarRobotInfo.RobotName
            );

            var robotQuery = new CreateRobotQuery
            {
                IsarId = isarRobotInfo.IsarId,
                Name = isarRobotInfo.RobotName,
                RobotType = isarRobotInfo.RobotType,
                SerialNumber = isarRobotInfo.SerialNumber,
                CurrentInstallationCode = installation.InstallationCode,
                Documentation = isarRobotInfo.DocumentationQueries,
                Host = isarRobotInfo.Host,
                Port = isarRobotInfo.Port,
                RobotCapabilities = isarRobotInfo.Capabilities,
                Status = RobotStatus.Available,
            };

            try
            {
                var newRobot = await RobotService.CreateFromQuery(robotQuery);
                _logger.LogInformation(
                    "Added robot '{RobotName}' with ISAR id '{IsarId}' to database",
                    newRobot.Name,
                    newRobot.IsarId
                );
            }
            catch (DbUpdateException)
            {
                _logger.LogError(
                    "Failed to add robot {robotQueryName} with to the database",
                    robotQuery.Name
                );
            }
        }

        private async void OnIsarRobotInfo(IsarRobotInfoMessage isarRobotInfo)
        {
            var installation = await InstallationService.ReadByInstallationCode(
                isarRobotInfo.CurrentInstallation,
                readOnly: true
            );

            if (installation is null)
            {
                _logger.LogError(
                    new InstallationNotFoundException(
                        $"No installation with code {isarRobotInfo.CurrentInstallation} found"
                    ),
                    "Could not create new robot due to missing installation"
                );
                return;
            }

            try
            {
                var robot = await RobotService.ReadByIsarId(isarRobotInfo.IsarId, readOnly: true);

                if (robot == null)
                {
                    CreateRobot(isarRobotInfo, installation);
                    return;
                }
                List<string> updatedFields = [];

                if (isarRobotInfo.Host is not null)
                    UpdateHostIfChanged(isarRobotInfo.Host, ref robot, ref updatedFields);

                UpdatePortIfChanged(isarRobotInfo.Port, ref robot, ref updatedFields);

                if (isarRobotInfo.CurrentInstallation is not null)
                    UpdateCurrentInstallationIfChanged(installation, ref robot, ref updatedFields);
                if (isarRobotInfo.Capabilities is not null)
                    UpdateRobotCapabilitiesIfChanged(
                        isarRobotInfo.Capabilities,
                        ref robot,
                        ref updatedFields
                    );
                if (updatedFields.Count < 1)
                    return;

                await RobotService.Update(robot);
                _logger.LogInformation(
                    "Updated robot '{Id}' ('{RobotName}') in database: {Updates}",
                    robot.Id,
                    robot.Name,
                    updatedFields
                );
            }
            catch (DbUpdateException e)
            {
                _logger.LogError(e, "Could not add robot to db");
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Could not update robot in db");
            }
        }

        private static void UpdateHostIfChanged(
            string host,
            ref Robot robot,
            ref List<string> updatedFields
        )
        {
            if (host.Equals(robot.Host, StringComparison.Ordinal))
                return;

            updatedFields.Add($"\nHost ({robot.Host} -> {host})\n");
            robot.Host = host;
        }

        private static void UpdatePortIfChanged(
            int port,
            ref Robot robot,
            ref List<string> updatedFields
        )
        {
            if (port.Equals(robot.Port))
                return;

            updatedFields.Add($"\nPort ({robot.Port} -> {port})\n");
            robot.Port = port;
        }

        private static void UpdateCurrentInstallationIfChanged(
            Installation newCurrentInstallation,
            ref Robot robot,
            ref List<string> updatedFields
        )
        {
            if (
                newCurrentInstallation.InstallationCode.Equals(
                    robot.CurrentInstallation?.InstallationCode,
                    StringComparison.Ordinal
                )
            )
                return;

            updatedFields.Add(
                $"\nCurrentInstallation ({robot.CurrentInstallation} -> {newCurrentInstallation})\n"
            );
            robot.CurrentInstallation = newCurrentInstallation;
        }

        public static void UpdateRobotCapabilitiesIfChanged(
            IList<RobotCapabilitiesEnum> newRobotCapabilities,
            ref Robot robot,
            ref List<string> updatedFields
        )
        {
            if (
                robot.RobotCapabilities != null
                && Enumerable.SequenceEqual(newRobotCapabilities, robot.RobotCapabilities)
            )
                return;

            updatedFields.Add(
                $"\nRobotCapabilities ({robot.RobotCapabilities} -> {newRobotCapabilities})\n"
            );
            robot.RobotCapabilities = newRobotCapabilities;
        }

        private async void OnIsarMissionAborted(IsarMissionAbortedMessage isarAbortedMission)
        {
            var robot = await RobotService.ReadByIsarId(isarAbortedMission.IsarId, readOnly: true);
            if (robot is null)
            {
                _logger.LogError(
                    "Could not find robot '{RobotName}' with ISAR id '{IsarId}'",
                    isarAbortedMission.RobotName,
                    isarAbortedMission.IsarId
                );
                return;
            }

            try
            {
                var missionRun = await MissionScheduling.MoveMissionRunBackToQueue(
                    robot.Id,
                    isarAbortedMission.MissionId,
                    isarAbortedMission.Reason
                );

                _logger.LogInformation(
                    "Mission '{Id}' (ISARMissionID='{IsarMissionId}') was aborted by ISAR for robot '{RobotName}' with ISAR id '{IsarId}': {Reason}",
                    missionRun.Id,
                    isarAbortedMission.MissionId,
                    isarAbortedMission.RobotName,
                    isarAbortedMission.IsarId,
                    isarAbortedMission.Reason
                );
            }
            catch (NoUnfinishedTasksInMissionException) { }
            catch (RobotNotFoundException)
            {
                _logger.LogWarning(
                    "Mission with ISAR ID '{IsarMissionId}' was aborted by ISAR with ISAR id '{IsarId}' but that robot could not be found: {Reason}",
                    isarAbortedMission.MissionId,
                    isarAbortedMission.IsarId,
                    isarAbortedMission.Reason
                );
            }
            catch (MissionRunNotFoundException)
            {
                _logger.LogWarning(
                    "Mission with ISAR ID '{IsarMissionId}' was aborted by ISAR with ISAR id '{IsarId}' but could not be found: {Reason}",
                    isarAbortedMission.MissionId,
                    isarAbortedMission.IsarId,
                    isarAbortedMission.Reason
                );
            }
            catch (Exception e)
            {
                _logger.LogError(
                    "Mission with ISAR ID '{IsarMissionId}' was aborted by ISAR with ISAR id '{IsarId}' but an unhandled exception occured: {Reason}",
                    isarAbortedMission.MissionId,
                    isarAbortedMission.IsarId,
                    e.StackTrace
                );
            }
        }

        private async void OnIsarMissionUpdate(IsarMissionMessage isarMission)
        {
            MissionStatus status;
            try
            {
                status = MissionRun.GetMissionStatusFromString(isarMission.Status);
            }
            catch (ArgumentException e)
            {
                _logger.LogError(
                    e,
                    "Failed to parse mission status from MQTT message. Mission with ISARMissionId '{IsarMissionId}' was not updated",
                    isarMission.MissionId
                );
                return;
            }

            var flotillaMissionRun = await MissionRunService.ReadById(
                isarMission.MissionId,
                readOnly: true,
                includeDeprecated: true
            );
            if (flotillaMissionRun is null)
            {
                _logger.LogInformation(
                    $"Mission with isar mission Id {isarMission.MissionId} was not found. This is expected if the mission is a return home mission."
                );

                var isarRobot = await RobotService.ReadByIsarId(isarMission.IsarId, readOnly: true);

                // Check if return home mission fails
                if (status == MissionStatus.Failed && isarRobot != null)
                {
                    string errorDescription =
                        isarMission.ErrorDescription ?? "The initiated mission failed";
                    string reportMessage = $"Failed mission for robot {isarRobot.Name}";

                    SignalRService.ReportGeneralFailToSignalR(
                        isarRobot,
                        reportMessage,
                        errorDescription
                    );
                }

                return;
            }

            if (
                flotillaMissionRun.Status == MissionStatus.Aborted
                && status == MissionStatus.Cancelled
            )
                status = MissionStatus.Aborted;
            // Handle that mission_status only reflects last part of mission if recharging occurred during mission
            if (
                status == MissionStatus.Successful
                && flotillaMissionRun.Tasks.Any(task =>
                    task.Status == Database.Models.TaskStatus.Failed
                )
            )
                status = MissionStatus.PartiallySuccessful;
            else if (
                status == MissionStatus.Failed
                && flotillaMissionRun.Tasks.Any(task =>
                    task.Status == Database.Models.TaskStatus.Successful
                )
            )
                status = MissionStatus.PartiallySuccessful;

            MissionRun updatedFlotillaMissionRun;
            try
            {
                if (flotillaMissionRun.IsDeprecated)
                {
                    updatedFlotillaMissionRun = await MissionRunService.UpdateMissionRunProperty(
                        isarMission.MissionId,
                        "IsDeprecated",
                        false,
                        includeDeprecated: true
                    );
                    _logger.LogInformation(
                        $"Mission with isar mission Id {isarMission.MissionId} was deprecated on mission updated, setting to not deprecated."
                    );
                }

                if (isarMission.ErrorDescription?.Length >= 450)
                {
                    _logger.LogInformation(
                        $"Mission with isar mission Id {isarMission.MissionId} got error description: {isarMission.ErrorDescription} from ISAR. This text is more than 450 char and will be shorted down."
                    );
                    isarMission.ErrorDescription =
                        isarMission.ErrorDescription.Substring(0, 446) + "...";
                }

                updatedFlotillaMissionRun = await MissionRunService.UpdateMissionRunStatus(
                    isarMission.MissionId,
                    status,
                    isarMission.ErrorDescription
                );
            }
            catch (MissionRunNotFoundException)
            {
                return;
            }

            _logger.LogInformation(
                "Mission '{Id}' (ISARMissionID='{IsarMissionId}') status updated to '{Status}' for robot '{RobotName}' with ISAR id '{IsarId}'",
                updatedFlotillaMissionRun.Id,
                isarMission.MissionId,
                isarMission.Status,
                isarMission.RobotName,
                isarMission.IsarId
            );

            var robot = await RobotService.ReadByIsarId(isarMission.IsarId, readOnly: true);
            if (robot is null)
            {
                _logger.LogError(
                    "Could not find robot '{RobotName}' with ISAR id '{IsarId}'",
                    isarMission.RobotName,
                    isarMission.IsarId
                );
                return;
            }

            if (!updatedFlotillaMissionRun.IsCompleted)
            {
                await RobotService.UpdateCurrentMissionId(robot.Id, updatedFlotillaMissionRun.Id);
                robot.CurrentMissionId = updatedFlotillaMissionRun.Id;
                return;
            }

            _logger.LogInformation(
                "Robot '{Id}' ('{Name}') - completed mission run {MissionRunId}",
                robot.IsarId,
                robot.Name,
                updatedFlotillaMissionRun.Id
            );
            if (robot.CurrentMissionId == flotillaMissionRun.Id)
            {
                await RobotService.UpdateCurrentMissionId(robot.Id, null);
                robot.CurrentMissionId = null;
            }

            try
            {
                await LastMissionRunService.SetLastMissionRun(
                    updatedFlotillaMissionRun.Id,
                    updatedFlotillaMissionRun.MissionId
                );
            }
            catch (MissionNotFoundException)
            {
                _logger.LogError(
                    "Mission not found when setting last mission run for mission definition {missionId}",
                    updatedFlotillaMissionRun.MissionId
                );
                return;
            }

            await TaskDurationService.UpdateAverageDurationPerTask(robot);
        }

        private async void OnIsarTaskUpdate(IsarTaskMessage task)
        {
            IsarTaskStatus status;
            try
            {
                status = IsarTask.StatusFromString(task.Status);
            }
            catch (ArgumentException e)
            {
                _logger.LogError(
                    e,
                    "Failed to parse mission status from MQTT message. Mission '{Id}' was not updated",
                    task.MissionId
                );
                return;
            }

            if (!task.IsInspectionTask(task.TaskType))
            {
                _logger.LogInformation(
                    "Received status update to status {status} for task of type {taskType}. As this is not an inspection task, the task update will be disregarded.",
                    status,
                    task.TaskType
                );
                return;
            }

            MissionTask missionTask;
            try
            {
                missionTask = await MissionTaskService.UpdateMissionTaskStatus(
                    task.TaskId,
                    status,
                    task.ErrorDescription
                );
            }
            catch (MissionTaskNotFoundException)
            {
                return;
            }

            var missionRun = await MissionRunService.ReadById(task.MissionId, readOnly: true);
            if (missionRun is null)
            {
                _logger.LogWarning("Mission run with ID {Id} was not found", task.MissionId);
                return;
            }

            _ = SignalRService.SendMessageAsync(
                "Mission run updated",
                missionRun.InspectionArea.Installation,
                new MissionRunResponse(missionRun)
            );

            _logger.LogInformation(
                "Task '{Id}' updated to '{Status}' for robot '{RobotName}' with ISAR id '{IsarId}'",
                task.TaskId,
                task.Status,
                task.RobotName,
                task.IsarId
            );
        }

        private async Task<(string, string)?> GetRobotInstallationCodeAndId(string robotIsarId)
        {
            if (!_cache.TryGetValue(robotIsarId, out (string, string)? installationCodeAndId))
            {
                var robot = await RobotService.ReadByIsarId(robotIsarId);

                if (robot == null)
                    return null;
                var cacheEntryOptions = new MemoryCacheEntryOptions
                {
                    AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(1),
                };
                _cache.Set(
                    robotIsarId,
                    (robot.CurrentInstallation.InstallationCode, robot.Id),
                    cacheEntryOptions
                );
                installationCodeAndId = (robot.CurrentInstallation.InstallationCode, robot.Id);
            }
            return installationCodeAndId;
        }

        private async void OnIsarBatteryUpdate(IsarBatteryMessage batteryStatus)
        {
            (string installationCode, string robotId)? installationCodeAndId =
                await GetRobotInstallationCodeAndId(batteryStatus.IsarId);

            if (installationCodeAndId == null)
                return;

            _batteryMetrics[batteryStatus.IsarId] = new RobotMetricData(
                batteryStatus.BatteryLevel,
                installationCodeAndId.Value.robotId,
                installationCodeAndId.Value.installationCode,
                DateTimeOffset.UtcNow
            );

            await SignalRService.SendMessageAsync(
                "Robot telemetry updated",
                installationCodeAndId.Value.installationCode,
                new UpdateRobotTelemetryMessage
                {
                    RobotId = installationCodeAndId.Value.robotId,
                    TelemetryName = "batteryState",
                    TelemetryValue = batteryStatus.BatteryState,
                }
            );
            await SignalRService.SendMessageAsync(
                "Robot telemetry updated",
                installationCodeAndId.Value.installationCode,
                new UpdateRobotTelemetryMessage
                {
                    RobotId = installationCodeAndId.Value.robotId,
                    TelemetryName = "batteryLevel",
                    TelemetryValue = batteryStatus.BatteryLevel,
                }
            );
        }

        private async void OnIsarPressureUpdate(IsarPressureMessage pressureStatus)
        {
            (string installationCode, string robotId)? installationCodeAndId =
                await GetRobotInstallationCodeAndId(pressureStatus.IsarId);

            if (installationCodeAndId == null)
                return;

            _pressureMetrics[pressureStatus.IsarId] = new RobotMetricData(
                pressureStatus.PressureLevel,
                installationCodeAndId.Value.robotId,
                installationCodeAndId.Value.installationCode,
                DateTimeOffset.UtcNow
            );

            await SignalRService.SendMessageAsync(
                "Robot telemetry updated",
                installationCodeAndId.Value.installationCode,
                new UpdateRobotTelemetryMessage
                {
                    RobotId = installationCodeAndId.Value.robotId,
                    TelemetryName = "pressureLevel",
                    TelemetryValue = pressureStatus.PressureLevel,
                }
            );
        }

        private async void OnIsarPoseUpdate(IsarPoseMessage poseStatus)
        {
            (string installationCode, string robotId)? installationCodeAndId =
                await GetRobotInstallationCodeAndId(poseStatus.IsarId);

            if (installationCodeAndId == null)
                return;

            var pose = new Pose(poseStatus.Pose);

            await SignalRService.SendMessageAsync(
                "Robot telemetry updated",
                installationCodeAndId.Value.installationCode,
                new UpdateRobotTelemetryMessage
                {
                    RobotId = installationCodeAndId.Value.robotId,
                    TelemetryName = "pose",
                    TelemetryValue = pose,
                }
            );
        }

        private async void OnIsarCloudHealthUpdate(IsarCloudHealthMessage cloudHealthStatus)
        {
            var robot = await RobotService.ReadByIsarId(cloudHealthStatus.IsarId, readOnly: true);
            if (robot == null)
            {
                _logger.LogInformation(
                    "Received message from unknown ISAR instance {Id} with robot name {Name}",
                    cloudHealthStatus.IsarId,
                    cloudHealthStatus.RobotName
                );
                return;
            }

            string message = $"Failed telemetry request for robot {cloudHealthStatus.RobotName}.";

            _eventAggregatorSingletonService.Publish(new TeamsMessageEventArgs(message));
        }

        private async void OnIsarInterventionNeededUpdate(
            IsarInterventionNeededMessage interventionNeededMessage
        )
        {
            var robot = await RobotService.ReadByIsarId(
                interventionNeededMessage.IsarId,
                readOnly: true
            );
            if (robot == null)
            {
                _logger.LogInformation(
                    "Received message from unknown ISAR instance {Id} with robot name {Name}",
                    interventionNeededMessage.IsarId,
                    interventionNeededMessage.RobotName
                );
                return;
            }

            string message =
                $"Intervention needed for robot {interventionNeededMessage.RobotName}. "
                + $"Reason: {interventionNeededMessage.Reason}";

            _eventAggregatorSingletonService.Publish(new TeamsMessageEventArgs(message));
        }

        private async void OnIsarStartup(IsarStartupMessage startupMessage)
        {
            var robot = await RobotService.ReadByIsarId(startupMessage.IsarId, readOnly: true);
            if (robot == null)
            {
                _logger.LogInformation(
                    "Received message from unknown ISAR instance {Id}",
                    startupMessage.IsarId
                );
                return;
            }

            _logger.LogInformation(
                "Received ISAR restart event for robot {robotName} with ISAR id {isarId}.",
                robot.Name,
                robot.IsarId
            );

            var missionToAbort = robot.CurrentMissionId;
            if (missionToAbort == null)
            {
                _logger.LogInformation(
                    "Robot {robotName} with ISAR id {isarId} has no ongoing mission. No action required.",
                    robot.Name,
                    robot.IsarId
                );
                return;
            }

            try
            {
                var missionRun = await MissionScheduling.MoveMissionRunBackToQueue(
                    robot.Id,
                    missionToAbort,
                    "Isar restarted during mission"
                );

                _logger.LogInformation(
                    "Mission with id '{Id}' was aborted for robot '{RobotName}' due to ISAR restart",
                    missionRun.Id,
                    robot.Name
                );
            }
            catch (NoUnfinishedTasksInMissionException) { }
            catch (RobotNotFoundException)
            {
                _logger.LogWarning(
                    "Could not find robot with id {RobotId} when attempting to abort mission '{MissionToAbort}' due to isar restart",
                    robot.Id,
                    missionToAbort
                );
            }
            catch (MissionRunNotFoundException)
            {
                _logger.LogWarning(
                    "Could not find mission with id {MissionToAbort} when attempting to abort mission due to isar restart",
                    missionToAbort
                );
            }
            catch (Exception e)
            {
                _logger.LogError(
                    "An unhandled exception occured when attempting to abort mission with id {MissionToAbort} on robot {RobotId} due to isar restart. Error message: {StackTrace}",
                    missionToAbort,
                    robot.Id,
                    e.StackTrace
                );
            }
        }

        private async void OnSaraInspectionResultUpdate(
            SaraInspectionResultMessage inspectionResult
        )
        {
            var inspectionResultMessage = new InspectionResultMessage
            {
                InspectionId = inspectionResult.InspectionId,
            };

            var missionRun = await MissionRunService.ReadByTaskId(
                inspectionResult.InspectionId,
                readOnly: true
            );

            var installation = missionRun?.InspectionArea?.Installation;

            if (installation == null)
            {
                _logger.LogError(
                    "Installation could not be found when processing SARA inspection result update with inspection ID {InspectionId}",
                    inspectionResult.InspectionId
                );
                return;
            }

            _ = SignalRService.SendMessageAsync(
                "Inspection Visulization Ready",
                installation,
                inspectionResultMessage
            );
        }

        private async void OnSaraAnalysisResultMessage(SaraAnalysisResultMessage saraAnalysisResult)
        {
            if (saraAnalysisResult.InspectionIds.Count == 0)
            {
                _logger.LogError(
                    "SARA analysis result message contained no inspection IDs; skipping"
                );
                return;
            }

            // TODO: SARA may emit multiple inspection IDs for group analyses
            // (e.g. results derived from several inspections). For now we only
            // persist the result against the first ID; future work should iterate
            // the full list and emit one persist + SignalR event per inspection.
            var inspectionId = saraAnalysisResult.InspectionIds[0];

            var missionRun = await MissionRunService.ReadByTaskId(inspectionId, readOnly: true);

            var installation = missionRun?.InspectionArea?.Installation;

            if (installation == null)
            {
                _logger.LogError(
                    "Installation could not found when processing SARA analysis result update with inspection ID {inspectionId}",
                    inspectionId
                );
                return;
            }

            _ = SignalRService.SendMessageAsync(
                "Analysis Result Ready",
                installation,
                new AnalysisResultMessage()
                {
                    InspectionId = inspectionId,
                    AnalysisType = saraAnalysisResult.AnalysisType,
                    InstallationCode = installation.InstallationCode,
                }
            );
        }
    }
}