# defmodule HelixWeb.MainLive do
#   use HelixWeb, :live_view

#   alias Helix.Graph

#   require Dotx
#   require UUID

#   @impl true
#   def mount(_params, _session, socket) do

#     graphs = Graph.list_local_graphs()

#     if connected?(socket) do
#       HelixWeb.Endpoint.subscribe("LiveModule")
#     end

#     {:ok, assign(socket,
#         page_title: "Helix",
#         selected_graph: graphs |> List.first(),
#         graphs: graphs,
#         graph_preview: Graph.load_and_render_template(graphs |> List.first()),
#         started: false,
#         all_events: [],
#         load_error: nil,
#         loaded_graph_name: "",
#         input_targets: [],
#         message: "",
#         target: ""
#       )
#     }
#   end

#   @impl true
#   def handle_event("select_graph", %{"graph" => graph}, socket) do
#     {:noreply, assign(socket,
#         selected_graph: graph,
#         graph_preview: Graph.load_and_render_template(graph)
#       )}
#   end

#   @impl true
#   def handle_event("load_graph", _, socket) do
#     try do
#       {nodes, graph} = Graph.load_graph(socket.assigns.selected_graph)
#       has_input = Graph.has_live_input?(nodes)
#       input_targets = Enum.reduce(nodes, [], fn i, acc ->
#         {key, node} = i
#         name = key |> List.first()
#         if Map.get(node.attrs, "module") == "LiveInputModule" do
#           acc ++ [name]
#         else
#           acc
#         end
#       end)
#       {:noreply, assign(socket,
#         started: true,
#         load_error: nil,
#         loaded_graph_name: Map.keys(graph) |> List.first(),
#         page_title: Map.keys(graph) |> List.first(),
#         input_targets: input_targets,
#         target: input_targets |> List.first(),
#         has_input: has_input
#       )}
#     catch
#       k, e ->
#         {:noreply, assign(socket,
#             started: false,
#             load_error: Kernel.inspect(k) <> ": " <> Kernel.inspect(e)
#         )}
#     end
#   end

#   @impl true
#   def handle_event("submit_message", %{"input" => %{"message" => message, "target" => target}}, socket) do

#     if socket.assigns.has_input do
#       target_pid = :ets.lookup(:pids, target) |> Enum.at(0) |> elem(1)
#       event = %{
#         type: :text,
#         value: message,
#         source_id: "You:" <> target,
#         message_id: UUID.uuid4(),
#         timestamp: :os.system_time(:milli_seconds)
#       }
#       GenServer.cast(target_pid, {:convey, event})
#       {
#         :noreply, assign(socket,
#         all_events: socket.assigns.all_events ++ [event],
#         message: "",
#         target: target
#       )}
#     else
#       {:noreply, socket}
#     end
#   end

#   def handle_event("message_updated", %{"input" => %{"message" => message, "target" => target}}, socket) do
#     {:noreply, assign(socket, message: message, target: target)}
#   end

#   ##
#   # From Task Modules
#   ##

#   @impl true
#   def handle_info(%{event: "convey", payload: event}, socket) do
#     {:noreply,
#       socket
#       |> assign(all_events: socket.assigns.all_events ++ [event])
#       |> push_event("scrollbox", %{scrollbox: true})
#     }
#   end

# end