package io.oxygenhub.android.api

import kotlinx.coroutines.delay

import kotlinx.serialization.SerialName

import kotlinx.serialization.Serializable

import okhttp3.HttpUrl.Companion.toHttpUrl

import okhttp3.OkHttpClient

import okhttp3.Request

import okhttp3.RequestBody.Companion.toRequestBody

import java.io.IOException

/** The scopes the app asks for. The user may untick any of them on the web. */

val AppScopes: List<String> = listOf("repo:read", "user:read")

/** Why a device sign-in ended without a token. */

sealed class DeviceFlowException(message: String) : Exception(message) {

    class Denied : DeviceFlowException("The sign-in was denied on the web.")

    class Expired : DeviceFlowException("The code expired before it was approved. Start again for a new one.")

    class Refused(val status: Int, val detail: String) : DeviceFlowException(detail)

}

/**

 * Device sign-in (oxygenhub#67, RFC 8628's shape), as `oh auth login` does

 * it: ask the hub for a code, show it, the user approves it on the hub's

 * `/device` page (signed in there with their password and, if they use one,

 * their second factor), and the app's next poll gets a token. The app never

 * sees a password or a second-factor code.

 */

interface DeviceAuth {

    /** `POST /device/code`: a code to show, and one to poll with. */

    suspend fun requestCode(client: String, scopes: List<String> = AppScopes): DeviceCode

    /**

     * Polls `POST /device/token` every `interval` seconds (five more after a

     * `slow_down`) until the user answers or the code expires.

     */

    suspend fun awaitToken(code: DeviceCode): TokenGrant

    /** The account a new token belongs to, checking that the token works. */

    suspend fun whoAmI(token: String): User

}

class HubDeviceAuth(

    private val hub: String,

    private val http: OkHttpClient,

    /** How the poll waits; tests pass a recorder. */

    private val sleep: suspend (Long) -> Unit = { delay(it) },

) : DeviceAuth {

    private val base = "${hub.trimEnd('/')}/api/v1/".toHttpUrl()

    @Serializable

    private data class CodeRequest(val client: String, val scopes: List<String>)

    @Serializable

    private data class TokenRequest(@SerialName("device_code") val deviceCode: String)

    override suspend fun requestCode(client: String, scopes: List<String>): DeviceCode {

        val (status, body) = post("device/code", HubJson.encodeToString(CodeRequest.serializer(), CodeRequest(client.take(80), scopes)))

        if (status != 200) throw DeviceFlowException.Refused(status, "$hub cannot sign in a device: ${errorDetail(body)}")

        return decode(body, DeviceCode.serializer(), "device/code")

    }

    override suspend fun awaitToken(code: DeviceCode): TokenGrant {

        var interval = code.interval.coerceAtLeast(1)

        val life = code.expiresIn.coerceAtLeast(1) * 1000

        var waited = 0L

        val request = HubJson.encodeToString(TokenRequest.serializer(), TokenRequest(code.deviceCode))

        while (true) {

            sleep(interval * 1000)

            waited += interval * 1000

            if (waited > life) throw DeviceFlowException.Expired()

            val (status, body) = post("device/token", request)

            if (status == 200) return decode(body, TokenGrant.serializer(), "device/token")

            val error = runCatching { HubJson.decodeFromString(OAuthError.serializer(), body) }.getOrNull()

            when (error?.error) {

                "authorization_pending" -> {}

                "slow_down" -> interval += 5

                "access_denied" -> throw DeviceFlowException.Denied()

                "expired_token" -> throw DeviceFlowException.Expired()

                else -> throw DeviceFlowException.Refused(status, "Signing in failed: HTTP $status: ${errorDetail(body)}")

            }

        }

    }

    override suspend fun whoAmI(token: String): User = HubClient(hub, token, http).user()

    /** POSTs JSON, returning the status and body whatever the status: the poll's waits are errors by design. */

    private suspend fun post(path: String, json: String): Pair<Int, String> {

        val request = Request.Builder()

            .url(base.resolve(path)!!)

            .header("Accept", "application/json")

            .post(json.toRequestBody(JsonMedia))

            .build()

        return try {

            http.newCall(request).await().use { r -> r.code to r.body?.string().orEmpty() }

        } catch (e: IOException) {

            throw HubException.Network(e)

        }

    }

    private fun <T> decode(body: String, serializer: kotlinx.serialization.KSerializer<T>, what: String): T = try {

        HubJson.decodeFromString(serializer, body)

    } catch (e: IllegalArgumentException) {

        throw HubException.Unreadable(what, e)

    }

}