package io.oxygenhub.android.ui

import io.oxygenhub.android.FakeHubApi

import io.oxygenhub.android.MainDispatcherRule

import io.oxygenhub.android.api.FlowJob

import io.oxygenhub.android.api.FlowRun

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.StarterAssistant

import io.oxygenhub.android.api.StarterStatus

import io.oxygenhub.android.api.UserFlowRun

import io.oxygenhub.android.api.Visibility

import io.oxygenhub.android.ui.flow.RunFilter

import io.oxygenhub.android.ui.flow.filtered

import io.oxygenhub.android.ui.flow.runSky

import io.oxygenhub.android.ui.flow.took

import io.oxygenhub.android.ui.repos.Making

import io.oxygenhub.android.ui.repos.NewRepositoryViewModel

import org.junit.Assert.assertEquals

import org.junit.Assert.assertTrue

import org.junit.Rule

import org.junit.Test

class NewRepositoryAndFlowTest {

    @get:Rule val main = MainDispatcherRule()

    private val api = FakeHubApi()

    @Test

    fun aRepositoryIsMadeUnderYouOrAnOrganisationYouBelongTo() {

        val vm = NewRepositoryViewModel(api, "andymccall")

        assertEquals(listOf("andymccall", "doomsdayone"), vm.owners.value)

        vm.create("doomsdayone", " pong ", " A game ", Visibility.Private, ask = "")

        val done = vm.making.value as Making.Done

        assertEquals(("doomsdayone" to "pong"), done.repo.owner to done.repo.name)

        assertEquals(Visibility.Private, done.repo.visibility)

        assertTrue("no starter without an assistant: ${api.calls}", api.calls.none { it.startsWith("start starter") })

    }

    @Test

    fun anAssistantDraftsTheStarterAndTheScreenFollowsIt() {

        api.starterAssistants = { listOf(StarterAssistant("Helper", "m1", "the site")) }

        api.starterStatuses = mutableListOf(StarterStatus("running", "Helper"), StarterStatus("done", "Helper", "abc", listOf("README.md", "src/main.rs")))

        val vm = NewRepositoryViewModel(api, "andymccall", pollMs = 10)

        vm.create("andymccall", "pong", "", Visibility.Public, ask = "A pong game in Rust")

        assertTrue(vm.making.value is Making.Drafting)

        main.dispatcher.scheduler.advanceUntilIdle()

        val done = vm.making.value as Making.Done

        assertEquals(listOf("README.md", "src/main.rs"), done.files)

        assertEquals("Helper", done.assistant)

    }

    @Test

    fun aFailedDraftStillOpensTheRepositoryAndSaysWhy() {

        api.starterAssistants = { listOf(StarterAssistant("Helper")) }

        api.starterStatuses = mutableListOf(StarterStatus("failed", "Helper", error = "the assistant answered without any files"))

        val vm = NewRepositoryViewModel(api, "andymccall", pollMs = 10)

        vm.create("andymccall", "pong", "", Visibility.Public, ask = "something")

        main.dispatcher.scheduler.advanceUntilIdle()

        val failed = vm.making.value as Making.Failed

        assertTrue(failed.message, failed.message.contains("without any files"))

        assertEquals("pong", failed.repo?.name)

    }

    @Test

    fun aPhoneWithoutRepoAdminIsToldHowToAllowIt() {

        api.createRepository = { _, _, _, _ -> throw HubException.Http(403, "this token lacks the repo:admin scope") }

        val vm = NewRepositoryViewModel(api, "andymccall")

        vm.create("andymccall", "pong", "", Visibility.Public, ask = "")

        val failed = vm.making.value as Making.Failed

        assertTrue(failed.message, failed.message.contains("sign out and in again"))

    }

    private fun run(repo: String, n: Long, status: String, created: Long, finished: Long? = null, jobs: List<String> = emptyList()) =

        UserFlowRun(repo, FlowRun(number = n, status = status, createdMs = created, finishedMs = finished, jobs = jobs.map { FlowJob(name = it, status = status) }))

    @Test

    fun theMonitorFiltersDrawsAndTimesRuns() {

        val runs = listOf(

            run("andy/a", 3, "running", 9_000),

            run("andy/b", 2, "failed", 5_000, 8_000),

            run("andy/a", 1, "passed", 1_000, 200_000, jobs = listOf("build", "test")),

        )

        assertEquals(listOf(3L), filtered(runs, RunFilter.Live).map { it.run.number })

        assertEquals(listOf(2L), filtered(runs, RunFilter.Failed).map { it.run.number })

        assertEquals(3, filtered(runs, RunFilter.All).size)

        val sky = runSky(runs, now = 10_000)

        assertEquals(listOf("andy/a", "andy/b"), sky.repos)

        assertEquals(listOf(listOf(0L, 4L, 9_000L, 1L), listOf(1L, 4L, 5_000L, 1L), listOf(0L, 4L, 1_000L, 1L)), sky.events)

        assertEquals("3 s", took(runs[1].run, now = 10_000))

        assertEquals("3 min 19 s", took(runs[2].run, now = 0))

        assertEquals("1 s", took(runs[0].run, now = 10_000), )

    }

}