package io.oxygenhub.android.ui.nav

import androidx.compose.animation.AnimatedContentTransitionScope.SlideDirection

import androidx.compose.animation.core.tween

import androidx.compose.animation.fadeIn

import androidx.compose.animation.fadeOut

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.filled.AccountCircle

import androidx.compose.material.icons.filled.Book

import androidx.compose.material.icons.filled.Dashboard

import androidx.compose.material.icons.filled.Inbox

import androidx.compose.material.icons.filled.RocketLaunch

import androidx.compose.material.icons.filled.Search

import androidx.compose.material.icons.filled.ViewKanban

import androidx.compose.material.icons.outlined.AccountCircle

import androidx.compose.material.icons.outlined.Book

import androidx.compose.material.icons.outlined.Dashboard

import androidx.compose.material.icons.outlined.Inbox

import androidx.compose.material.icons.outlined.RocketLaunch

import androidx.compose.material.icons.outlined.Search

import androidx.compose.material.icons.outlined.ViewKanban

import androidx.compose.material3.Badge

import androidx.compose.material3.BadgedBox

import androidx.compose.material3.Icon

import androidx.compose.material3.Text

import androidx.compose.material3.adaptive.currentWindowAdaptiveInfo

import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteScaffold

import androidx.compose.runtime.Composable

import androidx.compose.runtime.LaunchedEffect

import androidx.compose.runtime.getValue

import androidx.compose.runtime.rememberCoroutineScope

import androidx.compose.ui.graphics.vector.ImageVector

import androidx.compose.ui.platform.LocalUriHandler

import androidx.lifecycle.ViewModel

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import androidx.lifecycle.viewmodel.compose.viewModel

import androidx.lifecycle.viewmodel.initializer

import androidx.lifecycle.viewmodel.viewModelFactory

import androidx.navigation.NavDestination.Companion.hasRoute

import androidx.navigation.NavDestination.Companion.hierarchy

import androidx.navigation.NavGraph.Companion.findStartDestination

import androidx.navigation.NavHostController

import androidx.navigation.compose.NavHost

import androidx.navigation.compose.composable

import androidx.navigation.compose.currentBackStackEntryAsState

import androidx.navigation.compose.rememberNavController

import androidx.navigation.toRoute

import androidx.window.core.layout.WindowSizeClass

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.auth.Session

import io.oxygenhub.android.ui.account.AccountScreen

import io.oxygenhub.android.ui.backdrop.repoSkyOrNull

import io.oxygenhub.android.ui.code.ChangeScreen

import io.oxygenhub.android.ui.code.ChangeViewModel

import io.oxygenhub.android.ui.code.CodeViewModel

import io.oxygenhub.android.ui.code.FileScreen

import io.oxygenhub.android.ui.code.FileViewModel

import io.oxygenhub.android.ui.code.HistoryScreen

import io.oxygenhub.android.ui.code.HistoryViewModel

import io.oxygenhub.android.ui.common.rememberAvatar

import io.oxygenhub.android.ui.dashboard.DashboardScreen

import io.oxygenhub.android.ui.dashboard.DashboardViewModel

import io.oxygenhub.android.ui.flow.FlowMonitorScreen

import io.oxygenhub.android.ui.flow.FlowMonitorViewModel

import io.oxygenhub.android.ui.flow.JobLogScreen

import io.oxygenhub.android.ui.flow.JobLogViewModel

import io.oxygenhub.android.ui.flow.RunScreen

import io.oxygenhub.android.ui.flow.RunViewModel

import io.oxygenhub.android.ui.flow.RunsViewModel

import io.oxygenhub.android.ui.inbox.InboxScreen

import io.oxygenhub.android.ui.inbox.InboxViewModel

import io.oxygenhub.android.ui.issues.IssueScreen

import io.oxygenhub.android.ui.issues.IssueViewModel

import io.oxygenhub.android.ui.issues.IssuesViewModel

import io.oxygenhub.android.ui.issues.NewIssueScreen

import io.oxygenhub.android.ui.issues.NewIssueViewModel

import io.oxygenhub.android.ui.owners.OwnerScreen

import io.oxygenhub.android.ui.owners.OwnerViewModel

import io.oxygenhub.android.ui.projects.BoardScreen

import io.oxygenhub.android.ui.projects.BoardViewModel

import io.oxygenhub.android.ui.projects.ProjectsScreen

import io.oxygenhub.android.ui.projects.ProjectsViewModel

import io.oxygenhub.android.ui.proposals.ProposalFilesScreen

import io.oxygenhub.android.ui.proposals.ProposalFilesViewModel

import io.oxygenhub.android.ui.proposals.ProposalScreen

import io.oxygenhub.android.ui.proposals.ProposalViewModel

import io.oxygenhub.android.ui.proposals.ProposalsViewModel

import io.oxygenhub.android.ui.releases.ReleasesViewModel

import io.oxygenhub.android.ui.releases.SearchScreen

import io.oxygenhub.android.ui.releases.SearchViewModel

import io.oxygenhub.android.ui.repos.NewRepositoryScreen

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

import io.oxygenhub.android.ui.repos.RepositoriesScreen

import io.oxygenhub.android.ui.repos.RepositoriesViewModel

import io.oxygenhub.android.ui.repos.RepositoryScreen

import kotlin.reflect.KClass

import kotlinx.coroutines.launch

import kotlinx.serialization.Serializable

// The app's routes. Top-level ones are in the navigation bar (or rail, or

// drawer, as the window allows); the rest are pushed over them. Browse

// (oxygenhub-android#3) adds a repository's overview, code and history

// under the repository's route.

@Serializable data object DashboardRoute

@Serializable data object RepositoriesRoute

@Serializable data object NewRepositoryRoute

@Serializable data object FlowRoute

@Serializable data object InboxRoute

@Serializable data object ProjectsRoute

@Serializable data object SearchRoute

/** A project board. */

@Serializable data class BoardRoute(val owner: String, val number: Long)

@Serializable data object AccountRoute

/** A repository's issues, opened from outside the repositories list (the dashboard). */

@Serializable data class IssuesRoute(val owner: String, val name: String)

/** One proposal, pushed over the repository it belongs to. */

@Serializable data class ProposalRoute(val owner: String, val name: String, val number: Long)

/** A proposal's files with their diffs (#4). */

@Serializable data class ProposalFilesRoute(val owner: String, val name: String, val number: Long)

/** A file at a reference, a history (of a file when [path] is given), and a change (#3). */

@Serializable data class FileRoute(val owner: String, val name: String, val ref: String, val path: String)

@Serializable data class HistoryRoute(val owner: String, val name: String, val ref: String, val path: String? = null)

@Serializable data class ChangeRoute(val owner: String, val name: String, val hash: String)

/** An issue, and a new one (#4). */

@Serializable data class IssueRoute(val owner: String, val name: String, val number: Long)

@Serializable data class NewIssueRoute(val owner: String, val name: String)

/** An account's or organisation's page. */

@Serializable data class OwnerRoute(val name: String)

/** A Flow run, and a job's log (#5). */

@Serializable data class RunRoute(val owner: String, val name: String, val number: Long)

@Serializable data class JobLogRoute(val owner: String, val name: String, val number: Long, val job: String)

/**

 * Where the bar or rail goes. [wide] ones show only when there is room (the

 * unfolded Fold, a tablet: #14); on a phone the bar keeps its four and they

 * are reached from the dashboard.

 */

enum class TopLevel(

    val label: String,

    val icon: ImageVector,

    val selectedIcon: ImageVector,

    val route: Any,

    val routeClass: KClass<*>,

    val wide: Boolean = false,

) {

    Dashboard("Dashboard", Icons.Outlined.Dashboard, Icons.Filled.Dashboard, DashboardRoute, DashboardRoute::class),

    Repositories("Repositories", Icons.Outlined.Book, Icons.Filled.Book, RepositoriesRoute, RepositoriesRoute::class),

    Flow("Flow", Icons.Outlined.RocketLaunch, Icons.Filled.RocketLaunch, FlowRoute, FlowRoute::class),

    Projects("Projects", Icons.Outlined.ViewKanban, Icons.Filled.ViewKanban, ProjectsRoute, ProjectsRoute::class, wide = true),

    Search("Search", Icons.Outlined.Search, Icons.Filled.Search, SearchRoute, SearchRoute::class, wide = true),

    Inbox("Inbox", Icons.Outlined.Inbox, Icons.Filled.Inbox, InboxRoute, InboxRoute::class),

    Account("Account", Icons.Outlined.AccountCircle, Icons.Filled.AccountCircle, AccountRoute, AccountRoute::class),

}

/** A view model made by [make], kept by the screen's back stack entry (or [key] within it). */

@Composable

inline fun <reified VM : ViewModel> rememberViewModel(key: String? = null, crossinline make: () -> VM): VM =

    viewModel(key = key, factory = viewModelFactory { initializer { make() } })

/** The signed-in app: navigation around the dashboard, repositories, inbox and account. */

@Composable

fun SignedInApp(

    session: Session,

    api: HubApi,

    nativeCore: () -> String,

    onSignOut: suspend () -> Unit,

    start: TopLevel = TopLevel.Dashboard,

    /** A repository to show beside the list from the start (`owner/name`). */

    selectedRepository: String? = null,

    /** A proposal to open, as a notification asks (#20); [onOpened] once it is. */

    open: ProposalRoute? = null,

    onOpened: () -> Unit = {},

) {

    val nav = rememberNavController()

    // One inbox for the badge, the dashboard's count and the inbox screen.

    val inbox = rememberViewModel(key = "inbox:${session.hub}:${session.username}") { InboxViewModel(api) }

    val inboxState by inbox.state.collectAsStateWithLifecycle()

    val unread = inboxState.valueOrNull?.unread ?: 0

    val entry by nav.currentBackStackEntryAsState()

    // A hub page opens on its own screen when the app has one, else in the browser.

    val uri = LocalUriHandler.current

    val openLink: (String) -> Unit = { url -> routeFor(url, session.hub)?.let { nav.navigate(it) } ?: uri.openUri(url) }

    val destination = entry?.destination

    val roomy = currentWindowAdaptiveInfo().windowSizeClass.isWidthAtLeastBreakpoint(WindowSizeClass.WIDTH_DP_MEDIUM_LOWER_BOUND)

    NavigationSuiteScaffold(

        navigationSuiteItems = {

            TopLevel.entries.filter { roomy || !it.wide }.forEach { top ->

                val selected = destination?.hierarchy?.any { it.hasRoute(top.routeClass) } == true

                item(

                    selected = selected,

                    onClick = { nav.goTo(top) },

                    icon = {

                        val icon = if (selected) top.selectedIcon else top.icon

                        if (top == TopLevel.Inbox && unread > 0) {

                            BadgedBox(badge = { Badge { Text(if (unread > 99) "99+" else unread.toString()) } }) {

                                Icon(icon, contentDescription = "${top.label}, $unread unread")

                            }

                        } else {

                            Icon(icon, contentDescription = top.label)

                        }

                    },

                    label = { Text(top.label) },

                )

            }

        },

    ) {

        NavHost(

            nav,

            startDestination = start.route,

            // A screen opened comes in a little from the side it leads to as it fades in, and

            // goes back the way it came (#23): where you are going reads in the motion.

            enterTransition = { slideIntoContainer(SlideDirection.Start, tween(NAV_MS), initialOffset = { it / 8 }) + fadeIn(tween(NAV_MS)) },

            exitTransition = { fadeOut(tween(NAV_MS * 2 / 3)) },

            popEnterTransition = { fadeIn(tween(NAV_MS)) },

            popExitTransition = { slideOutOfContainer(SlideDirection.End, tween(NAV_MS), targetOffset = { it / 8 }) + fadeOut(tween(NAV_MS * 2 / 3)) },

        ) {

            composable<DashboardRoute> {

                DashboardScreen(

                    vm = rememberViewModel { DashboardViewModel(api, session) },

                    hub = session.hub,

                    inbox = inboxState,

                    onRefreshInbox = inbox::refresh,

                    onOpenRepository = { nav.navigate(IssuesRoute(it.owner, it.name)) },

                    onAllRepositories = { nav.goTo(TopLevel.Repositories) },

                    onInbox = { nav.goTo(TopLevel.Inbox) },

                    onOpenProposal = { nav.navigate(ProposalRoute(it.owner, it.name, it.number)) },

                    onSearch = { nav.navigate(SearchRoute) },

                    onProjects = if (roomy) null else { { nav.navigate(ProjectsRoute) } },

                )

            }

            composable<SearchRoute> {

                SearchScreen(rememberViewModel { SearchViewModel(api) }, onBack = { nav.popBackStack() }) { h ->

                    nav.navigate(if (h.kind == "proposal") ProposalRoute(h.owner, h.name, h.number) else IssueRoute(h.owner, h.name, h.number))

                }

            }

            composable<RepositoriesRoute> {

                RepositoriesScreen(

                    rememberViewModel { RepositoriesViewModel(api, session.username) },

                    selectedRepository,

                    onNew = { nav.navigate(NewRepositoryRoute) },

                ) { slug, onBack ->

                    val (owner, name) = slug.split('/', limit = 2)

                    RepositoryScreen(

                        rememberViewModel(key = "code:$slug") { CodeViewModel(api, owner, name) },

                        rememberViewModel(key = "issues:$slug") { IssuesViewModel(api, owner, name) },

                        rememberViewModel(key = "proposals:$slug") { ProposalsViewModel(api, owner, name) },

                        rememberViewModel(key = "runs:$slug") { RunsViewModel(api, owner, name) },

                        rememberViewModel(key = "releases:$slug") { ReleasesViewModel(api, owner, name) },

                        onBack,

                        onOpenProposal = { nav.navigate(ProposalRoute(owner, name, it.number)) },

                        onOpenFile = { ref, path -> nav.navigate(FileRoute(owner, name, ref, path)) },

                        onOpenHistory = { ref -> nav.navigate(HistoryRoute(owner, name, ref)) },

                        onOpenIssue = { nav.navigate(IssueRoute(owner, name, it)) },

                        onNewIssue = if (session.canWrite) { { nav.navigate(NewIssueRoute(owner, name)) } } else null,

                        onOpenRun = { nav.navigate(RunRoute(owner, name, it)) },

                        onOpenOwner = { nav.navigate(OwnerRoute(owner)) },

                        loadSky = { repoSkyOrNull(api, owner, name) },

                    )

                }

            }

            composable<IssuesRoute> { e ->

                val r = e.toRoute<IssuesRoute>()

                RepositoryScreen(

                    rememberViewModel { CodeViewModel(api, r.owner, r.name) },

                    rememberViewModel { IssuesViewModel(api, r.owner, r.name) },

                    rememberViewModel { ProposalsViewModel(api, r.owner, r.name) },

                    rememberViewModel { RunsViewModel(api, r.owner, r.name) },

                    rememberViewModel { ReleasesViewModel(api, r.owner, r.name) },

                    onBack = { nav.popBackStack() },

                    onOpenProposal = { nav.navigate(ProposalRoute(r.owner, r.name, it.number)) },

                    onOpenFile = { ref, path -> nav.navigate(FileRoute(r.owner, r.name, ref, path)) },

                    onOpenHistory = { ref -> nav.navigate(HistoryRoute(r.owner, r.name, ref)) },

                    onOpenIssue = { nav.navigate(IssueRoute(r.owner, r.name, it)) },

                    onNewIssue = if (session.canWrite) { { nav.navigate(NewIssueRoute(r.owner, r.name)) } } else null,

                    onOpenRun = { nav.navigate(RunRoute(r.owner, r.name, it)) },

                    onOpenOwner = { nav.navigate(OwnerRoute(r.owner)) },

                    loadSky = { repoSkyOrNull(api, r.owner, r.name) },

                )

            }

            composable<OwnerRoute> { e ->

                val r = e.toRoute<OwnerRoute>()

                OwnerScreen(

                    rememberViewModel { OwnerViewModel(api, r.name) },

                    api,

                    onBack = { nav.popBackStack() },

                    onOpenOwner = { nav.navigate(OwnerRoute(it)) },

                    onOpenRepository = { nav.navigate(IssuesRoute(it.owner, it.name)) },

                    onOpenProject = { nav.navigate(BoardRoute(it.owner, it.number)) },

                )

            }

            composable<ProjectsRoute> {

                ProjectsScreen(rememberViewModel { ProjectsViewModel(api, session.username) }) { p -> nav.navigate(BoardRoute(p.owner, p.number)) }

            }

            composable<BoardRoute> { e ->

                val r = e.toRoute<BoardRoute>()

                BoardScreen(

                    rememberViewModel { BoardViewModel(api, r.owner, r.number) },

                    canWrite = session.canWrite,

                    onBack = { nav.popBackStack() },

                    onOpenCard = { card ->

                        card.target?.let { (owner, name, n) ->

                            nav.navigate(if (card.kind == "proposal") ProposalRoute(owner, name, n) else IssueRoute(owner, name, n))

                        }

                    },

                )

            }

            composable<RunRoute> { e ->

                val r = e.toRoute<RunRoute>()

                RunScreen(

                    rememberViewModel { RunViewModel(api, r.owner, r.name, r.number) },

                    canWrite = session.canWrite,

                    onBack = { nav.popBackStack() },

                    onOpenJob = { j -> nav.navigate(JobLogRoute(r.owner, r.name, r.number, j.name)) },

                )

            }

            composable<JobLogRoute> { e ->

                val r = e.toRoute<JobLogRoute>()

                JobLogScreen(rememberViewModel { JobLogViewModel(api, r.owner, r.name, r.number, r.job) }, onBack = { nav.popBackStack() })

            }

            composable<IssueRoute> { e ->

                val r = e.toRoute<IssueRoute>()

                IssueScreen(rememberViewModel { IssueViewModel(api, r.owner, r.name, r.number) }, canWrite = session.canWrite, onBack = { nav.popBackStack() }, me = session.username)

            }

            composable<FlowRoute> {

                FlowMonitorScreen(rememberViewModel { FlowMonitorViewModel(api) }) { owner, name, number -> nav.navigate(RunRoute(owner, name, number)) }

            }

            composable<NewRepositoryRoute> {

                NewRepositoryScreen(

                    rememberViewModel { NewRepositoryViewModel(api, session.username) },

                    canCreate = session.canCreate,

                    onBack = { nav.popBackStack() },

                    onOpen = { r -> nav.navigate(IssuesRoute(r.owner, r.name)) { popUpTo<NewRepositoryRoute> { inclusive = true } } },

                )

            }

            composable<NewIssueRoute> { e ->

                val r = e.toRoute<NewIssueRoute>()

                NewIssueScreen(

                    rememberViewModel { NewIssueViewModel(api, r.owner, r.name) },

                    onBack = { nav.popBackStack() },

                    onOpened = { n -> nav.navigate(IssueRoute(r.owner, r.name, n)) { popUpTo<NewIssueRoute> { inclusive = true } } },

                )

            }

            composable<FileRoute> { e ->

                val r = e.toRoute<FileRoute>()

                FileScreen(

                    rememberViewModel { FileViewModel(api, r.owner, r.name, r.ref, r.path) },

                    onBack = { nav.popBackStack() },

                    onOpenHistory = { nav.navigate(HistoryRoute(r.owner, r.name, r.ref, r.path)) },

                )

            }

            composable<HistoryRoute> { e ->

                val r = e.toRoute<HistoryRoute>()

                HistoryScreen(

                    rememberViewModel { HistoryViewModel(api, r.owner, r.name, r.ref, r.path) },

                    onBack = { nav.popBackStack() },

                    onOpenChange = { nav.navigate(ChangeRoute(r.owner, r.name, it.hash)) },

                )

            }

            composable<ChangeRoute> { e ->

                val r = e.toRoute<ChangeRoute>()

                ChangeScreen(

                    rememberViewModel { ChangeViewModel(api, r.owner, r.name, r.hash) },

                    onBack = { nav.popBackStack() },

                    onOpenFile = { path -> nav.navigate(FileRoute(r.owner, r.name, r.hash, path)) },

                )

            }

            composable<ProposalRoute> { e ->

                val r = e.toRoute<ProposalRoute>()

                val scope = rememberCoroutineScope()

                ProposalScreen(

                    rememberViewModel { ProposalViewModel(api, r.owner, r.name, r.number) },

                    canWrite = session.canWrite,

                    onBack = { nav.popBackStack() },

                    // Signing out revokes this token; the new sign-in asks for repo:write.

                    onSignInAgain = { scope.launch { onSignOut() } },

                    onOpenFiles = { nav.navigate(ProposalFilesRoute(r.owner, r.name, r.number)) },

                )

            }

            composable<ProposalFilesRoute> { e ->

                val r = e.toRoute<ProposalFilesRoute>()

                ProposalFilesScreen(rememberViewModel { ProposalFilesViewModel(api, r.owner, r.name, r.number) }, onBack = { nav.popBackStack() })

            }

            composable<InboxRoute> { InboxScreen(inbox, onOpen = openLink) }

            composable<AccountRoute> { AccountScreen(session, rememberAvatar(api, session.username), api, nativeCore, onSignOut) }

        }

        LaunchedEffect(open) {

            open?.let {

                nav.navigate(it)

                onOpened()

            }

        }

    }

}

/** To a top-level destination, keeping one copy of each and its state, as the bar's own taps do. */

private fun NavHostController.goTo(top: TopLevel) {

    navigate(top.route) {

        popUpTo(graph.findStartDestination().id) { saveState = true }

        launchSingleTop = true

        restoreState = true

    }

}

/** How long a screen takes to come in (#23). */

private const val NAV_MS = 300