package io.oxygenhub.android.ui

import io.oxygenhub.android.FakeHubApi

import io.oxygenhub.android.api.FlowRun

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.UserFlowRun

import io.oxygenhub.android.api.UserSky

import io.oxygenhub.android.api.IssueBrief

import io.oxygenhub.android.ui.nav.AccountRoute

import io.oxygenhub.android.ui.nav.DashboardRoute

import io.oxygenhub.android.ui.nav.InboxRoute

import io.oxygenhub.android.ui.nav.IssueRoute

import io.oxygenhub.android.ui.nav.ProposalRoute

import io.oxygenhub.android.widget.HealthStrip

import io.oxygenhub.android.widget.SkyBitmap

import io.oxygenhub.android.widget.WidgetData

import io.oxygenhub.android.widget.WidgetTaps

import io.oxygenhub.android.widget.runnerLine

import kotlinx.coroutines.test.runTest

import org.junit.Assert.assertEquals

import org.junit.Assert.assertFalse

import org.junit.Assert.assertNotEquals

import org.junit.Assert.assertNull

import org.junit.Assert.assertTrue

import org.junit.Test

class WidgetDataTest {

    @Test

    fun theWidgetShowsTheLatestRunsAndCountsAndAsksForASignInWithoutOne() = runTest {

        val api = FakeHubApi()

        api.userFlowRuns = { (1L..5L).map { UserFlowRun("andy/a", FlowRun(number = it, status = "passed")) } }

        val d = WidgetData.load(api)

        assertEquals(listOf(1L, 2L, 3L), d.runs.map { it.run.number })

        assertEquals(1, d.reviews)

        assertFalse(WidgetData.load(null).signedIn)

    }

    @Test

    fun aPartTheHubCannotGiveIsLeftOutNotTheWholeWidget() = runTest {

        val api = FakeHubApi()

        api.userFlowRuns = { throw HubException.Http(404, "no such API route") }

        val d = WidgetData.load(api)

        assertEquals(emptyList<UserFlowRun>(), d.runs)

        assertEquals(1, d.reviews)

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

        assertNull(WidgetData.load(api).reviews)

    }

    @Test

    fun theWidgetFetchesYourSkyAndALostSkyLeavesThePlainSurface() = runTest {

        val api = FakeHubApi()

        val sky = UserSky(now = 10 * 86_400_000L, repos = listOf("andy/a"), events = listOf(listOf(0L, 0L, 9 * 86_400_000L, 3L)))

        api.userSky = { sky }

        assertEquals(sky, WidgetData.load(api).sky)

        api.userSky = { throw HubException.Http(404, "no such API route") }

        val d = WidgetData.load(api)

        assertNull(d.sky)

        assertEquals(1, d.reviews)

    }

    @Test

    fun onlyRealActivityIsDrawn() {

        assertFalse("nothing fetched", SkyBitmap.drawable(null))

        assertFalse("no repositories", SkyBitmap.drawable(UserSky()))

        assertFalse("repositories but no events", SkyBitmap.drawable(UserSky(repos = listOf("andy/a"))))

        assertFalse("only malformed events", SkyBitmap.drawable(UserSky(repos = listOf("andy/a"), events = listOf(listOf(7L, 0L, 0L, 1L)))))

        assertTrue(SkyBitmap.drawable(UserSky(now = 1, repos = listOf("andy/a"), events = listOf(listOf(0L, 4L, 0L, 1L)))))

    }

    @Test

    fun theSkysColoursFollowTheTheme() {

        val (light, dark) = SkyBitmap.colours(false) to SkyBitmap.colours(true)

        assertEquals(24, light.size)

        assertEquals(24, dark.size)

        assertNotEquals(light, dark)

        assertTrue("every channel is a fraction", (light + dark).all { it in 0f..1f })

    }

    @Test

    fun theCountsRowSaysWhatIsAssignedAndOneOfAKindOpensItself() = runTest {

        val api = FakeHubApi()

        val d = WidgetData.load(api)

        assertEquals(1, d.assigned)

        assertEquals(359L, d.onlyAssigned?.number)

        assertEquals(300L, d.onlyReview?.number)

        api.userIssues = { listOf(IssueBrief("andy/a", 1), IssueBrief("andy/a", 2)) }

        val two = WidgetData.load(api)

        assertEquals(2, two.assigned)

        assertNull("two open the dashboard, not one of them", two.onlyAssigned)

        api.userIssues = { throw HubException.Http(404, "no such API route") }

        val old = WidgetData.load(api)

        assertNull("a hub before /user/issues: the count is left out", old.assigned)

        assertEquals(1, old.reviews)

    }

    @Test

    fun theRunnerShowsOnlyWhileThePhoneServes() = runTest {

        val api = FakeHubApi()

        assertNull(WidgetData.load(api).runnerJobs)

        assertEquals(listOf("andy/a #7 test"), WidgetData.load(api, listOf("andy/a #7 test")).runnerJobs)

        assertEquals("Waiting for jobs", runnerLine(emptyList()))

        assertEquals("andy/a #7 test", runnerLine(listOf("andy/a #7 test")))

        assertEquals("2 jobs", runnerLine(listOf("andy/a #7 test", "andy/b #2 build")))

    }

    @Test

    fun aTapOnACountOpensItsScreen() {

        assertEquals(InboxRoute, WidgetTaps.route("inbox", "", 0))

        assertEquals(DashboardRoute, WidgetTaps.route("dashboard", "", 0))

        assertEquals(AccountRoute, WidgetTaps.route("account", "", 0))

        assertEquals(ProposalRoute("andy", "a", 3), WidgetTaps.route("proposal", "andy/a", 3))

        assertEquals(IssueRoute("andy", "a", 4), WidgetTaps.route("issue", "andy/a", 4))

        assertEquals("a broken reference falls back to the dashboard", DashboardRoute, WidgetTaps.route("issue", "nonsense", 4))

        assertNull("not from the widget", WidgetTaps.route(null, null, 0))

    }

    @Test

    fun needsYouAndTheHealthStripComeFromWhatTheWidgetFetches() = runTest {

        val api = FakeHubApi()

        val statuses = listOf("running", "passed", "failed", "cancelled", "passed", "passed")

        api.userFlowRuns = { statuses.mapIndexed { i, st -> UserFlowRun("andy/a", FlowRun(number = 10L - i, status = st)) } }

        val d = WidgetData.load(api)

        assertEquals(300L, d.topReview?.number)

        assertEquals(359L, d.topAssigned?.number)

        assertEquals("all the runs fetched, not just the three shown", statuses, d.health)

        assertEquals(3, d.runs.size)

    }

    @Test

    fun theHealthSummaryCountsFinishedRunsOnly() {

        assertEquals("75% of the last 4 finished runs passed", HealthStrip.summary(listOf("running", "passed", "failed", "cancelled", "passed", "passed")))

        assertEquals("100% of the last finished run passed", HealthStrip.summary(listOf("passed", "queued")))

        assertNull("nothing finished", HealthStrip.summary(listOf("running", "cancelled")))

        assertNull(HealthStrip.summary(emptyList()))

        assertEquals(HealthStrip.Kind.Failed, HealthStrip.kind("error"))

    }

}