l42fu

defmodule L42fu.Options do
  @moduledoc false

  import L42fu.Tools, only: [format_number: 3]

  def normalize(pfx_sfx_string, pfx_or_sfx \\ :prefix) do
    case String.split(pfx_sfx_string, ":") do
      [basic] -> basic
      ["incr", init] -> _make_increment(init, "1")
      ["incr", init, step] -> _make_increment(init, step)
      ["rand", infix | rest] -> _make_rand(rest, {infix, pfx_or_sfx})
      _ -> raise ArgumentError, "not a fixed string or correct generator expression"
    end
  end

  defp _force_integer!(value, name, base \\ 10) do
    case Integer.parse(value, base) do
      {ival, ""} -> ival
      _ -> raise ArgumentError, "#{value} of #{name} is not an Integer"
    end
  end

  defp _make_increment(init, step) do
    init1 = _force_integer!(init, "init")
    step1 = _force_integer!(step, "step")
    Stream.iterate(init1, &(&1 + step1))
  end

  defp _make_rand(values, infix)
  defp _make_rand([], infix), do: _make_rand(["0", "ffffffff", "x"], infix)
  defp _make_rand([upper], infix), do: _make_rand(["0", upper, "x"], infix)
  defp _make_rand([lower, upper], infix), do: _make_rand([lower, upper, "x"], infix)

  defp _make_rand([lower, upper, format], infix) do
    base =
      case format do
        "x" ->
          16

        "d" ->
          10

        "o" ->
          8

        "b" ->
          2

        x ->
          raise ArgumentError,
                "illegal base: #{inspect(x)}, legal values are #{inspect(~W[x d o b])}"
      end

    len = String.length(upper)

    lower1 = _force_integer!(lower, "lower", base)
    upper1 = _force_integer!(upper, "upper", base)

    Stream.iterate(_random(lower1, upper1, infix, base, len), fn _ ->
      _random(lower1, upper1, infix, base, len)
    end)
  end

  defp _random(lower, upper, infx, base, len)

  defp _random(lower, upper, {infx, :prefix}, base, len) do
    formatted =
      format_number(
        lower + :rand.uniform(upper - lower + 1) - 1,
        base,
        len
      )

    "#{formatted}#{infx}"
  end

  defp _random(lower, upper, {infx, :suffix}, base, len) do
    formatted =
      format_number(
        lower + :rand.uniform(upper - lower + 1) - 1,
        base,
        len
      )

    "#{infx}#{formatted}"
  end
end

# SPDX-License-Identifier: Apache-2.0