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); with [landable], also those it can land now (#20, oxygenhub#311).

     */

    suspend fun userProposals(landable: Boolean = false): 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

    /** One repository (`GET /repos/{owner}/{name}`): its default bookmark, for the code browser. */

    suspend fun repository(owner: String, name: String): Repository

    /** A directory of the tree at [ref] (a bookmark, tag or change), [path] "" for the top. */

    suspend fun tree(owner: String, name: String, ref: String, path: String = ""): List<TreeEntry>

    /** A file's bytes at [ref], as text. */

    suspend fun file(owner: String, name: String, ref: String, path: String): String

    /** [ref]'s history, newest first; only changes to [path] when given. */

    suspend fun history(owner: String, name: String, ref: String, path: String? = null, offset: Int = 0, limit: Int = 50): History

    suspend fun change(owner: String, name: String, hash: String): ChangeDetail

    /** The repository's bookmarks and tags, to browse at. */

    suspend fun refs(owner: String, name: String): Pair<List<String>, List<String>>

    /** 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 repository(owner: String, name: String): Repository = get(url("repos", owner, name), Repository.serializer())

    private fun parts(path: String): Array<String> = path.split('/').filter { it.isNotEmpty() }.toTypedArray()

    override suspend fun tree(owner: String, name: String, ref: String, path: String): List<TreeEntry> =

        get(url("repos", owner, name, "tree", ref, *parts(path)), ListSerializer(TreeEntry.serializer()))

    override suspend fun file(owner: String, name: String, ref: String, path: String): String =

        call(request(url("repos", owner, name, "file", ref, *parts(path))).get().build(), notifyUnauthorized = true)

    override suspend fun history(owner: String, name: String, ref: String, path: String?, offset: Int, limit: Int): History =

        get(

            url("repos", owner, name, "history", ref) {

                path?.let { addQueryParameter("path", it) }

                addQueryParameter("offset", offset.toString())

                addQueryParameter("limit", limit.toString())

            },

            History.serializer(),

        )

    override suspend fun change(owner: String, name: String, hash: String): ChangeDetail =

        get(url("repos", owner, name, "changes", hash), ChangeDetail.serializer())

    override suspend fun refs(owner: String, name: String): Pair<List<String>, List<String>> {

        val bookmarks = get(url("repos", owner, name, "bookmarks"), ListSerializer(NamedRef.serializer())).map { it.name }

        val tags = get(url("repos", owner, name, "tags"), ListSerializer(NamedRef.serializer())).map { it.name }

        return bookmarks to tags

    }

    override suspend fun userProposals(landable: Boolean): UserProposals =

        get(url("user", "proposals") { if (landable) addQueryParameter("landable", "true") }, 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

        }

    }

}