package io.gimbalabs.hilltop.api.v0.models

import com.jakewharton.retrofit2.adapter.rxjava2.HttpException
import io.apibuilder.app.ApiNetworkCallResponse
import io.apibuilder.app.CommonNetworkErrors
import io.apibuilder.app.CommonNetworkErrors.UnknownNetworkError
import io.apibuilder.app.EitherCallOrCommonNetworkError
import io.apibuilder.app.EitherCallOrCommonNetworkError.CallError
import io.apibuilder.app.EitherCallOrCommonNetworkError.CommonNetworkError
import io.reactivex.Single
import kotlin.Int
import kotlin.Long
import kotlin.String
import kotlin.Throwable
import kotlin.collections.List
import retrofit2.Response
import retrofit2.http.GET
import retrofit2.http.Path
import retrofit2.http.Query

/**
 * This code was generated by [models.generator.kotlin.KotlinGenerator]
 */
interface StakepoolsClient {
  /**
   * find pool details by vrf_vkey
   */
  @GET(value="stakepools/vrf_vkey/{vrf_vkey_hash}")
  fun getStakepoolsVrfVkeyVrfVkeyHash(@Path(value="vrf_vkey_hash") vrfVkeyHash: String):
      Single<Response<Stakepool>>

  /**
   * Epoch at which stake pool was originally registered
   */
  @GET(value="stakepools/{pool_id}/established_epoch")
  fun getStakepoolsPoolIdEstablishedEpoch(@Path(value="pool_id") poolId: String):
      Single<Response<Int>>

  /**
   * live stake in lovelaces
   */
  @GET(value="stakepools/{pool_id}/live_stake")
  fun getStakepoolsPoolIdLiveStake(@Path(value="pool_id") poolId: String): Single<Response<Long>>

  /**
   * number minted blocks in epoch
   */
  @GET(value="stakepools/{pool_id}/blocks")
  fun getStakepoolsPoolIdBlocks(@Path(value="pool_id") poolId: String, @Query(value="epoch")
      epoch: Int?): Single<Response<Int>>

  @GET(value="stakepools")
  fun getStakepools(): Single<Response<List<Stakepool>>>

  object GetStakepoolsVrfVkeyVrfVkeyHashCall {
    val toError: (Throwable) -> EitherCallOrCommonNetworkError<ErrorResponses> = {
    t ->
                    when (t) {
                        is HttpException -> {
                            val body: String? = t.response().errorBody()?.string()
                                when (t.code()) {
                                404 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error404(GenericError.parseJson(body))) } ?:
        CommonNetworkError(UnknownNetworkError(404, "No Body"))
                            else ->
        CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                            }
                        }
                        else -> CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                    }
                }


    fun getCallAndErrorLambda(client: StakepoolsClient, vrfVkeyHash: String) =
        ApiNetworkCallResponse(
       client.getStakepoolsVrfVkeyVrfVkeyHash(vrfVkeyHash)
         .map{ response -> 
             if(response.isSuccessful)
               response.body()?.let { body -> Pair(body, response.code())}
             else
               throw HttpException(response)}
         .map{it}
    , toError)

    /**
     * Error Responses for getStakepoolsVrfVkeyVrfVkeyHash - find pool details by vrf_vkey
     */
    sealed class ErrorResponses {
      data class Error404(
        val data: GenericError
      ) : ErrorResponses()
    }
  }

  object GetStakepoolsPoolIdEstablishedEpochCall {
    val toError: (Throwable) -> EitherCallOrCommonNetworkError<ErrorResponses> = {
    t ->
                    when (t) {
                        is HttpException -> {
                            val body: String? = t.response().errorBody()?.string()
                                when (t.code()) {
                                404 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error404(GenericError.parseJson(body))) } ?:
        CommonNetworkError(UnknownNetworkError(404, "No Body"))
                            else ->
        CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                            }
                        }
                        else -> CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                    }
                }


    fun getCallAndErrorLambda(client: StakepoolsClient, poolId: String) = ApiNetworkCallResponse(
       client.getStakepoolsPoolIdEstablishedEpoch(poolId)
         .map{ response -> 
             if(response.isSuccessful)
               response.body()?.let { body -> Pair(body, response.code())}
             else
               throw HttpException(response)}
         .map{it}
    , toError)

    /**
     * Error Responses for getStakepoolsPoolIdEstablishedEpoch - Epoch at which stake pool was
     * originally registered
     */
    sealed class ErrorResponses {
      data class Error404(
        val data: GenericError
      ) : ErrorResponses()
    }
  }

  object GetStakepoolsPoolIdLiveStakeCall {
    val toError: (Throwable) -> EitherCallOrCommonNetworkError<ErrorResponses> = {
    t ->
                    when (t) {
                        is HttpException -> {
                            val body: String? = t.response().errorBody()?.string()
                                when (t.code()) {
                                404 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error404(GenericError.parseJson(body))) } ?:
        CommonNetworkError(UnknownNetworkError(404, "No Body"))
                            else ->
        CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                            }
                        }
                        else -> CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                    }
                }


    fun getCallAndErrorLambda(client: StakepoolsClient, poolId: String) = ApiNetworkCallResponse(
       client.getStakepoolsPoolIdLiveStake(poolId)
         .map{ response -> 
             if(response.isSuccessful)
               response.body()?.let { body -> Pair(body, response.code())}
             else
               throw HttpException(response)}
         .map{it}
    , toError)

    /**
     * Error Responses for getStakepoolsPoolIdLiveStake - live stake in lovelaces
     */
    sealed class ErrorResponses {
      data class Error404(
        val data: GenericError
      ) : ErrorResponses()
    }
  }

  object GetStakepoolsPoolIdBlocksCall {
    val toError: (Throwable) -> EitherCallOrCommonNetworkError<ErrorResponses> = {
    t ->
                    when (t) {
                        is HttpException -> {
                            val body: String? = t.response().errorBody()?.string()
                                when (t.code()) {
                                404 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error404(GenericError.parseJson(body))) } ?:
        CommonNetworkError(UnknownNetworkError(404, "No Body"))
                            else ->
        CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                            }
                        }
                        else -> CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                    }
                }


    fun getCallAndErrorLambda(
      client: StakepoolsClient,
      poolId: String,
      epoch: Int?
    ) = ApiNetworkCallResponse(
       client.getStakepoolsPoolIdBlocks(poolId,epoch)
         .map{ response -> 
             if(response.isSuccessful)
               response.body()?.let { body -> Pair(body, response.code())}
             else
               throw HttpException(response)}
         .map{it}
    , toError)

    /**
     * Error Responses for getStakepoolsPoolIdBlocks - number minted blocks in epoch
     */
    sealed class ErrorResponses {
      data class Error404(
        val data: GenericError
      ) : ErrorResponses()
    }
  }
}