swift-mqtt-dewpoint/Sources/SensorsService/SensorsService.swift

import Dependencies
import DependenciesMacros
import Foundation
import Logging
import Models
import MQTTConnectionManager
import MQTTNIO
import NIO
import PsychrometricClient
import ServiceLifecycle
import TopicDependencies

/// Service that is responsible for listening to changes of the temperature and humidity
/// sensors, then publishing back the calculated dew-point temperature and enthalpy for
/// the sensor location.
///
///
public actor SensorsService: Service {

  @Dependency(\.mqttConnectionManager.stream) var connectionStream
  @Dependency(\.topicListener) var topicListener
  @Dependency(\.topicPublisher) var topicPublisher

  /// The logger to use for the service.
  private let logger: Logger?

  /// The sensors that we are listening for updates to, so
  /// that we can calculate the dew-point temperature and enthalpy
  /// values to publish back to the MQTT broker.
  var sensors: [TemperatureAndHumiditySensor]

  @_spi(Internal)
  public var isListening: Bool = false

  var topics: [String] {
    sensors.reduce(into: [String]()) { array, sensor in
      array.append(sensor.topics.temperature)
      array.append(sensor.topics.humidity)
    }
  }

  /// Create a new sensors service that listens to the passed in
  /// sensors.
  ///
  /// - Note: The service will fail to start if the array of sensors is not greater than 0.
  ///
  /// - Parameters:
  ///   - sensors: The sensors to listen for changes to.
  ///   - logger: An optional logger to use.
  public init(
    sensors: [TemperatureAndHumiditySensor],
    logger: Logger? = nil
  ) {
    self.sensors = sensors
    self.logger = logger
  }

  /// Start the service with graceful shutdown, which will attempt to publish
  /// any pending changes to the MQTT broker, upon a shutdown signal.
  public func run() async throws {
    precondition(sensors.count > 0, "Sensors should not be empty.")

    try await withGracefulShutdownHandler {
      // Listen for connection events, so that we can automatically
      // reconnect any sensor topics we're listening to upon a disconnect / reconnect
      // event.  We can also shutdown any topic listeners upon a shutdown event.
      for await event in try connectionStream().cancelOnGracefulShutdown() {
        switch event {
        case .shuttingDown:
          logger?.debug("Received shutdown event.")
          isListening = false
          try await self.shutdown()
        case .disconnected:
          logger?.debug("Received disconnected event.")
          isListening = false
          try await Task.sleep(for: .milliseconds(100))
        case .connected:
          logger?.debug("Received connected event.")
          let stream = try await makeStream()
          isListening = true
          for await result in stream.cancelOnGracefulShutdown() {
            logger?.debug("Received result for topic: \(result.topic)")
            await self.handleResult(result)
          }
        }
      }
    } onGracefulShutdown: {
      Task {
        self.logger?.debug("Received graceful shutdown.")
        try await self.shutdown()
      }
    }
  }

  @_spi(Internal)
  public func shutdown() async throws {
    try await publishUpdates()
    topicListener.shutdown()
  }

  private func makeStream() async throws -> AsyncStream<(buffer: ByteBuffer, topic: String)> {
    try await topicListener.listen(to: topics)
      // ignore errors, so that we continue to listen, but log them
      // for debugging purposes.
      .compactMap { result in
        switch result {
        case let .failure(error):
          self.logger?.debug("Received error listening for sensors: \(error)")
          return nil
        case let .success(info):
          return (info.payload, info.topicName)
        }
      }
      // ignore duplicate values, to prevent publishing dew-point and enthalpy
      // changes to frequently.
      .removeDuplicates { lhs, rhs in
        lhs.buffer == rhs.buffer
          && lhs.topic == rhs.topic
      }
      .eraseToStream()
  }

  private func handleResult(_ result: (buffer: ByteBuffer, topic: String)) async {
    do {
      let topic = result.topic
      assert(topics.contains(topic))
      logger?.debug("Begin handling result for topic: \(topic)")

      func decode<V: BufferInitalizable>(_: V.Type) -> V? {
        var buffer = result.buffer
        return V(buffer: &buffer)
      }

      if topic.contains("temperature") {
        logger?.debug("Begin handling temperature result.")
        guard let temperature = decode(DryBulb.self) else {
          logger?.debug("Failed to decode temperature: \(result.buffer)")
          throw DecodingError()
        }
        logger?.debug("Decoded temperature: \(temperature)")
        try sensors.update(topic: topic, keyPath: \.temperature, with: temperature)

      } else if topic.contains("humidity") {
        logger?.debug("Begin handling humidity result.")
        guard let humidity = decode(RelativeHumidity.self) else {
          logger?.debug("Failed to decode humidity: \(result.buffer)")
          throw DecodingError()
        }
        logger?.debug("Decoded humidity: \(humidity)")
        try sensors.update(topic: topic, keyPath: \.humidity, with: humidity)
      }

      try await publishUpdates()
      logger?.debug("Done handling result for topic: \(topic)")
    } catch {
      logger?.error("Received error while handling result: \(error)")
    }
  }

  private func publish(_ double: Double?, to topic: String) async throws {
    guard let double else { return }
    try await topicPublisher.publish(
      to: topic,
      payload: ByteBufferAllocator().buffer(string: "\(double)"),
      qos: .exactlyOnce,
      retain: true
    )
    logger?.debug("Published update to topic: \(topic)")
  }

  private func publishUpdates() async throws {
    for sensor in sensors.filter(\.needsProcessed) {
      try await publish(sensor.dewPoint?.value, to: sensor.topics.dewPoint)
      try await publish(sensor.enthalpy?.value, to: sensor.topics.enthalpy)
      try sensors.hasProcessed(sensor)
    }
  }
}

// MARK: - Errors

struct DecodingError: Error {}
struct SensorNotFoundError: Error {}

// MARK: - Helpers

private extension TemperatureAndHumiditySensor.Topics {
  func contains(_ topic: String) -> Bool {
    temperature == topic || humidity == topic
  }
}

private extension Array where Element == TemperatureAndHumiditySensor {

  mutating func update<V>(
    topic: String,
    keyPath: WritableKeyPath<TemperatureAndHumiditySensor, V>,
    with value: V
  ) throws {
    guard let index = firstIndex(where: { $0.topics.contains(topic) }) else {
      throw SensorNotFoundError()
    }
    self[index][keyPath: keyPath] = value
  }

  mutating func hasProcessed(_ sensor: TemperatureAndHumiditySensor) throws {
    guard let index = firstIndex(where: { $0.id == sensor.id }) else {
      throw SensorNotFoundError()
    }
    self[index].needsProcessed = false
  }
}