defmodule Day7 do
  def part1 do
    [0, 1, 2, 3, 4]
    |> permutations()
    |> Enum.map(fn digits -> {digits, test_inputs(digits)} end)
    |> Enum.max_by(fn {_, out} -> out end)
  end

  def part2 do
    [5, 6, 7, 8, 9]
    |> permutations()
    |> Enum.map(&test_looped/1)
    |> Enum.max()
  end

  def test_inputs(digits) do
    Enum.reduce(digits, 0, fn phase_setting, prev_output ->
      phase_setting
      |> start_amplifier()
      |> amplifier_step(prev_output)
    end)
  end

  def permutations([]), do: [[]]

  def permutations(list) do
    for x <- list, y <- permutations(list -- [x]), do: [x | y]
  end

  def test_looped(digits) do
    digits
    |> Enum.map(&start_amplifier/1)
    # |> IO.inspect()
    |> Stream.cycle()
    |> Enum.reduce_while(0, fn pid, prev_output ->
      case amplifier_step(pid, prev_output) do
        :halt ->
          {:halt, prev_output}

        output ->
          {:cont, output}
      end
    end)
  end

  def start_amplifier(phase_setting) do
    program = File.read!("lib/day7/input.txt") |> String.trim()
    # part 1 examples:
    # program = "3,15,3,16,1002,16,10,16,1,16,15,15,4,15,99,0,0"
    # program = "3,23,3,24,1002,24,10,24,1002,23,-1,23,101,5,23,23,1,24,23,23,4,23,99,0,0"
    # program =
    # "3,31,3,32,1002,32,10,32,1001,31,-2,31,1007,31,0,33,1002,33,7,33,1,33,31,31,1,32,31,31,4,31,99,0,0,0"
    # part 2 examples:
    # program =
    #   "3,26,1001,26,-4,26,3,27,1002,27,2,27,1,27,26,27,4,27,1001,28,-1,28,1005,28,6,99,0,0,5"
    # program =
    #   "3,52,1001,52,-5,52,3,53,1,52,56,54,1007,54,5,55,1005,55,26,1001,54,-5,54,1105,1,12,1,53,54,53,1008,54,0,55,1001,55,1,55,2,53,55,53,4,53,1001,56,-1,56,1005,56,6,99,0,0,0,0,10"

    program =
      program
      |> String.split(",")
      |> Enum.map(&String.to_integer/1)

    parent = self()

    pid =
      spawn(fn ->
        Day5.run(program, parent)
      end)

    receive do
      {:in, ^pid} -> send(pid, {:in, phase_setting})
    end

    pid
  end

  def amplifier_step(pid, prev_output) do
    receive do
      {:in, ^pid} ->
        send(pid, {:in, prev_output})

        receive do
          {:out, ^pid, val} ->
            val

          {:halt, ^pid} ->
            :halt
        end

      {:halt, ^pid} ->
        :halt
    end
  end
end