package com.nashtech.order.v1.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.String
import kotlin.Throwable
import kotlin.Unit
import retrofit2.Response
import retrofit2.http.Body
import retrofit2.http.DELETE
import retrofit2.http.GET
import retrofit2.http.POST
import retrofit2.http.PUT
import retrofit2.http.Path

/**
 * This code was generated by [models.generator.kotlin.KotlinGenerator]
 */
interface OrdersClient {
  @GET(value="{merchant_id}/orders/{number}")
  fun getMerchantIdOrdersNumber(@Path(value="merchant_id") merchantId: String, @Path(value="number")
      number: String): Single<Response<Order>>

  @POST(value="{merchant_id}/orders")
  fun postMerchantIdOrders(@Path(value="merchant_id") merchantId: String, @Body
      orderForm: OrderForm): Single<Response<Order>>

  @PUT(value="{merchant_id}/orders/{number}")
  fun putMerchantIdOrdersNumber(
    @Path(value="merchant_id") merchantId: String,
    @Path(value="number") number: String,
    @Body orderForm: OrderForm
  ): Single<Response<Order>>

  @DELETE(value="{merchant_id}/orders")
  fun deleteMerchantIdOrders(@Path(value="merchant_id") merchantId: String): Single<Response<Unit>>

  object GetMerchantIdOrdersNumberCall {
    val toError: (Throwable) -> EitherCallOrCommonNetworkError<ErrorResponses> = {
    t ->
                    when (t) {
                        is HttpException -> {
                            val body: String? = t.response().errorBody()?.string()
                                when (t.code()) {
                                401 -> CallError<ErrorResponses> (ErrorResponses.Error401)
                                404 -> CallError<ErrorResponses> (ErrorResponses.Error404)
                            else ->
        CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                            }
                        }
                        else -> CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                    }
                }


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

    sealed class ErrorResponses {
      object Error401 : ErrorResponses()

      object Error404 : ErrorResponses()
    }
  }

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


    fun getCallAndErrorLambda(
      client: OrdersClient,
      merchantId: String,
      orderForm: OrderForm
    ) = ApiNetworkCallResponse(
       client.postMerchantIdOrders(merchantId,orderForm)
         .map{ response -> 
             if(response.isSuccessful)
               response.body()?.let { body -> Pair(body, response.code())}
             else
               throw HttpException(response)}
         .map{it}
    , toError)

    sealed class ErrorResponses {
      object Error401 : ErrorResponses()

      object Error404 : ErrorResponses()

      data class Error422(
        val data: Error
      ) : ErrorResponses()
    }
  }

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


    fun getCallAndErrorLambda(
      client: OrdersClient,
      merchantId: String,
      number: String,
      orderForm: OrderForm
    ) = ApiNetworkCallResponse(
       client.putMerchantIdOrdersNumber(merchantId,number,orderForm)
         .map{ response -> 
             if(response.isSuccessful)
               response.body()?.let { body -> Pair(body, response.code())}
             else
               throw HttpException(response)}
         .map{it}
    , toError)

    sealed class ErrorResponses {
      object Error401 : ErrorResponses()

      object Error404 : ErrorResponses()

      data class Error422(
        val data: Error
      ) : ErrorResponses()
    }
  }

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


    fun getCallAndErrorLambda(client: OrdersClient, merchantId: String) = ApiNetworkCallResponse(
       client.deleteMerchantIdOrders(merchantId)
         .map{ response -> 
             if(response.isSuccessful)
               Pair(Unit, response.code())
             else
               throw HttpException(response)}
         .map{it}
    , toError)

    sealed class ErrorResponses {
      object Error401 : ErrorResponses()

      object Error404 : ErrorResponses()

      data class Error422(
        val data: Error
      ) : ErrorResponses()
    }
  }
}