import scala.concurrent.{Future, Promise}
import scala.util.{Failure, Random, Success}

import scala.concurrent.ExecutionContext.Implicits.global

object FutureTest {

  /** This immitates the BaseRecognizeCallback that you have. */
  trait BaseRecognizeCallback {
    def onTranscription(result: String): Unit
    def onFailure(exception: Throwable): Unit
  }

  /**
   * A function that computes the result asynchronously and informs the calling code through
   * a callback. In your case, this would be this 'recognizeUsingWebSocket'.
   * @param callback the function that will be called, when the result is available.
   */
  def recognizeUsingWebSocket(callback: BaseRecognizeCallback): Unit = {
    val randomSeconds = new Random().nextInt(5)

    println(s"Waiting randomly for $randomSeconds seconds")
    Thread.sleep(randomSeconds * 1000L)

    if (randomSeconds % 2 == 0) {
      callback.onFailure(new RuntimeException(s"Randomly Failed after $randomSeconds seconds"))
    } else {
      callback.onTranscription("Complete Success!")
    }
  }

  def getResultsLater(): Future[String] = {
    val maybeSolution = Promise[String]()

    val cb = new BaseRecognizeCallback {
      override def onTranscription(result: String): Unit =
        maybeSolution.complete(Success(result))

      override def onFailure(exception: Throwable): Unit =
        maybeSolution.complete(Failure(new RuntimeException("Error while doing complicated work!", exception)))
    }

    // now tell our asynchronous computation to compute the result
    recognizeUsingWebSocket(cb)

    // return the future result
    maybeSolution.future
  }

  /**
   * Just to make the example complete, here's the case where we don't have to wait.
   * @return future results.
   */
  def getImmediateResults(): Future[String] = {
    Future("This was quick!")
  }


  def main(args: Array[String]): Unit = {
    getResultsLater().onComplete {
      case Success(result) => println(s"This will only be executed once the future has succeeded: $result")
      case Failure(problem) => println(s"Desaster! ${problem.getMessage}")
    }

    getImmediateResults().onComplete {
      case Success(result) => println(s"$result")
      case Failure(problem) => println(s"This should never happen.. ;-) If it does, here's why: ${problem.getMessage}")
    }

  }

}