//an extension over string (support GET, PUT, POST, DELETE with httpGet(), httpPut(), httpPost(), httpDelete())
"https://httpbin.org/get".httpGet().responseString { request, response, result ->
  //do something with response
  when (result) {
    is Result.Failure -> {
      val ex = result.getException()
    }
    is Result.Success -> {
      val data = result.get()
    }
  }
}

//if we set baseURL beforehand, simply use relativePath
FuelManager.instance.basePath = "https://httpbin.org"
"/get".httpGet().responseString { request, response, result ->
    //make a GET to https://httpbin.org/get and do something with response
    val (data, error) = result
    if (error == null) {
        //do something when success
    } else {
        //error handling
    }
}

//if you prefer this a little longer way, you can always do
//get
Fuel.get("https://httpbin.org/get").responseString { request, response, result ->
	//do something with response
	result.fold({ d ->
	    //do something with data
	}, { err ->
	    //do something with error
	})
}

val (request, response, result) = "https://httpbin.org/get".httpGet().responseString() // result is Result<String, FuelError>

Fuel.get("https://httpbin.org/get").response { request, response, result ->
    println(request)
    println(response)
    val (bytes, error) = result
    if (bytes != null) {
        println(bytes)
    }
}

fun response(handler: (Request, Response, Result<ByteArray, FuelError>) -> Unit)

fun responseString(handler: (Request, Response, Result<String, FuelError>) -> Unit)

fun responseJson(handler: (Request, Response, Result<Json, FuelError>) -> Unit)

val jsonObject = json.obj() //JSONObject
val jsonArray = json.array() //JSONArray

fun <T> responseObject(deserializer: ResponseDeserializable<T>, handler: (Request, Response, Result<T, FuelError>) -> Unit)

Fuel.post("https://httpbin.org/post").response { request, response, result ->
}

// JSON body from string (automatically sets application/json as Content-Type)
Fuel.post("https://httpbin.org/post")
    .jsonBody("{ \"foo\" : \"bar\" }")
    .response { request, response, result -> }
    
// Body from a generic string
Fuel.post("https://httpbin.org/post")
    .header(Headers.CONTENT_TYPE, "text/plain")
    .body("my body is plain")
    .response { request, response, result -> }
    
// Body from a file
Fuel.post("https://httpbin.org/post")
    .header(Headers.CONTENT_TYPE, "text/plain")
    .body(File("lipsum.txt"))
    .response { request, response, result -> }
    
// Body from a generic stream
val stream = ByteArrayInputStream("source-string-from-string".toByteArray())
Fuel.post("https://httpbin.org/post")
    .header(Headers.CONTENT_TYPE, "text/plain")
    .body(stream)
    .response { request, response, result -> }

Fuel.put("https://httpbin.org/put")
    .response { request, response, result -> }
    
// Supports all the body methods, like POST requests

Fuel.delete("https://httpbin.org/delete")
    .response { request, response, result -> }

// Supports all the body methods, like POST requests

Fuel.head("https://httpbin.org/get")
    .response { request, response, result -> /* request body is empty */ }

Fuel.patch("https://httpbin.org/patch").response { request, response, result -> }

// Supports all the body methods, like POST requests

Fuel.request(Method.OPTIONS, "https://httpbin.org/anything")
    .response { request, response, result -> }

Fuel.request(Method.TRACE, "https://httpbin.org/anything")
    .response { request, response, result -> }

val request = Fuel.get("https://httpbin.org/get", parameters = listOf("key" to "value"))
println(request)

// --> GET (https://httpbin.org/get?key=value)
//    Body : (empty)
//    Headers : (2)
//    Accept-Encoding : compress;q=0.5, gzip;q=1.0
//    Device : Android

val (_, response, _) = Fuel.get("https://httpbin.org/get", parameters = listOf("key" to "value")).response()
println(response)
// <-- 200 (https://httpbin.org/get?key=value)
//    Body : (empty)

val request = Fuel.post("https://httpbin.org/post", parameters = listOf("foo" to "foo", "bar" to "bar", "key" to "value"))
println(request.cUrlString())

Fuel.get("https://httpbin.org/get", listOf("foo" to "foo", "bar" to "bar"))
    .response { request, response, result -> }
// resolve to https://httpbin.org/get?foo=foo&bar=bar
    
Fuel.delete("https://httpbin.org/delete", listOf("foo" to "foo", "bar" to "bar"))
    .response { request, response, result -> }
// resolve to https://httpbin.org/delete?foo=foo&bar=bar

Fuel.get("https://httpbin.org/get", listOf("foo" to "foo", "dwarf" to  arrayOf("grumpy","happy","sleepy","dopey")))
    .response { request, response, result -> }
// resolve to  https://httpbin.org/get?foo=foo&dwarf[]=grumpy&dwarf[]=happy&dwarf[]=sleepy&dwarf[]=dopey

Fuel.post("https://httpbin.org/post", listOf("foo" to "foo", "bar" to "bar"))
    .response { request, response, result -> }
// Body : "foo=foo&bar=bar"

Fuel.put("https://httpbin.org/put", listOf("foo" to "foo", "bar" to "bar"))
    .response { request, response, result -> }
// Body : "foo=foo&bar=bar"

val timeout = 5000 // 5000 milliseconds = 5 seconds.
val timeoutRead = 60000 // 60000 milliseconds = 1 minute.

Fuel.get("https://httpbin.org/get")
    .timeout(timeout)
    .timeoutRead(timeoutRead)
    .responseString { request, response, result -> }

Fuel.download("https://httpbin.org/bytes/32768")
    .destination { response, url -> File.createTempFile("temp", ".tmp") }
    .response { req, res, result -> }

Fuel.download("https://httpbin.org/bytes/32768")
    .destination { response, url -> File.createTempFile("temp", ".tmp") }
    .progress { readBytes, totalBytes ->
        val progress = readBytes.toFloat() / totalBytes.toFloat() * 100
        println("Bytes downloaded $readBytes / $totalBytes ($progress %)")
    }
    .response { req, res, result -> }

Fuel.upload("/post")
    .source { request, url -> File.createTempFile("temp", ".tmp") }
    .responseString { request, response, result -> }

// By default upload use Method.POST, unless it is specified as something else
Fuel.upload("/put", Method.PUT)
    .source { request, url -> File.createTempFile("temp", ".tmp") }
    .responseString { request, response, result -> }

// Upload with multiple files
Fuel.upload("/post")
    .sources { request, url ->
        listOf(
            File.createTempFile("temp1", ".tmp"),
            File.createTempFile("temp2", ".tmp")
        )
    }
    .name { "temp" }
    .responseString { request, response, result -> }

Fuel.upload("/post")
    .dataParts { request, url -> 
        listOf( 
            //DataPart takes a file, and you can specify the name and/or type
            DataPart(File.createTempFile("temp1", ".tmp"), "image/jpeg"), 
            DataPart(File.createTempFile("temp2", ".tmp"), "file2"), 
            DataPart(File.createTempFile("temp3", ".tmp"), "third-file", "image/jpeg") 
        ) 
    }
    .responseString { request, response, result -> /* ... */ }

val formData = listOf("Email" to "[email protected]", "Name" to "Joe Smith" )
Fuel.upload("/post", param = formData)
    // Upload normally requires a file, but we can give it an empty list of `DataPart`
    .dataParts { request, url -> listOf<DataPart>() } 
    .responseString { request, response, result -> /* ... */ }

Fuel.upload("/post")
    .blob { request, url -> Blob("filename.png", someObject.length) { someObject.getInputStream() } }

//User Model
data class User(val firstName: String = "",
                val lastName: String = "") {

    //User Deserializer
    class Deserializer : ResponseDeserializable<User> {
        override fun deserialize(content: String) = Gson().fromJson(content, User::class.java)
    }

}

//Use httpGet extension
"https://www.example.com/user/1".httpGet().responseObject(User.Deserializer()) { req, res, result ->
    //result is of type Result<User, Exception>
    val (user, err) = result

    println(user.firstName)
    println(user.lastName)
}

data class HttpBinUserAgentModel(var userAgent: String = "")
Fuel.get("/user-agent")
    .responseObject<HttpBinUserAgentModel> { _, _, result -> }

@Serializable
data class HttpBinUserAgentModel(var userAgent: String = "")

Fuel.get("/user-agent")
    .responseObject<HttpBinUserAgentModel> { _, _, result -> }

@Serializable
data class HttpBinUserAgentModel(var userAgent: String = "")

Fuel.get("/user-agent")
    .responseObject<HttpBinUserAgentModel>(json = JSON(nonstrict = true)) { _, _, result -> }

@Serializable
data class HttpBinUserAgentModel(var userAgent: String = "")

Fuel.get("/list/user-agent")
    .responseObject<HttpBinUserAgentModel>(loader = HttpBinUserAgentModel.serilaizer().list) { _, _, result -> }

@Serializable
data class HttpBinUserAgentModel(var userAgent: String = "")

Fuel.get("/user-agent")
    .awaitResponseObject<HttpBinUserAgentModel>(kotlinxDeserializerOf()) { _, _, result -> }

Fuel.testMode {
    timeout = 15000 // Optional feature, set all requests' timeout to this value.
}

Fuel.get("www.example.com/get")
    .liveDataResponse()
    .observe(this) { /* do something */ }

sealed class WeatherApi: FuelRouting {

    override val basePath = "https://www.metaweather.com"

    class weatherFor(val location: String): WeatherApi() {}

    override val method: Method
        get() {
            when(this) {
                is weatherFor -> return Method.GET
            }
        }

    override val path: String
        get() {
            return when(this) {
                is weatherFor -> "/api/location/search/"
            }
        }

    override val params: Parameters?
        get() {
            return when(this) {
                is weatherFor -> listOf("query" to this.location)
            }
        }

    override val headers: Map<String, String>?
        get() {
            return null
        }

}


// Usage
Fuel.request(WeatherApi.weatherFor("london"))
    .responseJson { request, response, result ->
        result.fold(success = { json ->
            Log.d("qdp success", json.array().toString())
        }, failure = { error ->
            Log.e("qdp error", error.toString())
        })
    }

runBlocking {
    val (request, response, result) = Fuel.get("https://httpbin.org/ip").awaitStringResponse()

    result.fold(
        { data -> println(data) /* "{"origin":"127.0.0.1"}" */ }, 
        { error -> println("An error of type ${error.exception} happened: ${error.message}") }
    )
}

runBlocking {
    Fuel.get("https://httpbin.org/ip")
        .awaitStringResult()
        .fold(
            { data -> println(data) /* "{"origin":"127.0.0.1"}" */ }, 
            { error -> println("An error of type ${error.exception} happened: ${error.message}") }
        )
}

runBlocking {
    try {
        println(Fuel.get("https://httpbin.org/ip").awaitString()) // "{"origin":"127.0.0.1"}"
    } catch(exception: Exception) {
        println("A network request exception was thrown: ${exception.message}")
    }
}

data class Ip(val origin: String)

object IpDeserializer : ResponseDeserializable<Ip> {
    override fun deserialize(content: String) =
        jacksonObjectMapper().readValue<Ip>(content)
}

runBlocking {
    Fuel.get("https://httpbin.org/ip")
        .awaitObjectResult(IpDeserializer)
        .fold(
            { data -> println(data.origin) /* 127.0.0.1 */ }, 
            { error -> println("An error of type ${error.exception} happened: ${error.message}") }
        )
}

runBlocking {
    try {
        val data = Fuel.get("https://httpbin.org/ip").awaitObject(IpDeserializer)
        println(data.origin) // 127.0.0.1
    } catch (exception: Exception) {
        when (exception){
            is HttpException -> println("A network request exception was thrown: ${exception.message}")
            is JsonMappingException -> println("A serialization/deserialization exception was thrown: ${exception.message}")
            else -> println("An exception [${exception.javaClass.simpleName}\"] was thrown")
        }
    }
}

Fuel.get("https://icanhazdadjoke.com")
    .header(Headers.ACCEPT to "text/plain")
    .monoString()
    .subscribe(::println)

data class Guest(val name: String)

object GuestMapper : ResponseDeserializable<Guest> {
    override fun deserialize(content: String) =
        jacksonObjectMapper().readValue<Guest>(content)
}

Fuel.get("/guestName").monoResultObject(GuestMapper)
    .map(Result<Guest, FuelError>::get)
    .map { (name) -> "Welcome to the party, $name!" }
    .onErrorReturn("I'm sorry, your name is not on the list.")
    .subscribe(::println)

FuelManager.instance.basePath = "https://httpbin.org"

Fuel.get("/status/404").monoResponse()
    .filter(Response::isSuccessful)
    .switchIfEmpty(Fuel.get("/status/200").monoResponse())
    .map(Response::statusCode)
    .subscribe(::println)