surface

defmodule Surface.Catalogue.Data do
  @moduledoc """
  Experimental module that provides conveniences for manipulating data
  in Examples and Playgrounds.

  Provide wrappers around built-in functions like `get_in/2` and `update_in/3`
  using a shorter syntax for accessors.

  ## Accessor Mapping

    * `[_]`: `Access.all/0`
    * `[fun]`: `Access.filter(fun)`
    * `[index]`: `Access.at(index)` (Shorthand for `[index: i]`)
    * `[index: i]`: `Access.at(i)`
    * `[key: k]`: `Access.key(k)`
    * `[first..last]`: `Surface.Catalogue.Data.slice(first..last)`

  ## Example

      Data.get(props.lists[_].cards[& &1.id == "Card_1"].tags[-1].name)

  The code above will be translated to:

      get_in(props, [:lists, Access.all, :cards, Access.filter(& &1.id == "Card_1"), :tags, Access.at(-1), :name])

  """

  @doc """
  Generates a short ramdom id.
  """
  def random_id(size \\ 6) do
    :crypto.strong_rand_bytes(size)
    |> Base.encode32(case: :lower)
    |> binary_part(0, size)
  end

  @doc """
  Gets an existing value from the given nested structure.

  Raises an error if none or more than one value is found.
  """
  defmacro get!(path) do
    {subject, selector} = split_path(path)

    quote do
      unquote(__MODULE__).__get__!(unquote(subject), unquote(selector))
    end
  end

  @doc """
  Gets a value from the given nested structure.

  A wrapper around `get_in/2`
  """
  defmacro get(path) do
    {subject, selector} = split_path(path)

    quote do
      get_in(unquote(subject), unquote(selector))
    end
  end

  @doc """
  Gets a value and updates a given nested structure.

  A wrapper around `get_and_update_in/3`
  """
  defmacro get_and_update(path, fun) do
    {subject, selector} = split_path(path)

    quote do
      get_and_update_in(unquote(subject), unquote(selector), unquote(fun))
    end
  end

  @doc """
  Pops a item from the given nested structure.

  A wrapper around `pop_in/2`
  """
  defmacro pop(path) do
    {subject, selector} = split_path(path)

    quote do
      pop_in(unquote(subject), unquote(selector))
    end
  end

  @doc """
  Updates an item in the given nested structure.

  A wrapper around `update_in/2`
  """
  defmacro update(path, fun) do
    {subject, selector} = split_path(path)

    quote do
      update_in(unquote(subject), unquote(selector), unquote(fun))
    end
  end

  @doc """
  Deletes an item from the given nested structure.
  """
  defmacro delete(path) do
    {subject, selector} = split_path(path)

    quote do
      unquote(__MODULE__).__delete__(unquote(subject), unquote(selector))
    end
  end

  @doc """
  Inserts an item into a list in the given nested structure.
  """
  defmacro insert_at(path, pos, value) do
    {subject, selector} = split_path(path)

    quote do
      unquote(__MODULE__).__insert_at__(
        unquote(subject),
        unquote(selector),
        unquote(pos),
        unquote(value)
      )
    end
  end

  @doc """
  Appends an item to a list in the given nested structure.
  """
  defmacro append(path, value) do
    {subject, selector} = split_path(path)

    quote do
      unquote(__MODULE__).__insert_at__(unquote(subject), unquote(selector), -1, unquote(value))
    end
  end

  @doc """
  Prepends an item to a list in the given nested structure.
  """
  defmacro prepend(path, value) do
    {subject, selector} = split_path(path)

    quote do
      unquote(__MODULE__).__insert_at__(unquote(subject), unquote(selector), 0, unquote(value))
    end
  end

  @doc false
  def __get__!(subject, selector) do
    case get_in(subject, selector) |> List.flatten() do
      [item] ->
        item

      [] ->
        raise "no value found"

      [_ | _] ->
        raise "more than one value found"
    end
  end

  @doc false
  def __insert_at__(subject, selector, pos, value) do
    update_in(subject, selector, fn list ->
      List.insert_at(list, pos, value)
    end)
  end

  @doc false
  def __delete__(subject, selector) do
    {_, list} = pop_in(subject, selector)
    list
  end

  @doc false
  def access_fun(value) when is_function(value) do
    Access.filter(value)
  end

  def access_fun(value) when is_integer(value) do
    Access.at(value)
  end

  def access_fun(from..to = range) when is_integer(from) and is_integer(to) do
    slice(range)
  end

  def access_fun(value) do
    Access.key(value)
  end

  defp quoted_access_fun({:_, _, _}) do
    quote do
      Access.all()
    end
  end

  defp quoted_access_fun(key: value) do
    quote do
      Access.key(unquote(value))
    end
  end

  defp quoted_access_fun(index: value) do
    quote do
      Access.at(unquote(value))
    end
  end

  defp quoted_access_fun(value) do
    quote do
      unquote(__MODULE__).access_fun(unquote(value))
    end
  end

  def slice(range) do
    fn op, data, next -> slice(op, data, range, next) end
  end

  defp slice(:get, data, range, next) when is_list(data) do
    data |> Enum.slice(range) |> Enum.map(next)
  end

  defp slice(:get_and_update, data, range, next) when is_list(data) do
    get_and_update_slice(data, range, next, [], [], -1)
  end

  defp slice(_op, data, _range, _next) do
    raise "slice expected a list, got: #{inspect(data)}"
  end

  defp normalize_range_bound(value, list_length) do
    if value < 0 do
      value + list_length
    else
      value
    end
  end

  defp get_and_update_slice([], _range, _next, updates, gets, _index) do
    {:lists.reverse(gets), :lists.reverse(updates)}
  end

  defp get_and_update_slice(list, from..to, next, updates, gets, -1) do
    list_length = length(list)
    from = normalize_range_bound(from, list_length)
    to = normalize_range_bound(to, list_length)
    get_and_update_slice(list, from..to, next, updates, gets, 0)
  end

  defp get_and_update_slice([head | rest], from..to = range, next, updates, gets, index) do
    new_index = index + 1

    if index >= from and index <= to do
      case next.(head) do
        {get, update} ->
          get_and_update_slice(rest, range, next, [update | updates], [get | gets], new_index)

        :pop ->
          get_and_update_slice(rest, range, next, updates, [head | gets], new_index)
      end
    else
      get_and_update_slice(rest, range, next, [head | updates], gets, new_index)
    end
  end

  defp split_path(path) do
    {[subject | rest], _} = unnest(path, [], true, "test")
    {subject, convert_selector(rest)}
  end

  defp convert_selector(list) do
    Enum.map(list, fn
      {:map, key} ->
        quote do
          Access.key!(unquote(key))
        end

      {:access, expr} ->
        quoted_access_fun(expr)
    end)
  end

  def unnest(path) do
    unnest(path, [], true, "test")
  end

  defp unnest({{:., _, [Access, :get]}, _, [expr, key]}, acc, _all_map?, kind) do
    unnest(expr, [{:access, key} | acc], false, kind)
  end

  defp unnest({{:., _, [expr, key]}, _, []}, acc, all_map?, kind)
       when is_tuple(expr) and :erlang.element(1, expr) != :__aliases__ and
              :erlang.element(1, expr) != :__MODULE__ do
    unnest(expr, [{:map, key} | acc], all_map?, kind)
  end

  defp unnest(other, [], _all_map?, kind) do
    raise ArgumentError,
          "expected expression given to #{kind} to access at least one element, " <>
            "got: #{Macro.to_string(other)}"
  end

  defp unnest(other, acc, all_map?, kind) do
    case proper_start?(other) do
      true ->
        {[other | acc], all_map?}

      false ->
        raise ArgumentError,
              "expression given to #{kind} must start with a variable, local or remote call " <>
                "and be followed by an element access, got: #{Macro.to_string(other)}"
    end
  end

  defp proper_start?({{:., _, [expr, _]}, _, _args})
       when is_atom(expr)
       when :erlang.element(1, expr) == :__aliases__
       when :erlang.element(1, expr) == :__MODULE__,
       do: true

  defp proper_start?({atom, _, _args})
       when is_atom(atom),
       do: true

  defp proper_start?(other), do: not is_tuple(other)
end