/**
 * Assert a simple value
 */
@Test
fun testHookCapturesRememberedState() = runComposeUiTest {
    val result by testHook {
        remember { mutableStateOf(42) }
    }
    assertEquals(42, result)
}

/**
 * Assert a value that requires a wrapper to set it up
 */
@Test
fun testHookWithCompositionLocalWrapper() {
    val TestLocal = compositionLocalOf { "default" }

    runComposeUiTest {
        val result by testHook(
            wrapper = { content ->
                CompositionLocalProvider(TestLocal provides "injected") {
                    content()
                }
            },
            hook = { TestLocal.current }
        )
        assertEquals("injected", result)
    }
}

/**
 * Assert a value when the value changes
 */
@Test
fun testHookWithLateChangingStateAndClockAdvancement() {
    runComposeUiTest {
        mainClock.autoAdvance = false
        val changingValue by testHook {
            rememberLateChangingVal()
        }
        println(changingValue)
        assertEquals(changingValue?.first, false)

        // Advance time
        mainClock.advanceTimeBy(changingValue?.second!!)
        assertEquals(changingValue?.first, true)
    }
}

/**
 * Wait for a condition to be asserted
 */
@Test
fun testWaitForCondition() {
    runComposeUiTest {
        val changingValue by testHook {
            rememberLateChangingVal()
        }
        assertEquals(changingValue?.first, false)

        // waitUntil advances the clock with each iteration, so we can "lose"
        // time as it goes through each iteration as it skips ahead faster than via
        // manual advancement. Checking 1 ms is safe unless the machine is VERY fast
        assertFailsWith<ComposeTimeoutException> {
            waitForCondition(timeoutMs = 1L) {
                assertEquals(changingValue?.first, true)
            }
        }

        // The value changed by this point
        waitForCondition(timeoutMs = changingValue?.second!!) {
            assertEquals(changingValue?.first, true)
        }

    }
}

@OptIn(ExperimentalCoroutinesApi::class)
@Test
fun reactsToStateChanges() = runTest {
        val trigger = CompletableDeferred<Unit>()
        val state by renderHook {
            rememberLateChangingVal(deferTrigger = trigger)
        }
        assertEquals(false, state)

        act { trigger.complete(Unit) }

        assertEquals(true, state)
    }

// Kotlin Multiplatform (all platforms), or iOS, WASMJs
kotlin {
    sourceSets {
        commonTest.dependencies {
            implementation("io.github.notoriouscorgi:composetesttools:1.0.0")
        }
    }
}

// Android-only
dependencies {
    androidTestImplementation("io.github.notoriouscorgi:composetesttools-android:1.0.0")
}

// JVM-only
dependencies {
    testImplementation("io.github.notoriouscorgi:composetesttools-jvm:1.0.0")
}