"io.github.sfali23" %% "grpc-rest-gateway-annotations" % "0.9.1" % "compile,protobuf"

addSbtPlugin("com.thesamet" % "sbt-protoc" % "1.0.8")

libraryDependencies ++= Seq(
  "com.thesamet.scalapb" %% "compilerplugin" % "0.11.8",
  "io.github.sfali23" %% "grpc-rest-gateway-code-gen" % "0.9.1"
)

Compile / PB.targets := Seq(
  scalapb.gen() → (Compile / sourceManaged).value / "scalapb",
  grpc_rest_gateway.gatewayGen(implementationType = grpc_rest_gateway.ImplementationType.Netty) → (Compile / sourceManaged).value / "scalapb",
  grpc_rest_gateway.openApiGen() → (Compile / resourceManaged).value / "specs"
)

// change the value of the "implementationType" parameter to grpc_rest_gateway.ImplementationType.Pekko or
// grpc_rest_gateway.ImplementationType.Akka to generate Pekko or Akka based implementation

// generate code for Scala 3
Compile / PB.targets := Seq(
  scalapb.gen(scala3Sources = true) → (Compile / sourceManaged).value / "scalapb",
  grpc_rest_gateway.gatewayGen(useScala3Features = true, implementationType = grpc_rest_gateway.ImplementationType.Pekko) → (Compile / sourceManaged).value / "scalapb",
  grpc_rest_gateway.openApiGen() → (Compile / resourceManaged).value / "specs"
)

// Add the following to add openapi specs into the classpath
Compile / resourceGenerators += (Compile / PB.generate)
      .map(.filter(.getName.endsWith("yml")))
      .taskValue

val AppVersion = "0.9.1"
val ScalaPb: String = scalapb.compiler.Version.scalapbVersion
val GrpcJava: String = scalapb.compiler.Version.grpcJavaVersion
val ScalaPbJson = "0.12.1"
libraryDependencies ++= Seq(
  "io.github.sfali23" %% "grpc-rest-gateway-runtime-netty" % AppVersion,
  "com.thesamet.scalapb" %% "compilerplugin" % ScalaPb % "compile;protobuf",
  "com.thesamet.scalapb" %% "scalapb-runtime" % ScalaPb % "compile;protobuf",
  "com.thesamet.scalapb" %% "scalapb-runtime-grpc" % ScalaPb,
  "io.grpc" % "grpc-netty" % GrpcJava,
  "com.thesamet.scalapb" %% "scalapb-json4s" % ScalaPbJson,
  "com.thesamet.scalapb.common-protos" %% "proto-google-common-protos-scalapb_0.11" % "2.9.6-0" % "compile,protobuf",
  // optional if using custom annotation
  "io.github.sfali23" %% "grpc-rest-gateway-annotations" % AppVersion,
  "io.github.sfali23" %% "grpc-rest-gateway-annotations" % AppVersion % "protobuf"
)

val AppVersion = "0.9.1"
val ScalaPb: String = scalapb.compiler.Version.scalapbVersion
val GrpcJava: String = scalapb.compiler.Version.grpcJavaVersion

lazy val root = project
  .in(file("."))
  .enablePlugins(PekkoGrpcPlugin)
  .settings(
      libraryDependencies = Seq(
        "io.github.sfali23" %% "grpc-rest-gateway-runtime-pekko" % AppVersion,
        "org.apache.pekko" %% "pekko-actor" % "1.1.2",
        "org.apache.pekko" %% "pekko-actor-typed" % "1.1.2",
        "org.apache.pekko" %% "pekko-stream-typed" % "1.1.2",
        "org.apache.pekko" %% "pekko-http" % "1.1.0",
        "org.apache.pekko" %% "pekko-grpc-runtime" % "1.1.1",
        "com.thesamet.scalapb.common-protos" %% "proto-google-common-protos-scalapb_0.11" % "2.9.6-0" % "compile,protobuf",
        // optional if using custom annotation
        "io.github.sfali23" %% "grpc-rest-gateway-annotations" % AppVersion,
        "io.github.sfali23" %% "grpc-rest-gateway-annotations" % AppVersion % "protobuf"
      ),
      pekkoGrpcGeneratedSources := generatedSource,
      pekkoGrpcCodeGeneratorSettings := Seq("grpc", "single_line_to_proto_string"),
      Compile / PB.targets = Seq(
        grpc_rest_gateway
          .gatewayGen(
              scala3Sources = true,
              implementationType = grpc_rest_gateway.ImplementationType.Pekko
           ) → crossTarget.value / "pekko-grpc" / "main",
          grpc_rest_gateway.openApiGen() → (Compile / resourceManaged).value / "specs"
      ),
      Compile / resourceGenerators += (Compile / PB.generate)
      .map(.filter(.getName.endsWith("yml")))
      .taskValue
  )

/*
 * Generated by GRPC-REST gateway compiler. DO NOT EDIT.
 */
package rest_gateway_test.api.scala_api

import scalapb.GeneratedMessage
import io.grpc.ManagedChannel
import io.netty.handler.codec.http.{HttpMethod, QueryStringDecoder}

import com.improving.grpc_rest_gateway.runtime
import runtime.core.*
import runtime.handlers.*

import scala.concurrent.{ExecutionContext, Future}
import scala.util.Try

object TestServiceBGatewayHandler {
  private val GetGetRequestPath = "/restgateway/test/testserviceb"
  private val PostProcessPath = "/restgateway/test/testserviceb"
  private val PutUpdatePath = "/restgateway/test/testserviceb/update"

  def apply(channel: ManagedChannel)(implicit ec: ExecutionContext): TestServiceBGatewayHandler =
    new TestServiceBGatewayHandler(channel)
}

class TestServiceBGatewayHandler(channel: ManagedChannel)(implicit ec: ExecutionContext)
  extends GrpcGatewayHandler(channel)(ec) {
  import TestServiceBGatewayHandler.*
  override val serviceName: String = "TestServiceB"
  override val specificationName: String = "TestServiceB"
  private lazy val client = TestServiceBGrpc.stub(channel)
  override protected val httpMethodsToUrisMap: Map[String, Seq[String]] = Map(
    "GET" -> Seq(
      GetGetRequestPath
    ),
    "POST" -> Seq(
      PostProcessPath
    ),
    "PUT" -> Seq(
      PutUpdatePath
    )
  )

  override protected def dispatchCall(method: HttpMethod, uri: String, body: String): Future[(Int, GeneratedMessage)] = {
    val queryString = new QueryStringDecoder(uri)
    val path = queryString.path
    val methodName = method.name
    if (isSupportedCall(HttpMethod.GET.name, GetGetRequestPath, methodName, path))
      dispatchGetRequest(200, mergeParameters(GetGetRequestPath, queryString))
    else if (isSupportedCall(HttpMethod.POST.name, PostProcessPath, methodName, path))
      dispatchProcess(200, body)
    else if (isSupportedCall(HttpMethod.PUT.name, PutUpdatePath, methodName, path))
      dispatchUpdate(204, body)
    else Future.failed(GatewayException.toInvalidArgument(s"No route defined for $methodName($path)"))
  }

  private def dispatchGetRequest(statusCode: Int, parameters: Map[String, Seq[String]]) = {
    val input = Try {
      val requestId = parameters.toLongValue("requestId")
      rest_gateway_test.api.model.TestRequestB(requestId = requestId)
    }
    toResponse(input, client.getRequest, statusCode)
  }

  private def dispatchProcess(statusCode: Int, body: String) = {
    val input = parseBody[rest_gateway_test.api.model.TestRequestB](body)
    toResponse(input, client.process, statusCode)
  }

  private def dispatchUpdate(statusCode: Int, body: String) = {
    val input = parseBody[rest_gateway_test.api.model.TestRequestB](body)
    toResponse(input, client.update, statusCode)
  }
}

/*
 * Generated by GRPC-REST gateway compiler. DO NOT EDIT.
 */
package rest_gateway_test.api.scala_api

import com.improving.grpc_rest_gateway.runtime
import runtime.core._
import runtime.handlers.GrpcGatewayHandler

import org.apache.pekko
import pekko.grpc.GrpcClientSettings
import pekko.actor.ClassicActorSystemProvider
import pekko.http.scaladsl.server.Route
import pekko.http.scaladsl.server.Directives._

import scala.concurrent.ExecutionContext
import scala.util.Try

class TestServiceBGatewayHandler(settings: GrpcClientSettings)(implicit sys: ClassicActorSystemProvider) extends GrpcGatewayHandler {

  private implicit val ec: ExecutionContext = sys.classicSystem.dispatcher
  private lazy val client = TestServiceBClient(settings)
  override val specificationName: String = "TestServiceB"

  override val route: Route = handleExceptions(exceptionHandler) {
      pathPrefix("restgateway") {
        pathPrefix("test") {
          pathPrefix("testserviceb") {
            concat(
              pathEnd {
                concat(
                  get {
                    parameterMultiMap { queryParameters =>
                      dispatchGetRequest(200, queryParameters)
                    }
                  },
                  post {
                    entity(as[String]) { body =>
                      dispatchProcess(200, body)
                    }
                  }
                )
              },
              pathPrefix("update") {
                pathEnd {
                  put {
                    entity(as[String]) { body =>
                      dispatchUpdate(204, body)
                    }
                  }
                }
              }
            )
          }
        }
      }
    }

  private def dispatchGetRequest(statusCode: Int, parameters: Map[String, Seq[String]]) = {
    val input = Try {
      val requestId = parameters.toLongValue("requestId")
      rest_gateway_test.api.model.TestRequestB(requestId = requestId)
    }
    completeResponse(input, client.getRequest, statusCode)
  }

  private def dispatchProcess(statusCode: Int, body: String) = {
    val input = parseBody[rest_gateway_test.api.model.TestRequestB](body)
    completeResponse(input, client.process, statusCode)
  }

  private def dispatchUpdate(statusCode: Int, body: String) = {
    val input = parseBody[rest_gateway_test.api.model.TestRequestB](body)
    completeResponse(input, client.update, statusCode)
  }
}

object TestServiceBGatewayHandler {

  def apply(settings: GrpcClientSettings)(implicit sys: ClassicActorSystemProvider): GrpcGatewayHandler = {
    new TestServiceBGatewayHandler(settings)
  }

  def apply(clientName: String)(implicit sys: ClassicActorSystemProvider): GrpcGatewayHandler = {
    TestServiceBGatewayHandler(GrpcClientSettings.fromConfig(clientName))
  }
}

import com.improving.grpc_rest_gateway.runtime.server.GatewayServer
import rest_gateway_test.api.scala_api.TestServiceB.TestServiceBGatewayHandler
import scala.concurrent.ExecutionContext

implicit val ex: ExecutionContext = ??? // provide ExecutionContext
val server = GatewayServer(
      serviceHost = "localhost",
      servicePort = 8080, // assuming gRPC server is running on port 8080
      gatewayPort = 7070, // REST end point is running at port 7070
      toHandlers = channel => Seq(TestServiceBGatewayHandler(channel)),
      executor = None, // Executor is useful if you want to allocate different thread pool for REST endpoint
      usePlainText = true
    )
server.start()

// stop server once done
server.stop()

// via Typesafe config
val mainConfig = ConfigFactory.load()
val server = GatewayServer(
  config = mainConfig.getConfig("rest-gateway"),
  toHandlers = channel => Seq(TestServiceBGatewayHandler(channel)),
  executor = None
)

implicit val system: ActorSystem[?] = ActorSystem[Nothing](Behaviors.empty, "grpc-rest-gateway-pekko")

val settings = GrpcClientSettings.fromConfig("pekko-gateway")
val config = system.settings.config
val restGatewayConfig = config.getConfig("rest-gateway")
GatewayServer(
  restGatewayConfig,
  TestServiceBGatewayHandler(settings)
).run()

// Or using HttSettings

GatewayServer(
  HttpSettings(restGatewayConfig),
  TestServiceBGatewayHandler(settings)
).run()

implicit val system: ActorSystem[?] = ActorSystem[Nothing](Behaviors.empty, "grpc-rest-gateway-pekko")

val settings = GrpcClientSettings.fromConfig("pekko-gateway")
val config = system.settings.config
GatewayServer(
  config.getConfig("rest-gateway"),
  TestServiceBGatewayHandler(settings)
).run()