// settings.gradle.kts
pluginManagement {
    repositories {
        mavenCentral()
        gradlePluginPortal()
    }
}

// build.gradle.kts
plugins {
    kotlin("multiplatform")
    id("org.jetbrains.kotlin.plugin.serialization")
    id("com.google.devtools.ksp") version "2.3.0"
    id("io.github.jermeyyy.quo-vadis") version "0.3.4"
}

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("io.github.jermeyyy:quo-vadis-core:0.3.4")
            implementation("io.github.jermeyyy:quo-vadis-annotations:0.3.4")
        }
    }
}

// Optional: Configure the plugin
quoVadis {
    // Override module prefix (defaults to project.name in PascalCase)
    modulePrefix = "MyApp"
}

// build.gradle.kts
plugins {
    kotlin("multiplatform")
    id("org.jetbrains.kotlin.plugin.serialization")
    id("com.google.devtools.ksp") version "2.3.0"
}

repositories {
    mavenCentral()
    google()
}

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("io.github.jermeyyy:quo-vadis-core:0.3.4")
            implementation("io.github.jermeyyy:quo-vadis-annotations:0.3.4")
        }
    }
    
    // Configure KSP module prefix
    ksp {
        arg("quoVadis.modulePrefix", "MyApp")
    }
}

dependencies {
    // KSP code generator (all targets)
    add("kspCommonMainMetadata", "io.github.jermeyyy:quo-vadis-ksp:0.3.4")
}

// Required for KMP: Register generated sources
kotlin.sourceSets.commonMain {
    kotlin.srcDir("build/generated/ksp/metadata/commonMain/kotlin")
}

// Required for KMP: Fix task dependencies
afterEvaluate {
    tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask<*>>().configureEach {
        if (!name.startsWith("ksp") && !name.contains("Test", ignoreCase = true)) {
            dependsOn("kspCommonMainKotlinMetadata")
        }
    }
}

// 1. Define a navigation stack with destinations
@Stack(name = "home", startDestination = Feed::class)
sealed class HomeDestination : NavDestination {

    @Destination(route = "home/feed")
    data object Feed : HomeDestination()

    @Destination(route = "home/article/{articleId}")
    data class Article(
        @Argument val articleId: String,
        @Argument(optional = true) val showComments: Boolean = false
    ) : HomeDestination()

    @Destination(route = "home/settings")
    data object Settings : HomeDestination()
}

// Simple screen (data object destination)
@Screen(HomeDestination.Feed::class)
@Composable
fun FeedScreen(navigator: Navigator) {
    Column {
        Text("Feed")
        Button(onClick = { 
            navigator.navigate(HomeDestination.Article(articleId = "123"))
        }) {
            Text("View Article")
        }
    }
}

// Screen with arguments (data class destination)
@Screen(HomeDestination.Article::class)
@Composable
fun ArticleScreen(destination: HomeDestination.Article, navigator: Navigator) {
    Column {
        Text("Article: ${destination.articleId}")
        if (destination.showComments) {
            Text("Comments visible")
        }
        Button(onClick = { navigator.navigateBack() }) {
            Text("Back")
        }
    }
}

@Composable
fun App() {
    val config = GeneratedNavigationConfig
    
    // Build the initial NavNode tree from your root destination
    val initialState = remember {
        config.buildNavNode(
            destinationClass = HomeDestination::class,
            parentKey = null
        )!!
    }
    
    // Create the navigator with config
    val navigator = remember {
        TreeNavigator(
            config = config,
            initialState = initialState
        )
    }
    
    // Render the navigation tree - config read from navigator
    NavigationHost(
        navigator = navigator,
        screenRegistry = config.screenRegistry
    )
}

// Define each tab as @TabItem + @Stack
@TabItem(label = "Home", icon = "home")
@Stack(name = "homeStack", startDestination = HomeTab.Feed::class)
sealed class HomeTab : NavDestination {
    @Destination(route = "home/feed")
    data object Feed : HomeTab()
    
    @Destination(route = "home/article/{id}")
    data class Article(@Argument val id: String) : HomeTab()
}

@TabItem(label = "Explore", icon = "explore")
@Stack(name = "exploreStack", startDestination = ExploreTab.Root::class)
sealed class ExploreTab : NavDestination {
    @Destination(route = "explore/root")
    data object Root : ExploreTab()
}

// Define the tabs container
@Tabs(
    name = "mainTabs",
    initialTab = HomeTab::class,
    items = [HomeTab::class, ExploreTab::class]
)
object MainTabs

@TabsContainer(MainTabs::class)
@Composable
fun MainTabsWrapper(scope: TabsContainerScope, content: @Composable () -> Unit) {
    Scaffold(
        bottomBar = {
            NavigationBar {
                scope.tabs.forEachIndexed { index, tab ->
                    NavigationBarItem(
                        selected = index == scope.activeIndex,
                        onClick = { scope.switchTab(index) },
                        icon = { Icon(tabIcon(tab.icon), tab.label) },
                        label = { Text(tab.label) }
                    )
                }
            }
        }
    ) { padding ->
        Box(Modifier.padding(padding)) {
            content()
        }
    }
}

@Pane(name = "catalog", backBehavior = PaneBackBehavior.PopUntilContentChange)
sealed class CatalogPane : NavDestination {

    @PaneItem(role = PaneRole.PRIMARY, rootGraph = ProductListGraph::class)
    @Destination(route = "catalog/list")
    data object List : CatalogPane()

    @PaneItem(
        role = PaneRole.SECONDARY,
        adaptStrategy = AdaptStrategy.OVERLAY,
        rootGraph = ProductDetailGraph::class
    )
    @Destination(route = "catalog/detail/{id}")
    data class Detail(@Argument val id: String) : CatalogPane()
}

@Stack(name = "home", startDestination = "List")
sealed class HomeDestination : NavDestination {

    // Default transition
    @Destination(route = "list")
    data object List : HomeDestination()

    // Horizontal slide for detail screens
    @Transition(type = TransitionType.SlideHorizontal)
    @Destination(route = "details/{id}")
    data class Details(@Argument val id: String) : HomeDestination()

    // Vertical slide for modals
    @Transition(type = TransitionType.SlideVertical)
    @Destination(route = "filter")
    data object Filter : HomeDestination()

    // Fade for overlays
    @Transition(type = TransitionType.Fade)
    @Destination(route = "help")
    data object Help : HomeDestination()
}

interface Navigator {
    val state: StateFlow<NavNode>
    val currentDestination: StateFlow<NavDestination?>
    val canNavigateBack: StateFlow<Boolean>
    
    // Basic navigation
    fun navigate(destination: NavDestination)
    fun navigateBack(): Boolean
    
    // Advanced navigation
    fun navigateAndClearTo(destination: NavDestination)
    fun navigateAndReplace(destination: NavDestination)
    
    // Pane navigation
    fun navigateToPane(role: PaneRole, destination: NavDestination)
    fun switchPane(role: PaneRole)
    
    // Deep links
    fun handleDeepLink(uri: String): Boolean
}

@Screen(HomeDestination.Article::class)
@Composable
fun ArticleScreen(
    destination: HomeDestination.Article,
    navigator: Navigator,
    sharedTransitionScope: SharedTransitionScope?,
    animatedVisibilityScope: AnimatedVisibilityScope?
) {
    // Use shared elements when scopes are available
    if (sharedTransitionScope != null && animatedVisibilityScope != null) {
        Image(
            modifier = Modifier.quoVadisSharedElement(
                key = "article-image-${destination.articleId}",
                sharedTransitionScope = sharedTransitionScope,
                animatedVisibilityScope = animatedVisibilityScope
            )
        )
    }
}

implementation("io.github.jermeyyy:quo-vadis-core-flow-mvi:0.3.4")

class ProfileContainer(scope: NavigationContainerScope) :
    NavigationContainer<ProfileState, ProfileIntent, ProfileAction>(scope) {
    
    override val store = store(ProfileState()) {
        reduce { intent ->
            when (intent) {
                is ProfileIntent.LoadProfile -> loadProfile()
                is ProfileIntent.NavigateToSettings -> navigator.navigate(SettingsDestination)
            }
        }
    }
    
    private suspend fun loadProfile() {
        updateState { copy(isLoading = true) }
        // Load data...
    }
}

@Composable
fun ProfileScreen() {
    val store = rememberContainer<ProfileContainer, ProfileState, ProfileIntent, ProfileAction>()
    
    with(store) {
        val state by subscribe()
        // Render UI
        Button(onClick = { intent(ProfileIntent.LoadProfile) }) {
            Text("Load")
        }
    }
}

class MainTabsContainer(scope: SharedContainerScope) :
    SharedNavigationContainer<TabsState, TabsIntent, TabsAction>(scope) {
    
    override val store = store(TabsState(badgeCount = 0)) {
        reduce { intent ->
            when (intent) {
                is TabsIntent.IncrementBadge -> updateState { copy(badgeCount = badgeCount + 1) }
            }
        }
    }
}

// In tabs wrapper
@TabsContainer(MainTabs::class)
@Composable
fun MainTabsWrapper(scope: TabsContainerScope, content: @Composable () -> Unit) {
    val store = rememberSharedContainer<MainTabsContainer, TabsState, TabsIntent, TabsAction>()
    
    CompositionLocalProvider(LocalMainTabsStore provides store) {
        val state by store.subscribe()
        Scaffold(
            bottomBar = { TabBar(badgeCount = state.badgeCount) }
        ) {
            content()
        }
    }
}

// Child screens can access the shared store
@Composable
fun HomeScreen() {
    val tabsStore = LocalMainTabsStore.current
    Button(onClick = { tabsStore?.intent(TabsIntent.IncrementBadge) }) {
        Text("Update Badge")
    }
}

val mviModule = module {
    navigationContainer<ProfileContainer> { scope ->
        ProfileContainer(scope)
    }
    
    sharedNavigationContainer<MainTabsContainer> { scope ->
        MainTabsContainer(scope)
    }
}

quoVadis {
    // Module prefix for generated class names
    // Default: project.name converted to PascalCase
    // Example: "feature-one" → "FeatureOne" → "FeatureOneNavigationConfig"
    modulePrefix = "CustomPrefix"
    
    // Use local KSP processor (for library development)
    // Default: false (uses Maven Central artifact)
    useLocalKsp = true
}

// In app module
val combinedConfig = AppNavigationConfig + 
    Feature1NavigationConfig + 
    Feature2NavigationConfig

NavigationHost(
    navigator = navigator,
    config = combinedConfig
)

@Test
fun `navigate to details screen`() {
    val config = GeneratedNavigationConfig
    val initialState = config.buildNavNode(HomeDestination::class, null)!!
    // For testing, config can be passed or use defaults (NavigationConfig.Empty)
    val navigator = TreeNavigator(config = config, initialState = initialState)
    
    navigator.navigate(HomeDestination.Article(articleId = "123"))
    
    assertEquals(
        HomeDestination.Article(articleId = "123"),
        navigator.currentDestination.value
    )
}