Navigation that
writes itself.

plugins {
    kotlin("multiplatform")
    id("org.jetbrains.compose")
    id("org.jetbrains.kotlin.plugin.compose")

    id("io.github.alims-repo.navease") version "0.2.0"
}

import io.github.alimsrepo.navease.runtime.NavEaseRoot

sealed class AppScreens : NavEaseRoot {

    data object Splash : AppScreens()
    data object Home : AppScreens()

    data class Profile(val userId: String, val isEditable: Boolean = false) : AppScreens()
    data class Detail(val itemId: String, val title: String) : AppScreens()
}

import io.github.alimsrepo.navease.runtime.annotations.AutoRegister
import io.github.alimsrepo.navease.runtime.navigation.NavEaseController
import io.github.alimsrepo.navease.runtime.screen.ActivityScreen

@AutoRegister
class HomeScreen : ActivityScreen<AppScreens.Home>() {

    @Composable
    override fun Content(navKey: AppScreens.Home, navEaseController: NavEaseController) {
        Button(onClick = { navEaseController.navigate(AppScreens.Profile(userId = "alim")) }) {
            Text("Open profile")
        }
    }
}

@AutoRegister
class ProfileScreen : ActivityScreen<AppScreens.Profile>() {

    @Composable
    override fun Content(navKey: AppScreens.Profile, navEaseController: NavEaseController) {
        Text("User ${navKey.userId}")     // typed — no casting
        if (navKey.isEditable) EditForm()
    }
}

import io.github.alimsrepo.navease.runtime.host.NavEaseHost

@Composable
fun App() {
    MaterialTheme {
        NavEaseHost<AppScreens>(
            start = AppScreens.Splash,
            onExitRequest = { finish() },     // back pressed on the root screen
        )
    }
}

/** Push a screen onto the back stack. */
fun navigate(
    navKey: NavKey,
    finish: Boolean = false,        // push and drop the screen underneath — replace
    singleTop: Boolean = false,     // skip if that screen class is already on top
    navTransition: NavTransition? = null,
)

/** Pop one screen. At the root, calls the host's onExitRequest instead. */
fun back()

/** Pop until [key]'s screen. Matched by runtime class — argument values ignored. */
fun popUpTo(key: NavKey, inclusive: Boolean = false)

/** Pop everything above [index] (0 = root). */
fun popToIndex(index: Int)

/** The current back stack, oldest entry first. */
fun getHistory(): List<NavKey>

// A default for the whole host…
NavEaseHost<AppScreens>(start = AppScreens.Splash, navTransition = NavTransition.Depth)

// …overridden for one navigation. Recorded per push, so the reverse plays
// on the way back — predictive back included.
nav.navigate(AppScreens.Detail(id, title), navTransition = NavTransition.Rise)

// Called whenever the top of the back stack changes, including for the start
// destination on first composition. For concerns that belong to the graph rather
// than to any one screen — screen-view analytics being the obvious one.
NavEaseHost<AppScreens>(
    start = AppScreens.Splash,
    onDestinationChanged = { navKey ->
        analytics.logScreenView(navKey::class.simpleName.orEmpty())
    },
)

// NavEaseController is the receiver, not a second parameter — so a hook that
// only observes ignores it, and one that needs to navigate just uses it.
NavEaseHost<HomeNav>(
    start = HomeNav.Root,
    onDestinationChanged = { navKey -> hideBottomBar(navKey !is HomeNav.Root) },
)

import io.github.alimsrepo.navease.runtime.navigation.backWithResult
import io.github.alimsrepo.navease.runtime.navigation.resultOf

data class ProfileResult(val saved: Boolean)

// On the screen returning a value:
navEaseController.backWithResult(ProfileResult(saved = true))

// On the screen waiting for it:
val result by navEaseController.resultOf<ProfileResult>()
LaunchedEffect(result) {
    if (result?.saved == true) showSnackbar("Profile saved")
}

// Turn it on at the host that owns the transition. A shared element only morphs
// within one host, so enable it on the host containing both screens.
NavEaseHost<AppScreens>(start = AppScreens.Splash, enableSharedTransitions = true)

// Then read both scopes in the two screens, matching the key exactly.
import io.github.alimsrepo.navease.runtime.composition.LocalNavEaseAnimatedContentScope
import io.github.alimsrepo.navease.runtime.composition.LocalNavEaseSharedTransitionScope

@OptIn(ExperimentalSharedTransitionApi::class)
@Composable
fun Avatar(userId: String) {
    val sharedScope = LocalNavEaseSharedTransitionScope.current
    val animScope = LocalNavEaseAnimatedContentScope.current

    // Guard on null so the same composable still renders when the flag is off.
    val modifier = if (sharedScope != null) {
        with(sharedScope) {
            Modifier.sharedBounds(
                sharedContentState = rememberSharedContentState(key = "avatar_$userId"),
                animatedVisibilityScope = animScope,
            )
        }
    } else Modifier

    Box(modifier.size(88.dp))
}

// A nested graph is another sealed root with its own screens and its own host.
sealed class WizardStep : NavEaseRoot {
    data object PickRole : WizardStep()
    data class Confirm(val role: String) : WizardStep()
}

@AutoRegister class PickRoleScreen : ActivityScreen<WizardStep.PickRole>()
@AutoRegister class ConfirmScreen  : ActivityScreen<WizardStep.Confirm>()

// Inside a screen of the outer graph:
NavEaseHost<WizardStep>(
    start = WizardStep.PickRole,
    onExitRequest = { outerController.back() },   // back on the nested root leaves the feature
)