package io.oxygenhub.android.api

import io.oxygenhub.android.Fixtures

import kotlinx.coroutines.test.runTest

import kotlinx.serialization.json.jsonArray

import kotlinx.serialization.json.jsonObject

import kotlinx.serialization.json.jsonPrimitive

import okhttp3.OkHttpClient

import okhttp3.mockwebserver.MockResponse

import okhttp3.mockwebserver.MockWebServer

import org.junit.After

import org.junit.Assert.assertEquals

import org.junit.Assert.assertTrue

import org.junit.Assert.fail

import org.junit.Before

import org.junit.Test

class DeviceFlowTest {

    private lateinit var server: MockWebServer

    private val sleeps = mutableListOf<Long>()

    @Before

    fun setUp() {

        server = MockWebServer()

        server.start()

        sleeps.clear()

    }

    @After

    fun tearDown() {

        server.shutdown()

    }

    private fun auth() = HubDeviceAuth(server.url("/").toString().trimEnd('/'), OkHttpClient()) { sleeps += it }

    private fun answer(name: String, code: Int) = MockResponse().setResponseCode(code).setBody(Fixtures.text(name))

    private fun code() = HubJson.decodeFromString(DeviceCode.serializer(), Fixtures.text("device_code.json"))

    @Test

    fun requestingACodeNamesTheAppAndItsScopes() = runTest {

        server.enqueue(answer("device_code.json", 200))

        val code = auth().requestCode("OxygenHub for Android on Pixel 10 Pro Fold")

        assertEquals("BCDF-GHJK", code.userCode)

        val req = server.takeRequest()

        assertEquals("POST", req.method)

        assertEquals("/api/v1/device/code", req.path)

        assertEquals(null, req.getHeader("Authorization"))

        val body = HubJson.parseToJsonElement(req.body.readUtf8()).jsonObject

        assertEquals("OxygenHub for Android on Pixel 10 Pro Fold", body["client"]!!.jsonPrimitive.content)

        assertEquals(AppScopes, body["scopes"]!!.jsonArray.map { it.jsonPrimitive.content })

    }

    @Test

    fun aHubThatCannotSignInDevices() = runTest {

        server.enqueue(MockResponse().setResponseCode(400).setBody("""{"error":"invalid_scope","error_description":"unknown scope"}"""))

        try {

            auth().requestCode("app")

            fail("expected a refusal")

        } catch (e: DeviceFlowException.Refused) {

            assertEquals(400, e.status)

            assertTrue(e.message!!.endsWith("unknown scope"))

        }

    }

    @Test

    fun pollsUntilApprovedSlowingDownWhenTold() = runTest {

        server.enqueue(answer("device_authorization_pending.json", 400))

        server.enqueue(answer("device_slow_down.json", 400))

        server.enqueue(answer("device_authorization_pending.json", 400))

        server.enqueue(answer("device_token.json", 200))

        val grant = auth().awaitToken(code())

        assertEquals("oxy_test_not_a_real_token", grant.accessToken)

        assertEquals(listOf(5000L, 5000L, 10000L, 10000L), sleeps)

        repeat(4) {

            val req = server.takeRequest()

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

            val body = HubJson.parseToJsonElement(req.body.readUtf8()).jsonObject

            assertEquals(code().deviceCode, body["device_code"]!!.jsonPrimitive.content)

        }

    }

    @Test(expected = DeviceFlowException.Denied::class)

    fun denied() = runTest {

        server.enqueue(answer("device_access_denied.json", 400))

        auth().awaitToken(code())

    }

    @Test(expected = DeviceFlowException.Expired::class)

    fun expiredOnTheHub() = runTest {

        server.enqueue(answer("device_expired_token.json", 400))

        auth().awaitToken(code())

    }

    @Test

    fun expiresHereWhenTheHubNeverAnswers() = runTest {

        // A code with ten seconds to live, polled every five: two polls, then give up.

        repeat(5) { server.enqueue(answer("device_authorization_pending.json", 400)) }

        try {

            auth().awaitToken(code().copy(expiresIn = 10))

            fail("expected expiry")

        } catch (_: DeviceFlowException.Expired) {

        }

        assertEquals(2, server.requestCount)

    }

    @Test

    fun anUnexpectedAnswerStops() = runTest {

        server.enqueue(MockResponse().setResponseCode(500).setBody("""{"error":"server_error","error_description":"db down"}"""))

        try {

            auth().awaitToken(code())

            fail("expected a refusal")

        } catch (e: DeviceFlowException.Refused) {

            assertEquals(500, e.status)

            assertTrue(e.message!!.contains("db down"))

        }

    }

    @Test

    fun whoAmIUsesTheNewToken() = runTest {

        server.enqueue(answer("user.json", 200))

        assertEquals("andymccall", auth().whoAmI("oxy_new").username)

        val req = server.takeRequest()

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

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

    }

}