package io.apibuilder.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 java.util.UUID
import kotlin.Boolean
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 WatchesClient {
  /**
   * Search attributes. Always paginated.
   */
  @GET(value="watches")
  fun getWatches(
    @Query(value="guid") guid: UUID?,
    @Query(value="user_guid") userGuid: UUID?,
    @Query(value="organization_key") organizationKey: String?,
    @Query(value="application_key") applicationKey: String?,
    @Query(value="limit") limit: Long,
    @Query(value="offset") offset: Long
  ): Single<Response<List<Watch>>>

  /**
   * Returns information about a specific watch.
   */
  @GET(value="watches/{guid}")
  fun getWatchesGuid(@Path(value="guid") guid: UUID): Single<Response<Watch>>

  /**
   * Quick check if a user is watching a specific application.
   */
  @GET(value="watches/check")
  fun getWatchesCheck(
    @Query(value="user_guid") userGuid: UUID?,
    @Query(value="organization_key") organizationKey: String,
    @Query(value="application_key") applicationKey: String
  ): Single<Response<Boolean>>

  /**
   * Create a new watch.
   */
  @POST(value="watches")
  fun postWatches(@Body watchForm: WatchForm): Single<Response<Watch>>

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

  object GetWatchesGuidCall {
    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: WatchesClient, guid: UUID) = ApiNetworkCallResponse(
       client.getWatchesGuid(guid)
         .map{ response -> 
             if(response.isSuccessful)
               response.body()?.let { body -> Pair(body, response.code())}
             else
               throw HttpException(response)}
         .map{it}
    , toError)

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

  object PostWatchesCall {
    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(io.apibuilder.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: WatchesClient, watchForm: WatchForm) = ApiNetworkCallResponse(
       client.postWatches(watchForm)
         .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 postWatches - Create a new watch.
     */
    sealed class ErrorResponses {
      data class Error409(
        val data: List<Error>
      ) : ErrorResponses()
    }
  }

  object DeleteWatchesGuidCall {
    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: WatchesClient, guid: UUID) = ApiNetworkCallResponse(
       client.deleteWatchesGuid(guid)
         .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()
    }
  }
}