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.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 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"))

    }

}