object Reddit142 {

  sealed trait Material
  case object Rock extends Material  { override def toString() = "#" }
  case object Sand extends Material  { override def toString() = "." }
  case object Space extends Material { override def toString() = " " }

  type Line = List[Material]
  val Elements = List(Rock, Space, Space, Space)

  def main(args: Array[String]) {
   val grid = generateMap(10,10)
   val result = activateGravity(grid)
   println("Original Grid\n" + "="*20)
   grid map ( x => println(x mkString "" ))
   println("Resulting Grid\n" + "="*20)
   result map ( x => println(x mkString "" ))

  }


  def generateMap(x: Int, y: Int): List[Line] = {
    @tailrec
    def generateMapR(x: Int, y: Int, lines: List[Line]): List[Line] = (x, y) match {
      case (_, 0) => List.fill(x)(Sand) :: lines
      case (x, y) => generateMapR(x, y-1, (Random.shuffle(Elements flatMap (m => List.fill(x){ m })) take x) :: lines)
    }
    generateMapR(x, y, List())
  }

  def moveDown(above:Line, below: Line): (Line, Line) = {
    def moveDownR(above: Line, below: Line, result: Line): Line = (above, below) match {
      case(Nil, Nil)                       => result
      case(Sand :: aRest,  Space :: bRest) => moveDownR(aRest, bRest, result :+ Sand)
      case(_    :: aRest,  Rock :: bRest)  => moveDownR(aRest, bRest, result :+ Rock)
      case(_    :: aRest,  Space :: bRest) => moveDownR(aRest, bRest, result :+ Space)
      case(_,_) => throw new IllegalArgumentException
    }
    val newLine = moveDownR(above, below, List())
    val oldLine = above.zip(newLine) map {
      case(old,cur) =>
        if (old == Sand && cur == Rock) Sand
        else if (old == Sand && cur == Sand) Space
        else old
    }
    (oldLine, newLine)
  }

  def activateGravity(grid: List[Line]) = {
    val height = grid.size
    val widht = grid.head.size
    def activateGravityR(grid: List[Line], level: Int, result: List[Line], temp: Line): List[Line] = level match {
      case(y) if(y < height-1)=>
        val (validLine, nextLine) = moveDown(temp, grid(y+1))
        activateGravityR(grid, y+1, result :+ validLine, nextLine)
      case _ => result :+ temp
    }
    activateGravityR(grid, 0, List(), grid.head)
  }
}