// sbt.version = 0.13.11
// addSbtPlugin("io.spray" % "sbt-revolver" % "0.8.0")
// addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.14.2")
lazy val commonSettings = Seq(
  name := "akka-http-vs-spray",
  version := "1.0.0",
  scalaVersion := "2.11.8",
  scalacOptions := Seq("-unchecked", "-deprecation", "-encoding", "utf8", "-Xlint")
)
val akkaV = "2.4.4"
val sprayV = "1.3.3"
lazy val spraySettings = Seq(
  libraryDependencies ++= {
    Seq(
      "com.typesafe.akka"   %%  "akka-actor"    % akkaV,
      "io.spray"            %%  "spray-can"     % sprayV,
      "io.spray"            %%  "spray-routing" % sprayV
    )
  }
)
lazy val akkaSettings = Seq(
  libraryDependencies ++= {
    Seq(
      "com.typesafe.akka" %% "akka-actor" % akkaV,
      "com.typesafe.akka" %% "akka-stream" % akkaV,
      "com.typesafe.akka" %% "akka-http-experimental" % akkaV
    )
  }
)
lazy val sprayServer = (project in file("spray-server"))
.settings(commonSettings: _*)
.settings(spraySettings: _*)
.settings(assemblyOutputPath in assembly := file("./spray-server.jar"))
lazy val akkaServer = (project in file("akka-server"))
.settings(commonSettings: _*)
.settings(akkaSettings: _*)
.settings(assemblyOutputPath in assembly := file("./akka-server.jar"))
Revolver.settings

package akka.server
import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.server.Directives._
import akka.stream.ActorMaterializer
object Boot extends App {
  implicit lazy val system = ActorSystem("akka-server")
  implicit lazy val materializer = ActorMaterializer()
  implicit val ec = system.dispatcher
  private val route =
    pathSingleSlash {
      get {
        complete("Hello world!")
      }
    }
  Http().bindAndHandle(route, "localhost", 8080)
}

package spray.server
import akka.actor._
import akka.io.IO
import spray.can.Http
import spray.routing._
import spray.http._
import akka.pattern.ask
import akka.util.Timeout
import scala.concurrent.duration._
object Boot extends App {
  implicit val system = ActorSystem("spray-server")
  implicit val timeout = Timeout(5.seconds)
  val service = system.actorOf(Props[ServiceActor], "spray-service")
  IO(Http) ? Http.Bind(service, "localhost", 8080)
}
class ServiceActor extends Actor with HttpService {
  private val route =
    pathSingleSlash {
      get {
        complete("Hello world!")
      }
    }
  def actorRefFactory = context
  def receive = runRoute(route)
}

logLevel := Level.Warn
addSbtPlugin("io.spray" % "sbt-revolver" % "0.8.0")
addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.14.2")

name := "akka-http-standalone"
version := "1.0"
scalaVersion := "2.11.8"
scalacOptions := Seq("-unchecked", "-deprecation", "-encoding", "utf8", "-Xlint")
assemblyOutputPath in assembly := file("./akka-http-standalone.jar")
libraryDependencies ++= {
  val akkaV = "2.4.2"
  Seq(
    "com.typesafe.akka" %% "akka-actor" % akkaV,
    "com.typesafe.akka" %% "akka-stream" % akkaV,
    "com.typesafe.akka" %% "akka-http-experimental" % akkaV,
    "com.typesafe.akka" %% "akka-http-spray-json-experimental" % akkaV,
    "com.typesafe.akka" %% "akka-http-xml-experimental" % akkaV,
    "com.typesafe.akka" %% "akka-http-testkit" % akkaV
  )
}
Revolver.settings

import spray.json.DefaultJsonProtocol
object MyData {
  case class User(id: Int, name: String)
  case class ErrorResponse(message: String)
  case class CreateUserRequest(name: String)
  case class UpdateUserRequest(name: String)
}
object JsonProtocol extends DefaultJsonProtocol {
  import MyData._
  implicit lazy val userFormat = jsonFormat2(User)
  implicit lazy val errorResponse = jsonFormat1(ErrorResponse)
  implicit lazy val createUserRequestFormat = jsonFormat1(CreateUserRequest)
  implicit lazy val updateUserRequest = jsonFormat1(UpdateUserRequest)
}

import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
import akka.http.scaladsl.model._
import akka.http.scaladsl.server.Directives._
trait Route extends SprayJsonSupport {
  import MyData._
  import JsonProtocol._
  implicit val db: DB
  val routes =
    pathSingleSlash {
      get {
        // GET localhost:8080
        index()
      }
    } ~
      path("ping") {
        get {
          // GET localhost:8080/ping
          complete("pong")
        }
      } ~
      pathPrefix("users") {
        pathEndOrSingleSlash {
          get {
            // GET localhost:8080/users
            getUsers()
          } ~
            post {
              // POST localhost:8080/users
              entity(as[CreateUserRequest]) { request =>
                createUser(request.name)
              }
            }
        } ~
          path(IntNumber) { id =>
            get {
              // GET localhost:8080/users.:id
              getUser(id)
            } ~
              patch {
                // PATCH localhost:8080/users.:id
                entity(as[UpdateUserRequest]) { request =>
                  updateUser(id, request.name)
                }
              } ~
              delete {
                // DELETE localhost:8080/users.:id
                deleteUser(id)
              }
          }
      }
  private def index() = complete(
    HttpResponse(
      entity = HttpEntity(
        ContentTypes.`text/html(UTF-8)`,
        <html>
          <body>
            <h1>Welcome to <i>akka-http</i>!</h1>
          </body>
        </html>.toString
      )
    )
  )
  private val userNotFound = "user_not_found"
  private def createUser(name: String)(implicit db: DB) =
    db.createUser(name) match {
      case Left(err) =>
        failWith(err)
      case Right(user) =>
        complete(user)
    }
  private def getUsers()(implicit db: DB) =
    db.getUsers match {
      case Left(err) =>
        failWith(err)
      case Right(users) =>
        complete(users)
    }
  private def getUser(id: Int)(implicit db: DB) =
    db.getUser(id) match {
      case Left(err) =>
        failWith(err)
      case Right(None) =>
        complete(StatusCodes.NotFound -> ErrorResponse(userNotFound))
      case Right(Some(user)) =>
        complete(user)
    }
  private def updateUser(id: Int, name: String)(implicit db: DB) =
    db.updateUser(id, name) match {
      case Left(err) =>
        failWith(err)
      case Right(None) =>
        complete(StatusCodes.NotFound -> ErrorResponse(userNotFound))
      case Right(Some(user)) =>
        complete(user)
    }
  private def deleteUser(id: Int)(implicit db: DB) =
    db.deleteUser(id) match {
      case Left(err) =>
        failWith(err)
      case Right(()) =>
        complete(StatusCodes.OK)
    }
}

import MyData.User
trait DB {
  def createUser(name: String): Either[Throwable, User]
  def getUsers: Either[Throwable, Seq[User]]
  def getUser(id: Int): Either[Throwable, Option[User]]
  def updateUser(id: Int, name: String): Either[Throwable, Option[User]]
  def deleteUser(id: Int): Either[Throwable, Unit]
}
object MockDB extends DB {
  private var user_table = Seq[User]()
  private var next_user_id = 0
  private def nextId() = {
    next_user_id += 1
    next_user_id
  }
  def createUser(name: String) = {
    val user = User(nextId(), name)
    user_table = user_table :+ user
    Right(user)
  }
  def getUsers = Right(user_table)
  def getUser(id: Int) = Right(user_table.find(_.id == id))
  def updateUser(id: Int, name: String) = {
    user_table = user_table.map(u =>
      if (u.id == id) u.copy(name = name)
      else u
    )
    getUser(id)
  }
  def deleteUser(id: Int) = {
    user_table = user_table.filterNot(_.id == id)
    Right(())
  }
}

import akka.actor.ActorSystem
import akka.event.Logging
import akka.http.scaladsl.Http
import akka.stream.ActorMaterializer
object Boot extends App with Route {
  implicit lazy val system = ActorSystem("my-system")
  implicit lazy val materializer = ActorMaterializer()
  override implicit val db = MockDB
  implicit val ec = system.dispatcher
  val interface = "localhost"
  val port = 8080
  val logger = Logging(system, getClass)
  val binding = Http().bindAndHandle(routes, interface, port)
  binding.onFailure {
    case err: Exception =>
      logger.error(err, s"Failed to bind to $interface $port")
  }
}