package io.oxygenhub.android.ui

import io.oxygenhub.android.FakeHubApi

import io.oxygenhub.android.MainDispatcherRule

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.ProposalState

import io.oxygenhub.android.auth.Session

import io.oxygenhub.android.ui.common.Load

import io.oxygenhub.android.ui.proposals.LandAction

import io.oxygenhub.android.ui.proposals.ProposalPage

import io.oxygenhub.android.ui.proposals.ProposalViewModel

import io.oxygenhub.android.ui.proposals.ProposalsViewModel

import org.junit.Assert.assertEquals

import org.junit.Assert.assertFalse

import org.junit.Assert.assertNull

import org.junit.Assert.assertTrue

import org.junit.Rule

import org.junit.Test

class ProposalViewModelTest {

    @get:Rule val main = MainDispatcherRule()

    private val api = FakeHubApi()

    private fun page(vm: ProposalViewModel): ProposalPage = (vm.state.value as Load.Ready).value

    @Test

    fun listsOpenProposalsNewestFirstAndTheLandedOnAsked() {

        val vm = ProposalsViewModel(api, "andymccall", "oxygenhub")

        assertEquals(listOf(301L, 300L), (vm.state.value as Load.Ready).value.map { it.number })

        vm.setFilter(ProposalState.Landed)

        assertEquals(listOf(264L), (vm.state.value as Load.Ready).value.map { it.number })

        assertTrue("proposals andymccall/oxygenhub landed" in api.calls)

    }

    @Test

    fun showsAProposalWithItsChecks() {

        val p = page(ProposalViewModel(api, "andymccall", "oxygenhub", 300))

        assertTrue(p.proposal.landable)

        assertEquals(5, p.checks?.size)

    }

    @Test

    fun withoutItsChecksTheProposalStillShows() {

        api.checks = { throw HubException.Http(500, "down") }

        val p = page(ProposalViewModel(api, "andymccall", "oxygenhub", 300))

        assertNull(p.checks)

        assertEquals(300L, p.proposal.number)

    }

    @Test

    fun landingSaysSoAndShowsItLanded() {

        val vm = ProposalViewModel(api, "andymccall", "oxygenhub", 300)

        // The hub's answer after landing, as the refresh will read it.

        val landed = api.land(300)

        api.proposal = { landed }

        vm.land()

        assertEquals(LandAction.Done("Landed #300 into main."), vm.action.value)

        assertEquals("landed", page(vm).proposal.state)

        assertTrue("land 300" in api.calls)

    }

    @Test

    fun aRefusalShowsTheHubsReason() {

        api.land = { throw HubException.Http(409, "required checks not passed on the projected state: test") }

        val vm = ProposalViewModel(api, "andymccall", "oxygenhub", 300)

        vm.land()

        assertEquals(LandAction.Failed("required checks not passed on the projected state: test"), vm.action.value)

        assertEquals("open", page(vm).proposal.state)

        vm.dismiss()

        assertEquals(LandAction.Idle, vm.action.value)

    }

    @Test

    fun aReadOnlyTokenIsAskedToSignInAgain() {

        api.land = { throw HubException.Http(403, "this token lacks the repo:write scope") }

        val vm = ProposalViewModel(api, "andymccall", "oxygenhub", 300)

        vm.land()

        val f = vm.action.value as LandAction.Failed

        assertTrue(f.needsWrite)

        // Another 403 is not about the scope.

        assertFalse(ProposalViewModel.failure(HubException.Http(403, "only maintainers may land over checks")).needsWrite)

    }

    @Test

    fun autoLandIsSetAndCleared() {

        val vm = ProposalViewModel(api, "andymccall", "oxygenhub", 301)

        assertEquals("andymccall", page(vm).proposal.autoLand)

        val cleared = api.autoLand(301, false)

        api.proposal = { cleared }

        vm.setAutoLand(false)

        assertEquals(LandAction.Done("#301 will not land by itself."), vm.action.value)

        assertNull(page(vm).proposal.autoLand)

        assertTrue("auto-land 301 false" in api.calls)

    }

    @Test

    fun aSessionMayWriteOnlyWithTheScope() {

        assertTrue(Session("h", "u", "t", listOf("repo:read", "repo:write")).canWrite)

        assertFalse(Session("h", "u", "t", listOf("repo:read", "user:read")).canWrite)

        // The hub did not say: let it decide.

        assertTrue(Session("h", "u", "t").canWrite)

    }

}