servers/admin/app/controllers/Application.scala - predictionio - Git at Google

 package controllers

 import io.prediction.commons.Config
 import io.prediction.commons.settings._
 import io.prediction.commons.modeldata.ItemRecScores
 import io.prediction.commons.appdata.{ Users, Items, U2IActions }
 import io.prediction.output.AlgoOutputSelector

 import Helper.{ algoToJson, offlineEvalMetricToJson }
 import Helper.{ dateTimeToString, algoParamToString, offlineEvalSplitterParamToString }
 import Helper.{ getSimEvalStatus, getOfflineTuneStatus, createOfflineEval }

 import play.api._
 import play.api.mvc._
 import play.api.data._
 import play.api.data.Forms._
 import play.api.data.format.Formats._
 import play.api.data.validation.{ Constraints }
 import play.api.i18n.{ Messages, Lang }
 import play.api.libs.concurrent.Execution.Implicits._
 import play.api.libs.json.Json.toJson
 import play.api.libs.json.{ JsNull, JsArray, Json, JsValue, Writes, JsObject }
 import play.api.libs.ws.WS
 import play.api.Play.current
 import play.api.http

 import scala.concurrent.{ Await, Future }
 import scala.concurrent.duration._
 import scala.util.Random

 import com.github.nscala_time.time.Imports._
 import org.apache.commons.codec.digest.DigestUtils

 import Forms._

 /*
  * TODO:
  * - decodeURIComponent any GET custom param
  */

 /*
  * Backend of ControlPanel.
  * Pure REST APIs in JSON.
  */
 object Application extends Controller {
   /** PredictionIO Commons settings*/
   val config = new Config()
   val users = config.getSettingsUsers()
   val apps = config.getSettingsApps()
   val engines = config.getSettingsEngines()
   val engineInfos = config.getSettingsEngineInfos()
   val algos = config.getSettingsAlgos()
   val algoInfos = config.getSettingsAlgoInfos()
   val offlineEvalMetricInfos = config.getSettingsOfflineEvalMetricInfos()
   val offlineEvalSplitterInfos = config.getSettingsOfflineEvalSplitterInfos()
   val offlineEvals = config.getSettingsOfflineEvals()
   val offlineEvalMetrics = config.getSettingsOfflineEvalMetrics()
   val offlineEvalResults = config.getSettingsOfflineEvalResults()
   val offlineEvalSplitters = config.getSettingsOfflineEvalSplitters()
   val offlineTunes = config.getSettingsOfflineTunes()
   val paramGens = config.getSettingsParamGens()

   /** PredictionIO Commons modeldata */
   val itemRecScores = config.getModeldataItemRecScores()
   val itemSimScores = config.getModeldataItemSimScores()

   /** PredictionIO Commons modeldata */
   val trainingItemRecScores = config.getModeldataTrainingItemRecScores()
   val trainingItemSimScores = config.getModeldataTrainingItemSimScores()

   /** PredictionIO Commons appdata */
   val appDataUsers = config.getAppdataUsers()
   val appDataItems = config.getAppdataItems()
   val appDataU2IActions = config.getAppdataU2IActions()

   /** PredictionIO Commons training set appdata */
   val trainingSetUsers = config.getAppdataTrainingUsers()
   val trainingSetItems = config.getAppdataTrainingItems()
   val trainingSetU2IActions = config.getAppdataTrainingU2IActions()

   /** PredictionIO Commons validation set appdata */
   val validationSetUsers = config.getAppdataValidationUsers()
   val validationSetItems = config.getAppdataValidationItems()
   val validationSetU2IActions = config.getAppdataValidationU2IActions()

   /** PredictionIO Commons test set appdata */
   val testSetUsers = config.getAppdataTestUsers()
   val testSetItems = config.getAppdataTestItems()
   val testSetU2IActions = config.getAppdataTestU2IActions()

   /** Scheduler setting */
   val settingsSchedulerUrl = config.settingsSchedulerUrl

   /** PredictionIO Output */
   val algoOutputSelector = new AlgoOutputSelector(algos)

   /** misc */
   val nameRegex = """\b[a-zA-Z][a-zA-Z0-9_-]*\b""".r

   /** Play Framework security */
   def username(request: RequestHeader) = request.session.get(Security.username)

   def onUnauthorized(request: RequestHeader) = Forbidden(toJson(Map("message" -> toJson("Haven't signed in yet."))))

   def withAuth(f: => String => Request[AnyContent] => Result) = {
     Security.Authenticated(username, onUnauthorized) { user =>
       Action(request => f(user)(request))
     }
   }

   def withAuthAsync(f: => String => Request[AnyContent] => Future[SimpleResult]) = {
     Security.Authenticated(username, onUnauthorized) { user =>
       Action.async(request => f(user)(request))
     }
   }

   object WithUser {
     def apply(f: User => Request[AnyContent] => SimpleResult) = async { user =>
       implicit request =>
         Future.successful(f(user)(request))
     }

     def async(f: User => Request[AnyContent] => Future[SimpleResult]) = withAuthAsync { username =>
       implicit request =>
         users.getByEmail(username).map { user =>
           f(user)(request)
         }.getOrElse(Future.successful(onUnauthorized(request)))
     }
   }

   object WithApp {
     def apply(appid: Int)(f: (User, App) => Request[AnyContent] => SimpleResult) = async(appid) { (user, app) =>
       implicit request =>
         Future.successful(f(user, app)(request))
     }

     def async(appid: Int)(f: (User, App) => Request[AnyContent] => Future[SimpleResult]) = WithUser.async { user =>
       implicit request =>
         apps.getByIdAndUserid(appid, user.id).map { app =>
           f(user, app)(request)
         }.getOrElse(Future.successful(NotFound(Json.obj("message" -> s"Invalid appid ${appid}."))))
     }
   }

   object WithEngine {
     def apply(appid: Int, engineid: Int)(f: (User, App, Engine) => Request[AnyContent] => SimpleResult) = async(appid, engineid) {
       (user, app, eng) =>
         implicit request =>
           Future.successful(f(user, app, eng)(request))
     }

     def async(appid: Int, engineid: Int)(f: (User, App, Engine) => Request[AnyContent] => Future[SimpleResult]) = WithApp.async(appid) {
       (user, app) =>
         implicit request =>
           engines.getByIdAndAppid(engineid, appid).map { eng =>
             f(user, app, eng)(request)
           }.getOrElse(Future.successful(NotFound(Json.obj("message" -> s"Invalid engineid ${engineid}."))))
     }
   }

   object WithAlgo {
     def apply(appid: Int, engineid: Int, algoid: Int)(f: (User, App, Engine, Algo) => Request[AnyContent] => SimpleResult) = async(appid, engineid, algoid) {
       (user, app, eng, algo) =>
         implicit request =>
           Future.successful(f(user, app, eng, algo)(request))
     }

     def async(appid: Int, engineid: Int, algoid: Int)(f: (User, App, Engine, Algo) => Request[AnyContent] => Future[SimpleResult]) = WithEngine.async(appid, engineid) {
       (user, app, eng) =>
         implicit request =>
           algos.getByIdAndEngineid(algoid, engineid).map { algo =>
             f(user, app, eng, algo)(request)
           }.getOrElse(Future.successful(NotFound(Json.obj("message" -> s"Invalid algoid ${algoid}."))))
     }
   }

   object WithOfflineEval {
     def apply(appid: Int, engineid: Int, offlineevalid: Int)(f: (User, App, Engine, OfflineEval) => Request[AnyContent] => SimpleResult) = async(appid, engineid, offlineevalid) {
       (user, app, eng, eval) =>
         implicit request =>
           Future.successful(f(user, app, eng, eval)(request))
     }

     def async(appid: Int, engineid: Int, offlineevalid: Int)(f: (User, App, Engine, OfflineEval) => Request[AnyContent] => Future[SimpleResult]) = WithEngine.async(appid, engineid) {
       (user, app, eng) =>
         implicit request =>
           offlineEvals.getByIdAndEngineid(offlineevalid, engineid).map { eval =>
             f(user, app, eng, eval)(request)
           }.getOrElse(Future.successful(NotFound(Json.obj("message" -> s"Invalid offlineevalid ${offlineevalid}."))))
     }
   }

   private def md5password(password: String) = DigestUtils.md5Hex(password)

   /** Appkey Generation */
   def randomAlphanumeric(n: Int): String = {
     Random.alphanumeric.take(n).mkString
   }

   def showWeb() = Action {
     Ok(views.html.Web.index())
   }

   /* Serve Engines/Algorithms Static Files (avoid PlayFramework's Assets cache problem during development)*/
   def enginebase(path: String) = Action {
     Ok.sendFile(new java.io.File(Play.application.path, "/enginebase/" + path))
     //TODO: Fix Content-Disposition
   }

   def redirectToWeb = Action {
     Redirect("web/")
   }

   /* case class to json conversion */
   implicit val userWrites = new Writes[User] {
     /* note: do not return password */
     def writes(u: User): JsValue = {
       Json.obj(
         "id" -> u.id,
         "username" -> (u.firstName + u.lastName.map(" " + _).getOrElse("")),
         "email" -> u.email
       )
     }
   }

   /**
    * Authenticates user
    *
    * {{{
    * POST
    * JSON parameters:
    *   {
    *     "email" : <string>,
    *     "password" : <string>,
    *     "remember" : <optional string "on">
    *   }
    * JSON response:
    *   {
    *     "id" : <string>,
    *     "username" : <string>,
    *     "email" : <string>
    *   }
    * }}}
    *
    */
   def signin = Action { implicit request =>
     val loginForm = Form(
       tuple(
         "email" -> text,
         "password" -> text,
         "remember" -> optional(text)
       ) verifying ("Invalid email or password", result => result match {
           case (email, password, remember) => users.authenticateByEmail(email, md5password(password)) map { _ => true } getOrElse false
         })
     )

     loginForm.bindFromRequest.fold(
       formWithErrors => Forbidden(toJson(Map("message" -> toJson("Incorrect Email or Password.")))),
       form => {
         users.getByEmail(form._1).map(user =>
           Ok(Json.toJson(user)).withSession(Security.username -> user.email)
         ).getOrElse(
           InternalServerError(Json.obj("message" -> "Could not find your user account."))
         )
       }
     )
   }

   /**
    * Signs out
    *
    * {{{
    * POST
    * JSON parameters:
    *   None
    * JSON response:
    *   None
    * }}}
    */
   def signout = Action {
     Ok.withNewSession
   }

   /**
    * Returns authenticated user info
    * (from session cookie)
    *
    * {{{
    * GET
    * JSON parameters:
    *   None
    * JSON response:
    *   If authenticated
    *   OK
    *   {
    *     "id" : <string>,
    *     "username" : <string>,
    *     "email": <string>
    *   }
    *
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    * }}}
    */
   def getAuth = WithUser { user =>
     implicit request =>
       Ok(Json.toJson(user))
   }

   /**
    * Returns list of apps of the authenticated user
    *
    * {{{
    * GET
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If no app:
    *   No Content
    *
    *   If apps are found:
    *   OK
    *   [ { "id" : <appid int>,  "appname" : <string> },
    *     ...
    *   ]
    *
    * }}}
    */
   def getApplist = WithUser { user =>
     implicit request =>

       val userApps = apps.getByUserid(user.id)
       if (!userApps.hasNext) NoContent
       else {
         Ok(JsArray(userApps.map { app =>
           Json.obj("id" -> app.id, "appname" -> app.display)
         }.toSeq))
       }
   }

   /**
    * Returns the app details of this appid
    *
    * {{{
    * GET
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If app is not found:
    *   NotFound
    *   {
    *     "message" : "Invalid appid."
    *   }
    *
    *   If app is found:
    *   Ok
    *   {
    *     "id" : <appid int>,
    *     "updatedtime" : <string>,
    *     "userscount": <num of users int>
    *     "itemscount": <num of items int>
    *     "u2icount": <num of u2i Actions int>
    *     "apiurl": <url of API server, string>
    *     "appkey": <string>
    *   }
    * }}}
    *
    * @param id the App ID
    */
   def getAppDetails(id: Int) = WithApp(id) { (user, app) =>
     implicit request =>
       val numUsers = appDataUsers.countByAppid(app.id)
       val numItems = appDataItems.countByAppid(app.id)
       val numU2IActions = appDataU2IActions.countByAppid(app.id)
       Ok(Json.obj(
         "id" -> app.id,
         "updatedtime" -> dateTimeToString(DateTime.now),
         "userscount" -> numUsers,
         "itemscount" -> numItems,
         "u2icount" -> numU2IActions,
         "apiurl" -> "http://yourhost.com:123/appid12",
         "appkey" -> app.appkey
       ))
   }

   /**
    * Returns an app
    *
    * {{{
    * GET
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If app is found:
    *   Ok
    *   {
    *     "id" : <appid int>
    *     "appname" : <string>
    *   }
    *
    * }}}
    *
    * @param id the App ID
    */
   def getApp(id: Int) = WithApp(id) { (user, app) =>
     implicit request =>
       Ok(Json.obj(
         "id" -> app.id,
         "appname" -> app.display
       ))
   }

   /**
    * Create an app
    *
    * {{{
    * POST
    * JSON Parameters:
    *   {
    *     "appname" : <the new app name. string>
    *   }
    * JSON Response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If creation failed:
    *   BadRequest
    *   {
    *     "message" : "Invalid character for app name."
    *    }
    *
    *   If app is created:
    *   OK
    *   {
    *     "id" : <the appid of the created app. int>,
    *     "appname" : <string>
    *   }
    * }}}
    *
    */
   def createApp = WithUser { user =>
     implicit request =>

       val appForm = Form(single(
         "appname" -> nonEmptyText
       ))

       appForm.bindFromRequest.fold(
         formWithError => {
           val msg = formWithError.errors(0).message // extract 1st error message only
           BadRequest(toJson(Map("message" -> toJson(msg))))
         },
         formData => {
           val an = formData
           val appid = apps.insert(App(
             id = 0,
             userid = user.id,
             appkey = randomAlphanumeric(64),
             display = an,
             url = None,
             cat = None,
             desc = None,
             timezone = "UTC"
           ))
           Logger.info("Create app ID " + appid)

           Ok(Json.obj(
             "id" -> appid,
             "appname" -> an
           ))
         }
       )
   }

   /**
    * Remove an app
    *
    * {{{
    * DELETE
    * JSON Parameters:
    *   None
    * JSON Response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If not found:
    *   NotFound
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If error:
    *   InternalServerError
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If deleted successfully:
    *   Ok
    * }}}
    *
    * @param id the App ID
    */
   def removeApp(id: Int) = WithApp.async(id) { (user, app) =>
     implicit request =>

       // don't delete if there is any deployed aglo, sim eval or offline tune pending
       val appEngines = engines.getByAppid(app.id).toList

       val enginesDeployed = appEngines.filter(eng =>
         !(algos.getDeployedByEngineid(eng.id).isEmpty)
       )
       val msgDeployed = "There are deployed algorithms in engines: " + enginesDeployed.map(_.name).mkString(", ") + ". Please undeploy them before delete this app."

       val enginesSimEvals = appEngines.filter(eng =>
         !(Helper.getSimEvalsByEngineid(eng.id).filter(Helper.isPendingSimEval(_)).isEmpty)
       )
       val msgSimEvals = "There are running simulated evaluations in engines: " + enginesSimEvals.map(_.name).mkString(", ") + ". Please stop and delete them before delete this app."

       val enginesOfflineTunes = appEngines.filter(eng =>
         !(offlineTunes.getByEngineid(eng.id).filter(Helper.isPendingOfflineTune(_)).isEmpty)
       )
       val msgOfflineTunes = "There are auto-tuning algorithms in engines: " + enginesOfflineTunes.map(_.name).mkString(", ") + ". Please stop and delete them before delete this app."

       val runningEngines = List(
         (enginesDeployed, msgDeployed),
         (enginesSimEvals, msgSimEvals),
         (enginesOfflineTunes, msgOfflineTunes)
       ).filter { case (x, y) => (!x.isEmpty) }

       if (!runningEngines.isEmpty) {
         val msg = runningEngines.map { case (x, y) => y }.mkString(" ")
         concurrent.Future(Forbidden(Json.obj("message" -> msg)))
       } else {

         val timeout = play.api.libs.concurrent.Promise.timeout("Scheduler is unreachable. Giving up.", concurrent.duration.Duration(10, concurrent.duration.MINUTES))
         val delete = Helper.deleteAppScheduler(app.id)

         concurrent.Future.firstCompletedOf(Seq(delete, timeout)).map {
           case r: SimpleResult => {
             if (r.header.status == http.Status.OK) {
               Helper.deleteApp(id, user.id, keepSettings = false)
             }
             r
           }
           case t: String => InternalServerError(Json.obj("message" -> t))
         }
       }
   }

   /**
    * Erase appdata of this appid
    *
    * {{{
    * POST
    * JSON Parameters:
    *   None
    * JSON Response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If erased successfully:
    *   Ok
    * }}}
    *
    * @param id the App ID
    */
   def eraseAppData(id: Int) = WithApp.async(id) { (user, app) =>
     implicit request =>

       val timeout = play.api.libs.concurrent.Promise.timeout("Scheduler is unreachable. Giving up.", concurrent.duration.Duration(10, concurrent.duration.MINUTES))
       val delete = Helper.deleteAppScheduler(app.id)

       concurrent.Future.firstCompletedOf(Seq(delete, timeout)).map {
         case r: SimpleResult => {
           if (r.header.status == http.Status.OK) {
             Helper.deleteApp(id, user.id, keepSettings = true)
           }
           r
         }
         case t: String => InternalServerError(Json.obj("message" -> t))
       }
   }

   /**
    * Returns a list of available engine infos in the system
    *
    * {{{
    * GET
    * JSON Parameters:
    *   None
    * JSON Response:
    *   Ok
    *   [ { "id" : <engine info id stirng>,
    *       "engineinfoname" : <name of the engine info>,
    *       "description": <description in html string>
    *     },
    *     ...
    *   ]
    * }}}
    */
   def getEngineInfoList = Action {
     Ok(JsArray(engineInfos.getAll() map {
       eng =>
         Json.obj(
           "id" -> eng.id,
           "engineinfoname" -> eng.name,
           "description" -> eng.description
         )
     }))
   }

   /**
    * Returns a list of available algo infos of a specific engine info
    *
    * {{{
    * GET
    * JSON Parameters:
    *   None
    * JSON Response:
    *   If the engine info id is not found:
    *   InternalServerError
    *   {
    *     "message" : "Invalid EngineInfo ID."
    *   }
    *
    *   If found:
    *   Ok
    *   { "engineinfoname" : <the name of the engine info>,
    *     "algotypelist" : [ { "id" : <algo info id>,
    *                          "algoinfoname" : <name of the algo info>,
    *                          "description" : <string>,
    *                          "req" : [<technology requirement string>],
    *                          "datareq" : [<data requirement string>]
    *                        }, ...
    *                      ]
    *   }
    * }}}
    *
    * @param id the engine info id
    */
   def getEngineInfoAlgoInfoList(id: String) = Action {
     engineInfos.get(id) map { engineInfo =>
       Ok(Json.obj(
         "engineinfoname" -> engineInfo.name,
         "algotypelist" -> JsArray(
           algoInfos.getByEngineInfoId(id).map { algoInfo =>
             Json.obj(
               "id" -> algoInfo.id,
               "algoinfoname" -> algoInfo.name,
               "description" -> algoInfo.description.getOrElse[String](""),
               "req" -> Json.toJson(algoInfo.techreq),
               "datareq" -> Json.toJson(algoInfo.datareq)
             )
           }
         )
       ))
     } getOrElse InternalServerError(Json.obj("message" -> s"Invalid EngineInfo ID: ${id}."))
   }

   /**
    * Returns a list of available metric infos of a specific engine info
    *
    * {{{
    * GET
    * JSON Parameters:
    *   None
    * JSON Response:
    *   If the engine info id is not found:
    *   InternalServerError
    *   {
    *     "message" : "Invalid EngineInfo ID."
    *   }
    *
    *   If found:
    *   Ok
    *   { "engineinfoname" : <the name of the engine info>,
    *     "defaultmetric" : <default metric info id>,
    *     "metricslist" : [ { "id" : <metric info id>,
    *                         "name" : <short name of the metric info>,
    *                         "description" : <long name of the metric info>,
    *                       }, ...
    *                     ]
    *   }
    * }}}
    *
    * @param id the engine info id
    */
   def getEngineInfoMetricInfoList(id: String) = Action {
     engineInfos.get(id) map { engInfo =>
       val metrics = offlineEvalMetricInfos.getByEngineinfoid(engInfo.id).map { m =>
         Json.obj(
           "id" -> m.id,
           "name" -> m.name,
           "description" -> m.description
         )
       }
       Ok(Json.obj(
         "engineinfoname" -> engInfo.name,
         "defaultmetric" -> engInfo.defaultofflineevalmetricinfoid,
         "metricslist" -> JsArray(metrics)
       ))
     } getOrElse {
       InternalServerError(Json.obj("message" -> s"Invalid engineinfo ID: ${id}."))
     }
   }

   /**
    * Returns a list of available splitter infos of a specific engine info
    *
    * {{{
    * GET
    * JSON Parameters:
    *   None
    * JSON Response:
    *   If the engine info id is not found:
    *   InternalServerError
    *   {
    *     "message" : "Invalid EngineInfo ID."
    *   }
    *
    *   If found:
    *   Ok
    *   { "engineinfoname" : <the name of the engine info>,
    *     "defaultsplitter": <default splitter info id>,
    *     "splitterlist" : [ { "id" : <splitter info id>,
    *                          "name" : <name of splitter>,
    *                          "description" : <splitter description>,
    *                       }, ...
    *                     ]
    *   }
    * }}}
    *
    * @param id the engine info id
    */
   def getEngineInfoSplitterInfoList(id: String) = Action {
     engineInfos.get(id).map { engInfo =>
       val splitters = offlineEvalSplitterInfos.getByEngineinfoid(engInfo.id).map { m =>
         Json.obj(
           "id" -> m.id,
           "name" -> m.name,
           "description" -> m.description
         )
       }
       Ok(Json.obj(
         "engineinfoname" -> engInfo.name,
         "defaultsplitter" -> engInfo.defaultofflineevalsplitterinfoid,
         "splitterlist" -> JsArray(splitters)
       ))
     }.getOrElse {
       InternalServerError(Json.obj("message" -> s"Invalid engineinfo ID: ${id}."))
     }
   }

   /**
    * Returns list of engines of this appid
    *
    * {{{
    * GET
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If no engine:
    *   NoContent
    *
    *   If engines found:
    *   Ok
    *   {
    *     "id" : <appid int>,
    *     "enginelist" : [ { "id" : <engineid int>, "enginename" : <string>, "engineinfoid" : <string> },
    *                       ....,
    *                      { "id" : <engineid int>, "enginename" : <string>, "engineinfoid" : <string> } ]
    *
    *   }
    * }}}
    *
    * @param id the App ID
    */
   def getAppEnginelist(appid: Int) = WithApp(appid) { (user, app) =>
     implicit request =>

       val appEngines = engines.getByAppid(appid)

       if (!appEngines.hasNext) NoContent
       else
         Ok(Json.obj(
           "id" -> appid,
           "enginelist" -> JsArray(appEngines.map { eng =>
             Json.obj("id" -> eng.id, "enginename" -> eng.name, "engineinfoid" -> eng.infoid)
           }.toSeq)
         ))
   }

   /**
    * Returns the engine of this engineid
    *
    * {{{
    * GET
    * JSON Parameters:
    *   None
    * JSON Response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If engine not found:
    *   NotFound
    *   {
    *     "message" : "Invalid app id or engine id."
    *   }
    *
    *   If engine found:
    *   Ok
    *   {
    *     "id" : <engine id>,
    *     "engineinfoid" : <engine info id>,
    *     "enginename" : <engine name>,
    *     "enginestatus" : <engine status>
    *   }
    * }}}
    * @note engine status:
    *   noappdata
    *   nodeployedalgo
    *   firsttraining
    *   nomodeldata
    *   nomodeldatanoscheduler
    *   training
    *   running
    *   runningnoscheduler
    *
    * @param appid the App ID
    * @param id the engine ID
    */
   def getEngine(appid: Int, id: Int) = WithEngine(appid, id) { (user, app, eng) =>
     implicit request =>

       val modelDataExist: Boolean = eng.infoid match {
         case "itemrec" => try { itemRecScores.existByAlgo(algoOutputSelector.itemRecAlgoSelection(eng)) } catch { case e: RuntimeException => false }
         case "itemsim" => try { itemSimScores.existByAlgo(algoOutputSelector.itemSimAlgoSelection(eng)) } catch { case e: RuntimeException => false }
         case _ => false
       }
       val deployedAlgos = algos.getDeployedByEngineid(eng.id)
       val hasDeployedAlgo = deployedAlgos.hasNext
       val algo = if (deployedAlgos.hasNext) Some(deployedAlgos.next()) else None
       val engineStatus: String =
         if (appDataUsers.countByAppid(eng.appid) == 0 && appDataItems.countByAppid(eng.appid) == 0 && appDataU2IActions.countByAppid(eng.appid) == 0)
           "noappdata"
         else if (!hasDeployedAlgo)
           "nodeployedalgo"
         else if (!modelDataExist)
           try {
             (Await.result(WS.url(s"${settingsSchedulerUrl}/apps/${eng.appid}/engines/${eng.id}/algos/${algo.get.id}/status").get(), scala.concurrent.duration.Duration(5, SECONDS)).json \ "status").as[String] match {
               case "jobrunning" => "firsttraining"
               case _ => "nomodeldata"
             }
           } catch {
             case e: java.net.ConnectException => "nomodeldatanoscheduler"
           }
         else
           try {
             (Await.result(WS.url(s"${settingsSchedulerUrl}/apps/${eng.appid}/engines/${eng.id}/algos/${algo.get.id}/status").get(), scala.concurrent.duration.Duration(5, SECONDS)).json \ "status").as[String] match {
               case "jobrunning" => "training"
               case _ => "running"
             }
           } catch {
             case e: java.net.ConnectException => "runningnoscheduler"
           }
       Ok(Json.obj(
         "id" -> eng.id, // engine id
         "engineinfoid" -> eng.infoid,
         "appid" -> eng.appid,
         "enginename" -> eng.name,
         "enginestatus" -> engineStatus))
   }

   /**
    * Creates an Engine
    *
    * {{{
    * POST
    * JSON parameters:
    *   {
    *     "engineinfoid" : <engine info id>,
    *     "enginename" : <engine name>
    *   }
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   if invalid appid:
    *   NotFound
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If bad param:
    *   BadRequest
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If created:
    *   Ok
    *   {
    *     "id" : <new engine id>,
    *     "engineinfoid" : <engine info id>,
    *     "appid" : <app id>,
    *     "enginename" : <engine name>
    *   }
    *
    * }}}
    *
    * @param appid the App ID
    */
   def createEngine(appid: Int) = WithApp(appid) { (user, app) =>
     implicit request =>

       val supportedEngineTypes: Seq[String] = engineInfos.getAll() map { _.id }
       val enginenameConstraint = Constraints.pattern(nameRegex, "constraint.enginename", "Engine names should only contain alphanumerical characters, underscores, or dashes. The first character must be an alphabet.")

       val engineForm = Form(tuple(
         "engineinfoid" -> (text verifying ("This feature will be available soon.", e => supportedEngineTypes.contains(e))),
         "enginename" -> (text verifying ("Please name your engine.", enginename => enginename.length > 0)
           verifying enginenameConstraint)
       ) verifying ("Engine name must be unique.", f => !engines.existsByAppidAndName(appid, f._2))
         verifying ("Engine type is invalid.", f => engineInfos.get(f._1).map(_ => true).getOrElse(false)))

       engineForm.bindFromRequest.fold(
         formWithError => {
           val msg = formWithError.errors(0).message // extract 1st error message only
           BadRequest(toJson(Map("message" -> toJson(msg))))
         },
         formData => {
           val (enginetype, enginename) = formData
           val engineInfo = engineInfos.get(enginetype).get
           val engineId = engines.insert(Engine(
             id = -1,
             appid = appid,
             name = enginename,
             infoid = enginetype,
             itypes = None, // NOTE: default None (means all itypes)
             params = engineInfo.params.map(s => (s._2.id, s._2.defaultvalue))
           ))
           Logger.info("Create engine ID " + engineId)

           // automatically create default algo
           val defaultAlgoType = engineInfo.defaultalgoinfoid
           val params = algoInfos.get(defaultAlgoType).get.params.mapValues(_.defaultvalue)

           val defaultAlgo = Algo(
             id = -1,
             engineid = engineId,
             name = "Default-Algo",
             infoid = defaultAlgoType,
             command = "",
             params = params,
             settings = Map(), // no use for now
             modelset = false, // init value
             createtime = DateTime.now,
             updatetime = DateTime.now,
             status = "deployed", // this is default deployed algo
             offlineevalid = None,
             loop = None
           )

           val algoId = algos.insert(defaultAlgo)
           Logger.info("Create algo ID " + algoId)

           WS.url(settingsSchedulerUrl + "/users/" + user.id + "/sync").get()

           Ok(Json.obj(
             "id" -> engineId, // engine id
             "engineinfoid" -> enginetype,
             "appid" -> appid,
             "enginename" -> enginename))
         }
       )

   }

   /**
    * Removes an engine
    *
    * {{{
    * DELETE
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If deleted:
    *   Ok
    *
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    */
   def removeEngine(appid: Int, engineid: Int) = WithEngine.async(appid, engineid) { (user, app, eng) =>
     implicit request =>
       // don't delete if there is any sim eval and offline tune pending, or deployed algorithm
       val pendingSimEvals = Helper.getSimEvalsByEngineid(eng.id).filter(x => Helper.isPendingSimEval(x)).toList
       val pendingOfflineTunes = offlineTunes.getByEngineid(eng.id).filter(x => Helper.isPendingOfflineTune(x)).toList
       val deployedAlgos = algos.getDeployedByEngineid(eng.id).toList

       if (deployedAlgos.size != 0) {
         val names = deployedAlgos map (x => x.name) mkString (",")
         Future.successful(Forbidden(Json.obj("message" -> s"This engine has deployed algorithms (${names}). Please undeploy them before delete this engine.")))
       } else if (pendingSimEvals.size != 0) {
         Future.successful(Forbidden(Json.obj("message" -> "There are running simulated evaluations. Please stop and delete them before delete this engine.")))
       } else if (pendingOfflineTunes.size != 0) {
         Future.successful(Forbidden(Json.obj("message" -> "There are auto-tuning algorithms. Please stop and delete them before delete this engine.")))
       } else {
         /** Deletion could take a while */
         val timeout = play.api.libs.concurrent.Promise.timeout("Scheduler is unreachable. Giving up.", concurrent.duration.Duration(10, concurrent.duration.MINUTES))

         // to scheduler: delete engine
         val delete = Helper.deleteEngineScheduler(appid, engineid)

         concurrent.Future.firstCompletedOf(Seq(delete, timeout)).map {
           case r: SimpleResult => {
             if (r.header.status == http.Status.OK) {
               Helper.deleteEngine(engineid, appid, keepSettings = false)
             }
             r
           }
           case t: String => InternalServerError(Json.obj("message" -> t))
         }
       }
   }

   /**
    * Returns a list of available (added but not deployed) algorithms of this engine
    * {{{
    * GET
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If no algo:
    *   NoContent
    *
    *   If algos found:
    *   [ { see algoToJson
    *     }, ...
    *   ]
    * }}}
    * @note algo status
    *   TODO: add more info here...
    *
    * @param appid the App ID
    * @param engineid the engine ID
    */
   def getAvailableAlgoList(appid: Int, engineid: Int) = WithEngine(appid, engineid) { (user, app, eng) =>
     implicit request =>

       val engineAlgos = algos.getByEngineid(engineid).filter { Helper.isAvailableAlgo(_) }

       if (!engineAlgos.hasNext) NoContent
       else
         Ok(Json.toJson( // NOTE: only display algos which are not "deployed", nor "simeval"
           engineAlgos.map { algo =>
             val algoInfo = algoInfos.get(algo.infoid)
             algoToJson(algo, appid, algoInfo)
           }.toSeq
         ))
   }

   /**
    * Returns an available algorithm
    * {{{
    * GET
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If algo not found:
    *   NotFound
    *   {
    *     "message" : "Invalid app id, engine id or algo id."
    *   }
    *
    *   If found:
    *   Ok
    *   {
    *     see algoToJson
    *   }
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    * @param id the algo ID
    */
   def getAvailableAlgo(appid: Int, engineid: Int, id: Int) = WithAlgo(appid, engineid, id) { (user, app, eng, algo) =>
     implicit request =>
       algoInfos.get(algo.infoid).map { info =>
         Ok(algoToJson(algo, appid, Some(info)))
       }.getOrElse {
         InternalServerError(Json.obj("message" -> s"Algoinfo ${algo.infoid} not found."))
       }
   }

   /**
    * Creates an new algorithm
    * {{{
    * POST
    * JSON parameters:
    *   {
    *     "algoinfoid" : <algo info id>,
    *     "algoname" : <algo name>,
    *   }
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If invalid appid or engineid:
    *   NotFound
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If creation failed:
    *   BadRequest
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If created:
    *   Ok
    *   {
    *     see algoToJson
    *   }
    *
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    */
   def createAvailableAlgo(appid: Int, engineid: Int) = WithEngine(appid, engineid) { (user, app, eng) =>
     implicit request =>

       val supportedAlgoTypes: Seq[String] = algoInfos.getAll map { _.id }
       val algonameConstraint = Constraints.pattern(nameRegex, "constraint.algoname", "Algorithm names should only contain alphanumerical characters, underscores, or dashes. The first character must be an alphabet.")

       val createAlgoForm = Form(tuple(
         "algoinfoid" -> (nonEmptyText verifying ("This feature will be available soon.", t => supportedAlgoTypes.contains(t))),
         "algoname" -> (text verifying ("Please name your algo.", name => name.length > 0)
           verifying algonameConstraint) // same name constraint as engine
       ) verifying ("Algo name must be unique.", f => !algos.existsByEngineidAndName(engineid, f._2)))

       createAlgoForm.bindFromRequest.fold(
         formWithError => {
           val msg = formWithError.errors(0).message // extract 1st error message only
           BadRequest(toJson(Map("message" -> toJson(msg))))
         },
         formData => {
           val (algoType, algoName) = formData

           algoInfos.get(algoType).map { algoInfo =>

             val newAlgo = Algo(
               id = -1,
               engineid = engineid,
               name = algoName,
               infoid = algoType,
               command = "",
               params = algoInfo.params.mapValues(_.defaultvalue),
               settings = Map(), // no use for now
               modelset = false, // init value
               createtime = DateTime.now,
               updatetime = DateTime.now,
               status = "ready", // default status
               offlineevalid = None,
               loop = None
             )

             val algoId = algos.insert(newAlgo)
             Logger.info("Create algo ID " + algoId)

             Ok(algoToJson(newAlgo.copy(id = algoId), appid, Some(algoInfo)))
           }.getOrElse {
             InternalServerError(Json.obj("message" -> s"Algoinfo ${algoType} not found."))
           }
         }
       )
   }

   /**
    * Deletes an algorithm
    * {{{
    * DELETE
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If deleted:
    *   Ok
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    * @param id the algo ID
    */
   def removeAvailableAlgo(appid: Int, engineid: Int, id: Int) = WithAlgo.async(appid, engineid, id) { (user, app, eng, algo) =>
     implicit request =>
       /** Deletion could take a while */
       val timeout = play.api.libs.concurrent.Promise.timeout("Scheduler is unreachable. Giving up.", concurrent.duration.Duration(10, concurrent.duration.MINUTES))

       val deleteTune = algo.offlinetuneid map { tuneid =>
         offlineTunes.get(tuneid) map { tune =>
           /** Make sure to unset offline tune's creation time to prevent scheduler from picking up */
           offlineTunes.update(tune.copy(createtime = None))

           Helper.stopAndDeleteOfflineTuneScheduler(appid, engineid, tuneid)
         } getOrElse {
           concurrent.Future { Ok }
         }
       } getOrElse {
         concurrent.Future { Ok }
       }

       val deleteAlgo: concurrent.Future[SimpleResult] = Helper.deleteAlgoScheduler(appid, engineid, algo.id)

       val complete: concurrent.Future[SimpleResult] = concurrent.Future.reduce(Seq(deleteTune, deleteAlgo)) { (a, b) =>
         if (a.header.status != http.Status.OK) // keep the 1st error
           a
         else
           b
       }

       concurrent.Future.firstCompletedOf(Seq(complete, timeout)).map {
         case r: SimpleResult => {
           if (r.header.status == http.Status.OK) {
             algo.offlinetuneid map { tuneid =>
               Helper.deleteOfflineTune(tuneid, keepSettings = false)
             }
             Helper.deleteAlgo(algo.id, keepSettings = false)
           }
           r
         }
         case t: String => InternalServerError(Json.obj("message" -> t))
       }
   }

   /**
    * Returns a list of deployed algorithms
    * {{{
    * GET
    * JSON parameters:
    *   None
    * JSON repseon:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If no deployed algo:
    *   NoContent
    *
    *   If deployed algos found:
    *   {
    *     "updatedtime" : <TODO>,
    *     "status" : <TODO>,
    *     "algolist" : [ { see algoToJson
    *                    }, ...
    *                  ]
    *   }
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    */
   def getDeployedAlgoList(appid: Int, engineid: Int) = WithEngine(appid, engineid) { (user, app, eng) =>
     implicit request =>

       val deployedAlgos = algos.getDeployedByEngineid(engineid)

       if (!deployedAlgos.hasNext) NoContent
       else
         Ok(Json.obj(
           "updatedtime" -> "12-03-2012 12:32:12", // TODO: what's this time for?
           "status" -> "Running",
           "algolist" -> Json.toJson(deployedAlgos.map { algo =>
             val algoInfo = algoInfos.get(algo.infoid)
             algoToJson(algo, appid, algoInfo)
           }.toSeq)
         ))
   }

   /**
    * Deploys a list of algorithms (also undeploys any existing deployed algorithms)
    * The status of deployed algorithms change to "deployed"
    *
    * {{{
    * POST
    * JSON parameters:
    *   {
    *     "algoidlist" : [ array of algo ids ]
    *   }
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If any of the algo id is not valid:
    *   BadRequest
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If done:
    *   Ok
    *
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    */
   def algoDeploy(appid: Int, engineid: Int) = WithEngine(appid, engineid) { (user, app, eng) =>
     implicit request =>
       val deployForm = Form(
         "algoidlist" -> list(number)
       )
       deployForm.bindFromRequest.fold(
         formWithErrors => Ok,
         form => {
           val algoidList = form
           val algoList = algoidList.map(id => (id, algos.getByIdAndEngineid(id, engineid)))
           val invalidAlgos = algoList.filter {
             case (id, algoOpt) => algoOpt match {
               case None => true // not exist
               case Some(x) => (x.status != "ready") // not ready
             }
           }

           // make sure all algoids are valid
           if (!invalidAlgos.isEmpty) {
             val ids = invalidAlgos.map { case (id, algoOpt) => id }.mkString(", ")
             BadRequest(Json.obj("message" -> s"Invalid algo ids: ${ids}."))
           } else {
             algos.getDeployedByEngineid(engineid).foreach { algo =>
               algos.update(algo.copy(status = "ready"))
             }
             algoList.foreach {
               case (id, algoOpt) =>
                 // algoOpt can't be None because of invalidAlgos check
                 algos.update(algoOpt.get.copy(status = "deployed"))
             }
             WS.url(settingsSchedulerUrl + "/users/" + user.id + "/sync").get()
             Ok
           }
         }
       )
   }

   /**
    * Undeploys all deployed algorithms
    * {{{
    * POST
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If done:
    *   Ok
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    */
   def algoUndeploy(appid: Int, engineid: Int) = WithEngine(appid, engineid) { (user, app, eng) =>
     implicit request =>

       algos.getDeployedByEngineid(engineid) foreach { algo =>
         algos.update(algo.copy(status = "ready"))
       }
       WS.url(settingsSchedulerUrl + "/users/" + user.id + "/sync").get()
       Ok
   }

   /**
    * Requests to train model now
    * {{{
    * POST
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If error:
    *   InternalServerError
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If done:
    *   Ok
    *   {
    *     "message" : <message from scheduler>
    *   }
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    */
   def algoTrainNow(appid: Int, engineid: Int) = WithEngine.async(appid, engineid) { (user, app, eng) =>
     implicit request =>
       // No extra param required
       val timeout = play.api.libs.concurrent.Promise.timeout("Scheduler is unreachable. Giving up.", concurrent.duration.Duration(10, concurrent.duration.MINUTES))
       val request = WS.url(s"${settingsSchedulerUrl}/apps/${appid}/engines/${engineid}/trainoncenow").get() map { r =>
         Ok(Json.obj("message" -> (r.json \ "message").as[String]))
       } recover {
         case e: Exception => InternalServerError(Json.obj("message" -> e.getMessage()))
       }

       /** Detect timeout (10 minutes by default) */
       concurrent.Future.firstCompletedOf(Seq(request, timeout)).map {
         case r: SimpleResult => r
         case t: String => InternalServerError(Json.obj("message" -> t))
       }
   }

   /**
    * Returns a list of simulated evalulation for this engine
    *
    * {{{
    * GET
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If no sim evals:
    *   NoContent
    *
    *   If found:
    *   Ok
    *   [
    *     { "id" : <sim eval id>,
    *       "appid" : <app id>,
    *       "engineid" : <engine id>,
    *       "algolist" : [
    *                      { "id" : <algo id>,
    *                        "algoname" : <algo name>,
    *                        "appid" : <app id>,
    *                        "engineid" : <engine id>,
    *                        "algoinfoid" : <algo info id>,
    *                        "algoinfoname" : <algo info name>,
    *                        "settingsstring" : <algo setting string>
    *                      }, ...
    *                    ],
    *       "status" : <sim eval status>,
    *       "createtime" : <sim eval create time>,
    *       "endtime" : <sim eval end time>
    *     }, ...
    *   ]
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    */
   def getSimEvalList(appid: Int, engineid: Int) = WithEngine(appid, engineid) { (user, app, eng) =>
     implicit request =>

       // get offlineeval for this engine
       val engineOfflineEvals = Helper.getSimEvalsByEngineid(engineid)

       if (!engineOfflineEvals.hasNext) NoContent
       else {
         val resp = Json.toJson(

           engineOfflineEvals.map { eval =>

             val algolist = Json.toJson(
               algos.getByOfflineEvalid(eval.id).map { algo =>
                 val algoInfo = algoInfos.get(algo.infoid)
                 algoToJson(algo, appid, algoInfo, withParam = true)
               }.toSeq
             )

             val createtime = eval.createtime.map(dateTimeToString(_)).getOrElse("-")
             val starttime = eval.starttime.map(dateTimeToString(_)).getOrElse("-")
             val endtime = eval.endtime.map(dateTimeToString(_)).getOrElse("-")

             Json.obj(
               "id" -> eval.id,
               "appid" -> appid,
               "engineid" -> eval.engineid,
               "algolist" -> algolist,
               "status" -> getSimEvalStatus(eval),
               "createtime" -> createtime, // NOTE: use createtime here for test date
               "endtime" -> endtime
             )
           }.toSeq
         )
         Ok(resp)
       }
   }

   /**
    * Creates a simulated evalution
    *
    * {{{
    * POST
    * JSON parameters:
    *
    *  {
    *    "infoid[i]": <metric or splitter info id>
    *    "infotype[i]": <"offlineevalmetric" or "offlineevalsplitter">
    *    "other param [i]": <the parameter value for corresponding infoid[i]>
    *    "algo" : <list of algo ids to be evaluated>
    *    "splittrain": <training set split percentage 1 to 100>,
    *    "splittest": <test set split percentage 1 to 100>,
    *    "evaliteration": <number of iterations>
    *  }
    *
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If error:
    *   BadRequest
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If created:
    *   Ok
    *
    * }}}
    * @param appid the App ID
    * @param engineid the engine ID
    */
   def createSimEval(appid: Int, engineid: Int) = WithEngine(appid, engineid) { (user, app, eng) =>
     implicit request =>
       val simEvalForm = Form(tuple(
         "infoid" -> seqOfMapOfStringToAny,
         "algoids" -> list(number), // algo id
         "splittrain" -> number(1, 100),
         "splittest" -> number(1, 100),
         "evaliteration" -> (number verifying ("Number of Iteration must be greater than 0", x => (x > 0)))
       ))

       simEvalForm.bindFromRequest.fold(
         e => BadRequest(Json.obj("message" -> e.toString)),
         f => {
           val (params, algoids, splitTrain, splitTest, evalIteration) = f

           val metricList = params.filter(p => (p("infotype") == "offlineevalmetric")).map(p =>
             OfflineEvalMetric(
               id = 0,
               infoid = p("infoid").asInstanceOf[String],
               evalid = 0, // will be assigned later
               params = p - "infoid" - "infotype" // remove these keys from params
             )).toList

           // percentage param is standard for all splitter
           val percentageParam = Map(
             "trainingPercent" -> (splitTrain.toDouble / 100),
             "validationPercent" -> 0.0, // no validatoin set for sim eval
             "testPercent" -> (splitTest.toDouble / 100)
           )
           val splitterList = params.filter(p => (p("infotype") == "offlineevalsplitter")).map(p =>
             OfflineEvalSplitter(
               id = 0,
               evalid = 0, // will be assigned later
               name = "", // will be assigned later
               infoid = p("infoid").asInstanceOf[String],
               settings = p ++ percentageParam - "infoid" - "infotype" // remove these keys from params
             )).toList

           // get list of algo obj
           val optAlgos: List[Option[Algo]] = algoids.map { algos.get(_) }

           if (metricList.length == 0)
             BadRequest(Json.obj("message" -> "At least one metric is required."))
           else if (splitterList.length == 0)
             BadRequest(Json.obj("message" -> "One Splitter is required."))
           else if (splitterList.length > 1)
             BadRequest(Json.obj("message" -> "Multiple Splitters are not supported now."))
           else if (optAlgos.contains(None))
             BadRequest(Json.obj("message" -> "Invalid algo ids."))
           else {
             val algoList: List[Algo] = optAlgos.map(_.get) // NOTE: already check optAlgos does not contain None

             val evalid = createOfflineEval(eng, algoList, metricList, splitterList(0), evalIteration)

             WS.url(settingsSchedulerUrl + "/users/" + user.id + "/sync").get()

             Ok
           }
         }
       )
   }

   /**
    * Requests to stop and delete simulated evalution (including running/pending job)
    *
    * {{{
    * DELETE
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If not found:
    *   NotFound
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If error:
    *   InternalServerError
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If deleted:
    *   Ok
    *   {
    *      "message" : "Offline evaluation ID $id has been deleted"
    *   }
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    * @param id the offline evaluation ID
    *
    */
   def removeSimEval(appid: Int, engineid: Int, id: Int) = WithOfflineEval.async(appid, engineid, id) { (user, app, eng, oe) =>
     implicit request =>
       // remove algo, remove metric, remove offline eval
       /** Make sure to unset offline eval's creation time to prevent scheduler from picking up */
       offlineEvals.update(oe.copy(createtime = None))

       /** Deletion of app data and model data could take a while */
       val timeout = play.api.libs.concurrent.Promise.timeout("Scheduler is unreachable. Giving up.", concurrent.duration.Duration(10, concurrent.duration.MINUTES))

       val complete = Helper.stopAndDeleteSimEvalScheduler(appid, engineid, oe.id)

       /** Detect timeout (10 minutes by default) */
       concurrent.Future.firstCompletedOf(Seq(complete, timeout)).map {
         case r: SimpleResult => {
           if (r.header.status == http.Status.OK) {
             Helper.deleteOfflineEval(oe.id, keepSettings = false)
           }
           r
         }
         case t: String => InternalServerError(Json.obj("message" -> t))
       }
   }

   /**
    * Returns the simulated evaluation report
    *
    * {{{
    * GET
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If not found:
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If found:
    *   Ok
    *   {
    *     "id" : <sim eval id>,
    *     "appid" : <app id>,
    *     "engineid" : <engine id>,
    *     "algolist" : [
    *                    {
    *                      "id" : <algo id>,
    *                      "algoname" : <algo name>,
    *                      "appid" : <app id>,
    *                      "engineid" : <engine id>,
    *                      "algoinfoid" : <algo info id>,
    *                      "algoinfoname" : <algo info name>,
    *                      "settingsstring" : <algo setting string>
    *                    }, ...
    *                  ],
    *     "metricslist" : [
    *                       {
    *                         "id" : <metric id>,
    *                         "metricsinfoid" : <metric info id>,
    *                         "metricsname" : <metric info name>,
    *                         "settingsstring" : <metric setting string>
    *                       }, ...
    *                     ],
    *     "metricscorelist" : [
    *                           {
    *                             "algoid" : <algo id>,
    *                             "metricsid" : <metric id>,
    *                             "score" : <average score>
    *                           }, ...
    *                         ],
    *     "metricscoreiterationlist" : [
    *                                    [{
    *                                      "algoid" : <algo id>,
    *                                      "metricsid" : <metric id>,
    *                                      "score" : <score of 1st iteration>
    *                                     }, ...
    *                                    ],
    *                                    [{
    *                                      "algoid" : <algo id>,
    *                                      "metricsid" : <metric id>,
    *                                      "score" : <score of 2nd iteration>
    *                                     }, ...
    *                                    ],
    *                                  ],
    *     "splittrain" : <training set split percentage 1 to 100>,
    *     "splittest" : <test set split percentage 1 to 100>,
    *     "splittersettingsstring" : <splitter setting string>,
    *     "evaliteration" : <number of iterations>,
    *     "status" : <eval status>,
    *     "starttime" : <start time>,
    *     "endtime" : <end time>
    *   }
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    * @param id the offline evaluation ID
    */
   def getSimEvalReport(appid: Int, engineid: Int, id: Int) = WithOfflineEval(appid, engineid, id) { (user, app, eng, eval) =>
     implicit request =>

       val status = getSimEvalStatus(eval)

       val evalAlgos = algos.getByOfflineEvalid(eval.id).toArray

       val algolist = Json.toJson(
         evalAlgos.map { algo =>
           val algoInfo = algoInfos.get(algo.infoid)
           algoToJson(algo, appid, algoInfo, withParam = true)
         }.toSeq
       )

       val evalMetrics = offlineEvalMetrics.getByEvalid(eval.id).toArray

       val metricslist = Json.toJson(
         evalMetrics.map { metric =>
           val metricInfo = offlineEvalMetricInfos.get(metric.infoid)
           offlineEvalMetricToJson(metric, metricInfo, withParam = true)
         }.toSeq
       )

       val evalResults = offlineEvalResults.getByEvalid(eval.id).toArray

       val metricscorelist = Json.toJson(
         (for (algo <- evalAlgos; metric <- evalMetrics) yield {

           val results = evalResults
             .filter(x => ((x.metricid == metric.id) && (x.algoid == algo.id)))
             .map(x => x.score)

           val num = results.length
           val avg = if ((results.isEmpty) || (num != eval.iterations)) "N/A" else ((results.reduceLeft(_ + _) / num).toString)

           Json.obj(
             "algoid" -> algo.id,
             "metricsid" -> metric.id,
             "score" -> avg
           )
         }).toSeq
       )

       val metricscoreiterationlist = Json.toJson((for (i <- 1 to eval.iterations) yield {
         val defaultScore = (for (algo <- evalAlgos; metric <- evalMetrics) yield {
           ((algo.id, metric.id) -> "N/A") // default score
         }).toMap

         val evalScore = evalResults.filter(x => (x.iteration == i)).map(r =>
           ((r.algoid, r.metricid) -> r.score.toString)).toMap

         // overwrite defaultScore with evalScore
         (defaultScore ++ evalScore).map {
           case ((algoid, metricid), score) =>
             Json.obj("algoid" -> algoid, "metricsid" -> metricid, "score" -> score)
         }
       }).toSeq)

       val starttime = eval.starttime map (dateTimeToString(_)) getOrElse ("-")
       val endtime = eval.endtime map (dateTimeToString(_)) getOrElse ("-")

       // get splitter data
       val splitters = offlineEvalSplitters.getByEvalid(eval.id)

       if (splitters.hasNext) {
         val splitter = splitters.next

         val splitTrain = ((splitter.settings("trainingPercent").asInstanceOf[Double]) * 100).toInt
         val splitTest = ((splitter.settings("testPercent").asInstanceOf[Double]) * 100).toInt

         if (splitters.hasNext) {
           InternalServerError(Json.obj("message" -> s"More than one splitter found for this Offline Eval ID: ${eval.id}"))
         } else {
           Ok(Json.obj(
             "id" -> eval.id,
             "appid" -> appid,
             "engineid" -> eval.engineid,
             "algolist" -> algolist,
             "metricslist" -> metricslist,
             "metricscorelist" -> metricscorelist,
             "metricscoreiterationlist" -> metricscoreiterationlist,
             "splittrain" -> splitTrain,
             "splittest" -> splitTest,
             "splittersettingsstring" -> offlineEvalSplitterParamToString(splitter, offlineEvalSplitterInfos.get(splitter.infoid)),
             "evaliteration" -> eval.iterations,
             "status" -> status,
             "starttime" -> starttime,
             "endtime" -> endtime
           ))
         }
       } else {
         InternalServerError(Json.obj("message" -> s"No splitter found fo this Offline Eval ID ${eval.id}."))
       }

   }

   /**
    * Returns the algorithm auto tune report
    *
    * {{{
    * GET
    * JSON parameters:
    *   None
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If not found:
    *   NotFound
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If found:
    *   Ok
    *   {
    *     "id" : <original algo id>,
    *     "appid" : <app id>,
    *     "engineid" : <engine id>,
    *     "algo" : {
    *                "id" : <original algo id>,
    *                "algoname" : <algo name>,
    *                "appid" : <app id>,
    *                "engineid" : <engine id>,
    *                "algoinfoid" : <algo info id>,
    *                "algoinfoname" : <algo info name>,
    *                "settingsstring" : <algo setting string>
    *              },
    *     "metric" : {
    *                  "id" : <metric id>,
    *                  "metricsinfoid" : <metric info id>,
    *                  "metricsname" : <metric info name>,
    *                  "settingsstring" : <metric setting string>
    *                },
    *     "metricscorelist" : [
    *                           {
    *                             "algoautotuneid" : <tuned algo id>,
    *                             "algoinfoname" : <algo info name>,
    *                             "settingsstring" : <algo setting string>,
    *                             "score" : <average score>
    *                           }, ...
    *                         ],
    *     "metricscoreiterationlist" : [
    *                                    [ {
    *                                        "algoautotuneid" : <tuned algo id 1>,
    *                                        "algoinfoname" : <algo info name>,
    *                                        "settingsstring" : <algo setting string>,
    *                                        "score" : <score of 1st iteration for this tuned algo id>
    *                                      },
    *                                      {
    *                                        "algoautotuneid" : <tuned algo id 2>,
    *                                        "algoinfoname" : <algo info name>,
    *                                        "settingsstring" : <algo setting string>,
    *                                        "score" : <score of 1st iteration for this tuned algo id>
    *                                      }, ...
    *                                    ],
    *                                    [ {
    *                                        "algoautotuneid" : <tuned algo id 1>,
    *                                        "algoinfoname" : <algo info name>,
    *                                        "settingsstring" : <algo setting string>,
    *                                        "score" : <score of 2nd iteration for this tuned algo id>
    *                                      },
    *                                      {
    *                                        "algoautotuneid" : <tuned algo id 2>,
    *                                        "algoinfoname" : <algo info name>,
    *                                        "settingsstring" : <algo setting string>,
    *                                        "score" : <score of 2nd iteration for this tuned algo id>
    *                                      }, ...
    *                                    ], ...
    *                                  ],
    *     "splittrain" : <training set split percentage 1 to 100>,
    *     "splitvalidation" : <validation set split percentage 1 to 100>,
    *     "splittest" : <test set split percentage 1 to 100>,
    *     "splitmethod" : <split method string: randome, time>
    *     "splittersettingsstring" : <splitter setting string>,
    *     "evaliteration" : <number of iterations>,
    *     "status" : <auto tune status>,
    *     "starttime" : <start time>,
    *     "endtime" : <end time>
    *   }
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    * @param algoid the algo ID
    */
   def getAlgoAutotuningReport(appid: Int, engineid: Int, algoid: Int) = WithAlgo(appid, engineid, algoid) { (user, app, eng, algo) =>
     implicit request =>

       algo.offlinetuneid map { tuneid =>
         offlineTunes.get(tuneid) map { tune =>

           val algoInfo = algoInfos.get(algo.infoid)

           // get all offlineeval of this offlinetuneid
           val tuneOfflineEvals: Array[OfflineEval] = offlineEvals.getByTuneid(tuneid).toArray.sortBy(_.id)

           val tuneMetrics: Array[OfflineEvalMetric] = tuneOfflineEvals.flatMap { e => offlineEvalMetrics.getByEvalid(e.id) }

           val tuneSplitters: Array[OfflineEvalSplitter] = tuneOfflineEvals.flatMap { e => offlineEvalSplitters.getByEvalid(e.id) }

           // get all offlineeavlresults of each offlineevalid
           val tuneOfflineEvalResults: Array[OfflineEvalResult] = tuneOfflineEvals.flatMap { e => offlineEvalResults.getByEvalid(e.id) }

           // test set score
           val tuneOfflineEvalResultsTestSet: Array[OfflineEvalResult] = tuneOfflineEvalResults.filter(x => (x.splitset == "test"))

           val tuneOfflineEvalResultsTestSetAlgoidMap: Map[Int, Double] = tuneOfflineEvalResultsTestSet.map(x => (x.algoid -> x.score)).toMap

           // get all algos of each offlineevalid
           // note: this happen after getting all available offlineEvalResults,
           // so these retrieved algos may have more algo than those used in offlineEvalResults.
           val tuneAlgos: Array[Algo] = tuneOfflineEvals flatMap { e => algos.getByOfflineEvalid(e.id) }

           val tuneAlgosMap: Map[Int, Algo] = tuneAlgos.map { a => (a.id -> a) }.toMap

           // group by (loop, paramset)
           type AlgoGroupIndex = (Option[Int], Option[Int])

           val tuneAlgosGroup: Map[AlgoGroupIndex, Array[Algo]] = tuneAlgos.groupBy(a => (a.loop, a.paramset))

           // get param of each group
           val tuneAlgosGroupParams: Map[AlgoGroupIndex, (Int, String, String)] = tuneAlgosGroup.map {
             case (index, arrayOfAlgos) =>
               val tAlgo = arrayOfAlgos(0) // just take 1, all algos of this group will have same params
               val tAlgoInfo: Option[AlgoInfo] = algoInfos.get(tAlgo.infoid)
               val infoName = tAlgoInfo.map(_.name).getOrElse("Algo info ${tAlgo.infoid} not found")
               val settings = algoParamToString(tAlgo, tAlgoInfo)

               (index -> (tAlgo.id, settings, infoName))
           }

           // calculate avg
           val avgScores: Map[AlgoGroupIndex, String] = tuneAlgosGroup.mapValues { arrayOfAlgos =>
             // check if all scores available
             val allAvailable = arrayOfAlgos.map(algo => tuneOfflineEvalResultsTestSetAlgoidMap.contains(algo.id)).reduceLeft(_ && _)

             if (allAvailable) {
               val scores: Array[Double] = arrayOfAlgos.map(algo => tuneOfflineEvalResultsTestSetAlgoidMap(algo.id))

               (scores.sum / scores.size).toString
             } else {
               "N/A"
             }
           }

           val metricscorelist = avgScores.toSeq.sortBy(_._1).map {
             case (k, v) =>
               Json.obj(
                 "algoautotuneid" -> tuneAlgosGroupParams(k)._1,
                 "algoinfoname" -> tuneAlgosGroupParams(k)._3,
                 "settingsstring" -> tuneAlgosGroupParams(k)._2,
                 "score" -> v)
           }

           val metricscoreiterationlist = tuneOfflineEvals.map { e =>
             tuneOfflineEvalResultsTestSet.filter(x => (x.evalid == e.id)).sortBy(_.algoid).map { r =>

               val tAlgo = tuneAlgosMap(r.algoid)
               val tAlgoInfo: Option[AlgoInfo] = algoInfos.get(tAlgo.infoid)
               val infoName = tAlgoInfo.map(_.name).getOrElse("Algo info ${tAlgo.infoid} not found")

               Json.obj(
                 "algoautotuneid" -> r.algoid,
                 "algoinfoname" -> infoName,
                 "settingsstring" -> algoParamToString(tAlgo, tAlgoInfo),
                 "score" -> r.score)
             }.toSeq
           }.toSeq

           val metric = tuneMetrics(0)
           val metricInfo = offlineEvalMetricInfos.get(metric.infoid)
           val splitter = tuneSplitters(0)
           val splitTrain = ((splitter.settings("trainingPercent").asInstanceOf[Double]) * 100).toInt
           val splitValidation = ((splitter.settings("validationPercent").asInstanceOf[Double]) * 100).toInt
           val splitTest = ((splitter.settings("testPercent").asInstanceOf[Double]) * 100).toInt
           val evalIteration = tuneOfflineEvals.size // NOTE: for autotune, number of offline eval is the iteration
           val engineinfoid = engines.get(engineid) map { _.infoid } getOrElse { "unkown-engine" }

           val starttime = tune.starttime map (dateTimeToString(_)) getOrElse ("-")
           val endtime = tune.endtime map (dateTimeToString(_)) getOrElse ("-")

           Ok(Json.obj(
             "id" -> algoid,
             "appid" -> appid,
             "engineid" -> engineid,
             "algo" -> algoToJson(algo, appid, algoInfo, withParam = true),
             "metric" -> offlineEvalMetricToJson(metric, metricInfo, withParam = true),
             "metricscorelist" -> Json.toJson(metricscorelist),
             "metricscoreiterationlist" -> Json.toJson(metricscoreiterationlist),
             "splittrain" -> splitTrain,
             "splitvalidation" -> splitValidation,
             "splittest" -> splitTest,
             "splittersettingsstring" -> offlineEvalSplitterParamToString(splitter, offlineEvalSplitterInfos.get(splitter.infoid)),
             "evaliteration" -> evalIteration,
             "status" -> getOfflineTuneStatus(tune),
             "starttime" -> starttime,
             "endtime" -> endtime
           ))
         } getOrElse {
           InternalServerError(Json.obj("message" -> s"The offline tune id ${tuneid} does not exist."))
         }
       } getOrElse {
         InternalServerError(Json.obj("message" -> "This algo does not have offline tune."))
       }
   }

   /**
    * Applies the selected tuned algo's params to this algo
    *
    * {{{
    * POST
    * JSON parameters:
    *   {
    *     "tunedalgoid" : <the tuned algo id. This algo's parameters will be used>
    *   }
    * JSON response:
    *   If not authenticated:
    *   Forbidden
    *   {
    *     "message" : "Haven't signed in yet."
    *   }
    *
    *   If error:
    *   BadRequest
    *   {
    *     "message" : <error message>
    *   }
    *
    *   If algo not found:
    *   NotFound
    *   {
    *     "message" : <error message>
    *   }
    *   If applied:
    *   Ok
    *
    * }}}
    *
    * @param appid the App ID
    * @param engineid the engine ID
    * @param algoid the algo ID to which the tuned parameters are applied
    */
   def algoAutotuningSelect(appid: Int, engineid: Int, algoid: Int) = WithAlgo(appid, engineid, algoid) { (user, app, eng, algo) =>
     implicit request =>

       // Apply POST request params of tunedalgoid to algoid
       // update the status of algoid from 'tuning' or 'tuned' to 'ready'

       val form = Form("tunedalgoid" -> number)

       form.bindFromRequest.fold(
         formWithError => {
           val msg = formWithError.errors(0).message // extract 1st error message only
           BadRequest(toJson(Map("message" -> toJson(msg))))
         },
         formData => {
           val tunedAlgoid = formData

           val orgAlgo = algos.get(algoid)
           val tunedAlgo = algos.get(tunedAlgoid)

           if ((orgAlgo == None) || (tunedAlgo == None)) {
             NotFound(toJson(Map("message" -> toJson("Invalid app id, engine id or algo id."))))
           } else {
             val tunedAlgoParams = tunedAlgo.get.params ++ Map("tune" -> "manual")
             algos.update(orgAlgo.get.copy(
               params = tunedAlgoParams,
               status = "ready"
             ))

             Ok
           }
         }
       )
   }

   def getEngineSettings(appid: Int, engineid: Int) = WithEngine(appid, engineid) { (user, app, engine) =>
     implicit request =>
       engineInfos.get(engine.infoid) map { engineInfo =>
         val params = engineInfo.params.mapValues(_.defaultvalue) ++ engine.params

         Ok(toJson(Map(
           "id" -> toJson(engine.id), // engine id
           "appid" -> toJson(engine.appid),
           "allitemtypes" -> toJson(engine.itypes == None),
           "itemtypelist" -> engine.itypes.map(x => toJson(x.toIterator.toSeq)).getOrElse(JsNull)) ++
           (params map { case (k, v) => (k, toJson(v.toString)) })))
       } getOrElse {
         NotFound(toJson(Map("message" -> toJson(s"Invalid EngineInfo ID: ${engine.infoid}"))))
       }
   }

   def updateEngineSettings(appid: Int, engineid: Int) = WithEngine(appid, engineid) { (user, app, engine) =>
     implicit request =>
       val f = Form(tuple(
         "infoid" -> mapOfStringToAny,
         "allitemtypes" -> boolean,
         "itemtypelist" -> list(text)))
       f.bindFromRequest.fold(
         e => BadRequest(toJson(Map("message" -> toJson(e.toString)))),
         f => {
           val (params, allitemtypes, itemtypelist) = f
           // NOTE: read-modify-write the original param
           val itypes = if (itemtypelist.isEmpty) None else Option(itemtypelist)
           val updatedParams = engine.params ++ params - "infoid"
           val updatedEngine = engine.copy(itypes = itypes, params = updatedParams)
           engines.update(updatedEngine)
           Ok
         })
   }

   def getEngineTemplateHtml(appid: Int, engineid: Int) = WithEngine(appid, engineid) { (user, app, engine) =>
     implicit request =>
       //Ok(views.html.engines.template(engine.infoid))
       engineInfos.get(engine.infoid) map { engineInfo =>
         if (engineInfo.paramsections.isEmpty)
           Ok(views.html.engines.template(handleParamSections[EngineInfo](Seq(ParamSection(
             name = "Parameter Settings",
             description = Some("No extra setting is required for this engine."))), engineInfo, 1), true))
         else
           Ok(views.html.engines.template(handleParamSections[EngineInfo](engineInfo.paramsections, engineInfo, 1), false))
       } getOrElse {
         NotFound(s"EngineInfo ID ${engine.infoid} not found")
       }
   }

   def getEngineTemplateJs(appid: Int, engineid: Int) = WithEngine(appid, engineid) { (user, app, engine) =>
     implicit request =>
       Ok(views.js.engines.template(engine.infoid, Seq()))
       engineInfos.get(engine.infoid) map { engineInfo =>
         Ok(views.js.engines.template(
           engineInfo.id,
           engineInfo.paramsections.map(collectParams(engineInfo, _)).foldLeft(Set[Param]())(_ ++ _).toSeq))
       } getOrElse {
         NotFound(s"EngineInfo ID ${engine.infoid} not found")
       }
   }

   def getAlgoSettings(appid: Int, engineid: Int, algoid: Int) = WithAlgo(appid, engineid, algoid) { (user, app, engine, algo) =>
     implicit request =>
       algoInfos.get(algo.infoid) map { algoInfo =>
         // get default params from algoinfo and combined with existing params
         val params = algoInfo.params.mapValues(_.defaultvalue) ++ algo.params

         Ok(toJson(Map(
           "id" -> toJson(algo.id),
           "appid" -> toJson(appid),
           "engineid" -> toJson(engineid)) ++
           (params map { case (k, v) => (k, toJson(v.toString)) })))
       } getOrElse {
         NotFound(toJson(Map("message" -> toJson(s"Invalid AlgoInfo ID: ${algo.infoid}"))))
       }
   }

   def updateAlgoSettings(appid: Int, engineid: Int, algoid: Int) = WithAlgo(appid, engineid, algoid) { (user, app, engine, algo) =>
     implicit request =>
       val f = Form(tuple("infoid" -> mapOfStringToAny, "tune" -> text, "tuneMethod" -> text))
       f.bindFromRequest.fold(
         e => BadRequest(toJson(Map("message" -> toJson(e.toString)))),
         bound => {
           val (params, tune, tuneMethod) = bound
           // NOTE: read-modify-write the original param
           val updatedParams = algo.params ++ params ++ Map("tune" -> tune, "tuneMethod" -> tuneMethod) - "infoid"
           val updatedAlgo = algo.copy(params = updatedParams)

           if (updatedParams("tune") != "auto") {
             algos.update(updatedAlgo)
             Ok
           } else {
             // create offline eval with baseline algo
             // TODO: get from UI
             val defaultBaseLineAlgoType = engine.infoid match {
               case "itemrec" => "pdio-randomrank"
               case "itemsim" => "pdio-itemsimrandomrank"
             }

             engineInfos.get(engine.infoid).map { engineInfo =>
               val metricinfoid = engineInfo.defaultofflineevalmetricinfoid // TODO: from UI
               val splitterinfoid = engineInfo.defaultofflineevalsplitterinfoid // TODO: from UI
               algoInfos.get(defaultBaseLineAlgoType).map { baseLineAlgoInfo =>
                 offlineEvalMetricInfos.get(metricinfoid).map { metricInfo =>
                   offlineEvalSplitterInfos.get(splitterinfoid).map { splitterInfo =>

                     // delete previous offlinetune stuff if the algo's offlinetuneid != None
                     if (updatedAlgo.offlinetuneid != None) {
                       val tuneid = updatedAlgo.offlinetuneid.get

                       offlineTunes.get(tuneid) map { tune =>
                         /** Make sure to unset offline tune's creation time to prevent scheduler from picking up */
                         offlineTunes.update(tune.copy(createtime = None))

                         // TODO: check scheduler err
                         Helper.stopAndDeleteOfflineTuneScheduler(appid.toInt, engineid.toInt, tuneid)
                         Future {
                           Helper.deleteOfflineTune(tuneid, keepSettings = false)
                         }
                       }
                     }

                     // auto tune
                     algos.update(updatedAlgo)

                     // create an OfflineTune and paramGen
                     val offlineTune = OfflineTune(
                       id = -1,
                       engineid = updatedAlgo.engineid,
                       loops = 5, // TODO: default 5 now
                       createtime = None, // NOTE: no createtime yet
                       starttime = None,
                       endtime = None
                     )

                     val tuneid = offlineTunes.insert(offlineTune)
                     Logger.info("Create offline tune ID " + tuneid)

                     paramGens.insert(ParamGen(
                       id = -1,
                       infoid = "random", // TODO: default random scan param gen now
                       tuneid = tuneid,
                       params = Map() // TODO: param for param gen
                     ))

                     // update original algo status to tuning
                     algos.update(updatedAlgo.copy(
                       offlinetuneid = Some(tuneid),
                       status = "tuning"
                     ))

                     val baseLineAlgo = Algo(
                       id = -1,
                       engineid = updatedAlgo.engineid,
                       name = "Default-BasedLine-Algo-for-OfflineTune-" + tuneid,
                       infoid = baseLineAlgoInfo.id,
                       command = "",
                       params = baseLineAlgoInfo.params.mapValues(_.defaultvalue),
                       settings = Map(), // no use for now
                       modelset = false, // init value
                       createtime = DateTime.now,
                       updatetime = DateTime.now,
                       status = "simeval",
                       offlineevalid = None,
                       offlinetuneid = Some(tuneid),
                       loop = Some(0), // loop=0 reserved for autotune baseline
                       paramset = None
                     )

                     val metric = OfflineEvalMetric(
                       id = 0,
                       infoid = metricInfo.id,
                       evalid = 0, // will be assigned later
                       params = metricInfo.params.mapValues(_.defaultvalue)
                     )

                     // percentage param is standard for all splitter
                     // TODO: hardcode percentage for auto tune for now. get from UI
                     val percentageParam = Map(
                       "trainingPercent" -> 0.55,
                       "validationPercent" -> 0.2,
                       "testPercent" -> 0.2
                     )

                     val splitter = OfflineEvalSplitter(
                       id = 0,
                       evalid = 0, // will be assigned later
                       name = "", // will be assigned later
                       infoid = splitterInfo.id,
                       settings = splitterInfo.params.mapValues(_.defaultvalue) ++ percentageParam
                     )

                     // TODO: get iterations, metric info, etc from UI, now hardcode to 3.
                     for (i <- 1 to 3) {
                       createOfflineEval(engine, List(baseLineAlgo), List(metric), splitter, 1, Some(tuneid))
                     }

                     // after everything has setup,
                     // update with createtime, so scheduler can know it's ready to be picked up
                     offlineTunes.update(offlineTune.copy(
                       id = tuneid,
                       createtime = Some(DateTime.now)
                     ))

                     // call sync to scheduler here
                     WS.url(settingsSchedulerUrl + "/users/" + user.id + "/sync").get()

                     Ok

                   }.getOrElse(InternalServerError(Json.obj("message" -> s"OfflineEvalSplitterInfo ID ${splitterinfoid} not found.")))
                 }.getOrElse(InternalServerError(Json.obj("message" -> s"OfflineEvalMetricInfo ID ${metricinfoid} not found.")))
               }.getOrElse(InternalServerError(Json.obj("message" -> s"AlgoInfo ID ${defaultBaseLineAlgoType} not found.")))
             }.getOrElse(InternalServerError(Json.obj("message" -> s"EngineInfo ID ${engine.infoid} not found.")))
           }
         })
   }

   def getAlgoTemplateHtml(appid: Int, engineid: Int, algoid: Int) = WithAlgo(appid, engineid, algoid) { (user, app, engine, algo) =>
     implicit request =>
       algoInfos.get(algo.infoid) map { algoInfo =>
         if (algoInfo.paramsections.isEmpty)
           Ok(views.html.algos.template(handleParamSections[AlgoInfo](Seq(ParamSection(
             name = "Parameter Settings",
             description = Some("No extra setting is required for this algorithm."))), algoInfo, 1), true))
         else
           Ok(views.html.algos.template(handleParamSections[AlgoInfo](algoInfo.paramsections, algoInfo, 1), false))
       } getOrElse {
         NotFound(s"AlgoInfo ID ${algo.infoid} not found")
       }
   }

   def getAlgoTemplateJs(appid: Int, engineid: Int, algoid: Int) = WithAlgo(appid, engineid, algoid) { (user, app, engine, algo) =>
     implicit request =>
       algoInfos.get(algo.infoid) map { algoInfo =>
         Ok(views.js.algos.template(
           algoInfo.id,
           algoInfo.paramsections.map(collectParams(algoInfo, _)).foldLeft(Set[Param]())(_ ++ _).toSeq,
           algoInfo.paramsections.map(collectParams(algoInfo, _, true)).foldLeft(Set[Param]())(_ ++ _).toSeq))
       } getOrElse {
         NotFound(s"AlgoInfo ID ${algo.infoid} not found")
       }
   }

   def getMetricInfoTemplateHtml(engineinfoid: String, metricinfoid: String) = WithUser { user =>
     implicit request =>
       offlineEvalMetricInfos.get(metricinfoid) map { metricInfo =>
         if (metricInfo.paramsections.isEmpty)
           Ok(views.html.metrics.template(handleParamSections[OfflineEvalMetricInfo](Seq(ParamSection(
             name = "Parameter Settings",
             description = Some("No extra setting is required for this metric."))), metricInfo, 1), true))
         else
           Ok(views.html.metrics.template(handleParamSections[OfflineEvalMetricInfo](metricInfo.paramsections, metricInfo, 1), false))
       } getOrElse {
         NotFound(s"OfflineEvalMetricInfo ID ${metricinfoid} not found")
       }
   }

   def getSplitterInfoTemplateHtml(engineinfoid: String, splitterinfoid: String) = WithUser { user =>
     implicit request =>
       offlineEvalSplitterInfos.get(splitterinfoid) map { splitterInfo =>
         if (splitterInfo.paramsections.isEmpty)
           Ok(views.html.splitters.template(handleParamSections[OfflineEvalSplitterInfo](Seq(ParamSection(
             name = "Parameter Settings",
             description = Some("No extra setting is required for this splitter."))), splitterInfo, 1), true))
         else
           Ok(views.html.splitters.template(handleParamSections[OfflineEvalSplitterInfo](splitterInfo.paramsections, splitterInfo, 1), false))
       } getOrElse {
         NotFound(s"OfflineEvalSplitterInfo ID ${splitterinfoid} not found")
       }
   }

   def collectParams[T <: Info](info: T, paramsection: ParamSection, tuning: Boolean = false): Set[Param] = {
     if (tuning)
       if (paramsection.sectiontype == "tuning")
         paramsection.params.map(_.map(info.params(_)).toSet).getOrElse(Set()) ++
           paramsection.subsections.map(_.map(collectParams(info, _, false)).reduce(_ ++ _)).getOrElse(Set())
       else
         paramsection.subsections.map(_.map(collectParams(info, _, tuning)).reduce(_ ++ _)).getOrElse(Set())
     else
       paramsection.params.map(_.map(info.params(_)).toSet).getOrElse(Set()) ++
         paramsection.subsections.map(_.map(collectParams(info, _, tuning)).reduce(_ ++ _)).getOrElse(Set())
   }

   def handleParam[T <: Info](param: Param, info: T, tuning: Boolean = false): String = {
     val content = param.ui.uitype match {
       case "selection" =>
         uiSelection[T](info, param.id, param.name, param.description, param.ui.selections.map(_.map(s => (s.name, s.value))).get, Some(param.defaultvalue.toString))
       case "slider" =>
         uiSlider[T](info, param.id, param.name, param.description)
       case _ =>
         if (tuning)
           uiTextPair[T](info, param.id + "Min", param.id + "Max", param.name, param.description)
         else
           uiText[T](info, param.id, param.name, param.description, Some(param.defaultvalue.toString))
     }
     content.toString
   }

   def handleParamSections[T <: Info](paramsections: Seq[ParamSection], info: T, level: Int, tuning: Boolean = false): String = {
     paramsections map { paramsection =>
       if (paramsection.sectiontype == "tuning")
         views.html.algos.sectionmanualauto(
           paramsection.name,
           handleParamSectionContent[T](paramsection, info, level),
           handleParamSectionContent[T](paramsection, info, level, true))
       else if (level > 1)
         uiSection2[T](info, paramsection.name, paramsection.description, handleParamSectionContent[T](paramsection, info, level, tuning))
       else
         uiSection1[T](info, paramsection.name, paramsection.description, handleParamSectionContent[T](paramsection, info, level, tuning))
     } mkString ""
   }

   def handleParamSectionContent[T <: Info](paramsection: ParamSection, info: T, level: Int, tuning: Boolean = false) = {
     paramsection.params.map(_.map(p => handleParam[T](info.params(p), info, tuning)).mkString).getOrElse("") +
       paramsection.subsections.map(handleParamSections[T](_, info, level + 1, tuning)).getOrElse("")
   }

   def uiText[T <: Info](info: T, id: String, name: String, description: Option[String], defaultValue: Option[String] = None) = {
     info match {
       case _: AlgoInfo =>
         views.html.algos.text(id, name, description)
       case _: EngineInfo =>
         views.html.engines.text(id, name, description)
       case _: OfflineEvalMetricInfo =>
         views.html.metrics.text(id, name, description, defaultValue)
       case _: OfflineEvalSplitterInfo =>
         views.html.splitters.text(id, name, description, defaultValue)
     }
   }

   def uiTextPair[T <: Info](info: T, id1: String, id2: String, name: String, description: Option[String]) = {
     views.html.algos.textpair(id1, id2, name, description)
   }

   def uiSlider[T <: Info](info: T, id: String, name: String, description: Option[String]) = {
     views.html.engines.slider(id, name, description)
   }

   def uiSelection[T <: Info](info: T, id: String, name: String, description: Option[String], selections: Seq[(String, String)], defaultValue: Option[String] = None) = {
     info match {
       case _: AlgoInfo =>
         views.html.algos.selection(id, name, description, selections)
       case _: EngineInfo =>
         views.html.engines.selection(id, name, description, selections)
       case _: OfflineEvalMetricInfo =>
         views.html.metrics.selection(id, name, description, selections, defaultValue)
       case _: OfflineEvalSplitterInfo =>
         views.html.splitters.selection(id, name, description, selections, defaultValue)
     }
   }

   def uiSection1[T <: Info](info: T, name: String, description: Option[String], content: String) = {
     info match {
       case _: AlgoInfo =>
         views.html.algos.section1(name, description, content)
       case _: EngineInfo =>
         views.html.engines.section1(name, description, content)
       case _: OfflineEvalMetricInfo =>
         views.html.metrics.section1(name, description, content)
       case _: OfflineEvalSplitterInfo =>
         views.html.splitters.section1(name, description, content)
     }
   }

   def uiSection2[T <: Info](info: T, name: String, description: Option[String], content: String) = {
     info match {
       case _: AlgoInfo =>
         views.html.algos.section2(name, description, content)
       case _: EngineInfo =>
         views.html.engines.section2(name, description, content)
       // OfflineEvalMetricInfo doesn't support section2
       // OfflineEvalSplitterInfo doesn't support section2
     }
   }
 }