package com.rosetta.messenger

import android.Manifest
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.animation.*
import androidx.compose.animation.core.tween
import androidx.compose.foundation.background
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.Surface
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.core.content.ContextCompat
import androidx.fragment.app.FragmentActivity
import androidx.lifecycle.lifecycleScope
import com.google.firebase.FirebaseApp
import com.google.firebase.messaging.FirebaseMessaging
import com.rosetta.messenger.data.AccountManager
import com.rosetta.messenger.data.DecryptedAccount
import com.rosetta.messenger.data.EncryptedAccount
import com.rosetta.messenger.data.PreferencesManager
import com.rosetta.messenger.crypto.CryptoManager
import com.rosetta.messenger.data.RecentSearchesManager
import com.rosetta.messenger.data.resolveAccountDisplayName
import com.rosetta.messenger.database.RosettaDatabase
import com.rosetta.messenger.network.ProtocolManager
import com.rosetta.messenger.network.ProtocolState
import com.rosetta.messenger.network.SearchUser
import com.rosetta.messenger.repository.AvatarRepository
import com.rosetta.messenger.ui.auth.AccountInfo
import com.rosetta.messenger.ui.auth.AuthFlow
import com.rosetta.messenger.ui.auth.DeviceConfirmScreen
import com.rosetta.messenger.ui.chats.ChatDetailScreen
import com.rosetta.messenger.ui.chats.ChatsListScreen
import com.rosetta.messenger.ui.chats.ConnectionLogsScreen
import com.rosetta.messenger.ui.chats.GroupInfoScreen
import com.rosetta.messenger.ui.chats.GroupSetupScreen
import com.rosetta.messenger.ui.chats.RequestsListScreen
import com.rosetta.messenger.ui.chats.SearchScreen
import com.rosetta.messenger.ui.components.OptimizedEmojiCache
import com.rosetta.messenger.ui.components.SwipeBackBackgroundEffect
import com.rosetta.messenger.ui.components.SwipeBackContainer
import com.rosetta.messenger.ui.crashlogs.CrashLogsScreen
import com.rosetta.messenger.ui.onboarding.OnboardingScreen
import com.rosetta.messenger.ui.settings.BackupScreen
import com.rosetta.messenger.ui.settings.BiometricEnableScreen
import com.rosetta.messenger.ui.settings.OtherProfileScreen
import com.rosetta.messenger.ui.settings.ProfileScreen
import com.rosetta.messenger.ui.settings.SafetyScreen
import com.rosetta.messenger.ui.settings.ThemeScreen
import com.rosetta.messenger.ui.settings.UpdatesScreen
import com.rosetta.messenger.ui.splash.SplashScreen
import com.rosetta.messenger.ui.theme.RosettaAndroidTheme
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

class MainActivity : FragmentActivity() {
    private lateinit var preferencesManager: PreferencesManager
    private lateinit var accountManager: AccountManager

    companion object {
        private const val TAG = "MainActivity"

        // 🔔 FCM Логи для отображения в UI
        private val _fcmLogs = mutableStateListOf<String>()
        val fcmLogs: List<String>
            get() = _fcmLogs

        fun addFcmLog(message: String) {
            val timestamp = SimpleDateFormat("HH:mm:ss", Locale.getDefault()).format(Date())
            _fcmLogs.add(0, "[$timestamp] $message") // Добавляем в начало списка
            // Ограничиваем количество логов
            if (_fcmLogs.size > 20) {
                _fcmLogs.removeAt(_fcmLogs.size - 1)
            }
        }

        fun clearFcmLogs() {
            _fcmLogs.clear()
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()

        preferencesManager = PreferencesManager(this)
        accountManager = AccountManager(this)
        RecentSearchesManager.init(this)

        // 🔥 Инициализируем ProtocolManager для обработки онлайн статусов
        ProtocolManager.initialize(this)

        // 🔔 Инициализируем Firebase для push-уведомлений
        initializeFirebase()

        // 🔥 Помечаем что приложение в foreground
        com.rosetta.messenger.push.RosettaFirebaseMessagingService.isAppInForeground = true

        // 📱 Предзагружаем эмодзи в фоне для мгновенного открытия пикера
        // Используем новый оптимизированный кэш
        OptimizedEmojiCache.preload(this)

        setContent { // 🔔 Запрос разрешения на уведомления для Android 13+
            val notificationPermissionLauncher =
                    rememberLauncherForActivityResult(
                            contract = ActivityResultContracts.RequestPermission(),
                            onResult = { isGranted -> }
                    )

            // Запрашиваем разрешение при первом запуске (Android 13+)
            LaunchedEffect(Unit) {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                    val hasPermission =
                            ContextCompat.checkSelfPermission(
                                    this@MainActivity,
                                    Manifest.permission.POST_NOTIFICATIONS
                            ) == PackageManager.PERMISSION_GRANTED

                    if (!hasPermission) {
                        notificationPermissionLauncher.launch(
                                Manifest.permission.POST_NOTIFICATIONS
                        )
                    }
                }
            }

            val scope = rememberCoroutineScope()
            val themeMode by preferencesManager.themeMode.collectAsState(initial = "dark")
            val systemInDarkTheme = isSystemInDarkTheme()
            val isDarkTheme =
                    when (themeMode) {
                        "light" -> false
                        "dark" -> true
                        "auto" -> systemInDarkTheme
                        else -> true
                    }
            val isLoggedIn by accountManager.isLoggedIn.collectAsState(initial = null)
            val protocolState by ProtocolManager.state.collectAsState()
            var showSplash by remember { mutableStateOf(true) }
            var showOnboarding by remember { mutableStateOf(true) }
            var hasExistingAccount by remember { mutableStateOf<Boolean?>(null) }
            var currentAccount by remember { mutableStateOf<DecryptedAccount?>(null) }
            var accountInfoList by remember { mutableStateOf<List<AccountInfo>>(emptyList()) }
            var startCreateAccountFlow by remember { mutableStateOf(false) }

            // Check for existing accounts and build AccountInfo list
            // Also force logout so user always sees unlock screen on app restart
            LaunchedEffect(Unit) {
                accountManager.logout() // Always start logged out
                val accounts = accountManager.getAllAccounts()
                hasExistingAccount = accounts.isNotEmpty()
                accountInfoList = accounts.map { it.toAccountInfo() }
            }

            // Wait for initial load
            if (hasExistingAccount == null) {
                Box(
                        modifier =
                                Modifier.fillMaxSize()
                                        .background(
                                                if (isDarkTheme) Color(0xFF1B1B1B) else Color.White
                                        )
                )
                return@setContent
            }

            RosettaAndroidTheme(darkTheme = isDarkTheme, animated = true) {
                Surface(
                        modifier = Modifier.fillMaxSize(),
                        color = if (isDarkTheme) Color(0xFF1B1B1B) else Color.White
                ) {
                    AnimatedContent(
                            targetState =
                                    when {
                                        showSplash -> "splash"
                                        showOnboarding && hasExistingAccount == false ->
                                                "onboarding"
                                        isLoggedIn != true && hasExistingAccount == false ->
                                                "auth_new"
                                        isLoggedIn != true && hasExistingAccount == true ->
                                                "auth_unlock"
                                        isLoggedIn == true &&
                                                currentAccount == null &&
                                                hasExistingAccount == true ->
                                                "auth_unlock"
                                        protocolState ==
                                                ProtocolState.DEVICE_VERIFICATION_REQUIRED ->
                                                "device_confirm"
                                        else -> "main"
                                    },
                            transitionSpec = {
                                // Новый экран плавно появляется ПОВЕРХ старого.
                                // Старый остаётся видимым (alpha=1) пока новый не готов →
                                // нет белой вспышки от Surface.
                                fadeIn(animationSpec = tween(350)) togetherWith
                                        fadeOut(animationSpec = tween(1, delayMillis = 350))
                            },
                            label = "screenTransition"
                    ) { screen ->
                        when (screen) {
                            "splash" -> {
                                SplashScreen(
                                        isDarkTheme = isDarkTheme,
                                        onSplashComplete = { showSplash = false }
                                )
                            }
                            "onboarding" -> {
                                OnboardingScreen(
                                        isDarkTheme = isDarkTheme,
                                        onThemeToggle = {
                                            scope.launch {
                                                val newMode = if (isDarkTheme) "light" else "dark"
                                                preferencesManager.setThemeMode(newMode)
                                            }
                                        },
                                        onStartMessaging = { showOnboarding = false }
                                )
                            }
                            "auth_new", "auth_unlock" -> {
                                AuthFlow(
                                        isDarkTheme = isDarkTheme,
                                        hasExistingAccount = screen == "auth_unlock",
                                        accounts = accountInfoList,
                                        accountManager = accountManager,
                                        startInCreateMode = startCreateAccountFlow,
                                        onAuthComplete = { account ->
                                            startCreateAccountFlow = false
                                            currentAccount = account
                                            hasExistingAccount = true
                                            // Save as last logged account
                                            account?.let {
                                                accountManager.setLastLoggedPublicKey(it.publicKey)
                                            }

                                            // Reload accounts list
                                            scope.launch {
                                                val accounts = accountManager.getAllAccounts()
                                                accountInfoList = accounts.map { it.toAccountInfo() }
                                            }
                                        },
                                        onLogout = {
                                            startCreateAccountFlow = false
                                            // Set currentAccount to null immediately to prevent UI
                                            // lag
                                            currentAccount = null
                                            scope.launch {
                                                com.rosetta.messenger.network.ProtocolManager
                                                        .disconnect()
                                                accountManager.logout()
                                            }
                                        }
                                )
                            }
                            "main" -> {
                                MainScreen(
                                        account = currentAccount,
                                        isDarkTheme = isDarkTheme,
                                        themeMode = themeMode,
                                        onToggleTheme = {
                                            scope.launch {
                                                val newMode = if (isDarkTheme) "light" else "dark"
                                                preferencesManager.setThemeMode(newMode)
                                            }
                                        },
                                        onThemeModeChange = { mode ->
                                            scope.launch { preferencesManager.setThemeMode(mode) }
                                        },
                                        onLogout = {
                                            startCreateAccountFlow = false
                                            // Set currentAccount to null immediately to prevent UI
                                            // lag
                                            currentAccount = null
                                            scope.launch {
                                                com.rosetta.messenger.network.ProtocolManager
                                                        .disconnect()
                                                accountManager.logout()
                                            }
                                        },
                                        onDeleteAccount = {
                                            startCreateAccountFlow = false
                                            val publicKey = currentAccount?.publicKey ?: return@MainScreen
                                            scope.launch {
                                                try {
                                                    val database = RosettaDatabase.getDatabase(this@MainActivity)
                                                    // 1. Delete all messages
                                                    database.messageDao().deleteAllByAccount(publicKey)
                                                    // 2. Delete all dialogs
                                                    database.dialogDao().deleteAllByAccount(publicKey)
                                                    // 3. Delete blacklist
                                                    database.blacklistDao().deleteAllByAccount(publicKey)
                                                    // 4. Delete avatars from DB
                                                    database.avatarDao().deleteAvatars(publicKey)
                                                    // 5. Delete account from Room DB
                                                    database.accountDao().deleteAccount(publicKey)
                                                    // 6. Disconnect protocol
                                                    com.rosetta.messenger.network.ProtocolManager.disconnect()
                                                    // 7. Delete account from AccountManager DataStore (removes from accounts list + clears login)
                                                    accountManager.deleteAccount(publicKey)
                                                    // 8. Refresh accounts list
                                                    val accounts = accountManager.getAllAccounts()
                                                    accountInfoList = accounts.map { it.toAccountInfo() }
                                                    hasExistingAccount = accounts.isNotEmpty()
                                                    // 8. Navigate away last
                                                    currentAccount = null
                                                } catch (e: Exception) {
                                                    android.util.Log.e("DeleteAccount", "Failed to delete account", e)
                                                }
                                            }
                                        },
                                        onAccountInfoUpdated = {
                                            // Reload account list when profile is updated
                                            val accounts = accountManager.getAllAccounts()
                                            accountInfoList = accounts.map { it.toAccountInfo() }
                                        },
                                        onDeleteAccountFromSidebar = { targetPublicKey ->
                                            startCreateAccountFlow = false
                                            scope.launch {
                                                try {
                                                    val database = RosettaDatabase.getDatabase(this@MainActivity)
                                                    // 1. Delete all messages
                                                    database.messageDao().deleteAllByAccount(targetPublicKey)
                                                    // 2. Delete all dialogs
                                                    database.dialogDao().deleteAllByAccount(targetPublicKey)
                                                    // 3. Delete blacklist
                                                    database.blacklistDao().deleteAllByAccount(targetPublicKey)
                                                    // 4. Delete avatars from DB
                                                    database.avatarDao().deleteAvatars(targetPublicKey)
                                                    // 5. Delete account from Room DB
                                                    database.accountDao().deleteAccount(targetPublicKey)
                                                    // 6. Disconnect protocol only if deleting currently open account
                                                    if (currentAccount?.publicKey == targetPublicKey) {
                                                        com.rosetta.messenger.network.ProtocolManager.disconnect()
                                                    }
                                                    // 7. Delete account from AccountManager DataStore
                                                    accountManager.deleteAccount(targetPublicKey)
                                                    // 8. Refresh accounts list
                                                    val accounts = accountManager.getAllAccounts()
                                                    accountInfoList = accounts.map { it.toAccountInfo() }
                                                    hasExistingAccount = accounts.isNotEmpty()
                                                    // 9. If current account is deleted, return to main login screen
                                                    if (currentAccount?.publicKey == targetPublicKey) {
                                                        currentAccount = null
                                                    }
                                                } catch (e: Exception) {
                                                    android.util.Log.e("DeleteAccount", "Failed to delete account from sidebar", e)
                                                }
                                            }
                                        },
                                        onSwitchAccount = { targetPublicKey ->
                                            startCreateAccountFlow = false
                                            // Save target account before leaving main screen so Unlock
                                            // screen preselects the account the user tapped.
                                            accountManager.setLastLoggedPublicKey(targetPublicKey)

                                            // Switch to another account: logout current, then show unlock.
                                            currentAccount = null
                                            scope.launch {
                                                com.rosetta.messenger.network.ProtocolManager.disconnect()
                                                accountManager.logout()
                                            }
                                        },
                                        onAddAccount = {
                                            startCreateAccountFlow = true
                                            currentAccount = null
                                            scope.launch {
                                                com.rosetta.messenger.network.ProtocolManager.disconnect()
                                                accountManager.logout()
                                            }
                                        }
                                )
                            }
                            "device_confirm" -> {
                                DeviceConfirmScreen(
                                        isDarkTheme = isDarkTheme,
                                        onExit = {
                                            currentAccount = null
                                            scope.launch {
                                                ProtocolManager.disconnect()
                                                accountManager.logout()
                                            }
                                        }
                                )
                            }
                        }
                    }
                }
            }
        }
    }

    override fun onResume() {
        super.onResume()
        // 🔥 Приложение стало видимым - отключаем уведомления
        com.rosetta.messenger.push.RosettaFirebaseMessagingService.isAppInForeground = true
        // ⚡ На возврате в приложение пробуем мгновенный reconnect без ожидания backoff.
        ProtocolManager.reconnectNowIfNeeded("activity_onResume")
    }

    override fun onPause() {
        super.onPause()
        // 🔥 Приложение ушло в background - включаем уведомления
        com.rosetta.messenger.push.RosettaFirebaseMessagingService.isAppInForeground = false
    }

    /** 🔔 Инициализация Firebase Cloud Messaging */
    private fun initializeFirebase() {
        lifecycleScope.launch(Dispatchers.Default) {
            try {
                addFcmLog("🔔 Инициализация Firebase...")
                // Инициализируем Firebase (тяжёлая операция — не на Main)
                FirebaseApp.initializeApp(this@MainActivity)
                addFcmLog("✅ Firebase инициализирован")

                // Получаем FCM токен
                addFcmLog("📲 Запрос FCM токена...")
                FirebaseMessaging.getInstance().token.addOnCompleteListener { task ->
                    if (!task.isSuccessful) {
                        addFcmLog("❌ Ошибка получения токена: ${task.exception?.message}")
                        return@addOnCompleteListener
                    }

                    val token = task.result

                    if (token != null) {
                        val shortToken = "${token.take(12)}...${token.takeLast(8)}"
                        addFcmLog("✅ FCM токен получен: $shortToken")
                        // Сохраняем токен локально
                        saveFcmToken(token)
                        addFcmLog("💾 Токен сохранен локально")

                        // Token will be sent by ProtocolManager.onAuthenticated()
                        // when protocol reaches AUTHENTICATED state
                    } else {
                        addFcmLog("⚠️ Токен пустой")
                    }

                    // Токен будет отправлен через ProtocolManager.subscribePushTokenIfAvailable()
                    // при достижении состояния AUTHENTICATED
                }
            } catch (e: Exception) {
                addFcmLog("❌ Ошибка Firebase: ${e.message}")
            }
        }
    }

    /** Сохранить FCM токен в SharedPreferences */
    private fun saveFcmToken(token: String) {
        val prefs = getSharedPreferences("rosetta_prefs", MODE_PRIVATE)
        prefs.edit().putString("fcm_token", token).apply()
    }

}

private fun buildInitials(displayName: String): String =
        displayName
                .trim()
                .split(Regex("\\s+"))
                .filter { it.isNotEmpty() }
                .let { words ->
                    when {
                        words.isEmpty() -> "??"
                        words.size == 1 -> words[0].take(2).uppercase()
                        else -> "${words[0].first()}${words[1].first()}".uppercase()
                    }
                }

private fun EncryptedAccount.toAccountInfo(): AccountInfo {
    val displayName = resolveAccountDisplayName(publicKey, name, username)
    return AccountInfo(
            id = publicKey,
            name = displayName,
            username = username ?: "",
            initials = buildInitials(displayName),
            publicKey = publicKey
    )
}

/**
 * Navigation sealed class — replaces ~15 boolean flags with a type-safe navigation stack. ChatsList
 * is always the base layer and is not part of the stack. Each SwipeBackContainer reads a
 * derivedStateOf, so pushing/popping an unrelated screen won't trigger recomposition of other
 * screens.
 */
sealed class Screen {
    data object Profile : Screen()
    data object Requests : Screen()
    data object Search : Screen()
    data object GroupSetup : Screen()
    data class GroupInfo(val group: SearchUser) : Screen()
    data class ChatDetail(val user: SearchUser) : Screen()
    data class OtherProfile(val user: SearchUser) : Screen()
    data object Updates : Screen()
    data object Theme : Screen()
    data object Safety : Screen()
    data object Backup : Screen()
    data object Logs : Screen()
    data object ConnectionLogs : Screen()
    data object CrashLogs : Screen()
    data object Biometric : Screen()
    data object Appearance : Screen()
}

@Composable
fun MainScreen(
        account: DecryptedAccount? = null,
        isDarkTheme: Boolean = true,
        themeMode: String = "dark",
        onToggleTheme: () -> Unit = {},
        onThemeModeChange: (String) -> Unit = {},
        onLogout: () -> Unit = {},
        onDeleteAccount: () -> Unit = {},
        onAccountInfoUpdated: suspend () -> Unit = {},
        onSwitchAccount: (String) -> Unit = {},
        onDeleteAccountFromSidebar: (String) -> Unit = {},
        onAddAccount: () -> Unit = {}
) {
    val accountPublicKey = account?.publicKey.orEmpty()

    // Reactive state for account name and username
    var accountName by remember(accountPublicKey) {
        mutableStateOf(resolveAccountDisplayName(accountPublicKey, account?.name, null))
    }
    val accountPhone =
            account?.publicKey?.take(16)?.let {
                "+${it.take(1)} ${it.substring(1, 4)} ${it.substring(4, 7)}${it.substring(7)}"
            }
                    .orEmpty()
    val accountPrivateKey = account?.privateKey ?: ""
    val privateKeyHash = account?.privateKeyHash ?: ""

    // Username state - загружается из EncryptedAccount
    // Following desktop version pattern: username is stored locally and loaded on app start
    var accountUsername by remember { mutableStateOf("") }
    var accountVerified by remember(accountPublicKey) { mutableIntStateOf(0) }
    var reloadTrigger by remember { mutableIntStateOf(0) }

    // Load username AND name from AccountManager (persisted in DataStore)
    val context = LocalContext.current
    LaunchedEffect(accountPublicKey, reloadTrigger) {
        if (accountPublicKey.isNotBlank()) {
            val accountManager = AccountManager(context)
            val encryptedAccount = accountManager.getAccount(accountPublicKey)
            val username = encryptedAccount?.username
            accountUsername = username.orEmpty()
            accountVerified = ProtocolManager.getCachedUserInfo(accountPublicKey)?.verified ?: 0
            accountName =
                    resolveAccountDisplayName(
                            accountPublicKey,
                            encryptedAccount?.name ?: accountName,
                            username
                    )
        } else {
            accountVerified = 0
        }
    }

    // Состояние протокола для передачи в SearchScreen
    val protocolState by ProtocolManager.state.collectAsState()

    // Реактивно обновляем username/name когда сервер отвечает на fetchOwnProfile()
    val ownProfileUpdated by ProtocolManager.ownProfileUpdated.collectAsState()
    LaunchedEffect(ownProfileUpdated) {
        if (ownProfileUpdated > 0L && accountPublicKey.isNotBlank()) {
            val accountManager = AccountManager(context)
            val encryptedAccount = accountManager.getAccount(accountPublicKey)
            val username = encryptedAccount?.username
            accountUsername = username.orEmpty()
            accountVerified = ProtocolManager.getCachedUserInfo(accountPublicKey)?.verified ?: 0
            accountName =
                    resolveAccountDisplayName(
                            accountPublicKey,
                            encryptedAccount?.name ?: accountName,
                            username
                    )
        }
    }

    // ═══════════════════════════════════════════════════════════
    // Navigation stack — sealed class instead of ~15 boolean flags.
    // ChatsList is always the base layer (not in stack).
    // Each derivedStateOf only recomposes its SwipeBackContainer
    // when that specific screen appears/disappears — not on every
    // navigation change. This eliminates the massive recomposition
    // that happened when ANY boolean flag changed.
    // ═══════════════════════════════════════════════════════════
    var navStack by remember { mutableStateOf<List<Screen>>(emptyList()) }

    // Derived visibility — only triggers recomposition when THIS screen changes
    val isProfileVisible by remember { derivedStateOf { navStack.any { it is Screen.Profile } } }
    val isRequestsVisible by remember { derivedStateOf { navStack.any { it is Screen.Requests } } }
    val isSearchVisible by remember { derivedStateOf { navStack.any { it is Screen.Search } } }
    val isGroupSetupVisible by remember { derivedStateOf { navStack.any { it is Screen.GroupSetup } } }
    val chatDetailScreen by remember {
        derivedStateOf { navStack.filterIsInstance<Screen.ChatDetail>().lastOrNull() }
    }
    val selectedUser = chatDetailScreen?.user
    val groupInfoScreen by remember {
        derivedStateOf { navStack.filterIsInstance<Screen.GroupInfo>().lastOrNull() }
    }
    val selectedGroup = groupInfoScreen?.group
    val otherProfileScreen by remember {
        derivedStateOf { navStack.filterIsInstance<Screen.OtherProfile>().lastOrNull() }
    }
    val selectedOtherUser = otherProfileScreen?.user
    val isUpdatesVisible by remember { derivedStateOf { navStack.any { it is Screen.Updates } } }
    val isThemeVisible by remember { derivedStateOf { navStack.any { it is Screen.Theme } } }
    val isSafetyVisible by remember { derivedStateOf { navStack.any { it is Screen.Safety } } }
    val isBackupVisible by remember { derivedStateOf { navStack.any { it is Screen.Backup } } }
    val isLogsVisible by remember { derivedStateOf { navStack.any { it is Screen.Logs } } }
    val isConnectionLogsVisible by remember {
        derivedStateOf { navStack.any { it is Screen.ConnectionLogs } }
    }
    val isCrashLogsVisible by remember {
        derivedStateOf { navStack.any { it is Screen.CrashLogs } }
    }
    val isBiometricVisible by remember {
        derivedStateOf { navStack.any { it is Screen.Biometric } }
    }
    val isAppearanceVisible by remember {
        derivedStateOf { navStack.any { it is Screen.Appearance } }
    }

    // Navigation helpers
    fun pushScreen(screen: Screen) {
        // Anti-spam: do not stack duplicate screens from rapid taps.
        if (navStack.lastOrNull() == screen) return
        if (screen is Screen.Requests && navStack.any { it is Screen.Requests }) return
        navStack = navStack + screen
    }
    fun isCurrentAccountUser(user: SearchUser): Boolean {
        val candidatePublicKey = user.publicKey.trim()
        val normalizedAccountPublicKey = accountPublicKey.trim()
        if (
                candidatePublicKey.isNotBlank() &&
                        normalizedAccountPublicKey.isNotBlank() &&
                        candidatePublicKey.equals(normalizedAccountPublicKey, ignoreCase = true)
        ) {
            return true
        }

        val candidateUsername = user.username.trim().trimStart('@')
        val normalizedAccountUsername = accountUsername.trim().trimStart('@')
        return candidatePublicKey.isBlank() &&
                candidateUsername.isNotBlank() &&
                normalizedAccountUsername.isNotBlank() &&
                candidateUsername.equals(normalizedAccountUsername, ignoreCase = true)
    }
    fun popScreen() {
        navStack = navStack.dropLast(1)
    }
    fun openOwnProfile() {
        navStack =
                navStack.filterNot {
                    it is Screen.ChatDetail || it is Screen.OtherProfile || it is Screen.GroupInfo
                }
        pushScreen(Screen.Profile)
    }
    fun popProfileAndChildren() {
        navStack =
                navStack.filterNot {
                    it is Screen.Profile ||
                            it is Screen.Theme ||
                            it is Screen.Safety ||
                            it is Screen.Backup ||
                            it is Screen.Logs ||
                            it is Screen.CrashLogs ||
                            it is Screen.Biometric ||
                            it is Screen.Appearance
                }
    }
    fun popChatAndChildren() {
        navStack =
                navStack.filterNot {
                    it is Screen.ChatDetail || it is Screen.OtherProfile || it is Screen.GroupInfo
                }
    }

    // ProfileViewModel для логов
    val profileViewModel: com.rosetta.messenger.ui.settings.ProfileViewModel =
            androidx.lifecycle.viewmodel.compose.viewModel()
    val profileState by profileViewModel.state.collectAsState()
    val chatsListViewModel: com.rosetta.messenger.ui.chats.ChatsListViewModel =
            androidx.lifecycle.viewmodel.compose.viewModel()

    // Appearance: background blur color preference
    val prefsManager = remember { com.rosetta.messenger.data.PreferencesManager(context) }
    val backgroundBlurColorId by
            prefsManager
                    .backgroundBlurColorIdForAccount(accountPublicKey)
                    .collectAsState(initial = "avatar")
    val chatWallpaperId by prefsManager.chatWallpaperId.collectAsState(initial = "")
    val pinnedChats by prefsManager.pinnedChats.collectAsState(initial = emptySet())

    // AvatarRepository для работы с аватарами
    val avatarRepository =
            remember(accountPublicKey) {
                if (accountPublicKey.isNotBlank()) {
                    val database = RosettaDatabase.getDatabase(context)
                    AvatarRepository(
                            context = context,
                            avatarDao = database.avatarDao(),
                            currentPublicKey = accountPublicKey
                    )
                } else {
                    null
                }
            }

    // Coroutine scope for profile updates
    val mainScreenScope = rememberCoroutineScope()

    // 🔥 Простая навигация с swipe back
    Box(modifier = Modifier.fillMaxSize()) {
        // Base layer - chats list (всегда видимый, чтобы его было видно при свайпе)
        SwipeBackBackgroundEffect(modifier = Modifier.fillMaxSize(), layer = 0) {
            ChatsListScreen(
                    isDarkTheme = isDarkTheme,
                    accountName = accountName,
                    accountUsername = accountUsername,
                    accountVerified = accountVerified,
                    accountPhone = accountPhone,
                    accountPublicKey = accountPublicKey,
                    accountPrivateKey = accountPrivateKey,
                    privateKeyHash = privateKeyHash,
                    onToggleTheme = onToggleTheme,
                    onProfileClick = { pushScreen(Screen.Profile) },
                    onNewGroupClick = {
                        pushScreen(Screen.GroupSetup)
                    },
                    onContactsClick = {
                        // TODO: Navigate to contacts
                    },
                    onCallsClick = {
                        // TODO: Navigate to calls
                    },
                    onSavedMessagesClick = {
                        // Открываем чат с самим собой (Saved Messages)
                        pushScreen(
                                Screen.ChatDetail(
                                        SearchUser(
                                                title = "Saved Messages",
                                                username = "",
                                                publicKey = accountPublicKey,
                                                verified = 0,
                                                online = 1
                                        )
                                )
                        )
                    },
                    onSettingsClick = { pushScreen(Screen.Profile) },
                    onInviteFriendsClick = {
                        // TODO: Share invite link
                    },
                    onSearchClick = { pushScreen(Screen.Search) },
                    onRequestsClick = { pushScreen(Screen.Requests) },
                    onNewChat = {
                        // TODO: Show new chat screen
                    },
                    onUserSelect = { selectedChatUser ->
                        pushScreen(Screen.ChatDetail(selectedChatUser))
                    },
                    backgroundBlurColorId = backgroundBlurColorId,
                    pinnedChats = pinnedChats,
                    onTogglePin = { opponentKey ->
                        mainScreenScope.launch { prefsManager.togglePinChat(opponentKey) }
                    },
                    chatsViewModel = chatsListViewModel,
                    avatarRepository = avatarRepository,
                    onAddAccount = {
                        onAddAccount()
                    },
                    onSwitchAccount = onSwitchAccount,
                    onDeleteAccountFromSidebar = onDeleteAccountFromSidebar
            )
        }

        SwipeBackContainer(
                isVisible = isRequestsVisible,
                onBack = { navStack = navStack.filterNot { it is Screen.Requests } },
                isDarkTheme = isDarkTheme,
                layer = 1
        ) {
                RequestsListScreen(
                    isDarkTheme = isDarkTheme,
                    chatsViewModel = chatsListViewModel,
                    pinnedChats = pinnedChats,
                    onTogglePin = { opponentKey ->
                        mainScreenScope.launch {
                            prefsManager.togglePinChat(opponentKey)
                        }
                    },
                    onBack = { navStack = navStack.filterNot { it is Screen.Requests } },
                    onUserSelect = { selectedRequestUser ->
                        navStack =
                            navStack.filterNot {
                                it is Screen.ChatDetail || it is Screen.OtherProfile
                            } + Screen.ChatDetail(selectedRequestUser)
                    },
                    avatarRepository = avatarRepository
                )
        }

        // ═══════════════════════════════════════════════════════════
        // Profile Screen — MUST be before sub-screens so it stays
        // visible beneath them during swipe-back animation
        // ═══════════════════════════════════════════════════════════
        SwipeBackContainer(
                isVisible = isProfileVisible,
                onBack = { popProfileAndChildren() },
                isDarkTheme = isDarkTheme,
                layer = 1,
                propagateBackgroundProgress = false
        ) {
            // Экран профиля
            ProfileScreen(
                    isDarkTheme = isDarkTheme,
                    accountName = accountName,
                    accountUsername = accountUsername,
                    accountVerified = accountVerified,
                    accountPublicKey = accountPublicKey,
                    accountPrivateKeyHash = privateKeyHash,
                    onBack = { popProfileAndChildren() },
                    onSaveProfile = { name, username ->
                        accountName = name
                        accountUsername = username
                        mainScreenScope.launch { onAccountInfoUpdated() }
                    },
                    onLogout = onLogout,
                    onNavigateToTheme = { pushScreen(Screen.Theme) },
                    onNavigateToAppearance = { pushScreen(Screen.Appearance) },
                    onNavigateToSafety = { pushScreen(Screen.Safety) },
                    onNavigateToLogs = { pushScreen(Screen.Logs) },
                    onNavigateToBiometric = { pushScreen(Screen.Biometric) },
                    viewModel = profileViewModel,
                    avatarRepository = avatarRepository,
                    dialogDao = RosettaDatabase.getDatabase(context).dialogDao(),
                    backgroundBlurColorId = backgroundBlurColorId
            )
        }

        // Other screens with swipe back
        SwipeBackContainer(
                isVisible = isSafetyVisible,
                onBack = { navStack = navStack.filterNot { it is Screen.Safety } },
                isDarkTheme = isDarkTheme,
                layer = 2
        ) {
            SafetyScreen(
                    isDarkTheme = isDarkTheme,
                    accountPublicKey = accountPublicKey,
                    accountPrivateKey = accountPrivateKey,
                    onBack = { navStack = navStack.filterNot { it is Screen.Safety } },
                    onBackupClick = {
                        navStack = navStack + Screen.Backup
                    },
                    onDeleteAccount = onDeleteAccount
            )
        }

        SwipeBackContainer(
                isVisible = isBackupVisible,
                onBack = { navStack = navStack.filterNot { it is Screen.Backup } },
                isDarkTheme = isDarkTheme,
                layer = 3
        ) {
            BackupScreen(
                    isDarkTheme = isDarkTheme,
                    onBack = {
                        navStack = navStack.filterNot { it is Screen.Backup }
                    },
                    onVerifyPassword = { password ->
                        // Verify password by trying to decrypt the private key
                        try {
                            val publicKey = account?.publicKey ?: return@BackupScreen null
                            val accountManager = AccountManager(context)
                            val encryptedAccount = accountManager.getAccount(publicKey)

                            if (encryptedAccount != null) {
                                // Try to decrypt private key with password
                                val decryptedPrivateKey =
                                        com.rosetta.messenger.crypto.CryptoManager
                                                .decryptWithPassword(
                                                        encryptedAccount.encryptedPrivateKey,
                                                        password
                                                )

                                if (decryptedPrivateKey != null) {
                                    // Password is correct, decrypt seed phrase
                                    com.rosetta.messenger.crypto.CryptoManager.decryptWithPassword(
                                            encryptedAccount.encryptedSeedPhrase,
                                            password
                                    )
                                } else {
                                    null
                                }
                            } else {
                                null
                            }
                        } catch (e: Exception) {
                            null
                        }
                    }
            )
        }

        SwipeBackContainer(
                isVisible = isThemeVisible,
                onBack = { navStack = navStack.filterNot { it is Screen.Theme } },
                isDarkTheme = isDarkTheme,
                layer = 2,
                deferToChildren = true
        ) {
            ThemeScreen(
                    isDarkTheme = isDarkTheme,
                    currentThemeMode = themeMode,
                    currentWallpaperId = chatWallpaperId,
                    onBack = { navStack = navStack.filterNot { it is Screen.Theme } },
                    onThemeModeChange = onThemeModeChange,
                    onWallpaperChange = { wallpaperId ->
                        mainScreenScope.launch { prefsManager.setChatWallpaperId(wallpaperId) }
                    }
            )
        }

        SwipeBackContainer(
                isVisible = isAppearanceVisible,
                onBack = { navStack = navStack.filterNot { it is Screen.Appearance } },
                isDarkTheme = isDarkTheme,
                layer = 2
        ) {
            com.rosetta.messenger.ui.settings.AppearanceScreen(
                    isDarkTheme = isDarkTheme,
                    currentBlurColorId = backgroundBlurColorId,
                    onBack = { navStack = navStack.filterNot { it is Screen.Appearance } },
                    onBlurColorChange = { newId ->
                        mainScreenScope.launch {
                            prefsManager.setBackgroundBlurColorId(accountPublicKey, newId)
                        }
                    },
                    onToggleTheme = onToggleTheme,
                    accountPublicKey = accountPublicKey,
                    accountName = accountName,
                    avatarRepository = avatarRepository
            )
        }

        SwipeBackContainer(
                isVisible = isUpdatesVisible,
                onBack = { navStack = navStack.filterNot { it is Screen.Updates } },
                isDarkTheme = isDarkTheme,
                layer = 2
        ) {
            UpdatesScreen(
                    isDarkTheme = isDarkTheme,
                    onBack = { navStack = navStack.filterNot { it is Screen.Updates } }
            )
        }

        // 🔒 Lock swipe-back while chat overlays are open (image viewer/editor/media picker/camera).
        var isChatSwipeLocked by remember { mutableStateOf(false) }

        // 🔴 Badge: total unread from OTHER chats (excluding current) for back-chevron badge
        val totalUnreadFromOthers by remember(accountPublicKey, selectedUser?.publicKey) {
            val db = RosettaDatabase.getDatabase(context)
            val opponentKey = selectedUser?.publicKey ?: ""
            if (accountPublicKey.isNotBlank() && opponentKey.isNotBlank()) {
                db.dialogDao().getTotalUnreadCountExcludingFlow(accountPublicKey, opponentKey)
            } else {
                kotlinx.coroutines.flow.flowOf(0)
            }
        }.collectAsState(initial = 0)

        SwipeBackContainer(
                isVisible = selectedUser != null,
                onBack = { popChatAndChildren() },
                isDarkTheme = isDarkTheme,
                layer = 1,
                swipeEnabled = !isChatSwipeLocked,
                propagateBackgroundProgress = false
        ) {
            selectedUser?.let { currentChatUser ->
                // Экран чата
                ChatDetailScreen(
                        user = currentChatUser,
                        currentUserPublicKey = accountPublicKey,
                        currentUserPrivateKey = accountPrivateKey,
                        currentUserName = accountName,
                        currentUserUsername = accountUsername,
                        totalUnreadFromOthers = totalUnreadFromOthers,
                        onBack = { popChatAndChildren() },
                        onUserProfileClick = { user ->
                            if (isCurrentAccountUser(user)) {
                                // Свой профиль — открываем My Profile
                                openOwnProfile()
                            } else {
                                // Открываем профиль другого пользователя
                                pushScreen(Screen.OtherProfile(user))
                            }
                        },
                        onGroupInfoClick = { groupUser ->
                            pushScreen(Screen.GroupInfo(groupUser))
                        },
                        onNavigateToChat = { forwardUser ->
                            // 📨 Forward: переход в выбранный чат с полными данными
                            navStack =
                                    navStack.filterNot {
                                        it is Screen.ChatDetail || it is Screen.OtherProfile
                                    } + Screen.ChatDetail(forwardUser)
                        },
                        isDarkTheme = isDarkTheme,
                        chatWallpaperId = chatWallpaperId,
                        avatarRepository = avatarRepository,
                        onImageViewerChanged = { isLocked -> isChatSwipeLocked = isLocked }
                )
            }
        }

        var isGroupInfoSwipeEnabled by remember { mutableStateOf(true) }
        LaunchedEffect(selectedGroup?.publicKey) {
            isGroupInfoSwipeEnabled = true
        }

        SwipeBackContainer(
                isVisible = selectedGroup != null,
                onBack = { navStack = navStack.filterNot { it is Screen.GroupInfo } },
                isDarkTheme = isDarkTheme,
                layer = 2,
                swipeEnabled = isGroupInfoSwipeEnabled,
                propagateBackgroundProgress = false
        ) {
            selectedGroup?.let { groupUser ->
                GroupInfoScreen(
                        groupUser = groupUser,
                        currentUserPublicKey = accountPublicKey,
                        currentUserPrivateKey = accountPrivateKey,
                        isDarkTheme = isDarkTheme,
                        avatarRepository = avatarRepository,
                        onBack = { navStack = navStack.filterNot { it is Screen.GroupInfo } },
                        onMemberClick = { member ->
                            if (isCurrentAccountUser(member)) {
                                openOwnProfile()
                            } else {
                                pushScreen(Screen.OtherProfile(member))
                            }
                        },
                        onSwipeBackEnabledChanged = { enabled ->
                            isGroupInfoSwipeEnabled = enabled
                        },
                        onGroupLeft = {
                            navStack =
                                    navStack.filterNot {
                                        it is Screen.GroupInfo ||
                                                (it is Screen.ChatDetail &&
                                                        it.user.publicKey == groupUser.publicKey)
                                    }
                        }
                )
            }
        }

        SwipeBackContainer(
                isVisible = isSearchVisible,
                onBack = { navStack = navStack.filterNot { it is Screen.Search } },
                isDarkTheme = isDarkTheme,
                layer = 1,
                deferToChildren = true
        ) {
            // Экран поиска
            SearchScreen(
                    privateKeyHash = privateKeyHash,
                    currentUserPublicKey = accountPublicKey,
                    isDarkTheme = isDarkTheme,
                    protocolState = protocolState,
                    onBackClick = { navStack = navStack.filterNot { it is Screen.Search } },
                    onUserSelect = { selectedSearchUser ->
                        navStack =
                                navStack.filterNot { it is Screen.Search } +
                                        Screen.ChatDetail(selectedSearchUser)
                    },
                    onNavigateToCrashLogs = {
                        navStack = navStack.filterNot { it is Screen.Search } + Screen.CrashLogs
                    }
            )
        }

        SwipeBackContainer(
                isVisible = isGroupSetupVisible,
                onBack = { navStack = navStack.filterNot { it is Screen.GroupSetup } },
                isDarkTheme = isDarkTheme,
                layer = 1
        ) {
            GroupSetupScreen(
                    isDarkTheme = isDarkTheme,
                    accountPublicKey = accountPublicKey,
                    accountPrivateKey = accountPrivateKey,
                    accountName = accountName,
                    accountUsername = accountUsername,
                    avatarRepository = avatarRepository,
                    onBack = { navStack = navStack.filterNot { it is Screen.GroupSetup } },
                    onGroupOpened = { groupUser ->
                        navStack =
                                navStack.filterNot { it is Screen.GroupSetup } +
                                        Screen.ChatDetail(groupUser)
                    }
            )
        }

        SwipeBackContainer(
                isVisible = isLogsVisible,
                onBack = { navStack = navStack.filterNot { it is Screen.Logs } },
                isDarkTheme = isDarkTheme,
                layer = 2
        ) {
            com.rosetta.messenger.ui.settings.ProfileLogsScreen(
                    isDarkTheme = isDarkTheme,
                    logs = profileState.logs,
                    onBack = { navStack = navStack.filterNot { it is Screen.Logs } },
                    onClearLogs = { profileViewModel.clearLogs() }
            )
        }

        SwipeBackContainer(
                isVisible = isCrashLogsVisible,
                onBack = { navStack = navStack.filterNot { it is Screen.CrashLogs } },
                isDarkTheme = isDarkTheme,
                layer = 1
        ) {
            CrashLogsScreen(
                    onBackClick = { navStack = navStack.filterNot { it is Screen.CrashLogs } }
            )
        }

        SwipeBackContainer(
                isVisible = isConnectionLogsVisible,
                onBack = { navStack = navStack.filterNot { it is Screen.ConnectionLogs } },
                isDarkTheme = isDarkTheme,
                layer = 1
        ) {
            ConnectionLogsScreen(
                    isDarkTheme = isDarkTheme,
                    onBack = { navStack = navStack.filterNot { it is Screen.ConnectionLogs } }
            )
        }

        var isOtherProfileSwipeEnabled by remember { mutableStateOf(true) }
        LaunchedEffect(selectedOtherUser?.publicKey) {
            isOtherProfileSwipeEnabled = true
        }

        SwipeBackContainer(
                isVisible = selectedOtherUser != null,
                onBack = { navStack = navStack.filterNot { it is Screen.OtherProfile } },
                isDarkTheme = isDarkTheme,
                layer = 2,
                swipeEnabled = isOtherProfileSwipeEnabled,
                propagateBackgroundProgress = false
        ) {
            selectedOtherUser?.let { currentOtherUser ->
                OtherProfileScreen(
                        user = currentOtherUser,
                        isDarkTheme = isDarkTheme,
                        onBack = { navStack = navStack.filterNot { it is Screen.OtherProfile } },
                        onSwipeBackEnabledChanged = { enabled ->
                            isOtherProfileSwipeEnabled = enabled
                        },
                        avatarRepository = avatarRepository,
                        currentUserPublicKey = accountPublicKey,
                        currentUserPrivateKey = accountPrivateKey,
                        onWriteMessage = { chatUser ->
                            // Close profile and navigate to chat
                            navStack = navStack.filterNot {
                                it is Screen.OtherProfile || it is Screen.ChatDetail
                            } + Screen.ChatDetail(chatUser)
                        }
                )
            }
        }

        // Biometric Enable Screen
        SwipeBackContainer(
                isVisible = isBiometricVisible,
                onBack = { navStack = navStack.filterNot { it is Screen.Biometric } },
                isDarkTheme = isDarkTheme,
                layer = 2
        ) {
            val biometricManager = remember {
                com.rosetta.messenger.biometric.BiometricAuthManager(context)
            }
            val biometricPrefs = remember {
                com.rosetta.messenger.biometric.BiometricPreferences(context)
            }
            val biometricAccountManager = remember { AccountManager(context) }
            val activity = context as? FragmentActivity

            BiometricEnableScreen(
                    isDarkTheme = isDarkTheme,
                    onBack = { navStack = navStack.filterNot { it is Screen.Biometric } },
                    onEnable = { password, onSuccess, onError ->
                        if (activity == null) {
                            onError("Activity not available")
                            return@BiometricEnableScreen
                        }

                        // Verify password against the real account before saving
                        mainScreenScope.launch {
                            val account = biometricAccountManager.getAccount(accountPublicKey)
                            if (account == null) {
                                onError("Account not found")
                                return@launch
                            }
                            val decryptedKey = try {
                                CryptoManager.decryptWithPassword(account.encryptedPrivateKey, password)
                            } catch (_: Exception) { null }
                            if (decryptedKey == null) {
                                onError("Incorrect password")
                                return@launch
                            }

                            biometricManager.encryptPassword(
                                    activity = activity,
                                    password = password,
                                    onSuccess = { encryptedPassword ->
                                        mainScreenScope.launch {
                                            biometricPrefs.saveEncryptedPassword(
                                                    accountPublicKey,
                                                    encryptedPassword
                                            )
                                            biometricPrefs.enableBiometric()
                                            onSuccess()
                                        }
                                    },
                                    onError = { error -> onError(error) },
                                    onCancel = {
                                        navStack = navStack.filterNot { it is Screen.Biometric }
                                    }
                            )
                        }
                    }
            )
        }
    }
}
