Automating the Hue Tap Dial Switch in Elixir via MQTT

def handle_info({:mqtt, _topic, %{"action" => "dial_rotate_" <> type}}, state) do
  speed = rotate_speed(type)
  set(%{brightness_step: speed})
  {:noreply, state}
end

defp rotate_speed("left_" <> speed), do: -rotate_speed(speed)
defp rotate_speed("right_" <> speed), do: rotate_speed(speed)
defp rotate_speed("step"), do: 10
defp rotate_speed("slow"), do: 20
defp rotate_speed("fast"), do: 45

TapDialController.start_link(
  device: boys_room_tap_dial(),
  scene: 0,
  rotate: fn _step ->
    # This disables the existing circadian automation.
    # I found that manually disabling it is more reliable than trying to
    # detect external changes over MQTT as messages may be delayed and arrive out of order.
    LightController.set_manual_override(boys_room_ceiling_light(), true)
  end,
  button_1: %{
    click: fn ->
      Mqtt.set(boys_room_ceiling_light(), %{state: "TOGGLE"})
    end,
    double_click: fn ->
      # This function compares the current light status and sets it to 100%
      # or reverts back to circadian lighting (if setup for the light).
      HueLights.toggle_max_brightness(boys_room_ceiling_light())
    end
  },
  button_2: %{
    click: fn state ->
      # The light controller normally uses circadian lighting to update
      # the light. Setting manual override pauses circadian lighting,
      # allowing us to manually control the light.
      LightController.set_manual_override(boys_room_ceiling_light(), true)
      # This function steps through different light states for the ceiling light
      # (hue 0..300 with 60 intervals) and stores it in `state`.
      next_scene(state)
    end
  },
  button_3: %{
    click: fn ->
      Mqtt.set(boys_room_floor_light(), %{state: "TOGGLE"})
    end,
    double_click: fn ->
      Mqtt.set(isidor_sleep_light(), %{state: "TOGGLE"})
    end,
    hold: fn ->
      Mqtt.set(isidor_sleep_light(), %{hue_move: 40, color: %{saturation: 100}})
    end,
    hold_release: fn ->
      Mqtt.set(isidor_sleep_light(), %{hue_move: 0})
    end
  },
  button_4: %{
    click: fn ->
      Mqtt.set(loke_lava_lamp(), %{state: "TOGGLE", brightness: 254})
    end,
    double_click: fn ->
      Mqtt.set(loke_sleep_light(), %{state: "TOGGLE"})
    end,
    hold: fn ->
      Mqtt.set(loke_sleep_light(), %{hue_move: 40, color: %{saturation: 100}})
    end,
    hold_release: fn ->
      Mqtt.set(loke_sleep_light(), %{hue_move: 0})
    end
  }
)

defmodule Haex.Mqtt.TapDialController do
  use GenServer
  alias Haex.Mqtt
  alias Haex.Mock
  require Logger

  @impl true
  def init(opts) do
    # This allows us to setup expectations and to collect what messages
    # the controller sends during unit testing.
    if parent = opts[:parent] do
      Mock.allow(parent, self())
    end

    device = opts[:device] || raise "Must specify `device`, got: #{inspect(opts)}"

    # Just subscribes to pubsub under the hood.
    Mqtt.subscribe_events(device)

    state =
      Map.new(opts)
      |> Map.put_new(:double_click_timeout, 350)

    {:ok, state}
  end

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts)
  end

  @impl true
  def handle_info({:mqtt, _topic, payload}, state) do
    case parse_action(payload) do
      {:button, button, fun} ->
        # We specify handlers with `button_3: %{}` specs.
        case fetch_button_handler(button, state) do
          {:ok, spec} ->
            # Dispatch to action handlers, such as `handle_hold` and `handle_press_release`.
            fun.(spec, state)

          :not_found ->
            {:noreply, state}
        end

      {:rotate, step} ->
        case fetch_rotate_handler(state) do
          {:ok, cb} ->
            call_handler(cb, step, state)

          :not_found ->
            {:noreply, state}
        end

      :skip ->
        {:noreply, state}
    end
  end

  def handle_info({:execute_single_press, ref, cb}, state) do
    # Only execute the callback for the last action.
    if state[:click_ref] == ref do
      call_handler(cb, Map.delete(state, :click_ref))
    else
      {:noreply, state}
    end
  end

  defp handle_press_release(spec, state) do
    single_click_handler = spec[:click]
    double_click_handler = spec[:double_click]

    cond do
      double_click_handler ->
        now = DateTime.utc_now()

        valid_double_click? =
          state[:last_press] &&
            DateTime.diff(now, state[:last_press], :millisecond) < state.double_click_timeout

        if valid_double_click? do
          # Execute a double click immediately.
          state =
            state
            |> Map.delete(:last_press)
            |> Map.delete(:click_ref)

          call_handler(double_click_handler, state)
        else
          # Delay single click to see if we get a double click later.
          ref = make_ref()

          Process.send_after(
            self(),
            {:execute_single_press, ref, single_click_handler},
            state.double_click_timeout
          )

          state =
            state
            |> Map.put(:last_press, now)
            |> Map.put(:click_ref, ref)

          {:noreply, state}
        end

      single_click_handler ->
        # No double click handler, so we can directly execute the single click.
        call_handler(single_click_handler, state)

      true ->
        {:noreply, state}
    end
  end

  defp handle_hold(spec, state) do
    call_handler(spec[:hold], state)
  end

  defp handle_hold_release(spec, state) do
    call_handler(spec[:hold_release], state)
  end

  defp call_handler(nil, state) do
    {:noreply, state}
  end

  defp call_handler(handler, state) do
    # If a callback expects one argument we'll also send the state,
    # otherwise we simply call it.
    case Function.info(handler)[:arity] do
      0 ->
        handler.()
        {:noreply, state}

      1 ->
        {:noreply, handler.(state)}

      x ->
        Logger.error(
          "Unsupported cb arity `#{x}` for #{state.device} tap dial expecting 0 or 1 args"
        )

        {:noreply, state}
    end
  end

  defp call_handler(nil, _arg1, state) do
    {:noreply, state}
  end

  defp call_handler(handler, arg1, state) do
    case Function.info(handler)[:arity] do
      1 ->
        handler.(arg1)
        {:noreply, state}

      2 ->
        {:noreply, handler.(arg1, state)}

      x ->
        Logger.error(
          "Unsupported cb arity `#{x}` for #{state.device} tap dial  expecting 1 or 2 args"
        )

        {:noreply, state}
    end
  end

  defp parse_action(%{"action" => "brightness_step_" <> dir, "action_step_size" => step}) do
    step =
      case dir do
        "up" -> step
        "down" -> -step
      end

    {:rotate, step}
  end

  defp parse_action(%{"action" => action}) do
    case Regex.run(~r/button_(\d)_(\w+)/, action, capture: :all_but_first) do
      [button, "press_release"] ->
        {:button, String.to_integer(button), &handle_press_release/2}

      [button, "hold"] ->
        {:button, String.to_integer(button), &handle_hold/2}

      [button, "hold_release"] ->
        {:button, String.to_integer(button), &handle_hold_release/2}

      _ ->
        :skip
    end
  end

  defp parse_action(_action) do
    Logger.debug("Skip fallback tap dial action: #{inspect(action)}")
    :skip
  end

  defp fetch_button_handler(button, state) do
    spec = state["button_#{button}" |> String.to_atom()]

    if spec do
      {:ok, Map.put(spec, :button, button)}
    else
      :not_found
    end
  end

  defp fetch_rotate_handler(state) do
    if spec = state[:rotate] do
      {:ok, spec}
    else
      :not_found
    end
  end
end