riichi

defmodule Riichi.Actor do
  alias Riichi.Rules

  @type t :: :actor1 | :actor2 | :actor3 | :actor4

  @spec actor_of_initial_seat(non_neg_integer()) :: t()
  def actor_of_initial_seat(seat) do
    case seat do
      0 -> :actor1
      1 -> :actor2
      2 -> :actor3
      3 -> :actor4
    end
  end

  @spec initial_seat_of_actor(t()) :: 1..3
  def initial_seat_of_actor(actor) do
    case actor do
      :actor1 -> 0
      :actor2 -> 1
      :actor3 -> 2
      :actor4 -> 3
    end
  end

  @spec next(t(), Rules.t()) :: t()
  def next(actor, %Rules{} = rules) do
    case {actor, Rules.player_count(rules)} do
      {:actor1, _} -> :actor2
      {:actor2, _} -> :actor3
      {:actor3, 3} -> :actor1
      {:actor3, 4} -> :actor4
      {:actor4, 4} -> :actor1
    end
  end

  @spec all() :: list(t())
  def all() do
    [:actor1, :actor2, :actor3, :actor4]
  end

  @spec all_after(t()) :: list(t())
  def all_after(actor) do
    idx = initial_seat_of_actor(actor)
    {actors_after, actors_before} = Enum.split(all(), idx + 1)
    actors_before ++ actors_after
  end

  @spec all(Rules.t()) :: list(t())
  def all(%Rules{} = rules) do
    Enum.take(all(), Rules.player_count(rules))
  end

  @spec for_each(Rules.t(), (t() -> k)) :: %{t() => k} when k: var
  def for_each(%Rules{} = rules, fun) do
    Map.new(all(rules), fn actor -> {actor, apply(fun, [actor])} end)
  end
end