INF = Float::INFINITY

BOARD_ARRAY = [
  [INF, 1, 1, 0, INF,   1,   1],
  [INF, 1, 1, 1, 1,     1,   0],
  [INF, 1, 0, 1, INF, INF, INF],
  [1,   1, 1, 1, INF,   0,   1],
  [1,   0, 1, 1, INF,   0,   1]
]

BOARD_ARRAY_TEST = [
  [INF, 1, 1, 1, 1, 1, 0, INF,   1,   1],
  [INF, 1, 1, 1, 1, 1, 1, 1,     1,   0],
  [INF, 1, 0, 1, INF, INF, 1, 1, 1,  INF],
  [1,   1, 1, 1, 1, 1, 1, INF,   0,   1],
  [1,   0, 1, 1, 1, 1, 1, INF,   0,   1]
]

class Board
  attr_reader :cells, :width, :height

  def initialize(array_2d)
    @cells = build_cells(array_2d)
    @height = array_2d.size
    @width = array_2d[0].size
  end

  def render
    system("clear")

    puts "░" * (width + 2)
    cells.each_slice(width) do |line|
      puts "░" + line.join("") + "░"
    end
    puts "░" * (width + 2)
  end

  def find(conditions)
    cells.find do |cell|
      conditions.all? do |key, value|
        cell.send(key) == value
      end
    end
  end

  def fill
    render
    queue = cells.select { |cell| cell.type == :flag }

    while current_cell = queue.shift
      current_cell.editable_adjacent.each do |empty_cell|
        if empty_cell.value.nil? || empty_cell.value > current_cell.value + 1
          empty_cell.value = current_cell.value + 1
          render
          sleep 0.1
          queue << empty_cell
        end
      end
    end
  end

  private

  def build_cells(array_2d)
    array_2d.map.with_index do |line, y|
      line.map.with_index do |cell, x|
        Cell.new(board: self, x: x, y: y, value: cell)
      end
    end.flatten
  end
end

class Cell
  attr_reader :x, :y, :type
  attr_accessor :value

  def initialize(board:, x:, y:, value:)
    @board = board
    @x = x
    @y = y
    @type = infer_type(value)
    @value = value if type == :flag
  end

  def editable_adjacent
    adjacent.select { |cell| cell.type == :empty }
  end

  def to_s
    case type
    when :empty
      value ? value.to_s : " "
    when :flag
      "*"
    when :wall
      "░"
    end
  end

  private

  attr_reader :board

  def infer_type(value)
    case value
    when Float::INFINITY
      :wall
    when 0
      :flag
    when 1
      :empty
    end
  end

  def adjacent
    [
      board.find(x: x - 1, y: y - 1),
      board.find(x: x, y: y - 1),
      board.find(x: x + 1, y: y - 1),
      board.find(x: x - 1, y: y),
      board.find(x: x + 1, y: y),
      board.find(x: x - 1, y: y + 1),
      board.find(x: x, y: y + 1),
      board.find(x: x + 1, y: y + 1)
    ].compact
  end
end


board = Board.new(BOARD_ARRAY_TEST)
board.fill