package io.oxygenhub.android.ui

import io.oxygenhub.android.FakeHubApi

import io.oxygenhub.android.MainDispatcherRule

import io.oxygenhub.android.api.DeviceAuth

import io.oxygenhub.android.api.DeviceCode

import io.oxygenhub.android.api.DeviceFlowException

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.TokenGrant

import io.oxygenhub.android.api.User

import io.oxygenhub.android.auth.MemorySessionStore

import io.oxygenhub.android.auth.Session

import io.oxygenhub.android.auth.SessionManager

import io.oxygenhub.android.ui.signin.SignInState

import io.oxygenhub.android.ui.signin.SignInViewModel

import kotlinx.coroutines.CompletableDeferred

import org.junit.Assert.assertEquals

import org.junit.Assert.assertNull

import org.junit.Assert.assertTrue

import org.junit.Rule

import org.junit.Test

class SignInViewModelTest {

    @get:Rule val main = MainDispatcherRule()

    private val code = DeviceCode("oxydev_x", "BCDF-GHJK", "https://hub.example/device", "https://hub.example/device?code=BCDF-GHJK")

    private val grant = TokenGrant("oxy_new", scope = "repo:read user:read", username = "andymccall")

    /** A device flow whose token arrives when the test says. */

    private inner class FakeAuth : DeviceAuth {

        val token = CompletableDeferred<TokenGrant>()

        var me: () -> User = { User("andymccall") }

        var asked: String? = null

        override suspend fun requestCode(client: String, scopes: List<String>): DeviceCode {

            asked = client

            return code

        }

        override suspend fun awaitToken(code: DeviceCode): TokenGrant = token.await()

        override suspend fun whoAmI(token: String): User = me()

    }

    private val store = MemorySessionStore()

    private val sessions = SessionManager(store) { _, _ -> FakeHubApi() }

    private val auth = FakeAuth()

    private val hubs = mutableListOf<String>()

    private fun vm() = SignInViewModel(sessions, { hubs += it; auth }, "OxygenHub for Android on Test", "https://oxygenhub.io")

    @Test

    fun theDefaultHubOrTheLastOne() {

        assertEquals("https://oxygenhub.io", vm().hub.value)

        store.lastHub = "https://hub.example"

        assertEquals("https://hub.example", vm().hub.value)

    }

    @Test

    fun signsInOnceApproved() {

        val vm = vm()

        vm.setHub("hub.example/")

        vm.signIn()

        assertEquals(listOf("https://hub.example"), hubs)

        assertEquals("https://hub.example", vm.hub.value)

        assertEquals("OxygenHub for Android on Test", auth.asked)

        assertEquals(SignInState.Approving(code), vm.state.value)

        assertNull(sessions.session.value)

        auth.token.complete(grant)

        assertEquals(Session("https://hub.example", "andymccall", "oxy_new", listOf("repo:read", "user:read")), sessions.session.value)

        assertEquals(store.load(), sessions.session.value)

        assertEquals(SignInState.Idle(), vm.state.value)

    }

    @Test

    fun aTokenWithoutUserReadUsesTheNameTheGrantGives() {

        auth.me = { throw HubException.Http(403, "this token lacks the user:read scope") }

        val vm = vm()

        vm.signIn()

        auth.token.complete(grant.copy(scope = "repo:read"))

        assertEquals("andymccall", sessions.session.value?.username)

        assertEquals(listOf("repo:read"), sessions.session.value?.scopes)

    }

    @Test

    fun aBadAddressIsRefusedHere() {

        val vm = vm()

        vm.setHub("http://insecure.example")

        vm.signIn()

        assertTrue(hubs.isEmpty())

        assertTrue((vm.state.value as SignInState.Idle).error!!.contains("HTTPS"))

    }

    @Test

    fun aDenialIsSaid() {

        val vm = vm()

        vm.signIn()

        auth.token.completeExceptionally(DeviceFlowException.Denied())

        assertEquals(SignInState.Idle("The sign-in was denied on the web."), vm.state.value)

        assertNull(sessions.session.value)

    }

    @Test

    fun anUnreachableHubIsSaid() {

        val vm = vm()

        vm.signIn()

        auth.token.completeExceptionally(HubException.Network(java.io.IOException("no route")))

        assertEquals(SignInState.Idle("Can't reach the hub. Check your connection and try again."), vm.state.value)

    }

    @Test

    fun cancelling() {

        val vm = vm()

        vm.signIn()

        vm.cancel()

        assertEquals(SignInState.Idle(), vm.state.value)

        auth.token.complete(grant)

        assertNull(sessions.session.value)

    }

}