package com.soteloje.mindkeep.navigation

import android.util.Log
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Scaffold
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.fragment.app.FragmentManager
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.viewmodel.compose.viewModel
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import com.soteloje.mindkeep.features.activitiesTemplate.viewmodel.TemplateActivitiesViewModel
import com.soteloje.mindkeep.features.auth.model.domain.UserType
import com.soteloje.mindkeep.features.auth.viewModel.AuthViewModel
import com.soteloje.mindkeep.features.auth.ui.AuthenticationScreen
import com.soteloje.mindkeep.features.auth.ui.signup.SignUpScreen
import com.soteloje.mindkeep.features.contactsManagement.viewModel.SendContactRequestViewModel
import com.soteloje.mindkeep.features.contactsManagement.viewModel.ContactRequestsViewModel
import com.soteloje.mindkeep.features.contactsManagement.viewModel.ContactsViewModel
import com.soteloje.mindkeep.features.access.LoadingStartScreen
import com.soteloje.mindkeep.features.auth.viewModel.ProfileViewModel
import com.soteloje.mindkeep.features.userManagement.viewModel.ManagedUsersViewModel
import com.soteloje.mindkeep.navigation.navgraphs.authGraph
import com.soteloje.mindkeep.navigation.navgraphs.mainGraph
import com.soteloje.mindkeep.navigation.navgraphs.activityGraph
import com.soteloje.mindkeep.navigation.navgraphs.taskGraph
import com.soteloje.mindkeep.navigation.navgraphs.arPathNavGraph
import com.soteloje.mindkeep.features.access.BottomBar
import com.soteloje.mindkeep.features.access.CreateItemScreen
import com.soteloje.mindkeep.features.analytics.viewModel.AnalyticsViewModel
import com.soteloje.mindkeep.features.arnavigation.viewmodel.ArViewModel
import com.soteloje.mindkeep.features.userManagement.ui.ManagedUsersScreen

@Composable
fun MindKeepNavHost(supportFragmentManager: FragmentManager, arViewModel: ArViewModel) {
    val navController = rememberNavController()
    val authViewModel: AuthViewModel = viewModel()
    val contactsViewModel: ContactsViewModel = viewModel()
    val profileViewModel: ProfileViewModel = viewModel()
    val analyticsViewModel: AnalyticsViewModel = viewModel()
    val sendContactRequestViewModel: SendContactRequestViewModel = viewModel()
    val viewContactRequestsViewModel: ContactRequestsViewModel = viewModel()
    val templateActivitiesVm : TemplateActivitiesViewModel = hiltViewModel()
    val arCompViewModel: ArViewModel = arViewModel

    val managedUsersViewModel: ManagedUsersViewModel = viewModel()
    // Observe authentication state
    val isAuthenticated by authViewModel.isAuthenticated.collectAsState()
    val userType by authViewModel.userType.collectAsState()


    LaunchedEffect(isAuthenticated) {
        if (!isAuthenticated) {
            navController.navigate(Screens.Authentication.route) {
                popUpTo(0) { inclusive = true }
            }
        } else {
            navController.navigate(Screens.LoadingStartScreen.route)
        }
    }

    Scaffold(
        bottomBar = {
            if (isAuthenticated) {
                userType?.let {
                    BottomBar(
                        navController = navController,
                        userType = userType!!
                    )
                }
            }
        }
    ) { innerPadding ->
        NavHost(
            navController = navController,
            startDestination = when {
                isAuthenticated -> Screens.LoadingStartScreen.route
                else -> Screens.Authentication.route
            },
            modifier = Modifier.padding(innerPadding)
        ) {
            composable(route = Screens.LoadingStartScreen.route) {
                LoadingStartScreen(
                    authViewModel,
                    onNavigateToTemplateStarterScreen = { navController.navigate(Screens.TemplateStartScreen.route) },
                    onNavigateToTaskListWelcome = { navController.navigate(Screens.TaskListWelcome.route) },
                    onNavigateToManagedUsersScreen = { navController.navigate(Screens.ManagedUsers.route) },
                    onNavigateToAuthScreen = {
                        navController.navigate(Screens.Authentication.route) {
                            popUpTo(Screens.Authentication.route) { inclusive = true }
                        }
                    }
                )
            }

            composable(route = Screens.CreateItemScreen.route) {
                CreateItemScreen(
                    onNavigateToActivityTemplateScreen = { navController.navigate(Screens.TemplateStartScreen.route) },
                    onNavigateToAddRoutineScreen = { navController.navigate(Screens.AddRoutine.route) },
                    onNavigateToAddTask = { navController.navigate(Screens.AddTask.createRoute("")) }
                )
            }

            authGraph(
                authViewModel,
                onLoginSuccess =
                {
                    navController.navigate(Screens.LoadingStartScreen.route)
                },
                onSignupSuccess =
                {
                    navController.navigate(Screens.LoadingStartScreen.route)
                },
                onRoleSelection =
                { userType ->
                    Log.d("RoleSelectionScreen", "Navigating to SignUp with UserType: $userType")
                    navController.navigate("signup/${userType}")
                    {
                        popUpTo("authentication") { saveState = true }
                        launchSingleTop = true
                        restoreState = true
                    }
                },
                onNavigateToAuthScreen = { navController.navigate(Screens.Authentication.route) },
                onNavigateBack = { navController.navigate(Screens.Authentication.route) }
            )

            composable(route = "signup/{usertype}") { backStackEntry ->
                val userTypeString = backStackEntry.arguments?.getString("usertype")

                if (!userTypeString.isNullOrEmpty()) {
                    val selectedUserType = UserType.entries.find { it.name == userTypeString }

                    if (selectedUserType != null) {
                        SignUpScreen(
                            viewModel = authViewModel,
                            userType = selectedUserType,
                            onSignupSuccess = {
                                navController.navigate(Screens.Home.route) {
                                    popUpTo(Screens.Authentication.route) { inclusive = true }
                                }
                            },
                            onNavigateBack = {
                                navController.navigate((Screens.RoleSelection.route))
                            }
                        )
                    } else {
                        Log.e("NavHost", "Invalid UserType argument: $userTypeString")
                    }
                } else {
                    Log.e("NavHost", "UserType argument is null or empty")
                }
            }
            composable(route = "addContact") { navController.navigate(Screens.AddContact.route) }


            composable(route = Screens.ManagedUsers.route) {
                ManagedUsersScreen(
                    managedUsersViewModel, authViewModel,
                    onNavigateToGraphs = { userId -> navController.navigate("user_charts/$userId") }
                )
            }

            mainGraph(
                authViewModel,
                contactsViewModel,
                profileViewModel,
                analyticsViewModel,
                sendContactRequestViewModel,
                viewContactRequestsViewModel,
                managedUsersViewModel,
                onNavigateToContacts = { navController.navigate(Screens.Contacts.route) },
                onNavigateToAddContact = { navController.navigate(Screens.AddContact.route) },
                onNavigateToProfile = { navController.navigate(Screens.Profile.route) },
                onSignOut = {
                    authViewModel.signOut()
                    navController.navigate(Screens.Authentication.route) {
                        popUpTo(0) { inclusive = true }
                    }
                },
                onNavigateToContactRequests = { navController.navigate(Screens.ContactRequests.route) },
                onNavigateToCharts = { userId -> navController.navigate("user_charts/$userId") },
                onBackPressed = { navController.popBackStack()},
            )
            composable(route = Screens.Authentication.route) {
                AuthenticationScreen(
                    authViewModel = authViewModel,
                    onLoginSuccess =
                    {
                        navController.navigate(Screens.LoadingStartScreen.route)
                    },
                    onSignupSuccess =
                    {
                        navController.navigate(Screens.LoadingStartScreen.route)
                    },
                    onRoleSelection = { userType -> navController.navigate("signup/${userType}") },
                    onNavigateToAuthScreen = { navController.navigate(Screens.Authentication.route) }
                )
            }

            taskGraph(
                onNavigateToTaskListWelcome = {
                    navController.navigate(Screens.TaskListWelcome.route)
                },
                //onNavigateToAddTask = { navController.navigate(Screens.AddTask.createRoute()) },
                onNavigateToAddTask = { routineId ->  // Pass routineId here
                    val validRoutineId = routineId ?: ""
                    navController.navigate(Screens.AddTask.createRoute(routineId = validRoutineId))
                },
                onNavigateToUpdateTask = { taskId -> navController.navigate("updateTask/$taskId") },
                onNavigateToTaskPriorityList = { navController.navigate(Screens.TaskPriorityList.route) },
                onNavigateToAddTaskToRoutine = {navController.navigate(Screens.TaskAddToRoutine.route)},
                onNavigationRoutineListWelcome = {navController.navigate(Screens.RoutineListWelcome.route)},
                onNavigationAddRoutine = {navController.navigate(Screens.AddRoutine.route)},
                onNavigationUpdateRoutine = { routineId ->
                    //Log.d("Navigation", "Navigating to updateTask with userId: $userId, routineId: $routineId")
                    navController.navigate("updateRoutine/$routineId") },
                authViewModel = authViewModel,
                onNavigationTasksListInRoutine  = { routineId ->
                    navController.navigate("taskListInRoutine/$routineId")
                },
                onNavigationUpdateTaskInRoutine = { routineId, taskId ->
                    Log.d("Navigation", "navigation UpdateTaskRoutine: $routineId, taskId: $taskId")

                    navController.navigate("updateTaskInRoutine/$routineId/$taskId")
                },
                onNavigateToAddPath = { navController.navigate(Screens.ArCreatePathCompScreen.route) },
                onNavigateToFollowPath = { navController.navigate(Screens.ArFollowPathCompScreen.route) },
                arViewModel = arCompViewModel,
                profileViewModel = profileViewModel
            )

            activityGraph(
                tempActivitiesViewModel = templateActivitiesVm,
                authViewModel = authViewModel,
                onNavigateToHomeScreen = {
                    navController.navigate(Screens.TaskListWelcome.route) {
                        popUpTo(Screens.TaskListWelcome.route) { inclusive = true }
                        launchSingleTop = true
                        restoreState = true
                    }
                },
                onNavigateToTemplateStarterScreen = {
                    navController.navigate(Screens.TemplateStartScreen.route)
                },
                onNavigateToActivities = { categoryName ->
                    navController.navigate("activities/$categoryName")
                },
                onNavigateToAddTask = { taskTitle ->
                    navController.navigate(Screens.SelectedActivitiesScreen.route)
                },
                onNavigateToPreviousScreen = {
                    navController.popBackStack()
                },
                onNavigateToSelectedActivitiesScreen = {
                    navController.navigate(Screens.SelectedActivitiesScreen.route)
                }
            )

            arPathNavGraph(
                arCompViewModel,
                supportFragmentManager = supportFragmentManager,
                onBackPress = {
                    navController.popBackStack()
                },
                onNavigateToTaskListView = {
                    navController.navigate(Screens.TaskListWelcome.route ) {
                        popUpTo(Screens.TaskListWelcome.route) { inclusive = true }
                        launchSingleTop = true
                        restoreState = true
                    }
                }
            )

        }
    }
}