package januar.apidoc.apidoc.api.v0.models

import com.fasterxml.jackson.core.type.TypeReference
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 januar.apidoc.apidoc.api.v0.enums.Publication
import java.util.UUID
import kotlin.Long
import kotlin.String
import kotlin.Throwable
import kotlin.Unit
import kotlin.collections.List
import retrofit2.Response
import retrofit2.http.Body
import retrofit2.http.DELETE
import retrofit2.http.GET
import retrofit2.http.POST
import retrofit2.http.Path
import retrofit2.http.Query

/**
 * This code was generated by [models.generator.kotlin.KotlinGenerator]
 */
interface SubscriptionsClient {
  /**
   * Search subscriptions. Always paginated.
   */
  @GET(value="subscriptions")
  fun getSubscriptions(
    @Query(value="guid") guid: UUID?,
    @Query(value="organization_key") organizationKey: String?,
    @Query(value="user_guid") userGuid: UUID?,
    @Query(value="publication") publication: Publication?,
    @Query(value="limit") limit: Long,
    @Query(value="offset") offset: Long
  ): Single<Response<List<Subscription>>>

  /**
   * Returns information about a specific subscription.
   */
  @GET(value="subscriptions/{guid}")
  fun getSubscriptionsGuid(@Path(value="guid") guid: UUID): Single<Response<Subscription>>

  /**
   * Create a new subscription.
   */
  @POST(value="subscriptions")
  fun postSubscriptions(@Body subscriptionForm: SubscriptionForm): Single<Response<Subscription>>

  @DELETE(value="subscriptions/{guid}")
  fun deleteSubscriptionsGuid(@Path(value="guid") guid: UUID): Single<Response<Unit>>

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


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

    /**
     * Error Responses for getSubscriptionsGuid - Returns information about a specific subscription.
     */
    sealed class ErrorResponses {
      object Error404 : ErrorResponses()
    }
  }

  object PostSubscriptionsCall {
    val toError: (Throwable) -> EitherCallOrCommonNetworkError<ErrorResponses> = {
    t ->
                    when (t) {
                        is HttpException -> {
                            val body: String? = t.response().errorBody()?.string()
                                when (t.code()) {
                                409 -> body?.let {
        CallError<ErrorResponses>(ErrorResponses.Error409(januar.apidoc.apidoc.api.v0.models.JacksonObjectMapperFactory.create().readValue(body,
        ErrorListTypeReference ))) } ?: CommonNetworkError(UnknownNetworkError(409, "No Body"))
                            else ->
        CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                            }
                        }
                        else -> CommonNetworkError(CommonNetworkErrors.processCommonNetworkError(t))
                    }
                }


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

    object ErrorListTypeReference : TypeReference<List<Error>>()

    /**
     * Error Responses for postSubscriptions - Create a new subscription.
     */
    sealed class ErrorResponses {
      data class Error409(
        val data: List<Error>
      ) : ErrorResponses()
    }
  }
}