package io.oxygenhub.android.api

import io.oxygenhub.android.Fixtures

import kotlinx.coroutines.test.runTest

import okhttp3.OkHttpClient

import okhttp3.mockwebserver.MockResponse

import okhttp3.mockwebserver.MockWebServer

import okhttp3.mockwebserver.SocketPolicy

import org.junit.After

import org.junit.Assert.assertEquals

import org.junit.Assert.assertNull

import org.junit.Assert.assertFalse

import org.junit.Assert.assertTrue

import org.junit.Assert.fail

import org.junit.Before

import org.junit.Test

class HubClientTest {

    private lateinit var server: MockWebServer

    private val http = OkHttpClient()

    private var unauthorized = 0

    @Before

    fun setUp() {

        server = MockWebServer()

        server.start()

        unauthorized = 0

    }

    @After

    fun tearDown() {

        server.shutdown()

    }

    // MockWebServer speaks plain HTTP; the client takes any base it is given.

    private fun client() = HubClient(server.url("/").toString().trimEnd('/'), "oxy_secret", http) { unauthorized++ }

    private fun json(name: String, code: Int = 200) =

        MockResponse().setResponseCode(code).setHeader("Content-Type", "application/json").setBody(Fixtures.text(name))

    @Test

    fun userSendsTheBearerToken() = runTest {

        server.enqueue(json("user.json"))

        val u = client().user()

        assertEquals("andymccall", u.username)

        val req = server.takeRequest()

        assertEquals("GET", req.method)

        assertEquals("/api/v1/user", req.path)

        assertEquals("Bearer oxy_secret", req.getHeader("Authorization"))

        assertEquals("application/json", req.getHeader("Accept"))

    }

    @Test

    fun anAvatarIsFetchedWithoutTheToken() = runTest {

        server.enqueue(MockResponse().setHeader("Content-Type", "image/svg+xml").setBody(Fixtures.text("identicon-bob.svg")))

        val a = client().avatar("bob")

        assertEquals(196, (a as Avatar.Identicon).hue)

        val req = server.takeRequest()

        assertEquals("/avatar/bob", req.path)

        assertNull(req.getHeader("Authorization"))

        server.enqueue(MockResponse().setResponseCode(404))

        assertNull(client().avatar("nobody"))

        assertEquals(0, unauthorized)

    }

    @Test

    fun proposalsAreListedReadAndLanded() = runTest {

        server.enqueue(json("proposals.json"))

        assertEquals(3, client().proposals("andymccall", "oxygenhub", ProposalState.All).size)

        assertEquals("/api/v1/repos/andymccall/oxygenhub/proposals?state=all", server.takeRequest().path)

        server.enqueue(json("checks.json"))

        assertEquals("failed", client().checks("andymccall", "oxygenhub", 300)[1].status)

        assertEquals("/api/v1/repos/andymccall/oxygenhub/proposals/300/checks", server.takeRequest().path)

        server.enqueue(json("proposal.json"))

        assertEquals(300L, client().land("andymccall", "oxygenhub", 300).number)

        val land = server.takeRequest()

        assertEquals("POST", land.method)

        assertEquals("/api/v1/repos/andymccall/oxygenhub/proposals/300/land", land.path)

        assertEquals("{}", land.body.readUtf8())

        server.enqueue(json("proposal.json"))

        client().setAutoLand("andymccall", "oxygenhub", 300, on = false)

        val off = server.takeRequest()

        assertEquals("DELETE" to "/api/v1/repos/andymccall/oxygenhub/proposals/300/auto-land", off.method to off.path)

    }

    @Test

    fun aRefusedLandingCarriesTheHubsReason() = runTest {

        server.enqueue(

            MockResponse().setResponseCode(409).setHeader("Content-Type", "application/problem+json")

                .setBody("""{"status":409,"title":"Conflict","detail":"0 of 1 required sealed approvals"}"""),

        )

        val e = runCatching { client().land("andymccall", "oxygenhub", 301) }.exceptionOrNull() as HubException.Http

        assertEquals(409 to "0 of 1 required sealed approvals", e.status to e.detail)

        server.enqueue(json("problem_403.json", 403))

        val scope = runCatching { client().land("andymccall", "oxygenhub", 301) }.exceptionOrNull()

        assertEquals("user:read", scope?.lackedScope)

    }

    @Test

    fun aRunnerTokenIsAskedForWithThePost() = runTest {

        server.enqueue(MockResponse().setResponseCode(201).setHeader("Content-Type", "application/json").setBody("""{"token":"flowreg_abc","owner":"andymccall"}"""))

        val t = client().runnerToken()

        assertEquals("andymccall", t.owner)

        assertEquals("flowreg_abc", t.token)

        assertFalse("the token is not printed", t.toString().contains("flowreg_abc"))

        val req = server.takeRequest()

        assertEquals("POST" to "/api/v1/user/runner-token", req.method to req.path)

        assertEquals("Bearer oxy_secret", req.getHeader("Authorization"))

    }

    @Test

    fun repositories() = runTest {

        server.enqueue(json("repos.json"))

        assertEquals(3, client().repositories().size)

        assertEquals("/api/v1/repos", server.takeRequest().path)

    }

    @Test

    fun issuesAskForTheState() = runTest {

        server.enqueue(json("issues.json"))

        val issues = client().issues("andymccall", "oxygenhub-android", IssueState.All)

        assertEquals(3, issues.size)

        assertEquals("/api/v1/repos/andymccall/oxygenhub-android/issues?state=all", server.takeRequest().path)

    }

    @Test

    fun pathSegmentsAreEncoded() = runTest {

        server.enqueue(MockResponse().setBody("[]"))

        client().issues("a b", "c/d")

        assertEquals("/api/v1/repos/a%20b/c%2Fd/issues?state=open", server.takeRequest().path)

    }

    @Test

    fun inboxWithALimit() = runTest {

        server.enqueue(json("inbox.json"))

        assertEquals(2, client().inbox(500).unread)

        assertEquals("/api/v1/notifications?limit=200", server.takeRequest().path)

    }

    @Test

    fun markingRead() = runTest {

        server.enqueue(MockResponse().setResponseCode(204))

        server.enqueue(MockResponse().setResponseCode(204))

        client().markRead(41)

        client().markAllRead()

        val one = server.takeRequest()

        assertEquals("POST", one.method)

        assertEquals("/api/v1/notifications/41/read", one.path)

        val all = server.takeRequest()

        assertEquals("POST", all.method)

        assertEquals("/api/v1/notifications/read", all.path)

    }

    @Test

    fun revokingDeletesTheOwnToken() = runTest {

        server.enqueue(MockResponse().setResponseCode(204))

        client().revokeToken()

        val req = server.takeRequest()

        assertEquals("DELETE", req.method)

        assertEquals("/api/v1/user/token", req.path)

        assertEquals("Bearer oxy_secret", req.getHeader("Authorization"))

    }

    @Test

    fun aProblemBecomesAnHttpError() = runTest {

        server.enqueue(json("problem_403.json", 403).setHeader("Content-Type", "application/problem+json"))

        try {

            client().user()

            fail("expected an error")

        } catch (e: HubException.Http) {

            assertEquals(403, e.status)

            assertEquals("this token lacks the user:read scope", e.detail)

            assertEquals("Not allowed: this token lacks the user:read scope", e.userMessage())

        }

        assertEquals(0, unauthorized)

    }

    @Test

    fun aRefusedTokenEndsTheSession() = runTest {

        server.enqueue(json("problem_401.json", 401))

        try {

            client().repositories()

            fail("expected an error")

        } catch (e: HubException.Http) {

            assertEquals(401, e.status)

        }

        assertEquals(1, unauthorized)

    }

    @Test

    fun revokingARefusedTokenDoesNotCallBack() = runTest {

        server.enqueue(json("problem_401.json", 401))

        try {

            client().revokeToken()

            fail("expected an error")

        } catch (e: HubException.Http) {

            assertEquals(401, e.status)

        }

        assertEquals(0, unauthorized)

    }

    @Test

    fun anUnreadableAnswer() = runTest {

        server.enqueue(MockResponse().setBody("<html>a proxy's page</html>"))

        try {

            client().repositories()

            fail("expected an error")

        } catch (e: HubException.Unreadable) {

            assertTrue(e.message!!.contains("/api/v1/repos"))

        }

    }

    @Test

    fun aBrokenConnection() = runTest {

        server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AT_START))

        try {

            client().user()

            fail("expected an error")

        } catch (e: HubException.Network) {

            assertEquals("Can't reach the hub. Check your connection and try again.", e.userMessage())

        }

    }

    @Test

    fun theTokenIsNotInToString() {

        assertFalse(client().toString().contains("oxy_secret"))

    }

}