package io.oxygenhub.android.ui.nav

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.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.material3.Badge

import androidx.compose.material3.BadgedBox

import androidx.compose.material3.Icon

import androidx.compose.material3.Text

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.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 io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.auth.Session

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

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.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.proposals.ProposalScreen

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

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

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 InboxRoute

@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 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)

enum class TopLevel(val label: String, val icon: ImageVector, val selectedIcon: ImageVector, val route: Any, val routeClass: KClass<*>) {

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

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

    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()

    val destination = entry?.destination

    NavigationSuiteScaffold(

        navigationSuiteItems = {

            TopLevel.entries.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) {

            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)) },

                )

            }

            composable<RepositoriesRoute> {

                RepositoriesScreen(rememberViewModel { RepositoriesViewModel(api, session.username) }, selectedRepository) { 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) },

                        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,

                    )

                }

            }

            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) },

                    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,

                )

            }

            composable<IssueRoute> { e ->

                val r = e.toRoute<IssueRoute>()

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

            }

            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() } },

                )

            }

            composable<InboxRoute> { InboxScreen(inbox) }

            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

    }

}