package io.oxygenhub.android.api

import kotlinx.coroutines.suspendCancellableCoroutine

import kotlinx.serialization.json.Json

import okhttp3.Call

import okhttp3.Callback

import okhttp3.MediaType.Companion.toMediaType

import okhttp3.OkHttpClient

import okhttp3.Response

import java.io.IOException

import java.util.concurrent.TimeUnit

import kotlin.coroutines.resume

import kotlin.coroutines.resumeWithException

/** The JSON settings every hub answer is read with. */

val HubJson: Json = Json {

    ignoreUnknownKeys = true

    explicitNulls = false

    coerceInputValues = true

}

internal val JsonMedia = "application/json".toMediaType()

/** One HTTP client for the whole app (connection pool, TLS sessions). */

fun hubHttpClient(): OkHttpClient = OkHttpClient.Builder()

    .connectTimeout(15, TimeUnit.SECONDS)

    .readTimeout(60, TimeUnit.SECONDS)

    .build()

/** A hub address as typed, made canonical: `https://host[:port][/path]`, no trailing slash. */

fun normalizeHubUrl(input: String): String? {

    var s = input.trim()

    if (s.isEmpty()) return null

    if (!s.contains("://")) s = "https://$s"

    s = s.trimEnd('/')

    val url = runCatching { java.net.URI(s) }.getOrNull() ?: return null

    if (url.scheme?.lowercase() != "https" || url.host.isNullOrBlank()) return null

    if (url.query != null || url.fragment != null) return null

    return s

}

/** Runs the call without blocking, cancelling it when the coroutine is. */

internal suspend fun Call.await(): Response = suspendCancellableCoroutine { cont ->

    cont.invokeOnCancellation { runCatching { cancel() } }

    enqueue(object : Callback {

        override fun onResponse(call: Call, response: Response) {

            cont.resume(response)

        }

        override fun onFailure(call: Call, e: IOException) {

            if (!cont.isCancelled) cont.resumeWithException(e)

        }

    })

}

/** Why a call to the hub failed. */

sealed class HubException(message: String, cause: Throwable? = null) : Exception(message, cause) {

    /** The hub answered with an error; [detail] is its problem document's reason. */

    class Http(val status: Int, val detail: String) : HubException("HTTP $status: $detail")

    /** The hub could not be reached, or the connection broke. */

    class Network(cause: IOException) : HubException(cause.message ?: "network error", cause)

    /** The hub answered with something this app cannot read. */

    class Unreadable(what: String, cause: Throwable) : HubException("unexpected answer to $what", cause)

}

/** The reason in an error body: a problem's `detail`, an OAuth `error_description`, or the text itself. */

internal fun errorDetail(body: String): String {

    val problem = runCatching { HubJson.decodeFromString<Problem>(body) }.getOrNull()

    if (problem != null && problem.detail.isNotBlank()) return problem.detail

    val oauth = runCatching { HubJson.decodeFromString<OAuthError>(body) }.getOrNull()

    if (oauth != null && oauth.description.isNotBlank()) return oauth.description

    return body.trim().take(200)

}

/** The scope a token lacked when the hub refused it for that (`this token lacks the repo:write scope`), else null. */

val Throwable.lackedScope: String?

    get() = (this as? HubException.Http)?.takeIf { it.status == 403 }

        ?.let { Regex("""lacks the (\S+) scope""").find(it.detail)?.groupValues?.get(1) }

/** A sentence for the user, for any failure the API layer throws. */

fun Throwable.userMessage(): String = when (this) {

    is HubException.Http -> when (status) {

        401 -> "Your sign-in has ended. Sign in again."

        403 -> "Not allowed: $detail"

        404 -> "Not found: $detail"

        in 500..599 -> "The hub had a problem ($status). Try again in a moment."

        else -> detail.ifBlank { "The hub said HTTP $status." }

    }

    is HubException.Network -> "Can't reach the hub. Check your connection and try again."

    is HubException.Unreadable -> "The hub's answer couldn't be read. The app may need an update."

    else -> message ?: "Something went wrong."

}