@testable import ClientLive
import EnvVars
import Logging
import Models
import MQTTNIO
import NIO
import Psychrometrics
import XCTest

final class AsyncClientTests: XCTestCase {

  static let hostname = ProcessInfo.processInfo.environment["MOSQUITTO_SERVER"] ?? "localhost"

  static let logger: Logger = {
    var logger = Logger(label: "AsyncClientTests")
    logger.logLevel = .trace
    return logger
  }()

  func createClient(identifier: String) -> AsyncClient {
    let envVars = EnvVars(
      appEnv: .testing,
      host: Self.hostname,
      port: "1883",
      identifier: identifier,
      userName: nil,
      password: nil
    )
    return .init(envVars: envVars, logger: Self.logger)
  }

  func testConnectAndShutdown() async throws {
    let client = createClient(identifier: "testConnectAndShutdown")
    await client.connect()
    await client.shutdown()
  }

  func testPublishingSensor() async throws {
    let client = createClient(identifier: "testPublishingSensor")
    await client.connect()
    let topic = Topics().sensors.mixedAirSensor.dewPoint
    try await client.addPublishListener(topic: topic, decoding: Temperature.self)
    try await client.publishSensor(.mixed(.init(temperature: 71.123, humidity: 50.5, needsProcessed: true)))
    try await client.publishSensor(.mixed(.init(temperature: 72.123, humidity: 50.5, needsProcessed: true)))
    await client.shutdown()
  }

  func testNewSensorSyntax() async throws {
    let client = createClient(identifier: "testNewSensorSyntax")
    let mqtt = client.client
    let receivedPublishInfo = PublishInfoContainer()
    let payload = ByteBufferAllocator().buffer(string: "75.123")
    let sensor = TemperatureAndHumiditySensor(location: .return)

    await client.connect()

    try await mqtt.subscribeToTemperature(sensor: sensor)

    let listener = mqtt.createPublishListener()

    Task { [receivedPublishInfo] in
      for await result in listener {
        switch result {
        case let .failure(error):
          XCTFail("\(error)")
        case let .success(publish):
          await receivedPublishInfo.addPublishInfo(publish)
        }
      }
    }

    try await mqtt.publish(to: sensor.topics.temperature, payload: payload, qos: .atLeastOnce)

    try await Task.sleep(for: .seconds(2))

    XCTAssertEqual(receivedPublishInfo.count, 1)

    if let publish = receivedPublishInfo.first {
      var buffer = publish.payload
      let string = buffer.readString(length: buffer.readableBytes)
      XCTAssertEqual(string, "75.123")
    } else {
      XCTFail("Did not receive any publish info.")
    }

    try await mqtt.disconnect()
    try mqtt.syncShutdownGracefully()
  }
}

// MARK: Helpers for tests, some of these should be able to be removed once the AsyncClient interface is done.

extension MQTTClient {

  func subscribeToTemperature(sensor: TemperatureAndHumiditySensor) async throws {
    _ = try await subscribe(to: [
      .init(topicFilter: sensor.topics.temperature, qos: .atLeastOnce)
    ])
  }
}

class PublishInfoContainer {
  private var receivedPublishInfo: [MQTTPublishInfo]

  init() {
    self.receivedPublishInfo = []
  }

  func addPublishInfo(_ info: MQTTPublishInfo) async {
    receivedPublishInfo.append(info)
  }

  var count: Int { receivedPublishInfo.count }

  var first: MQTTPublishInfo? { receivedPublishInfo.first }
}