package io.oxygenhub.android.api

import kotlinx.serialization.KSerializer

import kotlinx.serialization.builtins.ListSerializer

import okhttp3.HttpUrl

import okhttp3.HttpUrl.Companion.toHttpUrl

import okhttp3.OkHttpClient

import okhttp3.Request

import okhttp3.RequestBody.Companion.toRequestBody

import java.io.IOException

/**

 * What the app asks of a hub, signed in. The view models see only this, so

 * their tests give them a fake. Later screens (oxygenhub-android#3–#5) add

 * to it: a repository's tree, history, proposals, runs.

 */

interface HubApi {

    /** The signed-in account (`GET /user`, scope `user:read`). */

    suspend fun user(): User

    /** Every repository the caller can read (`GET /repos`). */

    suspend fun repositories(): List<Repository>

    /** A repository's issues (`GET /repos/{owner}/{name}/issues?state=`). */

    suspend fun issues(owner: String, name: String, state: IssueState = IssueState.Open): List<Issue>

    /** The inbox: the unread count and the newest entries (`GET /notifications`). */

    suspend fun inbox(limit: Int = 50): Inbox

    /** Marks one notification read (`POST /notifications/{id}/read`). */

    suspend fun markRead(id: Long)

    /** Marks the whole inbox read (`POST /notifications/read`). */

    suspend fun markAllRead()

    /** Revokes the token this client signs in with (`DELETE /user/token`). */

    suspend fun revokeToken()

    /** The proposals the caller should act on, across repositories (the hub's dashboard). */

    suspend fun userProposals(): UserProposals

    /** A repository's proposals: open (with drafts), landed, closed or all. */

    suspend fun proposals(owner: String, name: String, state: ProposalState = ProposalState.Open): List<Proposal>

    suspend fun proposal(owner: String, name: String, number: Long): Proposal

    /** The checks on a proposal's projected state. */

    suspend fun checks(owner: String, name: String, number: Long): List<Check>

    /**

     * Land it (`repo:write`); the proposal as landed. The hub refuses with 409

     * and its reason when it may not land, and 403 when the token lacks the scope.

     */

    suspend fun land(owner: String, name: String, number: Long): Proposal

    /** Land it by itself when its checks pass, or not (`repo:write`); the proposal after. */

    suspend fun setAutoLand(owner: String, name: String, number: Long, on: Boolean): Proposal

    /** A one-time token registering this phone as a runner for the account's repositories (`repo:write`). */

    suspend fun runnerToken(): RunnerToken

    /** An account's picture (`/avatar/{name}`, public); null when the hub has none this app can draw. */

    suspend fun avatar(name: String): Avatar?

}

/**

 * The hub's JSON API over OkHttp. [onUnauthorized] runs when the hub

 * refuses the token (revoked on the web, or 90 days unused), so the app

 * can drop the session and ask for a new sign-in.

 */

class HubClient(

    hub: String,

    private val token: String,

    private val http: OkHttpClient,

    private val onUnauthorized: () -> Unit = {},

) : HubApi {

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

    private val root: HttpUrl = "${hub.trimEnd('/')}/".toHttpUrl()

    override suspend fun user(): User = get("user", User.serializer())

    override suspend fun repositories(): List<Repository> = get("repos", ListSerializer(Repository.serializer()))

    override suspend fun issues(owner: String, name: String, state: IssueState): List<Issue> =

        get(url("repos", owner, name, "issues") { addQueryParameter("state", state.query) }, ListSerializer(Issue.serializer()))

    override suspend fun inbox(limit: Int): Inbox =

        get(url("notifications") { addQueryParameter("limit", limit.coerceIn(1, 200).toString()) }, Inbox.serializer())

    override suspend fun runnerToken(): RunnerToken = send("POST", url("user", "runner-token"), RunnerToken.serializer())

    override suspend fun userProposals(): UserProposals = get("user/proposals", UserProposals.serializer())

    override suspend fun proposals(owner: String, name: String, state: ProposalState): List<Proposal> =

        get(url("repos", owner, name, "proposals") { addQueryParameter("state", state.query) }, ListSerializer(Proposal.serializer()))

    override suspend fun proposal(owner: String, name: String, number: Long): Proposal =

        get(url("repos", owner, name, "proposals", number.toString()), Proposal.serializer())

    override suspend fun checks(owner: String, name: String, number: Long): List<Check> =

        get(url("repos", owner, name, "proposals", number.toString(), "checks"), ListSerializer(Check.serializer()))

    override suspend fun land(owner: String, name: String, number: Long): Proposal =

        send("POST", url("repos", owner, name, "proposals", number.toString(), "land"), Proposal.serializer())

    override suspend fun setAutoLand(owner: String, name: String, number: Long, on: Boolean): Proposal =

        send(if (on) "POST" else "DELETE", url("repos", owner, name, "proposals", number.toString(), "auto-land"), Proposal.serializer())

    override suspend fun markRead(id: Long) {

        send("POST", url("notifications", id.toString(), "read"))

    }

    override suspend fun markAllRead() {

        send("POST", url("notifications", "read"))

    }

    override suspend fun revokeToken() {

        send("DELETE", url("user", "token"), notifyUnauthorized = false)

    }

    override suspend fun avatar(name: String): Avatar? {

        val url = root.newBuilder().addPathSegment("avatar").addPathSegment(name).build()

        // A public picture: no token goes with it.

        val response = try {

            http.newCall(Request.Builder().url(url).get().build()).await()

        } catch (e: IOException) {

            throw HubException.Network(e)

        }

        response.use { r ->

            if (r.code == 404) return null

            val bytes = try {

                r.body?.bytes() ?: ByteArray(0)

            } catch (e: IOException) {

                throw HubException.Network(e)

            }

            if (!r.isSuccessful) throw HubException.Http(r.code, errorDetail(bytes.decodeToString()))

            return Avatar.parse(r.header("Content-Type"), bytes)

        }

    }

    // The bearer token is never part of a string anything prints.

    override fun toString(): String = "HubClient(${base})"

    private fun url(vararg segments: String, query: HttpUrl.Builder.() -> Unit = {}): HttpUrl {

        val b = base.newBuilder()

        // Each segment is encoded on its own: an owner or name never adds a path level.

        segments.forEach { b.addPathSegment(it) }

        b.query()

        return b.build()

    }

    private suspend fun <T> get(path: String, serializer: KSerializer<T>): T = get(url(*path.split('/').toTypedArray()), serializer)

    private suspend fun <T> get(url: HttpUrl, serializer: KSerializer<T>): T {

        val body = call(request(url).get().build(), notifyUnauthorized = true)

        return try {

            HubJson.decodeFromString(serializer, body)

        } catch (e: IllegalArgumentException) {

            // kotlinx.serialization's errors are IllegalArgumentExceptions.

            throw HubException.Unreadable("GET ${url.encodedPath}", e)

        }

    }

    private suspend fun send(method: String, url: HttpUrl, notifyUnauthorized: Boolean = true): String {

        val body = if (method == "DELETE") null else "{}".toRequestBody(JsonMedia)

        return call(request(url).method(method, body).build(), notifyUnauthorized)

    }

    private suspend fun <T> send(method: String, url: HttpUrl, serializer: KSerializer<T>): T {

        val body = send(method, url)

        return try {

            HubJson.decodeFromString(serializer, body)

        } catch (e: IllegalArgumentException) {

            throw HubException.Unreadable("$method ${url.encodedPath}", e)

        }

    }

    private fun request(url: HttpUrl): Request.Builder = Request.Builder()

        .url(url)

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

        .header("Authorization", "Bearer $token")

    private suspend fun call(request: Request, notifyUnauthorized: Boolean): String {

        val response = try {

            http.newCall(request).await()

        } catch (e: IOException) {

            throw HubException.Network(e)

        }

        response.use { r ->

            val text = try {

                r.body?.string().orEmpty()

            } catch (e: IOException) {

                throw HubException.Network(e)

            }

            if (!r.isSuccessful) {

                if (r.code == 401 && notifyUnauthorized) onUnauthorized()

                throw HubException.Http(r.code, errorDetail(text))

            }

            return text

        }

    }

}