defmodule MST.Store.Memory do
  @moduledoc """
  Map-backed in-memory MST node store.

  Suitable for tests and any use case where the full tree fits in memory.
  The store state is a plain `%{}` map from `DASL.CID` to `MST.Node`.

  ## Usage

      store = MST.Store.Memory.new()
      tree  = MST.Tree.new(store)

  """

  @behaviour MST.Store

  alias DASL.CID
  alias MST.Node

  @type state() :: %{CID.t() => Node.t()}

  @doc """
  Returns a new, empty memory store as a `{MST.Store.Memory, %{}}` pair.

  ## Examples

      iex> {mod, state} = MST.Store.Memory.new()
      iex> mod
      MST.Store.Memory
      iex> state
      %{}

  """
  @spec new() :: MST.Store.t()
  def new, do: {__MODULE__, %{}}

  # ---------------------------------------------------------------------------
  # MST.Store callbacks
  # ---------------------------------------------------------------------------

  @impl MST.Store
  @spec get(state(), CID.t()) :: {:ok, Node.t()} | {:error, :not_found}
  def get(state, cid) do
    case Map.fetch(state, cid) do
      {:ok, node} -> {:ok, node}
      :error -> {:error, :not_found}
    end
  end

  @impl MST.Store
  @spec put(state(), CID.t(), Node.t()) :: state()
  def put(state, cid, node), do: Map.put(state, cid, node)

  @impl MST.Store
  @spec has?(state(), CID.t()) :: boolean()
  def has?(state, cid), do: Map.has_key?(state, cid)

  @impl MST.Store
  @spec cids(state()) :: [CID.t()]
  def cids(state), do: Map.keys(state)
end