defmodule CherylsBirthday do
  # 0. A knows M and B knows D
  # 1. A doesn't know D:          M has more than one day
  # 2. A knows B doesn't know M:  M must have no unique days
  # 3. B didn't know M at first:  D found in at least two months
  # 4. B knows M after 2.:        D must be in only one of the remaining months
  # 5. A knows D after 4.:        M must have only one unshared day among remaining months
  def solve(dates) do
    day_to_months = Enum.group_by(dates, &day/1, &month/1)
    month_to_days = Enum.group_by(dates, &month/1, &day/1)

    possibilities = %{days: Map.keys(day_to_months), months: Map.keys(month_to_days)}

    possibilities
    # 1. M has more than one day
    |> Map.update!(:months, fn months -> Enum.filter(months, &(length(month_to_days[&1]) > 1)) end)
    # 2. M must have no unique days
    |> Map.update!(:months, fn months ->
      Enum.filter(months, fn month ->
        Enum.all?(month_to_days[month], fn day -> length(day_to_months[day]) != 1 end)
      end)
    end)
    # 3. D found in at least two months
    |> Map.update!(:days, fn days -> Enum.filter(days, &(length(day_to_months[&1]) > 1)) end)
    # 4. D must be in only one of the remaining months
    |> then(fn %{days: days, months: months} = possibilities ->
      days = Enum.filter(days, fn day -> Enum.count(months, &(day in month_to_days[&1])) == 1 end)
      %{possibilities | days: days}
    end)
    # 5. M must have only one unshared day among remaining months
    |> then(fn %{months: months} = possibilities ->
      {months, days} =
        months
        |> Enum.map(fn month ->
          unshared_days =
            Enum.filter(month_to_days[month], fn day ->
              Enum.all?(months -- [month], &(day not in month_to_days[&1]))
            end)

          {month, unshared_days}
        end)
        |> Enum.filter(fn {_month, unshared_days} -> length(unshared_days) == 1 end)
        |> Enum.unzip()

      %{possibilities | days: List.flatten(days), months: months}
    end)
    |> then(fn %{days: [day], months: [month]} -> {month, day} end)
  end

  def day({_month, day}), do: day
  def month({month, _day}), do: month

  def original_dates do
    may = {"May", [15, 16, 19]}
    jun = {"Jun", [17, 18]}
    jul = {"Jul", [14, 16]}
    aug = {"Aug", [14, 15, 17]}
    for {month, days} <- [may, jun, jul, aug], day <- days, do: {month, day}
  end

  def alternate_dates do
    jan = {"Jan", [4, 15]}
    mar = {"Mar", [13, 24]}
    may = {"May", [11, 17, 30]}
    jul = {"Jul", [13, 24, 30]}
    for {month, days} <- [jan, mar, may, jul], day <- days, do: {month, day}
  end
end

CherylsBirthday.original_dates()
|> CherylsBirthday.solve()
|> IO.inspect()
#=> {"Jul", 16}

CherylsBirthday.alternate_dates()
|> CherylsBirthday.solve()
|> IO.inspect()
#=> {"Jul", 30}