defmodule Localiser.Web.Channels.CalibrationChannel do
  use Phoenix.Channel

  alias Localiser.Domain.Sensors
  alias Localiser.Localisation.Sensor.Server, as: SensorServer

  @impl true
  def join("calibration:" <> sensor_id, _params, socket) do
    case Sensors.get_sensor_by_sensor_id(sensor_id) do
      nil ->
        {:error, %{reason: "sensor not found"}}

      _sensor ->
        Phoenix.PubSub.subscribe(Localiser.PubSub, "calibration:#{sensor_id}")
        state = SensorServer.calibration_state(sensor_id)
        {:ok, state, assign(socket, :sensor_id, sensor_id)}
    end
  end

  @impl true
  def handle_info({:calibration_mode_entered, _sensor_id, samples_needed}, socket) do
    push(socket, "mode_entered", %{samples_needed: samples_needed})
    {:noreply, socket}
  end

  def handle_info({:stage_started, _sensor_id, distance, completed_count}, socket) do
    push(socket, "stage_started", %{distance: distance, completed_stages: completed_count})
    {:noreply, socket}
  end

  def handle_info({:calibration_reading, _sensor_id, rssi, is_outlier, %{stage: {cur, total}}}, socket) do
    push(socket, "reading", %{rssi: rssi, outlier: is_outlier, stage_progress: %{current: cur, total: total}})
    {:noreply, socket}
  end

  def handle_info({:stage_complete, _sensor_id, distance, readings, mean_rssi}, socket) do
    rendered = Enum.map(readings, fn {rssi, outlier} -> %{rssi: rssi, outlier: outlier} end)
    push(socket, "stage_complete", %{distance: distance, readings: rendered, mean_rssi: mean_rssi})
    {:noreply, socket}
  end

  def handle_info({:calibration_finished, _sensor_id, rssi_ref, path_loss_exp}, socket) do
    push(socket, "finished", %{rssi_ref: rssi_ref, path_loss_exp: path_loss_exp})
    {:noreply, socket}
  end

  def handle_info({:calibration_cancelled, _sensor_id}, socket) do
    push(socket, "cancelled", %{})
    {:noreply, socket}
  end

  def handle_info(_msg, socket), do: {:noreply, socket}
end