Pit-Log-App/app/src/main/java/com/racingapp/pitlog/ui/PitNav.kt

package com.racingapp.pitlog.ui

import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.statusBarsPadding
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.semantics.semantics
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.navigation.NavType
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import androidx.navigation.navArgument
import com.racingapp.pitlog.ui.guide.SetupGuideScreen
import com.racingapp.pitlog.ui.home.CarsScreen
import com.racingapp.pitlog.ui.home.HomeScreen
import com.racingapp.pitlog.ui.night.NightDetailScreen
import com.racingapp.pitlog.ui.night.NightEditorScreen
import com.racingapp.pitlog.ui.night.SetupEditorScreen
import com.racingapp.pitlog.ui.run.RunDetailScreen
import com.racingapp.pitlog.ui.run.RunEditorScreen
import com.racingapp.pitlog.ui.settings.SettingsScreen
import com.racingapp.pitlog.ui.setup.CarSetupEditorScreen
import com.racingapp.pitlog.ui.setup.CarSetupScreen

@Composable
fun PitNav() {
    val nav = rememberNavController()
    val context = LocalContext.current
    val refreshing by LocalRepository.current.syncRefreshing().collectAsStateWithLifecycle(false)
    Box(Modifier.fillMaxSize()) {
    NavHost(navController = nav, startDestination = "cars") {
        composable("cars") {
            CarsScreen(
                onOpenCar = {
                    nav.navigate("home") {
                        popUpTo("cars")
                        launchSingleTop = true
                    }
                },
                onAddCar = { nav.navigate("settings/car") },
                onSettings = { nav.navigate("settings") },
            )
        }
        composable("home") {
            HomeScreen(
                onBack = { nav.popBackStack() },
                onNewNight = { nav.navigate("editor/night") },
                onOpenNight = { id -> nav.navigate("night/$id") },
                onLogRun = { id -> nav.navigate("editor/run/$id") },
                onSettings = { nav.navigate("settings/car") },
                onGuide = { nav.navigate("guide") },
                onCarSetup = { nav.navigate("car-setup") },
                onExport = { name, csv -> shareCsv(context, name, csv) },
            )
        }
        composable("settings") {
            SettingsScreen(showCar = false, onBack = { nav.popBackStack() })
        }
        composable("settings/car") {
            SettingsScreen(
                showCar = true,
                onBack = { nav.popBackStack() },
                onCarRemoved = { nav.popBackStack("cars", inclusive = false) },
            )
        }
        composable("guide") {
            SetupGuideScreen(onBack = { nav.popBackStack() })
        }
        composable("car-setup") {
            CarSetupScreen(
                onBack = { nav.popBackStack() },
                onEditOriginal = { nav.navigate("car-setup/original") },
                onLogChange = { nav.navigate("car-setup/change") },
            )
        }
        composable("car-setup/original") {
            CarSetupEditorScreen(loggingChange = false, onBack = { nav.popBackStack() })
        }
        composable("car-setup/change") {
            CarSetupEditorScreen(loggingChange = true, onBack = { nav.popBackStack() })
        }
        composable(
            route = "setup/{nightId}",
            arguments = listOf(navArgument("nightId") { type = NavType.LongType }),
        ) { entry ->
            val nightId = entry.arguments?.getLong("nightId") ?: return@composable
            SetupEditorScreen(nightId = nightId, onBack = { nav.popBackStack() })
        }
        composable("editor/night") {
            NightEditorScreen(
                nightId = null,
                onBack = { nav.popBackStack() },
                onSaved = { id ->
                    nav.navigate("night/$id") {
                        popUpTo("editor/night") { inclusive = true }
                    }
                },
            )
        }
        composable(
            route = "editor/night/{nightId}",
            arguments = listOf(navArgument("nightId") { type = NavType.LongType }),
        ) { entry ->
            NightEditorScreen(
                nightId = entry.arguments?.getLong("nightId"),
                onBack = { nav.popBackStack() },
                onSaved = { nav.popBackStack() },
            )
        }
        composable(
            route = "night/{nightId}",
            arguments = listOf(navArgument("nightId") { type = NavType.LongType }),
        ) { entry ->
            val nightId = entry.arguments?.getLong("nightId") ?: return@composable
            NightDetailScreen(
                nightId = nightId,
                onBack = { nav.popBackStack() },
                onEdit = { nav.navigate("editor/night/$nightId") },
                onLogRun = { nav.navigate("editor/run/$nightId") },
                onOpenRun = { runId -> nav.navigate("run/$nightId/$runId") },
                onDeleted = {
                    nav.popBackStack("home", inclusive = false)
                },
                onExport = { name, csv -> shareCsv(context, name, csv) },
                onSetup = { nav.navigate("setup/$nightId") },
            )
        }
        composable(
            route = "editor/run/{nightId}",
            arguments = listOf(navArgument("nightId") { type = NavType.LongType }),
        ) { entry ->
            val nightId = entry.arguments?.getLong("nightId") ?: return@composable
            RunEditorScreen(
                nightId = nightId,
                runId = null,
                onBack = { nav.popBackStack() },
                onSaved = { runId ->
                    nav.navigate("run/$nightId/$runId") {
                        popUpTo("editor/run/$nightId") { inclusive = true }
                    }
                },
            )
        }
        composable(
            route = "editor/run/{nightId}/{runId}",
            arguments = listOf(
                navArgument("nightId") { type = NavType.LongType },
                navArgument("runId") { type = NavType.LongType },
            ),
        ) { entry ->
            val nightId = entry.arguments?.getLong("nightId") ?: return@composable
            val runId = entry.arguments?.getLong("runId") ?: return@composable
            RunEditorScreen(
                nightId = nightId,
                runId = runId,
                onBack = { nav.popBackStack() },
                onSaved = { nav.popBackStack() },
            )
        }
        composable(
            route = "run/{nightId}/{runId}",
            arguments = listOf(
                navArgument("nightId") { type = NavType.LongType },
                navArgument("runId") { type = NavType.LongType },
            ),
        ) { entry ->
            val nightId = entry.arguments?.getLong("nightId") ?: return@composable
            val runId = entry.arguments?.getLong("runId") ?: return@composable
            RunDetailScreen(
                nightId = nightId,
                runId = runId,
                onBack = { nav.popBackStack() },
                onEdit = { nav.navigate("editor/run/$nightId/$runId") },
                onGuide = { nav.navigate("guide") },
                onDeleted = { nav.popBackStack() },
            )
        }
    }
        if (refreshing) {
            LinearProgressIndicator(
                modifier = Modifier
                    .align(Alignment.TopCenter)
                    .fillMaxWidth()
                    .statusBarsPadding()
                    .semantics { contentDescription = "Syncing" },
                color = MaterialTheme.colorScheme.primary,
                trackColor = MaterialTheme.colorScheme.background,
            )
        }
    }
}