defmodule Whisk do
  @moduledoc """
  The scrambler.
  """

  @typedoc """
  A string representation of a puzzle type.

  See `puzzle_types/0` for supported values.
  """
  @type puzzle_type :: atom()

  @typedoc """
  A scramble is string representing a sequence of moves, separated by spaces.

  Moves are also strings. Different puzzle types have different valid moves.
  """
  @type scramble :: String.t()

  # A moveset is a 3-tuple containing the following:
  # - a list of groups of turns on the same axis (e. g. R and L for cubes)
  # - a list of turn modifiers (e. g. for cubes, ', 2, and nothing)
  # - the default move count in a scramble

  # A puzzle spec is one of:
  # - a moveset
  # - {moveset, moveset, integer}
  # Interpretation:
  # A scramble for a puzzle spec of the second shape takes the form
  # (<moves of one pattern...> <moves of another pattern>) * <integer repetitions>

  @puzzle_spec_2x2 {[~w(R), ~w(F), ~w(U)], ["", "'", "2"], 10}
  @puzzle_spec_3x3 {[~w(R L), ~w(F B), ~w(U D)], ["", "'", "2"], 23}
  @puzzle_spec_4x4 {[~w(R L Rw), ~w(F B Fw), ~w(U D Uw)], ["", "'", "2"], 40}
  @puzzle_spec_5x5 {[~w(R L Rw Lw), ~w(F B Fw Bw), ~w(U D Uw Dw)], ["", "'", "2"], 60}
  @puzzle_spec_6x6 {[~w(R L Rw Lw 3Rw), ~w(F B Fw Bw 3Fw), ~w(U D Uw Dw 3Uw)], ["", "'", "2"], 80}
  @puzzle_spec_7x7 {[~w(R L Rw Lw 3Rw 3Lw), ~w(F B Fw Bw 3Fw 3Bw), ~w(U D Uw Dw 3Uw 3Dw)],
                    ["", "'", "2"], 100}

  @puzzle_spec_skewb {[~w(R), ~w(L), ~w(U), ~w(B)], ["", "'"], 11}

  @puzzle_spec_pyraminx {
    {[~w(U), ~w(L), ~w(R), ~w(B)], ["", "'"], 11},
    {[~w(u), ~w(l), ~w(r), ~w(b)], ["", "'"], 0..1},
    1
  }

  @puzzle_spec_megaminx {
    {[~w(R), ~w(D)], ["++", "--"], 10},
    {[~w(U)], ["", "'"], 1},
    7
  }

  ## API

  @doc """
  Returns a list of supported puzzle types.

  ```
  iex> Whisk.puzzle_types()
  [:"2x2", :"3x3", :"3x3 OH", :"3x3 BLD", :"4x4", :"5x5", :"6x6", :"7x7", :Skewb, :Pyraminx, :Megaminx]
  ```
  """
  @spec puzzle_types() :: [atom()]
  def puzzle_types do
    [
      :"2x2",
      :"3x3",
      :"3x3 OH",
      :"3x3 BLD",
      :"4x4",
      :"5x5",
      :"6x6",
      :"7x7",
      :Skewb,
      :Pyraminx,
      :Megaminx
    ]
  end

  @doc """
  Generate a scramble for a puzzle type. Also accepts the puzzle type as a string.

  Passing an unsupported puzzle type will generate an error.

  ## Options
    - `:length` - the number of moves in the scramble
    - `:reps` - for puzzles with repeating patterns, like Megaminx, specify the
      number of repetitions

  ## Examples

  ```
  iex> Whisk.scramble(:"3x3")
  "L F2 U R D B U2 R F' R F R2 D2 B R' B' D R B U"

  iex> Whisk.scramble(:"Skewb", length: 12)
  "L R B' R U' R' B L' U' B' L R U' R' L'"

  iex> Whisk.scramble(:Megaminx, length: 5, reps: 3)
  "D-- R-- D++ R-- D++ U' D++ R-- D++ R-- D++ U R-- D-- R-- D-- R++ U"
  ```

  """
  @spec scramble(puzzle_type() | String.t(), list()) :: scramble()
  def scramble(puzzle_name, opts \\ [])

  def scramble(puzzle_name, opts) when is_binary(puzzle_name) do
    puzzle_type_atom =
      try do
        String.to_existing_atom(puzzle_name)
      rescue
        ArgumentError -> raise "Unsupported puzzle type: #{inspect(puzzle_name)}"
      end

    scramble(puzzle_type_atom, opts)
  end

  def scramble(puzzle_name, opts) when is_atom(puzzle_name) do
    scramble_from_spec(puzzle_spec(puzzle_name), opts)
  end

  defp scramble_from_spec(spec, opts)

  defp scramble_from_spec(
         {
           {axes1, modifiers1, default_length},
           {axes2, modifiers2, length2},
           default_reps
         },
         opts
       ) do
    validate_opts(opts)
    length1 = opts[:length] || default_length
    reps = opts[:reps] || default_reps

    Enum.join(
      for _ <- 1..reps do
        part1 = generate_scramble(axes1, modifiers1, length1)
        part2 = generate_addon_scramble(axes2, modifiers2, length2)

        String.trim(part1 <> " " <> part2)
      end,
      " "
    )
  end

  defp scramble_from_spec({axes, modifiers, default_length}, opts) do
    validate_opts(opts)
    length = opts[:length] || default_length

    generate_scramble(axes, modifiers, length)
  end

  defp validate_opts(opts) do
    cond do
      opts[:length] && opts[:length] < 0 -> raise "Invalid length: #{inspect(opts[:length])}"
      opts[:reps] && opts[:reps] < 0 -> raise "Invalid reps: #{inspect(opts[:reps])}"
      true -> nil
    end
  end

  ## Helpers

  defp puzzle_spec(puzzle_name) do
    case puzzle_name do
      :"2x2" -> @puzzle_spec_2x2
      :"3x3" -> @puzzle_spec_3x3
      :"3x3 OH" -> @puzzle_spec_3x3
      :"3x3 BLD" -> @puzzle_spec_3x3
      :"4x4" -> @puzzle_spec_4x4
      :"5x5" -> @puzzle_spec_5x5
      :"6x6" -> @puzzle_spec_6x6
      :"7x7" -> @puzzle_spec_7x7
      :Skewb -> @puzzle_spec_skewb
      :Pyraminx -> @puzzle_spec_pyraminx
      :Megaminx -> @puzzle_spec_megaminx
      _ -> raise "Unsupported puzzle type: #{inspect(puzzle_name)}"
    end
  end

  defp generate_scramble(axes, modifiers, length) when is_number(length) do
    axis_idx = initial_axis_index(axes)
    Enum.join(generate_moves(axes, modifiers, axis_idx, [], length), " ")
  end

  defp generate_moves(axes, modifiers, last_axis_index, acc, remaining) do
    if remaining <= 0 do
      acc
    else
      axis_idx = different_axis_index(axes, last_axis_index)

      generate_moves(
        axes,
        modifiers,
        axis_idx,
        [generate_move(axes, modifiers, axis_idx) | acc],
        remaining - 1
      )
    end
  end

  defp generate_move(axes, modifiers, axis_idx) do
    Enum.random(Enum.at(axes, axis_idx)) <> Enum.random(modifiers)
  end

  defp generate_addon_scramble(axes, modifiers, %Range{} = range) do
    axes
    |> Enum.map(fn axis ->
      reps = Enum.random(range)

      1..reps//1
      |> Enum.map(fn _ -> Enum.random(axis) <> Enum.random(modifiers) end)
      |> Enum.join(" ")
    end)
    |> Enum.filter(fn move -> move != "" end)
    |> Enum.join(" ")
  end

  defp generate_addon_scramble(axes, modifiers, length) when is_number(length) do
    Enum.join(
      for axis <- axes do
        Enum.join(
          for _ <- 1..length//1 do
            Enum.random(axis) <> Enum.random(modifiers)
          end,
          " "
        )
      end,
      " "
    )
  end

  defp initial_axis_index(axes) when length(axes) == 1 do
    0
  end

  defp initial_axis_index(axes) do
    :rand.uniform(Enum.count(axes)) - 1
  end

  defp different_axis_index(axes, _index) when length(axes) == 1 do
    0
  end

  defp different_axis_index(axes, index) do
    axis_count = Enum.count(axes)
    rem(index + :rand.uniform(axis_count - 1), axis_count)
  end
end