package nm.joglog.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.String
import kotlin.Throwable
import kotlin.collections.List
import retrofit2.Response
import retrofit2.http.Body
import retrofit2.http.DELETE
import retrofit2.http.GET
import retrofit2.http.PATCH
import retrofit2.http.POST
import retrofit2.http.Path

/**
 * This code was generated by [models.generator.kotlin.KotlinGenerator]
 */
interface UsersClient {
  /**
   * Authentication
   */
  @POST(value="users/authenticate")
  fun postUsersAuthenticate(@Body `user.Minimal`: user.Minimal): Single<Response<String>>

  /**
   * Create a user
   */
  @POST(value="users")
  fun postUsers(@Body `user.Minimal`: user.Minimal): Single<Response<User>>

  /**
   * List all users
   */
  @GET(value="users")
  fun getUsers(): Single<Response<List<User>>>

  /**
   * Get a specific user
   */
  @GET(value="users/{id}")
  fun getUsersId(@Path(value="id") id: Int): Single<Response<User>>

  /**
   * Patch a user
   */
  @PATCH(value="users")
  fun patchUsers(@Body `user.patch.Entry`: List<user.patch.Entry>): Single<Response<User>>

  /**
   * Remove a specific user
   */
  @DELETE(value="users/{id}")
  fun deleteUsersId(@Path(value="id") id: Int): Single<Response<User>>

  object PostUsersAuthenticateCall {
    val toError: (Throwable) -> EitherCallOrCommonNetworkError<ErrorResponses> = {
    t ->
                    when (t) {
                        is HttpException -> {
                            val body: String? = t.response().errorBody()?.string()
                                when (t.code()) {
                                403 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error403(nm.joglog.api.v0.models.JacksonObjectMapperFactory.create().readValue(body,
        String::class.java))) } ?: CommonNetworkError(UnknownNetworkError(403, "No Body"))
                            else ->
        CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                            }
                        }
                        else -> CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                    }
                }


    fun getCallAndErrorLambda(client: UsersClient, `user.Minimal`: user.Minimal) =
        ApiNetworkCallResponse(
       client.postUsersAuthenticate(user.Minimal)
         .map{ response -> 
             if(response.isSuccessful)
               response.body()?.let { body -> Pair(body, response.code())}
             else
               throw HttpException(response)}
         .map{it}
    , toError)

    /**
     * Error Responses for postUsersAuthenticate - Authentication
     */
    sealed class ErrorResponses {
      data class Error403(
        val data: String
      ) : ErrorResponses()
    }
  }

  object PostUsersCall {
    val toError: (Throwable) -> EitherCallOrCommonNetworkError<ErrorResponses> = {
    t ->
                    when (t) {
                        is HttpException -> {
                            val body: String? = t.response().errorBody()?.string()
                                when (t.code()) {
                                400 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error400(nm.joglog.api.v0.models.JacksonObjectMapperFactory.create().readValue(body,
        String::class.java))) } ?: CommonNetworkError(UnknownNetworkError(400, "No Body"))
                                403 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error403(nm.joglog.api.v0.models.JacksonObjectMapperFactory.create().readValue(body,
        String::class.java))) } ?: CommonNetworkError(UnknownNetworkError(403, "No Body"))
                            else ->
        CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                            }
                        }
                        else -> CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                    }
                }


    fun getCallAndErrorLambda(client: UsersClient, `user.Minimal`: user.Minimal) =
        ApiNetworkCallResponse(
       client.postUsers(user.Minimal)
         .map{ response -> 
             if(response.isSuccessful)
               response.body()?.let { body -> Pair(body, response.code())}
             else
               throw HttpException(response)}
         .map{it}
    , toError)

    /**
     * Error Responses for postUsers - Create a user
     */
    sealed class ErrorResponses {
      data class Error400(
        val data: String
      ) : ErrorResponses()

      data class Error403(
        val data: String
      ) : ErrorResponses()
    }
  }

  object GetUsersCall {
    val toError: (Throwable) -> EitherCallOrCommonNetworkError<ErrorResponses> = {
    t ->
                    when (t) {
                        is HttpException -> {
                            val body: String? = t.response().errorBody()?.string()
                                when (t.code()) {
                                403 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error403(nm.joglog.api.v0.models.JacksonObjectMapperFactory.create().readValue(body,
        String::class.java))) } ?: CommonNetworkError(UnknownNetworkError(403, "No Body"))
                            else ->
        CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                            }
                        }
                        else -> CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                    }
                }


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

    /**
     * Error Responses for getUsers - List all users
     */
    sealed class ErrorResponses {
      data class Error403(
        val data: String
      ) : ErrorResponses()
    }
  }

  object GetUsersIdCall {
    val toError: (Throwable) -> EitherCallOrCommonNetworkError<ErrorResponses> = {
    t ->
                    when (t) {
                        is HttpException -> {
                            val body: String? = t.response().errorBody()?.string()
                                when (t.code()) {
                                403 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error403(nm.joglog.api.v0.models.JacksonObjectMapperFactory.create().readValue(body,
        String::class.java))) } ?: CommonNetworkError(UnknownNetworkError(403, "No Body"))
                                404 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error404(nm.joglog.api.v0.models.JacksonObjectMapperFactory.create().readValue(body,
        String::class.java))) } ?: CommonNetworkError(UnknownNetworkError(404, "No Body"))
                            else ->
        CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                            }
                        }
                        else -> CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                    }
                }


    fun getCallAndErrorLambda(client: UsersClient, id: Int) = ApiNetworkCallResponse(
       client.getUsersId(id)
         .map{ response -> 
             if(response.isSuccessful)
               response.body()?.let { body -> Pair(body, response.code())}
             else
               throw HttpException(response)}
         .map{it}
    , toError)

    /**
     * Error Responses for getUsersId - Get a specific user
     */
    sealed class ErrorResponses {
      data class Error403(
        val data: String
      ) : ErrorResponses()

      data class Error404(
        val data: String
      ) : ErrorResponses()
    }
  }

  object PatchUsersCall {
    val toError: (Throwable) -> EitherCallOrCommonNetworkError<ErrorResponses> = {
    t ->
                    when (t) {
                        is HttpException -> {
                            val body: String? = t.response().errorBody()?.string()
                                when (t.code()) {
                                403 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error403(nm.joglog.api.v0.models.JacksonObjectMapperFactory.create().readValue(body,
        String::class.java))) } ?: CommonNetworkError(UnknownNetworkError(403, "No Body"))
                            else ->
        CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                            }
                        }
                        else -> CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                    }
                }


    fun getCallAndErrorLambda(client: UsersClient, `user.patch.Entry`: List<user.patch.Entry>) =
        ApiNetworkCallResponse(
       client.patchUsers(user.patch.Entry)
         .map{ response -> 
             if(response.isSuccessful)
               response.body()?.let { body -> Pair(body, response.code())}
             else
               throw HttpException(response)}
         .map{it}
    , toError)

    /**
     * Error Responses for patchUsers - Patch a user
     */
    sealed class ErrorResponses {
      data class Error403(
        val data: String
      ) : ErrorResponses()
    }
  }

  object DeleteUsersIdCall {
    val toError: (Throwable) -> EitherCallOrCommonNetworkError<ErrorResponses> = {
    t ->
                    when (t) {
                        is HttpException -> {
                            val body: String? = t.response().errorBody()?.string()
                                when (t.code()) {
                                403 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error403(nm.joglog.api.v0.models.JacksonObjectMapperFactory.create().readValue(body,
        String::class.java))) } ?: CommonNetworkError(UnknownNetworkError(403, "No Body"))
                                404 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error404(nm.joglog.api.v0.models.JacksonObjectMapperFactory.create().readValue(body,
        String::class.java))) } ?: CommonNetworkError(UnknownNetworkError(404, "No Body"))
                            else ->
        CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                            }
                        }
                        else -> CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                    }
                }


    fun getCallAndErrorLambda(client: UsersClient, id: Int) = ApiNetworkCallResponse(
       client.deleteUsersId(id)
         .map{ response -> 
             if(response.isSuccessful)
               response.body()?.let { body -> Pair(body, response.code())}
             else
               throw HttpException(response)}
         .map{it}
    , toError)

    /**
     * Error Responses for deleteUsersId - Remove a specific user
     */
    sealed class ErrorResponses {
      data class Error403(
        val data: String
      ) : ErrorResponses()

      data class Error404(
        val data: String
      ) : ErrorResponses()
    }
  }
}