import com.google.rpc.{Code, Status}
import io.grpc.protobuf.StatusProto
import scala.concurrent.Future

// handle bad request
Future.failed(StatusProto.toStatusRuntimeException(
        Status
          .newBuilder()
          .setCode(Code.INVALID_ARGUMENT_VALUE)
          .setMessage("Invalid argument")
          .build())
)

// not found
Future.failed(StatusProto.toStatusRuntimeException(
        Status
          .newBuilder()
          .setCode(Code.NOT_FOUND_VALUE)
          .setMessage("Not found")
          .build())
)

/*
 * 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 rest_gateway_test.api.model.TestRequestB

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

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

  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 val client = TestServiceBGrpc.stub(channel)
  override protected val httpMethodsToUrisMap: Map[String, Seq[String]] = Map(
    "GET" -> Seq(
      GetGetRequestPath
    ),
    "POST" -> Seq(
      PostProcessPath
    )
  )

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

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

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

}

/*
 * 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 rest_gateway_test.api.model.TestRequestB

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 val client = TestServiceBClient(settings)
  override val specificationName: String = "TestServiceB"

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

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

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

}

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))
}