import config
import gleam/erlang/process
import gleam/option.{None, Some}
import readings_broadcaster
import spoke/mqtt
import spoke/mqtt_actor
import spoke/tcp

pub fn start(cfg: config.Config) -> mqtt_actor.Client {
  let client_id = cfg.mqtt_client_id
  let password = <<cfg.mqtt_pw:utf8>>
  let auth = mqtt.AuthDetails(username: cfg.mqtt_user, password: Some(password))
  let transport = tcp.connector_with_defaults(cfg.mqtt_host)
  let connection_options =
    mqtt.ConnectOptions(
      client_id: client_id,
      authentication: Some(auth),
      transport_options: transport,
      keep_alive_seconds: 120,
      server_timeout_ms: 15_000,
    )
  let assert Ok(started) =
    mqtt_actor.build(connection_options) |> mqtt_actor.start(100)
  let client = started.data

  let start_up_checker = process.new_subject()
  mqtt_actor.subscribe_to_updates(client, start_up_checker)
  mqtt_actor.connect(client, True, None)
  let assert Ok(mqtt.ConnectionStateChanged(mqtt.ConnectAccepted(_))) =
    process.receive(start_up_checker, 15_000)

  let assert Ok(broadcaster) = readings_broadcaster.start([])
  mqtt_actor.subscribe_to_updates(client, broadcaster)

  client
}

pub fn subscribe(client: mqtt_actor.Client, topic: String) {
  mqtt_actor.subscribe(client, [
    mqtt.SubscribeRequest(topic, mqtt.ExactlyOnce),
  ])
}

pub fn disconnect(client: mqtt_actor.Client) {
  mqtt_actor.disconnect(client)
}