persisting in postgres

lib/elixir_ai/conversation_manager.ex

@@ -1,8 +1,14 @@
 defmodule ElixirAi.ConversationManager do
   use GenServer
+  alias ElixirAi.{Conversation, Message}
 
-  def start_link(_opts), do: GenServer.start_link(__MODULE__, [], name: __MODULE__)
-  def init(names), do: {:ok, names}
+  def start_link(_opts), do: GenServer.start_link(__MODULE__, nil, name: __MODULE__)
+
+  def init(_) do
+    names = Conversation.all_names()
+    conversations = Map.new(names, fn name -> {name, []} end)
+    {:ok, conversations}
+  end
 
   def create_conversation(name) do
     GenServer.call(__MODULE__, {:create, name})
@@ -16,34 +22,76 @@ defmodule ElixirAi.ConversationManager do
     GenServer.call(__MODULE__, :list)
   end
 
-  def handle_call({:create, name}, _from, names) do
-    if name in names do
-      {:reply, {:error, :already_exists}, names}
+  def get_messages(name) do
+    GenServer.call(__MODULE__, {:get_messages, name})
+  end
+
+  def handle_call({:create, name}, _from, conversations) do
+    if Map.has_key?(conversations, name) do
+      {:reply, {:error, :already_exists}, conversations}
     else
-      {:reply, start_runner(name), [name | names]}
+      case Conversation.create(name) do
+        :ok ->
+          case start_and_subscribe(name) do
+            {:ok, _pid} = ok -> {:reply, ok, Map.put(conversations, name, [])}
+            error -> {:reply, error, conversations}
+          end
+
+        {:error, _} = error ->
+          {:reply, error, conversations}
+      end
     end
   end
 
-  def handle_call({:open, name}, _from, names) do
-    if name in names do
-      {:reply, start_runner(name), names}
+  def handle_call({:open, name}, _from, conversations) do
+    if Map.has_key?(conversations, name) do
+      case start_and_subscribe(name) do
+        {:ok, _pid} = ok -> {:reply, ok, conversations}
+        error -> {:reply, error, conversations}
+      end
     else
-      {:reply, {:error, :not_found}, names}
-    end
-  end
-  def handle_call(:list, _from, names) do
-    {:reply, names, names}
-  end
-
-  defp start_runner(name) do
-    case DynamicSupervisor.start_child(
-           ElixirAi.ChatRunnerSupervisor,
-           {ElixirAi.ChatRunner, name: name}
-         ) do
-      {:ok, pid} -> {:ok, pid}
-      {:error, {:already_started, pid}} -> {:ok, pid}
-      error -> error
+      {:reply, {:error, :not_found}, conversations}
     end
   end
 
+  def handle_call(:list, _from, conversations) do
+    {:reply, Map.keys(conversations), conversations}
+  end
+
+  def handle_call({:get_messages, name}, _from, conversations) do
+    {:reply, Map.get(conversations, name, []), conversations}
+  end
+
+  def handle_info({:store_message, name, message}, conversations) do
+    messages = Map.get(conversations, name, [])
+    position = length(messages)
+
+    case Conversation.find_id(name) do
+      {:ok, conv_id} -> Message.insert(conv_id, message, position)
+      _ -> :ok
+    end
+
+    {:noreply, Map.update(conversations, name, [message], &(&1 ++ [message]))}
+  end
+
+  defp start_and_subscribe(name) do
+    result =
+      case DynamicSupervisor.start_child(
+             ElixirAi.ChatRunnerSupervisor,
+             {ElixirAi.ChatRunner, name: name}
+           ) do
+        {:ok, pid} -> {:ok, pid}
+        {:error, {:already_started, pid}} -> {:ok, pid}
+        error -> error
+      end
+
+    case result do
+      {:ok, _pid} ->
+        Phoenix.PubSub.subscribe(ElixirAi.PubSub, "conversation_messages:#{name}")
+        result
+
+      _ ->
+        result
+    end
+  end
 end