test "greets the world" do
    assert HandyHaversacks.hello() == :world

  @example_rules [
    {"light red", ["bright white", "muted yellow"]},
    {"dark orange", ["bright white", "muted yellow"]},
    {"bright white", ["shiny gold"]},
    {"muted yellow", ["shiny gold", "faded blue"]},
    {"shiny gold", ["dark olive", "vibrant plum"]},
    {"dark olive", ["faded blue", "dotted black"]},
    {"vibrant plum", ["faded blue", "dotted black"]},
    {"faded blue", []},
    {"dotted black", []}
  ]
  test "parse rule" do
    assert HandyHaversacks.parse_rule(
             "light red bags contain 1 bright white bag, 2 muted yellow bags."
           ) == {"light red", ["bright white", "muted yellow"]}
    assert HandyHaversacks.parse_rule(
             "dark orange bags contain 3 bright white bags, 4 muted yellow bags."
           ) == {"dark orange", ["bright white", "muted yellow"]}
  end
  test "find_container" do
    assert HandyHaversacks.contains({"light red", ["bright white", "muted yellow"]}, "shiny gold") ==
             false
    assert HandyHaversacks.contains({"muted yellow", ["shiny gold", "faded blue"]}, "shiny gold") ==
             true
    assert HandyHaversacks.containers_of(
             [{"muted yellow", ["shiny gold", "faded blue"]}],
             "shiny gold"
           ) == ["muted yellow"]
    assert HandyHaversacks.containers_of(@example_rules, "shiny gold") == [
             "bright white",
             "muted yellow"
           ]
  end
  test "recursive_find_containers" do
    assert HandyHaversacks.rcontainers_of(
             [{"muted yellow", ["shiny gold", "faded blue"]}],
             "shiny gold"
           ) == ["muted yellow"]
    assert HandyHaversacks.rcontainers_of(@example_rules, "shiny gold") ==
             [
               "bright white",
               "muted yellow",
               "dark orange",
               "light red"
             ]
             |> Enum.sort()
  end
  test "example" do
    assert File.read!("example")
           |> String.split("\n", trim: true)
           |> Enum.map(&HandyHaversacks.parse_rule/1)
           |> HandyHaversacks.rcontainers_of("shiny gold")
           |> Enum.count() == 4

  test "part 1" do
    File.read!("input")
    |> String.split("\n", trim: true)
    |> Enum.map(&HandyHaversacks.parse_rule/1)
    |> HandyHaversacks.rcontainers_of("shiny gold")
    |> Enum.count()
    |> IO.inspect(label: "Part 1")
  end

      {:mix_test_watch, "~> 1.0", only: :dev, runtime: false}

  @moduledoc """
  Documentation for `HandyHaversacks`.
  """

  def parse_rule(rule) do
    [bag_type] = ~r/^(\w+ \w+) bags contain/ |> Regex.run(rule, capture: :all_but_first)

  @doc """
  Hello world.

    scans = ~r/\d+ (\w+ \w+) bag/ |> Regex.scan(rule, capture: :all_but_first) |> List.flatten()
    {bag_type, scans}
  end

  ## Examples

  def contains({_container, types}, type) do
    Enum.member?(types, type)
  end
  def containers_of(rules, type) do
    rules |> Enum.filter(&contains(&1, type)) |> Enum.map(&elem(&1, 0))
  end
  def rcontainers_of(rules, type) do
    containers = rules |> Enum.filter(&contains(&1, type)) |> Enum.map(&elem(&1, 0))

      iex> HandyHaversacks.hello()
      :world

    case containers do
      [] ->
        []

  """
  def hello do
    :world

      _ ->
        case Enum.map(containers, &rcontainers_of(rules, &1)) do
          [] -> containers
          whatever -> List.flatten(containers ++ whatever) |> Enum.uniq() |> Enum.sort()
        end
    end

light red bags contain 1 bright white bag, 2 muted yellow bags.
dark orange bags contain 3 bright white bags, 4 muted yellow bags.
bright white bags contain 1 shiny gold bag.
muted yellow bags contain 2 shiny gold bags, 9 faded blue bags.
shiny gold bags contain 1 dark olive bag, 2 vibrant plum bags.
dark olive bags contain 3 faded blue bags, 4 dotted black bags.
vibrant plum bags contain 5 faded blue bags, 6 dotted black bags.
faded blue bags contain no other bags.
dotted black bags contain no other bags.

  test "greets the world" do
    assert CustomCustoms.hello() == :world
  end

  @moduledoc """
  Documentation for `CustomCustoms`.
  """
  @doc """
  Hello world.
  ## Examples
      iex> CustomCustoms.hello()
      :world
  """
  def hello do
    :world
  end