//Original Java-Style builders
val response = serviceStub.myRpcMethod(ExampleServiceGrpc.MyRpcMethodRequest
                                   .newBuilder()
                                   .setId(100)
                                   .setName("some name")
                                   .build())
                                   
//Kroto+ Overloaded
val response = serviceStub.myRpcMethod{
                         id = 100
                         name = "some name"
                    }

//Original 
val response = serviceStub.myRpcMethod(Empty.getDefaultInstance())
                                   
//Kroto+ Overloaded
val response = serviceStub.myRpcMethod()

//If request type is Empty
inline fun ExampleServiceStub.myRpcMethod(): ExampleServiceGrpc.MyRpcMethodResponse =
    myRpcMethod(Empty.getDefaultInstace())

//Otherwise

//Future Stub
inline fun ExampleServiceFutureStub.myRpcMethod(block: ExampleServiceGrpc.MyRpcMethodRequest.Builder.() -> Unit): ListenableFuture<ExampleServiceGrpc.MyRpcMethodResponse> {
    val request = ExampleServiceGrpc.MyRpcMethodRequest.newBuilder().apply(block).build()
    return myRpcMethod(request)
}
    
//BlockingStub
inline fun ExampleServiceBlockingStub.myRpcMethod(block: ExampleServiceGrpc.MyRpcMethodRequest.Builder.() -> Unit): ExampleServiceGrpc.MyRpcMethodResponse {
    val request = ExampleServiceGrpc.MyRpcMethodRequest.newBuilder().apply(block).build()
    return myRpcMethod(request)
}

//Async Stub
suspend fun ExampleServiceStub.myRpcMethod(request: ExampleServiceGrpc.MyRpcMethodRequest): ExampleServiceGrpc.MyRpcMethodResponse =
    suspendingUnaryCallObserver{ observer -> myRpcMethod(request,observer) }
    
suspend inline fun ExampleServiceStub.myRpcMethod(block: ExampleServiceGrpc.MyRpcMethodRequest.Builder.() -> Unit): ExampleServiceGrpc.MyRpcMethodResponse {
    val request = ExampleServiceGrpc.MyRpcMethodRequest.newBuilder().apply(block).build()
    return myRpcMethod(request)
}

suspend fun findStrongestAttack(): StandProto.Attack {
    
    val standService = StandServiceGrpc.newStub(managedChannel)
    val characterService = CharacterServiceGrpc.newStub(managedChannel)
    
    val deferredStands = characterService.getAllCharactersStream() //Service call returns a ReceiveChannel<Character>
            .map { character ->
                //Suspending unary call. Using the generated overloads we can rely on
                //coroutines for deferred calls instead of listenable futures 
                async { standService.getStandByCharacter(character) }
            }
            .toList()
            
    val strongestAttack = deferredStands
            .flatMap { it.await().attacksList }
            .maxBy { it.damage }
            
    return strongestAttack ?: StandProto.Attack.getDefaultInstance()
}

@Test fun `Test Bidirectional Rpc Channel`() = runBlocking {
    
    val stub = StandServiceGrpc.newStub(grpcServerRule.channel)
    
    //Bidi method overload returns a channel that accepts our request type (A Character) and
    //returns our response type (A Stand)
    val rpcChannel = stub.getStandsForCharacters()
    
    //Our dummy service is sending three responses for each request it receives
     
    rpcChannel.send(characters["Dio Brando"]!!)
    stands["The World"].toString().let {
        assertEquals(it,rpcChannel.receive().toString())
        assertEquals(it,rpcChannel.receive().toString())
        assertEquals(it,rpcChannel.receive().toString())
    }
    
    rpcChannel.send(characters["Jotaro Kujo"]!!)
    stands["Star Platinum"].toString().let {
        assertEquals(it,rpcChannel.receive().toString())
        assertEquals(it,rpcChannel.receive().toString())
        assertEquals(it,rpcChannel.receive().toString())
    }
    
    //Closing the channel has the same behavior as calling onComplete on the request stream observer.
    //Calling close(throwable) behaves the same as onError(throwable)
    rpcChannel.close()
    
    //Assert that we consumed the expected number of responses from the stream
    assertNull(rpcChannel.receiveOrNull(),"Response quantity was greater than expected")
}

@Test fun `Test Unary Response Queue`(){
    
    MockStandService.getStandByNameResponseQueue.apply {
       //Queue up a valid response message
       addMessage {
           name = "Star Platinum"
           powerLevel = 500
           speed = 550
           addAttacks(StandProtoBuilders.Attack {
               name = "ORA ORA ORA"
               damage = 100
               range = StandProto.Attack.Range.CLOSE
           })
       }   
          
       //Queue up an error
       addError(Status.INVALID_ARGUMENT)
   }
   
   val standStub = StandServiceGrpc.newBlockingStub(grpcServerRule.channel)
   
   standStub.getStandByName { name = "Star Platinum" }.let{ response ->
       assertEquals("Star Platinum",response.name)
       assertEquals(500,response.powerLevel)
       assertEquals(550,response.speed)
       response.attacksList.first().let{ attack ->
           assertEquals("ORA ORA ORA",attack.name)
           assertEquals(100,attack.damage)
           assertEquals(StandProto.Attack.Range.CLOSE,attack.range)
       }
   }
   
   try{
       standStub.getStandByName { name = "The World" }
       fail("Exception was expected with status code: ${Status.INVALID_ARGUMENT.code}")
   }catch (e: StatusRuntimeException){
       assertEquals(Status.INVALID_ARGUMENT.code, e.status.code)
   }
}

val attack = StandProtoBuilders.Attack {
                name = "ORA ORA ORA"
                damage = 100
                range = StandProto.Attack.Range.CLOSE
            }

//Copy extensions are also generated
val newAttack = attack.copy { damage = 200 }