// package org.gerweck.scalafx.akka

// import language.implicitConversions

// import scala.collection.mutable.{ Clearable, Growable }
// import scala.concurrent._
// import scala.concurrent.duration._
// import scala.util._

// import akka.{ Done, NotUsed }
// import akka.stream.Materializer
// import akka.stream.scaladsl._

// import scalafx.application.Platform.runLater
// import scalafx.beans.Observable
// import scalafx.beans.property._

// import org.gerweck.scalafx.util.FutureObservable

// trait AkkaFXCollections extends Any {
//   implicit def sourceToRichSource[A, B](source: Source[A, B]) = new AkkaFXCollections.RichSource(source)
// }

// object AkkaFXCollections {
//   def collectionWriterSink[A]
//         (buffer: Observable with Growable[A] with Clearable,
//          clearFirst: Boolean,
//          groupingSize: Int = 50, groupingTimeout: FiniteDuration = 100.milliseconds)
//       : Sink[A, Future[Done]] = {
//     sealed trait PopulateAction
//     case class InsertRows(data: Seq[A]) extends PopulateAction
//     case object ClearData extends PopulateAction

//     val grouping = {
//       Flow[A]
//         .groupedWithin(groupingSize, groupingTimeout)
//         .map(InsertRows)
//         .named("GroupInsertActions")
//     }

//     val clearData = {
//       if (clearFirst)
//         Source.single(ClearData)
//       else
//         Source.empty
//     }.named("OptionalClearAction")

//     val combinedSource: Flow[A, PopulateAction, NotUsed] = grouping.prepend(clearData)
//     combinedSource .toMat {
//       Sink .foreach[PopulateAction] {
//         case ClearData        => runLater { buffer.clear() }
//         case InsertRows(data) => runLater { buffer ++= data }
//       } .named("BufferWriter")
//     }(Keep.right)
//   }

//   class RichSource[A, B](val inner: Source[A, B]) extends AnyVal {
//     def populateCollection[C >: A]
//           (buffer: Observable with Growable[C] with Clearable,
//            clearFirst: Boolean,
//            groupingSize: Int = 50, groupingTimeout: FiniteDuration = 100.milliseconds)
//           (implicit mat: Materializer, ec: ExecutionContext)
//         : ReadOnlyObjectProperty[Option[Try[Done]]] = {

//       val sink = collectionWriterSink(buffer, clearFirst, groupingSize, groupingTimeout)

//       val graph = inner.toMat(sink)(Keep.right)

//       FutureObservable.ofTryOption(graph.run())
//     }
//   }
// }