/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.nlpcraft.server.rest

import akka.http.scaladsl.coding.Coders
import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
import akka.http.scaladsl.model.HttpMethods._
import akka.http.scaladsl.model._
import akka.http.scaladsl.model.headers._
import akka.http.scaladsl.server.Directives.{entity, _}
import akka.http.scaladsl.server._
import com.fasterxml.jackson.core.JsonProcessingException
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.scala.DefaultScalaModule
import com.typesafe.scalalogging.LazyLogging
import io.opencensus.stats.Measure
import io.opencensus.trace.{Span, Status}
import org.apache.commons.validator.routines.UrlValidator
import org.apache.nlpcraft.common.opencensus.NCOpenCensusTrace
import org.apache.nlpcraft.common.pool.NCThreadPoolManager
import org.apache.nlpcraft.common.util.NCUtils.{jsonToJavaMap, uncompress}
import org.apache.nlpcraft.common.{JavaMeta, NCE, U}
import org.apache.nlpcraft.model.NCModelView
import org.apache.nlpcraft.server.apicodes.NCApiStatusCode.{API_OK, _}
import org.apache.nlpcraft.server.company.NCCompanyManager
import org.apache.nlpcraft.server.feedback.NCFeedbackManager
import org.apache.nlpcraft.server.mdo.{NCQueryStateMdo, NCUserMdo}
import org.apache.nlpcraft.server.opencensus.NCOpenCensusServerStats
import org.apache.nlpcraft.server.probe.NCProbeManager
import org.apache.nlpcraft.server.query.NCQueryManager
import org.apache.nlpcraft.server.sugsyn.NCSuggestSynonymManager
import org.apache.nlpcraft.server.user.NCUserManager
import spray.json.DefaultJsonProtocol._
import spray.json.{JsObject, JsValue, RootJsonFormat}

import scala.concurrent.{ExecutionContext, Future}
import scala.jdk.CollectionConverters._

/**
  * REST API default implementation.
  */
class NCBasicRestApi extends NCRestApi with LazyLogging with NCOpenCensusTrace with NCOpenCensusServerStats {
    protected final val URL_VALIDATOR = new UrlValidator(Array("http", "https"), UrlValidator.ALLOW_LOCAL_URLS)

    final val API_VER = 1
    final val API = "api" / s"v$API_VER"
    /** */
    private final val CORS_HDRS = List(
        `Access-Control-Allow-Origin`.*,
        `Access-Control-Allow-Credentials`(true),
        `Access-Control-Allow-Headers`("Authorization", "Content-Type", "X-Requested-With")
    )

    private final val JS_MAPPER = new ObjectMapper()

    JS_MAPPER.registerModule(DefaultScalaModule)

    /*
     * General control exception.
     * Note that these classes must be public because scala 2.11 internal errors (compilations problems).
     */
    case class AccessTokenFailure(acsTkn: String) extends NCE(s"Unknown or expired access token: $acsTkn")
    case class SignInFailure(email: String) extends NCE(s"Invalid or unknown user email: $email")
    case class AdminRequired(email: String) extends NCE(s"Admin privileges required: $email")
    case class InvalidOperation(email: String) extends NCE(s"Invalid operation.")
    case class NotImplemented() extends NCE("Not implemented.")

    class InvalidArguments(msg: String) extends NCE(msg)
    case class OutOfRangeField(fn: String, from: Number, to: Number) extends InvalidArguments(s"Parameter ($fn) value is out of range ($from, $to).")
    case class TooLargeField(fn: String, max: Int) extends InvalidArguments(s"Parameter ($fn) value exceeded max length of $max.")
    case class InvalidField(fn: String) extends InvalidArguments(s"Parameter invalid: $fn")
    case class EmptyField(fn: String) extends InvalidArguments(s"Parameter cannot be empty: $fn")
    case class InvalidExternalUserId(usrExtId: String) extends InvalidArguments(s"External user ID is invalid or unknown: $usrExtId")
    case class InvalidUserId(id: Long) extends InvalidArguments(s"User ID is invalid or unknown: $id")
    case class InvalidModelId(id: String) extends InvalidArguments(s"Unknown model ID: $id")
    case class InvalidModelOrElementId(mdlId: String, elmId: String) extends InvalidArguments(s"Unknown model element ID: $elmId")

    case class AskReqHolder(
        usrId: Long,
        txt: String,
        mdlId: String,
        usrAgent: Option[String],
        rmtAddr: Option[String],
        data: Option[String],
        enableLog: Boolean,
        parent: Span
    )

    /*
     * Maximum length specification for frequently used standard REST parameters,
     */
    private final val STD_FIELD_LENGTHS = Map[String, Int](
        "srvReqId" -> 32,
        "mdlId" -> NCModelView.MODEL_ID_MAXLEN,
        "elmId" -> NCModelView.MODEL_ELEMENT_ID_MAXLEN,
        "country" -> 32,
        "postalCode" -> 32,

        "usrExtId" -> 64,
        "name" -> 64,
        "firstName" -> 64,
        "lastName" -> 64,
        "passwd" -> 64,
        "newPasswd" -> 64,
        "email" -> 64,
        "adminEmail" -> 64,
        "adminPasswd" -> 64,
        "adminFirstName" -> 64,
        "adminLastName" -> 64,

        "website" -> 256,
        "acsTok" -> 256,

        "city" -> 512,
        "region" -> 512,
        "address" -> 512,

        "txt" -> 1024,
        "comment" -> 1024,

        "avatarUrl" -> 512000,
        "adminAvatarUrl" -> 512000
    )

    /**
      *
      * @param o
      * @return
      */
    @throws[NCE]
    private def toJs(o: AnyRef): String =
        try
            JS_MAPPER.writeValueAsString(o)
        catch {
            case e: JsonProcessingException => throw new NCE(s"JSON serialization error.", e)
        }

    /**
      *
      * @param acsTkn Access token to check.
      * @param shouldBeAdmin Admin flag.
      * @return
      */
    @throws[NCE]
    private def authenticate0(acsTkn: String, shouldBeAdmin: Boolean): NCUserMdo =
        startScopedSpan("authenticate0", "acsTkn" -> acsTkn, "shouldBeAdmin" -> shouldBeAdmin) { span =>
            NCUserManager.getUserForAccessToken(acsTkn, span) match {
                case None => throw AccessTokenFailure(acsTkn)
                case Some(usr) =>
                    require(usr.email.isDefined)

                    if (shouldBeAdmin && !usr.isAdmin)
                        throw AdminRequired(usr.email.get)

                    usr
            }
        }

    /**
      *
      * @param rmtAddr
      * @return
      */
    private def getAddress(rmtAddr: RemoteAddress): Option[String] =
        rmtAddr.toOption match {
            // 127.0.0.1 used to avoid local addresses like 0:0:0:0:0:0:0:1 (IPv6)
            case Some(a) => Some(if (a.getHostName == "localhost") "127.0.0.1" else a.getHostAddress)
            case None => None
        }

    /**
      *
      * @param acsUsr
      * @param srvReqIdsOpt
      * @param usrIdOpt
      * @param usrExtIdOpt
      * @param span
      */
    @throws[AdminRequired]
    private def getRequests(
        acsUsr: NCUserMdo,
        srvReqIdsOpt: Option[Set[String]],
        usrIdOpt: Option[Long],
        usrExtIdOpt: Option[String],
        span: Span
    ): Set[NCQueryStateMdo] = {
        require(acsUsr.email.isDefined)

        val userId = getUserId(acsUsr, usrIdOpt, usrExtIdOpt)

        val states = srvReqIdsOpt match {
            case Some(srvReqIds) =>
                val states = NCQueryManager.getForServerRequestIds(srvReqIds, span)

                if (usrIdOpt.isDefined || usrExtIdOpt.isDefined) states.filter(_.userId == userId) else states
            case None => NCQueryManager.getForUserId(userId, span)
        }

        if (states.exists(_.companyId != acsUsr.companyId) || !acsUsr.isAdmin && states.exists(_.userId != acsUsr.id))
            throw AdminRequired(acsUsr.email.get)

        states
    }

    /**
      *
      * @param s  Query state MDO to convert to map.
      * @return
      */
    private def queryStateToMap(s: NCQueryStateMdo): java.util.Map[String, Any] =
        Map(
            "srvReqId" -> s.srvReqId,
            "txt" -> s.text,
            "usrId" -> s.userId,
            "mdlId" -> s.modelId,
            "probeId" -> s.probeId.orNull,
            "status" -> s.status,
            "resType" -> s.resultType.orNull,
            "resBody" -> (
                if (s.resultBody.isDefined &&
                    s.resultType.isDefined &&
                    s.resultType.get == "json"
                )
                    U.jsonToObject(s.resultBody.get)
                else
                    s.resultBody.orNull
                ),
            "resMeta" -> s.resultMeta.orNull,
            "error" -> s.error.orNull,
            "errorCode" -> s.errorCode.map(Integer.valueOf).orNull,
            "logHolder" -> (if (s.logJson.isDefined) U.jsonToObject(s.logJson.get) else null),
            "intentId" -> s.intentId.orNull
        ).filter(_._2 != null).asJava

    /**
      * Extracts and checks JSON.
      *
      * @param jsOpt JSON value. Optional.
      * @param name Property name.
      */
    @throws[TooLargeField]
    @throws[InvalidField]
    private def extractJson(jsOpt: Option[spray.json.JsValue], name: String): Option[String] =
        jsOpt match {
            case Some(js) =>
                val s = js.compactPrint

                checkLength(name, s, 512000)

                // Validates.
                try
                    U.jsonToJavaMap(s)
                catch {
                    case _: NCE => throw InvalidField(name)
                }

                Some(s)
            case None => None
        }

    /**
      *
      * @param r Route to CORS enable.
      */
    protected def corsHandler(r: Route): Route = respondWithHeaders(CORS_HDRS) {
        options {
            complete(HttpResponse(StatusCodes.OK).
                withHeaders(`Access-Control-Allow-Methods`(OPTIONS, POST, PUT, GET, DELETE)))
        } ~ r
    }

    /**
      * Checks operation permissions and gets user ID.
      *
      * @param acsUsr Currently signed-in user.
      * @param usrIdOpt User ID. Optional.
      * @param usrExtIdOpt User 'on-behalf-of' external ID. Optional.
      */
    @throws[AdminRequired]
    @throws[InvalidUserId]
    @throws[InvalidExternalUserId]
    protected def getUserId(
        acsUsr: NCUserMdo,
        usrIdOpt: Option[Long],
        usrExtIdOpt: Option[String]
    ): Long = {
        require(acsUsr.email.isDefined)

        val id1Opt = usrIdOpt match {
            case Some(userId) =>
                if (!acsUsr.isAdmin && userId != acsUsr.id)
                    throw AdminRequired(acsUsr.email.get)

                val usr = NCUserManager.getUserById(userId).getOrElse(throw InvalidUserId(userId))

                if (usr.companyId != acsUsr.companyId)
                    throw InvalidUserId(userId)

                Some(userId)

            case None => None
        }

        val id2Opt = usrExtIdOpt match {
            case Some(usrExtId) =>
                if (!acsUsr.isAdmin)
                    throw AdminRequired(acsUsr.email.get)

                Some(NCUserManager.getOrInsertExternalUserId(acsUsr.companyId, usrExtId))

            case None => None
        }

        if (id1Opt.isDefined && id2Opt.isDefined && id1Opt.get != id2Opt.get)
            throw new InvalidArguments("User ID and external user ID are inconsistent.")

        id1Opt.getOrElse(id2Opt.getOrElse(acsUsr.id))
    }

    /**
      *
      * @param acsTkn Access token to check.
      */
    @throws[NCE]
    protected def authenticate(acsTkn: String): NCUserMdo = authenticate0(acsTkn, shouldBeAdmin = false)

    /**
      *
      * @param acsTkn Access token to check.
      */
    @throws[NCE]
    protected def authenticateAsAdmin(acsTkn: String): NCUserMdo = authenticate0(acsTkn, shouldBeAdmin = true)

    /**
      *
      * @param mdlId
      * @param compId
      */
    @throws[InvalidField]
    protected def checkModelId(mdlId: String, compId: Long): Unit =
        if (!NCProbeManager.existsForModel(compId, mdlId))
            throw InvalidModelId(mdlId)

    /**
      * Checks length of field value.
      *
      * @param name Field name.
      * @param v Field value.
      * @param maxLen Optional maximum length. If not specified - the standard range for 'name' will be used.
      */
    @throws[TooLargeField]
    @throws[EmptyField]
    protected def checkLength(name: String, v: String, maxLen: Int = -1): Unit = {
        val max: Int =
            if (maxLen == -1)
                STD_FIELD_LENGTHS.
                    getOrElse(name, throw new AssertionError(s"Unknown standard REST field: $name"))
            else
                maxLen

        if (v.length > max)
            throw TooLargeField(name, max)
        else if (v.length < 1)
            throw EmptyField(name)
    }

    /**
      * Checks length of field value.
      *
      * @param name Field name.
      * @param v Field value.
      * @param maxLen Maximum length.
      */
    @throws[TooLargeField]
    @throws[EmptyField]
    def checkLengthOpt(name: String, v: Option[_], maxLen: Int = -1): Unit =
        if (v.isDefined)
            checkLength(name, v.get.toString, maxLen)

    /**
      *
      * @param pairs
      */
    @throws[TooLargeField]
    @throws[EmptyField]
    protected def checkLength(pairs: (String, Any)*): Unit =
        pairs.foreach {
            case (name, value: Option[_]) => checkLengthOpt(name, value)
            case (name, value: String) => checkLength(name, value)

            case _ => assert(false)
        }

    /**
      * Checks numeric range of field value.
      *
      * @param name Field name.
      * @param v Field value.
      * @param from Minimum from.
      * @param to Maximum to.
      */
    @throws[OutOfRangeField]
    protected def checkRange[T](name: String, v: T, from: T, to: T)(implicit e: T => Number): Unit = {
        val d = v.doubleValue()

        if (d < from.doubleValue() || d > to.doubleValue())
            throw OutOfRangeField(name, from, to)
    }

    /**
      * Checks numeric range of field value.
      *
      * @param name Field name.
      * @param vOpt Field value. Optional.
      * @param from Minimum from.
      * @param to Maximum to.
      */
    @throws[OutOfRangeField]
    protected def checkRangeOpt[T](name: String, vOpt: Option[T], from: T, to: T)(implicit e: T => Number): Unit =
        if (vOpt.isDefined)
            checkRange(name, vOpt.get, from, to)

    /**
      *
      * @param js
      * @param fn
      */
    @throws[InvalidField]
    protected def convert[T](js: JsObject, fn: String, extractor: JsValue => T): T =
        try
            extractor(js.fields(fn))
        catch {
            case _: Exception => throw InvalidField(fn)
        }

    /**
      *
      * @param js
      * @param fn
      * @param extractor
      * @tparam T
      * @return
      */
    @throws[InvalidField]
    protected def convertOpt[T](js: JsObject, fn: String, extractor: JsValue => T): Option[T] =
        try
            js.fields.get(fn) match {
                case Some(v) => Some(extractor(v))
                case None => None
            }
        catch {
            case _: Exception => throw InvalidField(fn)
        }

    /**
      *
      * @return
      */
    protected def $signin(): Route = {
        case class Req$Signin$(
            email: String,
            passwd: String
        )
        case class Res$Signin$(
            status: String,
            acsTok: String
        )
        implicit val reqFmt: RootJsonFormat[Req$Signin$] = jsonFormat2(Req$Signin$)
        implicit val resFmt: RootJsonFormat[Res$Signin$] = jsonFormat2(Res$Signin$)

        // NOTE: no authentication requires on signin.
        entity(as[Req$Signin$]) { req =>
            startScopedSpan("signin$", "email" -> req.email) { span =>
                checkLength("email" -> req.email, "passwd" -> req.passwd)

                NCUserManager.signin(
                    req.email,
                    req.passwd,
                    span
                ) match {
                    case None => throw SignInFailure(req.email) // Email is unknown (user hasn't signed up).
                    case Some(acsTkn) => complete {
                        Res$Signin$(API_OK, acsTkn)
                    }
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $health(): Route = {
        case class Res$Health$(status: String)

        implicit val resFmt: RootJsonFormat[Res$Health$] = jsonFormat1(Res$Health$)

        complete {
            Res$Health$(API_OK)
        }
    }

    /**
      *
      * @return
      */
    protected def $signout(): Route = {
        case class Req$Signout$(
            acsTok: String
        )
        case class Res$Signout$(
            status: String
        )

        implicit val reqFmt: RootJsonFormat[Req$Signout$] = jsonFormat1(Req$Signout$)
        implicit val resFmt: RootJsonFormat[Res$Signout$] = jsonFormat1(Res$Signout$)

        entity(as[Req$Signout$]) { req =>
            startScopedSpan("signout$", "acsTok" -> req.acsTok) { span =>
                checkLength("acsTok" -> req.acsTok)

                val usr = authenticate(req.acsTok)

                for (mdlId <- NCProbeManager.getAllProbes(usr.companyId, span).flatMap(_.models.map(_.id))) {
                    NCProbeManager.clearConversation(usr.id, mdlId, span)
                    NCProbeManager.clearDialog(usr.id, mdlId, span)
                }

                NCUserManager.signout(req.acsTok, span)

                complete {
                    Res$Signout$(API_OK)
                }
            }
        }
    }

    /**
      *
      * @param fut
      */
    private def successWithJs(fut: Future[String]): Route =
        onSuccess(fut) {
            js => complete(HttpResponse(entity = HttpEntity(ContentTypes.`application/json`, js)))
        }

    /**
      *
      * @param o
      */
    private def completeJs(o: Object): Route =
        complete(HttpResponse(entity = HttpEntity(ContentTypes.`application/json`, toJs(o))))

    /**
      *
      * @param gzipOpt
      */
    @throws[NCE]
    private def unzipProperties(gzipOpt: Option[String]): Option[JavaMeta] =
        gzipOpt match {
            case Some(gzip) => Some(jsonToJavaMap(uncompress(gzip)))
            case None => None
        }

    /**
      *
      * @return
      */
    private def ask0(process: AskReqHolder => Route): Route = {
        case class Req$Ask$(
            acsTok: String,
            usrId: Option[Long],
            usrExtId: Option[String],
            txt: String,
            mdlId: String,
            data: Option[spray.json.JsValue],
            enableLog: Option[Boolean]
        )

        implicit val reqFmt: RootJsonFormat[Req$Ask$] = jsonFormat7(Req$Ask$)

        entity(as[Req$Ask$]) { req =>
            startScopedSpan(
                "ask$",
                "usrId" -> req.usrId.getOrElse(-1),
                "usrExtId" -> req.usrExtId.orNull,
                "acsTok" -> req.acsTok,
                "txt" -> req.txt,
                "mdlId" -> req.mdlId) { span =>
                checkLength(
                    "acsTok" -> req.acsTok, "usrExtId" -> req.usrExtId, "mdlId" -> req.mdlId, "txt" -> req.txt
                )

                val dataJs = extractJson(req.data, "data")
                val acsUsr = authenticate(req.acsTok)

                checkModelId(req.mdlId, acsUsr.companyId)

                optionalHeaderValueByName("User-Agent") { usrAgent =>
                    extractClientIP { rmtAddr =>
                        process(AskReqHolder(
                            usrId = getUserId(acsUsr, req.usrId, req.usrExtId),
                            txt = req.txt,
                            mdlId = req.mdlId,
                            usrAgent = usrAgent,
                            rmtAddr = getAddress(rmtAddr),
                            data = dataJs,
                            req.enableLog.getOrElse(false),
                            parent = span
                        ))
                    }
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $ask(): Route =
        ask0(
            (h: AskReqHolder) => {
                val newSrvReqId = NCQueryManager.asyncAsk(
                    h.usrId,
                    h.txt,
                    h.mdlId,
                    h.usrAgent,
                    h.rmtAddr,
                    h.data,
                    h.enableLog,
                    h.parent
                )

                case class Res$Ask$(
                    status: String,
                    srvReqId: String
                )

                implicit val resFmt: RootJsonFormat[Res$Ask$] = jsonFormat2(Res$Ask$)

                complete {
                    Res$Ask$(API_OK, newSrvReqId)
                }
            }
        )

    /**
      *
      * @return
      */
    protected def $ask$Sync(): Route =
        ask0(
            (h: AskReqHolder) => {
                val fut = NCQueryManager.futureAsk(
                    h.usrId,
                    h.txt,
                    h.mdlId,
                    h.usrAgent,
                    h.rmtAddr,
                    h.data,
                    h.enableLog,
                    h.parent
                )

                successWithJs(
                    fut.collect {
                        // We have to use Jackson (not spray) here to serialize 'resBody' field.
                        case res => toJs(
                            Map(
                                "status" -> API_OK.toString,
                                "state" -> queryStateToMap(res)
                            ).asJava
                        )
                    }
                )
            }
        )

    /**
      *
      * @return
      */
    protected def $cancel(): Route = {
        case class Req$Cancel$(
            acsTok: String,
            usrId: Option[Long],
            usrExtId: Option[String],
            srvReqIds: Option[Set[String]]
        )
        case class Res$Cancel$(
            status: String
        )

        implicit val reqFmt: RootJsonFormat[Req$Cancel$] = jsonFormat4(Req$Cancel$)
        implicit val resFmt: RootJsonFormat[Res$Cancel$] = jsonFormat1(Res$Cancel$)

        entity(as[Req$Cancel$]) { req =>
            startScopedSpan("cancel$",
                "acsTok" -> req.acsTok,
                "usrId" -> req.usrId.getOrElse(-1),
                "usrExtId" -> req.usrExtId.orNull,
                "srvReqIds" -> req.srvReqIds.getOrElse(Nil).mkString(",")) { span =>
                checkLength("acsTok" -> req.acsTok, "usrExtId" -> req.usrExtId)

                val acsUsr = authenticate(req.acsTok)

                val srvReqs = getRequests(acsUsr, req.srvReqIds, req.usrId, req.usrExtId, span)

                NCQueryManager.cancelForServerRequestIds(srvReqs.map(_.srvReqId), span)

                complete {
                    Res$Cancel$(API_OK)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $check(): Route = {
        case class Req$Check$(
            acsTok: String,
            usrId: Option[Long],
            usrExtId: Option[String],
            srvReqIds: Option[Set[String]],
            maxRows: Option[Int]
        )

        implicit val reqFmt: RootJsonFormat[Req$Check$] = jsonFormat5(Req$Check$)

        entity(as[Req$Check$]) { req =>
            startScopedSpan(
                "check$",
                "usrId" -> req.usrId.getOrElse(-1),
                "usrExtId" -> req.usrExtId.orNull,
                "acsTok" -> req.acsTok,
                "srvReqIds" -> req.srvReqIds.getOrElse(Nil).mkString(",")
            ) { span =>
                checkLength("acsTok" -> req.acsTok, "usrExtId" -> req.usrExtId)
                checkRangeOpt("maxRows", req.maxRows, 1, java.lang.Integer.MAX_VALUE)

                val acsUsr = authenticate(req.acsTok)

                val states =
                    getRequests(acsUsr, req.srvReqIds, req.usrId, req.usrExtId, span).
                        toSeq.sortBy(-_.createTstamp.getTime).
                        take(req.maxRows.getOrElse(Integer.MAX_VALUE))

                // We have to use Jackson (not spray) here to serialize 'resBody' field.
                val js = toJs(
                    Map(
                        "status" -> API_OK.toString,
                        "states" -> states.map(queryStateToMap).asJava
                    )
                        .asJava
                )

                complete(
                    HttpResponse(
                        entity = HttpEntity(ContentTypes.`application/json`, js)
                    )
                )
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $model$sugsyn(): Route = {
        case class Req$Model$Sugsyn(
            acsTok: String,
            mdlId: String,
            minScore: Option[Double]
        )

        implicit val reqFmt: RootJsonFormat[Req$Model$Sugsyn] = jsonFormat3(Req$Model$Sugsyn)

        entity(as[Req$Model$Sugsyn]) { req =>
            startScopedSpan(
                "model$sugsyn",
                "acsTok" -> req.acsTok,
                "mdlId" -> req.mdlId,
                "minScore" -> req.minScore.getOrElse(-1)) { span =>
                checkLength("acsTok" -> req.acsTok, "mdlId" -> req.mdlId)
                checkRangeOpt("minScore", req.minScore, 0.0, 1.0)

                val admUsr = authenticateAsAdmin(req.acsTok)

                checkModelId(req.mdlId, admUsr.companyId)

                val fut = NCSuggestSynonymManager.suggest(req.mdlId, req.minScore, span)

                successWithJs(
                    fut.collect {
                        // We have to use Jackson (not spray) here to serialize 'result' field.
                        case res => toJs(Map("status" -> API_OK.toString, "result" -> res).asJava)
                    }
                )
            }
        }
    }


    /**
      *
      * @return
      */
    protected def $model$syns(): Route = {
        case class Req$Model$Syns(
            acsTok: String,
            mdlId: String,
            elmId: String
        )

        implicit val reqFmt: RootJsonFormat[Req$Model$Syns] = jsonFormat3(Req$Model$Syns)

        entity(as[Req$Model$Syns]) { req =>
            startScopedSpan(
                "model$syns",
                "acsTok" -> req.acsTok,
                "mdlId" -> req.mdlId,
                "elmId" -> req.elmId) { span =>
                checkLength("acsTok" -> req.acsTok, "mdlId" -> req.mdlId, "elmId" -> req.elmId)

                val admUsr = authenticateAsAdmin(req.acsTok)
                val compId = admUsr.companyId

                if (!NCProbeManager.existsForModel(compId, req.mdlId))
                    throw InvalidModelId(req.mdlId)
                if (!NCProbeManager.existsForModelElement(compId, req.mdlId, req.elmId))
                    throw InvalidModelOrElementId(req.mdlId, req.elmId)

                val fut = NCProbeManager.getModelElementInfo(req.mdlId, req.elmId, span)

                successWithJs(
                    fut.collect {
                        // We have to use Jackson (not spray) here to serialize 'result' field.
                        case res =>
                            require(
                                res.containsKey("synonyms") &&
                                res.containsKey("synonymsExp") &&
                                res.containsKey("synonymsExpRatePct") &&
                                res.containsKey("synonymsExpCnt") &&
                                res.containsKey("synonymsCnt") &&
                                res.containsKey("values") &&
                                res.containsKey("valuesExp")
                            )

                            toJs(
                                Map(
                                    "status" -> API_OK.toString,
                                    "synonymsCnt" -> res.get("synonymsCnt"),
                                    "synonymsExpCnt" -> res.get("synonymsExpCnt"),
                                    "synonymsExpRatePct" -> res.get("synonymsExpRatePct"),
                                    "synonyms" -> res.get("synonyms"),
                                    "synonymsExp" -> res.get("synonymsExp"),
                                    "values" -> res.get("values"),
                                    "valuesExp" -> res.get("valuesExp")
                                )
                            )
                    }
                )
            }
        }
    }


    /**
      *
      * @return
      */
    protected def $model$info(): Route = {
        case class Req$Model$Info(
            acsTok: String,
            mdlId: String
        )

        implicit val reqFmt: RootJsonFormat[Req$Model$Info] = jsonFormat2(Req$Model$Info)

        entity(as[Req$Model$Info]) { req =>
            startScopedSpan(
                "model$syns",
                "acsTok" -> req.acsTok,
                "mdlId" -> req.mdlId
            ) { span =>
                checkLength("acsTok" -> req.acsTok, "mdlId" -> req.mdlId)

                val admUsr = authenticateAsAdmin(req.acsTok)
                val compId = admUsr.companyId

                if (!NCProbeManager.existsForModel(compId, req.mdlId))
                    throw InvalidModelId(req.mdlId)

                val fut = NCProbeManager.getModelInfo(req.mdlId, span)

                successWithJs(
                    fut.collect {
                        // We have to use Jackson (not spray) here to serialize 'result' field.
                        case res =>
                            toJs(
                                Map(
                                    "status" -> API_OK.toString,
                                    "model" -> res
                                )
                            )
                    }
                )
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $clear$Conversation(): Route = {
        case class Req$Clear$Conversation(
            acsTok: String,
            mdlId: String,
            usrId: Option[Long],
            usrExtId: Option[String]
        )
        case class Res$Clear$Conversation(
            status: String
        )

        implicit val reqFmt: RootJsonFormat[Req$Clear$Conversation] = jsonFormat4(Req$Clear$Conversation)
        implicit val resFmt: RootJsonFormat[Res$Clear$Conversation] = jsonFormat1(Res$Clear$Conversation)

        entity(as[Req$Clear$Conversation]) { req =>
            startScopedSpan(
                "clear$Conversation",
                "acsTok" -> req.acsTok,
                "mdlId" -> req.mdlId,
                "usrExtId" -> req.usrExtId.orNull,
                "usrId" -> req.usrId.getOrElse(-1)) { span =>
                //noinspection DuplicatedCode
                checkLength(
                    "acsTok" -> req.acsTok,
                    "mdlId" -> req.mdlId,
                    "usrExtId" -> req.usrExtId
                )

                val acsUsr = authenticate(req.acsTok)

                checkModelId(req.mdlId, acsUsr.companyId)

                NCProbeManager.clearConversation(getUserId(acsUsr, req.usrId, req.usrExtId), req.mdlId, span)

                complete {
                    Res$Clear$Conversation(API_OK)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $clear$Dialog(): Route = {
        case class Req$Clear$Dialog(
            acsTok: String,
            mdlId: String,
            usrId: Option[Long],
            usrExtId: Option[String]
        )
        case class Res$Clear$Dialog(
            status: String
        )

        implicit val reqFmt: RootJsonFormat[Req$Clear$Dialog] = jsonFormat4(Req$Clear$Dialog)
        implicit val resFmt: RootJsonFormat[Res$Clear$Dialog] = jsonFormat1(Res$Clear$Dialog)

        entity(as[Req$Clear$Dialog]) { req =>
            startScopedSpan(
                "clear$Dialog",
                "acsTok" -> req.acsTok,
                "usrExtId" -> req.usrExtId.orNull,
                "mdlId" -> req.mdlId,
                "usrId" -> req.usrId.getOrElse(-1)) { span =>
                //noinspection DuplicatedCode
                checkLength(
                    "acsTok" -> req.acsTok,
                    "mdlId" -> req.mdlId,
                    "usrExtId" -> req.usrExtId
                )

                val acsUsr = authenticate(req.acsTok)

                checkModelId(req.mdlId, acsUsr.companyId)

                NCProbeManager.clearDialog(getUserId(acsUsr, req.usrId, req.usrExtId), req.mdlId, span)

                complete {
                    Res$Clear$Dialog(API_OK)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $company$Add(): Route = {
        case class Req$Company$Add(
            acsTok: String,
            // New company.
            name: String,
            website: Option[String],
            country: Option[String],
            region: Option[String],
            city: Option[String],
            address: Option[String],
            postalCode: Option[String],
            // New company admin.
            adminEmail: String,
            adminPasswd: String,
            adminFirstName: String,
            adminLastName: String,
            adminAvatarUrl: Option[String],
            properties: Option[spray.json.JsValue]
        )
        case class Res$Company$Add(
            status: String,
            token: String,
            adminId: Long
        )

        implicit val reqFmt: RootJsonFormat[Req$Company$Add] = jsonFormat14(Req$Company$Add)
        implicit val resFmt: RootJsonFormat[Res$Company$Add] = jsonFormat3(Res$Company$Add)

        //noinspection DuplicatedCod
        entity(as[Req$Company$Add]) { req =>
            startScopedSpan("company$Add", "name" -> req.name) { span =>
                checkLength(
                    "acsTok" -> req.acsTok,
                    "name" -> req.name,
                    "website" -> req.website,
                    "country" -> req.country,
                    "region" -> req.region,
                    "city" -> req.city,
                    "address" -> req.address,
                    "postalCode" -> req.postalCode,
                    "adminEmail" -> req.adminEmail,
                    "adminPasswd" -> req.adminPasswd,
                    "adminFirstName" -> req.adminFirstName,
                    "adminLastName" -> req.adminLastName,
                    "adminAvatarUrl" -> req.adminAvatarUrl
                )

                val propsJs = extractJson(req.properties, "properties")

                // Via REST only administrators of already created companies can create new companies.
                authenticateAsAdmin(req.acsTok)

                val res = NCCompanyManager.addCompany(
                    req.name,
                    req.website,
                    req.country,
                    req.region,
                    req.city,
                    req.address,
                    req.postalCode,
                    req.adminEmail,
                    req.adminPasswd,
                    req.adminFirstName,
                    req.adminLastName,
                    req.adminAvatarUrl,
                    propsJs,
                    span
                )

                complete {
                    Res$Company$Add(API_OK, res.token, res.adminId)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $company$Get(): Route = {
        case class Req$Company$Get(
            acsTok: String
        )
        case class Res$Company$Get(
            status: String,
            id: Long,
            name: String,
            website: Option[String],
            country: Option[String],
            region: Option[String],
            city: Option[String],
            address: Option[String],
            postalCode: Option[String],
            properties: Option[JavaMeta]
        )

        implicit val reqFmt: RootJsonFormat[Req$Company$Get] = jsonFormat1(Req$Company$Get)

        entity(as[Req$Company$Get]) { req =>
            startScopedSpan("company$get", "acsTok" -> req.acsTok) { span =>
                checkLength("acsTok" -> req.acsTok)

                val acsUsr = authenticate(req.acsTok)

                val company = NCCompanyManager.
                    getCompany(acsUsr.companyId, span).
                    getOrElse(throw new NCE(s"Company not found: ${acsUsr.companyId}"))

                completeJs {
                    Res$Company$Get(API_OK,
                        company.id,
                        company.name,
                        company.website,
                        company.country,
                        company.region,
                        company.city,
                        company.address,
                        company.postalCode,
                        unzipProperties(company.propertiesGzip)
                    )
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $company$Update(): Route = {
        case class Req$Company$Update(
            // Caller.
            acsTok: String,

            // Updated company.
            name: String,
            website: Option[String],
            country: Option[String],
            region: Option[String],
            city: Option[String],
            address: Option[String],
            postalCode: Option[String],
            properties: Option[spray.json.JsValue]
        )
        case class Res$Company$Update(
            status: String
        )

        implicit val reqFmt: RootJsonFormat[Req$Company$Update] = jsonFormat9(Req$Company$Update)
        implicit val resFmt: RootJsonFormat[Res$Company$Update] = jsonFormat1(Res$Company$Update)

        entity(as[Req$Company$Update]) { req =>
            startScopedSpan("company$Update", "acsTok" -> req.acsTok, "name" -> req.name) { span =>
                checkLength("acsTok" -> req.acsTok,
                    "name" -> req.name,
                    "website" -> req.website,
                    "country" -> req.country,
                    "region" -> req.region,
                    "city" -> req.city,
                    "address" -> req.address,
                    "postalCode" -> req.postalCode
                )

                val propsJs = extractJson(req.properties, "properties")
                val admUsr = authenticateAsAdmin(req.acsTok)

                NCCompanyManager.updateCompany(
                    admUsr.companyId,
                    req.name,
                    req.website,
                    req.country,
                    req.region,
                    req.city,
                    req.address,
                    req.postalCode,
                    propsJs,
                    span
                )

                complete {
                    Res$Company$Update(API_OK)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $feedback$Add(): Route = {
        case class Req$Feedback$Add(
            acsTok: String,
            usrId : Option[Long],
            usrExtId: Option[String],
            srvReqId: String,
            score: Double,
            comment: Option[String]
        )
        case class Res$Feedback$Add(
            status: String,
            id: Long
        )

        implicit val reqFmt: RootJsonFormat[Req$Feedback$Add] = jsonFormat6(Req$Feedback$Add)
        implicit val resFmt: RootJsonFormat[Res$Feedback$Add] = jsonFormat2(Res$Feedback$Add)

        entity(as[Req$Feedback$Add]) { req =>
            startScopedSpan(
                "feedback$Add",
                "usrId" -> req.usrId.getOrElse(-1),
                "usrExtId" -> req.usrExtId.orNull,
                "srvReqId" -> req.srvReqId) { span =>
                checkLength(
                    "acsTok" -> req.acsTok,
                    "usrExtId" -> req.usrExtId,
                    "srvReqId" -> req.srvReqId,
                    "comment" -> req.comment
                )
                checkRange("score", req.score, 0, 1)

                // Via REST only administrators of already created companies can create new companies.
                val acsUsr = authenticate(req.acsTok)

                val id = NCFeedbackManager.addFeedback(
                    req.srvReqId,
                    getUserId(acsUsr, req.usrId, req.usrExtId),
                    req.score,
                    req.comment,
                    span
                )

                complete {
                    Res$Feedback$Add(API_OK, id)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $feedback$Delete(): Route = {
        case class Req$Feedback$Delete(
            acsTok: String,
            // Feedback IDs to delete (optional).
            id: Option[Long]
        )
        case class Res$Feedback$Delete(
            status: String
        )

        implicit val reqFmt: RootJsonFormat[Req$Feedback$Delete] = jsonFormat2(Req$Feedback$Delete)
        implicit val resFmt: RootJsonFormat[Res$Feedback$Delete] = jsonFormat1(Res$Feedback$Delete)

        entity(as[Req$Feedback$Delete]) { req =>
            startScopedSpan("feedback$Delete") { span =>
                checkLength("acsTok" -> req.acsTok)

                // Via REST only administrators of already created companies can create new companies.
                val acsUsr = authenticate(req.acsTok)

                require(acsUsr.email.isDefined)

                req.id match {
                    case Some(id) =>
                        NCFeedbackManager.getFeedback(id, span) match {
                            case Some(f) =>
                                val companyId =
                                    NCUserManager.
                                        getUserById(f.userId, span).
                                        getOrElse(throw new NCE(s"Company not found for user: ${f.userId}")).
                                        companyId

                                if (companyId != acsUsr.companyId || (f.userId != acsUsr.id && !acsUsr.isAdmin))
                                    throw AdminRequired(acsUsr.email.get)

                                NCFeedbackManager.deleteFeedback(f.id, span)
                            case None => // No-op.
                        }

                    case None =>
                        if (!acsUsr.isAdmin)
                            throw AdminRequired(acsUsr.email.get)

                        NCFeedbackManager.deleteAllFeedback(acsUsr.companyId, span)
                }

                complete {
                    Res$Feedback$Delete(API_OK)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $feedback$All(): Route = {
        case class Req$Feedback$All(
            acsTok: String,
            usrId: Option[Long],
            usrExtId: Option[String],
            srvReqId: Option[String]
        )
        case class Feedback_Feedback$All(
            id: Long,
            srvReqId: String,
            usrId: Long,
            score: Double,
            comment: Option[String],
            createTstamp: Long
        )
        case class Res$Feedback$All(
            status: String,
            feedback: Seq[Feedback_Feedback$All]
        )

        implicit val reqFmt: RootJsonFormat[Req$Feedback$All] = jsonFormat4(Req$Feedback$All)
        implicit val fbFmt: RootJsonFormat[Feedback_Feedback$All] = jsonFormat6(Feedback_Feedback$All)
        implicit val resFmt: RootJsonFormat[Res$Feedback$All] = jsonFormat2(Res$Feedback$All)

        entity(as[Req$Feedback$All]) { req =>
            startScopedSpan(
                "feedback$All",
                "usrId" -> req.usrId.getOrElse(-1),
                "usrExtId" -> req.usrExtId.orNull
            ) { span =>
                checkLength("acsTok" -> req.acsTok, "srvReqId" -> req.srvReqId, "usrExtId" -> req.usrExtId)

                val acsUsr = authenticate(req.acsTok)

                require(acsUsr.email.isDefined)

                val feedback =
                    NCFeedbackManager.getFeedback(
                        acsUsr.companyId,
                        req.srvReqId,
                        if (req.usrId.isDefined || req.usrExtId.isDefined)
                            Some(getUserId(acsUsr, req.usrId, req.usrExtId))
                        else
                            None,
                        span
                    ).map(f =>
                        Feedback_Feedback$All(
                            f.id,
                            f.srvReqId,
                            f.userId,
                            f.score,
                            f.feedbackComment,
                            f.createdOn.getTime
                        )
                    )

                if (!acsUsr.isAdmin && feedback.exists(_.usrId != acsUsr.id))
                    throw AdminRequired(acsUsr.email.get)

                complete {
                    Res$Feedback$All(API_OK, feedback)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $company$Token$Reset(): Route = {
        case class Req$Company$Token$Reset(
            // Caller.
            acsTok: String
        )
        case class Res$Company$Token$Reset(
            status: String,
            token: String
        )

        implicit val reqFmt: RootJsonFormat[Req$Company$Token$Reset] = jsonFormat1(Req$Company$Token$Reset)
        implicit val resFmt: RootJsonFormat[Res$Company$Token$Reset] = jsonFormat2(Res$Company$Token$Reset)

        entity(as[Req$Company$Token$Reset]) { req =>
            startScopedSpan("company$Token$Reset", "acsTok" -> req.acsTok) { span =>
                checkLength("acsTok" -> req.acsTok)

                val admUsr = authenticateAsAdmin(req.acsTok)

                val tkn = NCCompanyManager.resetToken(admUsr.companyId, span)

                complete {
                    Res$Company$Token$Reset(API_OK, tkn)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $company$Delete(): Route = {
        case class Req$Company$Delete(
            // Caller.
            acsTok: String
        )
        case class Res$Company$Delete(
            status: String
        )

        implicit val reqFmt: RootJsonFormat[Req$Company$Delete] = jsonFormat1(Req$Company$Delete)
        implicit val resFmt: RootJsonFormat[Res$Company$Delete] = jsonFormat1(Res$Company$Delete)

        entity(as[Req$Company$Delete]) { req =>
            startScopedSpan("company$Delete", "acsTok" -> req.acsTok) { span =>
                checkLength("acsTok" -> req.acsTok)

                val admUSr = authenticateAsAdmin(req.acsTok)

                NCCompanyManager.deleteCompany(admUSr.companyId, span)

                complete {
                    Res$Company$Delete(API_OK)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $user$Add(): Route = {
        case class Req$User$Add(
            // Caller.
            acsTok: String,

            // New user.
            email: String,
            passwd: String,
            firstName: String,
            lastName: String,
            avatarUrl: Option[String],
            isAdmin: Boolean,
            properties: Option[spray.json.JsValue],
            usrExtId: Option[String]
        )
        case class Res$User$Add(
            status: String,
            id: Long
        )

        implicit val reqFmt: RootJsonFormat[Req$User$Add] = jsonFormat9(Req$User$Add)
        implicit val resFmt: RootJsonFormat[Res$User$Add] = jsonFormat2(Res$User$Add)

        entity(as[Req$User$Add]) { req =>
            startScopedSpan("user$Add", "acsTok" -> req.acsTok, "email" -> req.email) { span =>
                checkLength(
                    "acsTok" -> req.acsTok,
                    "email" -> req.email,
                    "passwd" -> req.passwd,
                    "firstName" -> req.firstName,
                    "lastName" -> req.lastName,
                    "avatarUrl" -> req.avatarUrl,
                    "usrExtId" -> req.usrExtId
                )

                val propsJs = extractJson(req.properties, "properties")
                val admUsr = authenticateAsAdmin(req.acsTok)

                val id = NCUserManager.addUser(
                    admUsr.companyId,
                    req.email,
                    req.passwd,
                    req.firstName,
                    req.lastName,
                    req.avatarUrl,
                    req.isAdmin,
                    propsJs,
                    req.usrExtId,
                    span
                )

                complete {
                    Res$User$Add(API_OK, id)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $user$Update(): Route = {
        case class Req$User$Update(
            // Caller.
            acsTok: String,

            // Update user.
            id: Option[Long],
            firstName: String,
            lastName: String,
            avatarUrl: Option[String],
            properties: Option[spray.json.JsValue]
        )
        case class Res$User$Update(
            status: String
        )

        implicit val reqFmt: RootJsonFormat[Req$User$Update] = jsonFormat6(Req$User$Update)
        implicit val resFmt: RootJsonFormat[Res$User$Update] = jsonFormat1(Res$User$Update)

        entity(as[Req$User$Update]) { req =>
            startScopedSpan("user$Update", "acsTok" -> req.acsTok, "usrId" -> req.id.getOrElse(-1)) { span =>
                checkLength(
                    "acsTok" -> req.acsTok,
                    "firstName" -> req.firstName,
                    "lastName" -> req.lastName,
                    "avatarUrl" -> req.avatarUrl
                )

                val propsJs = extractJson(req.properties, "properties")
                val acsUsr = authenticate(req.acsTok)

                NCUserManager.updateUser(
                    getUserId(acsUsr, req.id, None),
                    req.firstName,
                    req.lastName,
                    req.avatarUrl,
                    propsJs,
                    span
                )

                complete {
                    Res$User$Update(API_OK)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $user$Delete(): Route = {
        case class Req$User$Delete(
            acsTok: String,
            id: Option[Long],
            usrExtId: Option[String]
        )
        case class Res$User$Delete(
            status: String
        )

        implicit val reqFmt: RootJsonFormat[Req$User$Delete] = jsonFormat3(Req$User$Delete)
        implicit val resFmt: RootJsonFormat[Res$User$Delete] = jsonFormat1(Res$User$Delete)

        entity(as[Req$User$Delete]) { req =>
            startScopedSpan(
                "user$Delete", "acsTok" -> req.acsTok, "usrId" -> req.id.getOrElse(-1)
            ) { span =>
                checkLength("acsTok" -> req.acsTok, "usrExtId" -> req.usrExtId)

                val acsUsr = authenticate(req.acsTok)

                require(acsUsr.email.isDefined)

                def delete(id: Long): Unit = {
                    NCUserManager.signoutAllSessions(id, span)
                    NCUserManager.deleteUser(id, span)

                    logger.info(s"User deleted: $id")
                }

                // Deletes all users from company except initiator.
                if (req.id.isEmpty && req.usrExtId.isEmpty) {
                    if (!acsUsr.isAdmin)
                        throw AdminRequired(acsUsr.email.get)

                    NCUserManager.
                        getAllUsers(acsUsr.companyId, span).
                        filter(_.id != acsUsr.id).
                        map(_.id).
                        foreach(delete)
                }
                else {
                    val delUsrId = getUserId(acsUsr, req.id, req.usrExtId)

                    // Tries to delete own account.
                    if (delUsrId == acsUsr.id &&
                        acsUsr.isAdmin &&
                        !NCUserManager.isOtherAdminsExist(acsUsr.id)
                    )
                        throw InvalidOperation(s"Last admin user cannot be deleted: ${acsUsr.email.get}")

                    delete(delUsrId)
                }

                complete {
                    Res$User$Delete(API_OK)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $user$Admin(): Route = {
        case class Req$User$Admin(
            acsTok: String,
            id: Option[Long],
            admin: Boolean
        )
        case class Res$User$Admin(
            status: String
        )

        implicit val reqFmt: RootJsonFormat[Req$User$Admin] = jsonFormat3(Req$User$Admin)
        implicit val resFmt: RootJsonFormat[Res$User$Admin] = jsonFormat1(Res$User$Admin)

        entity(as[Req$User$Admin]) { req =>
            startScopedSpan(
                "user$Admin", "acsTok" -> req.acsTok, "usrId" -> req.id.getOrElse(-1), "admin" -> req.admin
            ) { span =>
                checkLength("acsTok" -> req.acsTok)

                val initUsr = authenticateAsAdmin(req.acsTok)
                val usrId = req.id.getOrElse(initUsr.id)

                // Self update.
                if (
                    usrId == initUsr.id &&
                        !req.admin &&
                        !NCUserManager.isOtherAdminsExist(initUsr.id, span)
                )
                    throw InvalidOperation(s"Last admin user cannot lose admin privileges: ${initUsr.email}")

                NCUserManager.updateUserPermissions(usrId, req.admin, span)

                complete {
                    Res$User$Admin(API_OK)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $user$Passwd$Reset(): Route = {
        case class Req$User$Password$Reset(
            // Caller.
            acsTok: String,
            id: Option[Long],
            newPasswd: String
        )
        case class Res$User$Password$Reset(
            status: String
        )

        implicit val reqFmt: RootJsonFormat[Req$User$Password$Reset] = jsonFormat3(Req$User$Password$Reset)
        implicit val resFmt: RootJsonFormat[Res$User$Password$Reset] = jsonFormat1(Res$User$Password$Reset)

        entity(as[Req$User$Password$Reset]) { req =>
            startScopedSpan(
                "user$Password$Reset",
                "acsTok" -> req.acsTok, "usrId" -> req.id.getOrElse(-1)) { span =>
                checkLength("acsTok" -> req.acsTok, "newPasswd" -> req.newPasswd)

                val acsUsr = authenticate(req.acsTok)

                NCUserManager.resetPassword(getUserId(acsUsr, req.id, None), req.newPasswd, span)

                complete {
                    Res$User$Password$Reset(API_OK)
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $user$All(): Route = {
        case class Req$User$All(
            // Caller.
            acsTok: String
        )
        case class ResUser_User$All(
            id: Long,
            email: Option[String],
            usrExtId: Option[String],
            firstName: Option[String],
            lastName: Option[String],
            avatarUrl: Option[String],
            isAdmin: Boolean,
            companyId: Long,
            properties: Option[JavaMeta]
        )
        case class Res$User$All(
            status: String,
            users: Seq[ResUser_User$All]
        )

        implicit val reqFmt: RootJsonFormat[Req$User$All] = jsonFormat1(Req$User$All)

        entity(as[Req$User$All]) { req =>
            startScopedSpan("user$All", "acsTok" -> req.acsTok) { span =>
                checkLength("acsTok" -> req.acsTok)

                val admUSr = authenticateAsAdmin(req.acsTok)

                completeJs {
                    Res$User$All(
                        API_OK,
                        NCUserManager.getAllUsers(admUSr.companyId, span).map(u =>
                            ResUser_User$All(
                                u.id,
                                u.email,
                                u.extId,
                                u.firstName,
                                u.lastName,
                                u.avatarUrl,
                                u.isAdmin,
                                u.companyId,
                                unzipProperties(u.propertiesGzip)
                            )
                        )
                    )
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $user$Get(): Route = {
        case class Req$User$Get(
            // Caller.
            acsTok: String,
            id: Option[Long],
            usrExtId: Option[String]
        )
        case class Res$User$Get(
            status: String,
            id: Long,
            email: Option[String],
            usrExtId: Option[String],
            firstName: Option[String],
            lastName: Option[String],
            avatarUrl: Option[String],
            isAdmin: Boolean,
            properties: Option[JavaMeta]
        )

        implicit val reqFmt: RootJsonFormat[Req$User$Get] = jsonFormat3(Req$User$Get)

        entity(as[Req$User$Get]) { req =>
            startScopedSpan(
                "user$Get", "acsTok" -> req.acsTok, "id" -> req.id.orElse(null), "usrExtId" -> req.usrExtId.orNull
            ) { span =>
                checkLength("acsTok" -> req.acsTok, "usrExtId" -> req.usrExtId)

                val acsUsr = authenticate(req.acsTok)
                val usrId = getUserId(acsUsr, req.id, req.usrExtId)

                if (acsUsr.id != usrId && !acsUsr.isAdmin)
                    throw AdminRequired(acsUsr.email.get)

                val usr = NCUserManager.getUserById(usrId, span).getOrElse(throw new NCE(s"User not found: $usrId"))

                completeJs {
                    Res$User$Get(API_OK,
                        usr.id,
                        usr.email,
                        usr.extId,
                        usr.firstName,
                        usr.lastName,
                        usr.avatarUrl,
                        usr.isAdmin,
                        unzipProperties(usr.propertiesGzip)
                    )
                }
            }
        }
    }

    /**
      *
      * @return
      */
    protected def $probe$All(): Route = {
        case class Req$Probe$All(
            acsTok: String
        )
        case class Model_Probe$All(
            id: String,
            name: String,
            version: String,
            elementIds: Set[String],
            enabledBuiltInTokens: Set[String]
        )
        case class Probe_Probe$All(
            probeToken: String,
            probeId: String,
            probeGuid: String,
            probeApiVersion: String,
            probeApiDate: String,
            osVersion: String,
            osName: String,
            osArch: String,
            startTstamp: Long,
            tmzId: String,
            tmzAbbr: String,
            tmzName: String,
            userName: String,
            javaVersion: String,
            javaVendor: String,
            hostName: String,
            hostAddr: String,
            macAddr: String,
            models: Set[Model_Probe$All]
        )
        case class Res$Probe$All(
            status: String,
            probes: Seq[Probe_Probe$All]
        )

        implicit val reqFmt: RootJsonFormat[Req$Probe$All] = jsonFormat1(Req$Probe$All)
        implicit val mdlFmt: RootJsonFormat[Model_Probe$All] = jsonFormat5(Model_Probe$All)
        implicit val probFmt: RootJsonFormat[Probe_Probe$All] = jsonFormat19(Probe_Probe$All)
        implicit val resFmt: RootJsonFormat[Res$Probe$All] = jsonFormat2(Res$Probe$All)

        entity(as[Req$Probe$All]) { req =>
            startScopedSpan("probe$All", "acsTok" -> req.acsTok) { span =>
                checkLength("acsTok" -> req.acsTok)

                val admUsr = authenticateAsAdmin(req.acsTok)

                val probeLst = NCProbeManager.getAllProbes(admUsr.companyId, span).map(mdo => Probe_Probe$All(
                    mdo.probeToken,
                    mdo.probeId,
                    mdo.probeGuid,
                    mdo.probeApiVersion,
                    mdo.probeApiDate.toString,
                    mdo.osVersion,
                    mdo.osName,
                    mdo.osArch,
                    mdo.startTstamp.getTime,
                    mdo.tmzId,
                    mdo.tmzAbbr,
                    mdo.tmzName,
                    mdo.userName,
                    mdo.javaVersion,
                    mdo.javaVendor,
                    mdo.hostName,
                    mdo.hostAddr,
                    mdo.macAddr,
                    mdo.models.map(m => Model_Probe$All(
                        m.id,
                        m.name,
                        m.version,
                        m.elementIds,
                        m.enabledBuiltInTokens
                    ))
                ))

                complete {
                    Res$Probe$All(API_OK, probeLst)
                }
            }
        }
    }

    /**
      *
      * @param statusCode
      * @param errCode
      * @param errMsg
      */
    protected def completeError(statusCode: StatusCode, errCode: String, errMsg: String): Route = {
        currentSpan().setStatus(Status.INTERNAL.withDescription(s"code: $errCode, message: $errMsg"))

        corsHandler(
            complete(
                HttpResponse(
                    status = statusCode,
                    entity = HttpEntity(
                        ContentTypes.`application/json`,
                        toJs(Map("code" -> errCode, "msg" -> errMsg).asJava)
                    )
                )
            )
        )
    }

    /**
      *
      * @return
      */
    def getExceptionHandler: ExceptionHandler = ExceptionHandler {
        case e: AccessTokenFailure =>
            val errMsg = e.getLocalizedMessage
            val code = "NC_INVALID_ACCESS_TOKEN"

            completeError(StatusCodes.Unauthorized, code, errMsg)

        case e: SignInFailure =>
            val errMsg = e.getLocalizedMessage
            val code = "NC_SIGNIN_FAILURE"

            completeError(StatusCodes.Unauthorized, code, errMsg)

        case e: NotImplemented =>
            val errMsg = e.getLocalizedMessage
            val code = "NC_NOT_IMPLEMENTED"

            completeError(StatusCodes.NotImplemented, code, errMsg)

        case e: InvalidArguments =>
            val errMsg = e.getLocalizedMessage
            val code = "NC_INVALID_FIELD"

            completeError(StatusCodes.BadRequest, code, errMsg)

        case e: AdminRequired =>
            val errMsg = e.getLocalizedMessage
            val code = "NC_ADMIN_REQUIRED"

            completeError(StatusCodes.Forbidden, code, errMsg)

        case e: InvalidOperation =>
            val errMsg = e.getLocalizedMessage
            val code = "NC_INVALID_OPERATION"

            completeError(StatusCodes.Forbidden, code, errMsg)

        // General exception.
        case e: NCE =>
            val errMsg = "Unexpected system error."
            val code = "NC_ERROR"

            // We have to log error reason because even general exceptions are not expected here.
            U.prettyError(logger,s"Unexpected top level REST API error: $errMsg", e)

            completeError(StatusCodes.BadRequest, code, errMsg)

        // Unexpected errors.
        case e: Throwable =>
            val errMsg = "Unexpected system error."
            val code = "NC_ERROR"

            U.prettyError(logger,s"Unexpected system error: $errMsg", e)

            completeError(StatusCodes.InternalServerError, code, errMsg)
    }

    /**
      *
      * @return
      */
    def getRejectionHandler: RejectionHandler = {
        def complete(err: String): Route = completeError(StatusCodes.BadRequest, "NC_ERROR", err)

        RejectionHandler.newBuilder().
            handle {
                case _: UnsupportedRequestContentTypeRejection => complete("Unsupported content type.")
                case _: SchemeRejection => complete("Unsupported scheme.")
                case _: UnsatisfiableRangeRejection => complete("Invalid range.")
                case _: TransformationRejection => complete("Transformation error.")
                case _: MalformedRequestContentRejection => complete("Malformed or missing content.")
                case _: AuthenticationFailedRejection => complete("Authentication error.")
                case _: TooManyRangesRejection => complete("Too many ranges.")
                case err: MissingFormFieldRejection => complete(s"Missing form field: ${err.fieldName}")
                case _: UnacceptedResponseContentTypeRejection => complete(s"Unsupported response content type.")
                case _: MethodRejection => complete(s"Invalid method.")
                case _: UnacceptedResponseEncodingRejection => complete(s"Unsupported response encoding.")
                case _: UnsupportedRequestEncodingRejection => complete(s"Unsupported request encoding.")
                case err: MissingCookieRejection => complete(s"Missing cookie: ${err.cookieName}'")
                case err: InvalidRequiredValueForQueryParamRejection => complete(s"Invalid parameter value: ${err.parameterName}")
                case _: UnsupportedWebSocketSubprotocolRejection => complete(s"Unsupported web socket sub-protocol.")
                case _: CircuitBreakerOpenRejection => complete(s"Circuit breaker error.")
                case _: MissingHeaderRejection => complete(s"Missing header.")
                case err: MissingQueryParamRejection => complete(s"Missing parameter: ${err.parameterName}")
                case _: InvalidOriginRejection => complete(s"Invalid origin.")

                // Common case.
                case _: Rejection => complete(s"Bad request.")
            }.result()
    }

    /**
      *
      * @param m
      * @param f
      * @return
      */
    private def withMetric(m: Measure, f: () => Route): Route = {
        val start = U.now()

        try
            f()
        finally {
            recordStats(m -> (U.now() - start))
        }
    }

    /**
      * @return
      */
    private implicit def getContext: ExecutionContext = NCThreadPoolManager.getContext("probes.communication")

    /**
      *
      * @return
      */
    override def getRoute: Route = {
        val timeoutResp = HttpResponse(
            StatusCodes.EnhanceYourCalm,
            entity = "Unable to serve response within time limit."
        )

        handleExceptions(getExceptionHandler) {
            handleRejections(getRejectionHandler) {
                corsHandler (
                    get {
                        withRequestTimeoutResponse(_ => timeoutResp) {
                            path(API / "health") { $health() } // Also duplicated for POST.
                        }
                    } ~
                        post {
                            encodeResponseWith(Coders.NoCoding, Coders.Gzip) {
                                withRequestTimeoutResponse(_ => timeoutResp) {
                                    path(API / "health") { $health() } // Duplicate for POST.
                                    path(API / "signin") { withMetric(M_SIGNIN_LATENCY_MS, $signin) } ~
                                    path(API / "signout") { withMetric(M_SIGNOUT_LATENCY_MS, $signout) } ~
                                    path(API / "cancel") { withMetric(M_CANCEL_LATENCY_MS, $cancel) } ~
                                    path(API / "check") { withMetric(M_CHECK_LATENCY_MS, $check) } ~
                                    path(API / "clear"/ "conversation") { withMetric(M_CLEAR_CONV_LATENCY_MS, $clear$Conversation) } ~
                                    path(API / "clear"/ "dialog") { withMetric(M_CLEAR_DIALOG_LATENCY_MS, $clear$Dialog) } ~
                                    path(API / "company"/ "add") { withMetric(M_COMPANY_ADD_LATENCY_MS, $company$Add) } ~
                                    path(API / "company"/ "get") { withMetric(M_COMPANY_GET_LATENCY_MS, $company$Get) } ~
                                    path(API / "company" / "update") { withMetric(M_COMPANY_UPDATE_LATENCY_MS, $company$Update) } ~
                                    path(API / "company" / "token" / "reset") { withMetric(M_COMPANY_TOKEN_LATENCY_MS, $company$Token$Reset) } ~
                                    path(API / "company" / "delete") { withMetric(M_COMPANY_DELETE_LATENCY_MS, $company$Delete) } ~
                                    path(API / "user" / "get") { withMetric(M_USER_GET_LATENCY_MS, $user$Get) } ~
                                    path(API / "user" / "add") { withMetric(M_USER_ADD_LATENCY_MS, $user$Add) } ~
                                    path(API / "user" / "update") { withMetric(M_USER_UPDATE_LATENCY_MS, $user$Update) } ~
                                    path(API / "user" / "delete") { withMetric(M_USER_DELETE_LATENCY_MS, $user$Delete) } ~
                                    path(API / "user" / "admin") { withMetric(M_USER_ADMIN_LATENCY_MS, $user$Admin) } ~
                                    path(API / "user" / "passwd" / "reset") { withMetric(M_USER_PASSWD_RESET_LATENCY_MS, $user$Passwd$Reset) } ~
                                    path(API / "user" / "all") { withMetric(M_USER_ALL_LATENCY_MS, $user$All) } ~
                                    path(API / "feedback"/ "add") { withMetric(M_FEEDBACK_ADD_LATENCY_MS, $feedback$Add) } ~
                                    path(API / "feedback"/ "all") { withMetric(M_FEEDBACK_GET_LATENCY_MS, $feedback$All) } ~
                                    path(API / "feedback" / "delete") { withMetric(M_FEEDBACK_DELETE_LATENCY_MS, $feedback$Delete) } ~
                                    path(API / "probe" / "all") { withMetric(M_PROBE_ALL_LATENCY_MS, $probe$All) } ~
                                    path(API / "model" / "sugsyn") { withMetric(M_MODEL_SUGSYN_LATENCY_MS, $model$sugsyn) } ~
                                    path(API / "model" / "syns") { withMetric(M_MODEL_SYNS_LATENCY_MS, $model$syns) } ~
                                    path(API / "model" / "info") { withMetric(M_MODEL_SYNS_LATENCY_MS, $model$info) } ~
                                    path(API / "ask") { withMetric(M_ASK_LATENCY_MS, $ask) } ~
                                    path(API / "ask" / "sync") { withMetric(M_ASK_SYNC_LATENCY_MS, $ask$Sync) }
                                }
                            }
                        }
                )
            }
        }
    }
}