defmodule Day12 do
  defmodule Input do
    def sample_data() do
      """
      Sabqponm
      abcryxxl
      accszExk
      acctuvwj
      abdefghi
      """
    end
    @neighbors [{-1, 0}, {1, 0}, {0, -1}, {0, 1}]

    def parse(input) do
      rows =
        input
        |> String.split("\n", trim: true)

      {row_len, col_len} = {length(rows), String.length(hd(rows))}

      rows
      |> populate_vertices()
      |> populate_edges(row_len - 1, col_len - 1)
    end

    defp populate_vertices(input_rows) do
      input_rows
      |> Enum.with_index()
      |> Enum.reduce({:digraph.new(), nil, nil}, fn {line, r}, {graph, start, stop} ->
        String.codepoints(line)
        |> Enum.with_index()
        |> Enum.reduce({graph, start, stop}, fn {<<val::utf8>>, c}, {g, begin, final} ->
          case val do
            83 ->
              :digraph.add_vertex(g, {c, r}, ?a)
              {g, {c, r}, final}

            69 ->
              :digraph.add_vertex(g, {c, r}, ?z)
              {g, begin, {c, r}}

            _ ->
              :digraph.add_vertex(g, {c, r}, val)
              {g, begin, final}
          end
        end)
      end)
    end

    defp populate_edges({graph, start, stop}, rows, cols) do
      edged_graph =
        for r <- 0..rows,
            c <- 0..cols,
            reduce: graph do
          graff ->
            {emanating_vertex, v1} = :digraph.vertex(graff, {c, r})

            @neighbors
            |> Enum.reduce(graff, fn {x, y}, gr ->
              incident = :digraph.vertex(graff, {c + x, r + y})

              case incident do
                {incident_vertex, v2} when v2 - v1 == 1 ->
                  :digraph.add_edge(gr, emanating_vertex, incident_vertex)
                  gr

                {incident_vertex, v2} when v2 - v1 <= 0 ->
                  :digraph.add_edge(gr, emanating_vertex, incident_vertex)
                  gr

                _ ->
                  gr
              end
            end)
        end

      {edged_graph, start, stop}
    end
  end

  def part1({graph, start, stop}) do
    :digraph.get_short_path(graph, start, stop) |> Enum.count() |> Kernel.-(1)
  end

  def part2({graph, _start, stop}) do
    graph
    |> :digraph.vertices()
    |> Enum.filter(fn vertex -> {vertex, ?a} == :digraph.vertex(graph, vertex) end)
    |> Enum.map(fn starter -> :digraph.get_short_path(graph, starter, stop) end)
    |> Enum.filter(& &1)
    |> Enum.map(fn path -> Enum.count(path) - 1 end)
    |> Enum.min()
  end