 
   @doc false
   def start_link do
-    GenStage.start_link(__MODULE__, [], [name: __MODULE__])
+    GenStage.start_link(__MODULE__, [], name: __MODULE__)
   end
 
   defmodule State do
     @moduledoc false
-    defstruct [repo_up: false, registered: %{}, handler: nil, env: struct(Macro.Env, [])]
+    defstruct repo_up: false,
+              registered: %{},
+              handler: nil,
+              env: struct(Macro.Env, [])
   end
 
   def init([]) do
     case @handler.start_link() do
       {:ok, handler} ->
         all_gpios = ConfigStorage.all_gpios()
-        state = initial_state(all_gpios, struct(State, [handler: handler]))
+        state = initial_state(all_gpios, struct(State, handler: handler))
         Process.send_after(self(), :update_fb_state_tree, 10)
-        {:producer_consumer, state, subscribe_to: [handler], dispatcher: GenStage.BroadcastDispatcher}
-      err -> err
+
+        {:producer_consumer, state,
+         subscribe_to: [handler], dispatcher: GenStage.BroadcastDispatcher}
+
+      err ->
+        err
     end
   end
 
   defp initial_state([], state), do: state
 
-  defp initial_state([%GpioRegistry{pin: pin, sequence_id: sequence_id} | rest], state) do
+  defp initial_state(
+         [%GpioRegistry{pin: pin, sequence_id: sequence_id} | rest],
+         state
+       ) do
     case @handler.register_pin(pin) do
-      :ok -> initial_state(rest, %{state | registered: Map.put(state.registered, pin, sequence_id)})
-      _ -> initial_state(rest, state)
+      :ok ->
+        initial_state(rest, %{
+          state
+          | registered: Map.put(state.registered, pin, sequence_id)
+        })
+
+      _ ->
+        initial_state(rest, state)
     end
   end
 
   def handle_events(_, _, %{repo_up: false} = state) do
-    Logger.warn 3, "Not handling gpio events until Asset storage is up."
+    Logger.warn(3, "Not handling gpio events until Asset storage is up.")
     {:noreply, [], state}
   end
 
   def handle_events(pin_triggers, _from, state) do
     t = Enum.uniq(pin_triggers)
-    new_env = Enum.reduce(t, state.env, fn({:pin_trigger, pin}, env) ->
-      sequence_id = state.registered[pin]
-      if sequence_id do
-        Logger.busy 1, "Starting Sequence: #{sequence_id} from pin: #{pin}"
-        do_execute(sequence_id, env)
-      else
-        Logger.warn 3, "No sequence assosiated with: #{pin}"
-        env
-      end
-    end)
+
+    new_env =
+      Enum.reduce(t, state.env, fn {:pin_trigger, pin}, env ->
+        sequence_id = state.registered[pin]
+
+        if sequence_id do
+          Logger.busy(1, "Starting Sequence: #{sequence_id} from pin: #{pin}")
+          do_execute(sequence_id, env)
+        else
+          Logger.warn(3, "No sequence assosiated with: #{pin}")
+          env
+        end
+      end)
+
     {:noreply, [], %{state | env: new_env}}
   end
 

    rescue
      err ->
        message = Exception.message(err)
        Logger.warn 2, "Failed to execute sequence #{sequence_id} " <> message
        env
    end
  end

end

        case @handler.register_pin(pin_num) do
          :ok ->
            ConfigStorage.add_gpio_registry(pin_num, sequence_id)

            new_state = %{
              state
              | registered: Map.put(state.registered, pin_num, sequence_id)
            }

            {:reply, :ok, [{:gpio_registry, new_state.registered}], new_state}

          {:error, _} = err ->
            {:reply, err, [], state}
        end

      _ ->
        {:reply, {:error, :already_registered}, [], state}
    end
  end

  def handle_call({:unregister_pin, pin_num}, _from, state) do
    case state.registered[pin_num] do
      nil ->
        {:reply, {:error, :unregistered}, [], state}

      sequence_id ->
        case @handler.unregister_pin(pin_num) do
          :ok ->
            ConfigStorage.delete_gpio_registry(pin_num, sequence_id)

            new_state = %{
              state
              | registered: Map.delete(state.registered, pin_num)
            }

            {:reply, :ok, [{:gpio_registry, new_state.registered}], new_state}

          err ->
            {:reply, err, [], state}
        end
    end
  end
