Zurg escape solution elixir... 1st approach

zurg_escape.ex

defmodule ZurgEscape do
  def right_combinations({left_toys, right_toys, time_spending, steps}) do
    for {p1, t1} <- left_toys, {p2, t2} <- left_toys, p1 != p2, do: {left_toys, [{p1, t1}, {p2, t2}], right_toys, time_spending, steps}
  end
  def right_combinations(data, result \\ [])
  def right_combinations([], result), do: result
  def right_combinations([{left, _combinations, right, time, steps} | t], result) do
    right_combinations(t, right_combinations({left, right, time, steps}) ++ result)
  end

  def left_combinations({left_toys, right_toys, time_spending, steps}) do
    for {p1, t1} <- right_toys, do: {left_toys, [{p1, t1}], right_toys, time_spending, steps}
  end
  def left_combinations(data, result \\ [])
  def left_combinations([], result), do: result
  def left_combinations([{left, _combinations, right, time, steps} | t], result) do
    left_combinations(t, left_combinations({left, right, time, steps}) ++ result)
  end

  def calculate_right(data, data \\ [])
  def calculate_right([], data), do: data
  def calculate_right([{left_toys, combinations, right_toys, time, steps} | t], data) do
    calculate_time = combinations
                     |> Enum.map(fn({_p1, t1}) -> t1 end)
                     |> Enum.max

    calculate_right(t, [{left_toys -- combinations, [], Keyword.merge(right_toys, combinations), time + calculate_time, steps ++ combinations} | data])
  end

  def calculate_left(data, data \\ [])
  def calculate_left([], data), do: data
  def calculate_left([{left_toys, _combinations, right_toys, time, steps} | t], data) when length(left_toys) == 0 do
    calculate_left(t, [{left_toys, [], right_toys, time, steps} | data])
  end

  def calculate_left([{left_toys, combinations, right_toys, time, steps} | t], data) do
    calculate_time = combinations
                     |> Enum.map(fn({_p1, t1}) -> t1 end)
                     |> Enum.max

    calculate_left(t, [{Keyword.merge(left_toys, combinations), [], right_toys -- combinations, time + calculate_time, steps ++ combinations} | data])
  end

  def calculate_time(data = [{[], [], _right, 60, _steps} | _t]) do
    data
    |> Enum.uniq
    |> Enum.each(fn({_, _, _, time, steps}) ->
      IO.inspect {steps, time}
    end)
    :done
  end

  def calculate_time(state) do
    state
    |> right_combinations
    |> calculate_right
    |> left_combinations
    |> calculate_left
    |> Enum.filter(fn({_, _, _, time, _}) -> time <= 60 end)
    |> calculate_time
  end

  def initial_state do
    toys = [b: 5, w: 10, r: 20, h: 25]
    {toys, [], 0, []}
  end

end