defmodule LSG.IRC.DicePlugin do
  require Logger

  @moduledoc """
  # dice

  * **!dice `[1 | lancés]` `[6 | faces]`**: lance une ou plusieurs fois un dé de 6 ou autre faces
  """

  @default_faces 6
  @default_rolls 1
  @max_rolls 50

  def short_irc_doc, do: "!dice (jeter un dé)"
  defstruct client: nil, dets: nil

  def irc_doc, do: @moduledoc

  def start_link() do
    GenServer.start_link(__MODULE__, [], name: __MODULE__)
  end

  def init([]) do
    {:ok, _} = Registry.register(IRC.PubSub, "trigger:dice", [plugin: __MODULE__])
    {:ok, %__MODULE__{}}
  end

  def handle_info({:irc, :trigger, _, message = %{trigger: %{type: :bang, args: args}}}, state) do
    to_integer = fn(string, default) ->
      case Integer.parse(string) do
        {int, _} -> int
        _ -> default
      end
    end

    {rolls, faces} = case args do
      [] -> {@default_rolls, @default_faces}
      [faces, rolls] -> {to_integer.(rolls, @default_rolls), to_integer.(faces, @default_faces)}
      [rolls] -> {to_integer.(rolls, @default_rolls), @default_faces}
    end

    roll(state, message, faces, rolls)

    {:noreply, state}
  end

  def handle_info(info, state) do
    {:noreply, state}
  end

  defp roll(state, message, faces, 1) when faces > 0 do
    random = :crypto.rand_uniform(1, faces+1)
    message.replyfun.("#{message.sender.nick} dice: #{random}")
  end
  defp roll(state, message, faces, rolls) when faces > 0 and rolls > 0 and rolls <= @max_rolls do
    {results, acc} = Enum.map_reduce(Range.new(1, rolls), 0, fn(i, acc) ->
      random = :crypto.rand_uniform(1, faces+1)
      {random, acc + random}
    end)
    results = Enum.join(results, "; ")
    message.replyfun.("#{message.sender.nick} dice: [#{acc}] #{results}")
  end

  defp roll(_, _, _, _, _), do: nil

end