basics being displayed

lib/cobblemon_ui/cobblemon_fs/cobblemon_fs.ex

@@ -0,0 +1,256 @@
+defmodule CobblemonUi.CobblemonFS do
+  @moduledoc """
+  GenServer that reads Cobblemon player data from the filesystem.
+
+  Provides cached access to player party and PC storage data parsed
+  from NBT `.dat` files under the configured data directory.
+
+  ## Configuration
+
+      config :cobblemon_ui, CobblemonUi.CobblemonFS,
+        data_dir: "/cobblemon-data",
+        cache_ttl_ms: 2_000
+
+  ## Data directory structure
+
+      <data_dir>/world/pokemon/playerpartystore/<uuid>.dat
+      <data_dir>/world/pokemon/pcstore/<uuid>.dat
+  """
+
+  use GenServer
+
+  alias CobblemonUi.CobblemonFS.{PartyStore, PCStore}
+
+  @default_data_dir "/cobblemon-data"
+  @default_cache_ttl_ms 2_000
+  @uuid_regex ~r/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/
+
+  # --- Client API ---
+
+  def start_link(opts \\ []) do
+    name = Keyword.get(opts, :name, __MODULE__)
+    GenServer.start_link(__MODULE__, opts, name: name)
+  end
+
+  @doc "Returns full player data: party + PC."
+  @spec get_player(String.t()) :: {:ok, map()} | {:error, term()}
+  def get_player(uuid), do: call({:get_player, uuid})
+
+  @doc "Returns only the player's party Pokémon."
+  @spec get_party(String.t()) :: {:ok, list()} | {:error, term()}
+  def get_party(uuid), do: call({:get_party, uuid})
+
+  @doc "Returns only the player's PC boxes."
+  @spec get_pc(String.t()) :: {:ok, list()} | {:error, term()}
+  def get_pc(uuid), do: call({:get_pc, uuid})
+
+  @doc "Returns a specific Pokémon by index (0-5 = party, 6+ = PC)."
+  @spec get_pokemon(String.t(), non_neg_integer()) :: {:ok, map() | nil} | {:error, term()}
+  def get_pokemon(uuid, index), do: call({:get_pokemon, uuid, index})
+
+  @doc "Lists all players as `%{uuid: String.t(), name: String.t() | nil}` maps."
+  @spec list_players() :: {:ok, list(map())}
+  def list_players, do: GenServer.call(__MODULE__, :list_players)
+
+  defp call(msg), do: GenServer.call(__MODULE__, msg)
+
+  # --- Server Callbacks ---
+
+  @impl true
+  def init(opts) do
+    config = Application.get_env(:cobblemon_ui, __MODULE__, [])
+
+    data_dir = Keyword.get(config, :data_dir, Keyword.get(opts, :data_dir, @default_data_dir))
+    cache_ttl = Keyword.get(config, :cache_ttl_ms, @default_cache_ttl_ms)
+
+    {:ok,
+     %{
+       data_dir: data_dir,
+       cache_ttl: cache_ttl,
+       cache: %{}
+     }}
+  end
+
+  @impl true
+  def handle_call({:get_player, uuid}, _from, state) do
+    with :ok <- validate_uuid(uuid),
+         {player_data, state} <- fetch_player(uuid, state) do
+      {:reply, {:ok, player_data}, state}
+    else
+      {:error, _} = err -> {:reply, err, state}
+    end
+  end
+
+  def handle_call({:get_party, uuid}, _from, state) do
+    with :ok <- validate_uuid(uuid),
+         {player_data, state} <- fetch_player(uuid, state) do
+      {:reply, {:ok, player_data.party}, state}
+    else
+      {:error, _} = err -> {:reply, err, state}
+    end
+  end
+
+  def handle_call({:get_pc, uuid}, _from, state) do
+    with :ok <- validate_uuid(uuid),
+         {player_data, state} <- fetch_player(uuid, state) do
+      {:reply, {:ok, player_data.pc}, state}
+    else
+      {:error, _} = err -> {:reply, err, state}
+    end
+  end
+
+  def handle_call({:get_pokemon, uuid, index}, _from, state) do
+    with :ok <- validate_uuid(uuid),
+         {player_data, state} <- fetch_player(uuid, state) do
+      pokemon = find_pokemon(player_data, index)
+      {:reply, {:ok, pokemon}, state}
+    else
+      {:error, _} = err -> {:reply, err, state}
+    end
+  end
+
+  def handle_call(:list_players, _from, state) do
+    party_dir = Path.join([state.data_dir, "world", "pokemon", "playerpartystore"])
+    pc_dir = Path.join([state.data_dir, "world", "pokemon", "pcstore"])
+    usercache = load_usercache(state.data_dir)
+
+    uuids =
+      [party_dir, pc_dir]
+      |> Enum.flat_map(&list_uuids_in_dir/1)
+      |> Enum.uniq()
+      |> Enum.sort()
+
+    players =
+      Enum.map(uuids, fn uuid ->
+        %{uuid: uuid, name: Map.get(usercache, uuid)}
+      end)
+
+    {:reply, {:ok, players}, state}
+  end
+
+  # --- Private Helpers ---
+
+  defp validate_uuid(uuid) do
+    if Regex.match?(@uuid_regex, uuid), do: :ok, else: {:error, :invalid_uuid}
+  end
+
+  defp fetch_player(uuid, state) do
+    now = System.monotonic_time(:millisecond)
+
+    case Map.get(state.cache, uuid) do
+      {data, expires_at} when expires_at > now ->
+        {data, state}
+
+      _ ->
+        case load_player(uuid, state.data_dir) do
+          {:ok, data} ->
+            expires_at = now + state.cache_ttl
+            cache = Map.put(state.cache, uuid, {data, expires_at})
+            {data, %{state | cache: cache}}
+
+          {:error, _} = err ->
+            err
+        end
+    end
+  end
+
+  defp uuid_prefix(uuid), do: String.slice(uuid, 0, 2)
+
+  defp load_player(uuid, data_dir) do
+    prefix = uuid_prefix(uuid)
+
+    party_path =
+      Path.join([data_dir, "world", "pokemon", "playerpartystore", prefix, "#{uuid}.dat"])
+
+    pc_path = Path.join([data_dir, "world", "pokemon", "pcstore", prefix, "#{uuid}.dat"])
+
+    party_exists? = File.exists?(party_path)
+    pc_exists? = File.exists?(pc_path)
+
+    if not party_exists? and not pc_exists? do
+      {:error, :not_found}
+    else
+      party_result = if party_exists?, do: PartyStore.parse(party_path), else: {:ok, []}
+      pc_result = if pc_exists?, do: PCStore.parse(pc_path), else: {:ok, []}
+
+      case {party_result, pc_result} do
+        {{:ok, party}, {:ok, pc}} ->
+          {:ok, %{uuid: uuid, party: party, pc: pc}}
+
+        {{:error, reason}, _} ->
+          {:error, reason}
+
+        {_, {:error, reason}} ->
+          {:error, reason}
+      end
+    end
+  end
+
+  defp find_pokemon(%{party: party, pc: pc}, index) when is_integer(index) do
+    party_size = length(party)
+
+    if index < party_size do
+      Enum.at(party, index)
+    else
+      pc_index = index - party_size
+      all_pc_pokemon = Enum.flat_map(pc, fn box -> Map.get(box, :pokemon, []) end)
+      Enum.at(all_pc_pokemon, pc_index)
+    end
+  end
+
+  defp list_uuids_in_dir(dir) do
+    case File.ls(dir) do
+      {:ok, entries} ->
+        entries
+        |> Enum.flat_map(fn entry ->
+          subdir = Path.join(dir, entry)
+
+          case File.dir?(subdir) do
+            true ->
+              case File.ls(subdir) do
+                {:ok, files} ->
+                  files
+                  |> Enum.filter(&String.ends_with?(&1, ".dat"))
+                  |> Enum.reject(&String.ends_with?(&1, ".dat.old"))
+                  |> Enum.map(&String.trim_trailing(&1, ".dat"))
+                  |> Enum.filter(&Regex.match?(@uuid_regex, &1))
+
+                {:error, _} ->
+                  []
+              end
+
+            false ->
+              if String.ends_with?(entry, ".dat") and not String.ends_with?(entry, ".dat.old") do
+                uuid = String.trim_trailing(entry, ".dat")
+                if Regex.match?(@uuid_regex, uuid), do: [uuid], else: []
+              else
+                []
+              end
+          end
+        end)
+
+      {:error, _} ->
+        []
+    end
+  end
+
+  defp load_usercache(data_dir) do
+    path = Path.join(data_dir, "usercache.json")
+
+    case File.read(path) do
+      {:ok, data} ->
+        case Jason.decode(data) do
+          {:ok, entries} when is_list(entries) ->
+            Map.new(entries, fn entry ->
+              {Map.get(entry, "uuid", ""), Map.get(entry, "name")}
+            end)
+
+          _ ->
+            %{}
+        end
+
+      {:error, _} ->
+        %{}
+    end
+  end
+end