AppViewModel.kt

package to.bitkit.viewmodels

import android.content.Context
import android.content.Intent
import android.net.Uri
import androidx.annotation.StringRes
import androidx.compose.runtime.Stable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.synonym.bitkitcore.Activity
import com.synonym.bitkitcore.ActivityFilter
import com.synonym.bitkitcore.FeeRates
import com.synonym.bitkitcore.LightningInvoice
import com.synonym.bitkitcore.LnurlAuthData
import com.synonym.bitkitcore.LnurlChannelData
import com.synonym.bitkitcore.LnurlPayData
import com.synonym.bitkitcore.LnurlWithdrawData
import com.synonym.bitkitcore.OnChainInvoice
import com.synonym.bitkitcore.PaymentType
import com.synonym.bitkitcore.Scanner
import com.synonym.bitkitcore.SortDirection
import com.synonym.bitkitcore.validateBitcoinAddress
import dagger.hilt.android.lifecycle.HiltViewModel
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.collections.immutable.ImmutableList
import kotlinx.collections.immutable.ImmutableMap
import kotlinx.collections.immutable.persistentListOf
import kotlinx.collections.immutable.persistentMapOf
import kotlinx.collections.immutable.toImmutableList
import kotlinx.collections.immutable.toImmutableMap
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Job
import kotlinx.coroutines.TimeoutCancellationException
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import kotlinx.coroutines.withTimeout
import org.lightningdevkit.ldknode.ChannelDataMigration
import org.lightningdevkit.ldknode.ClosureReason
import org.lightningdevkit.ldknode.Event
import org.lightningdevkit.ldknode.PaymentFailureReason
import org.lightningdevkit.ldknode.PaymentId
import org.lightningdevkit.ldknode.SpendableUtxo
import org.lightningdevkit.ldknode.Txid
import to.bitkit.BuildConfig
import to.bitkit.R
import to.bitkit.data.CacheStore
import to.bitkit.data.SettingsStore
import to.bitkit.data.keychain.Keychain
import to.bitkit.data.resetPin
import to.bitkit.di.BgDispatcher
import to.bitkit.domain.commands.NotifyPaymentReceived
import to.bitkit.domain.commands.NotifyPaymentReceivedHandler
import to.bitkit.env.Defaults
import to.bitkit.env.Env
import to.bitkit.ext.WatchResult
import to.bitkit.ext.amountOnClose
import to.bitkit.ext.amountSats
import to.bitkit.ext.channelId
import to.bitkit.ext.claimableAtHeight
import to.bitkit.ext.getClipboardText
import to.bitkit.ext.getSatsPerVByteFor
import to.bitkit.ext.callbackAmountMsats
import to.bitkit.ext.isFixedAmount
import to.bitkit.ext.maxSendableSat
import to.bitkit.ext.maxWithdrawableSat
import to.bitkit.ext.minSendableSat
import to.bitkit.ext.minWithdrawableSat
import to.bitkit.ext.rawId
import to.bitkit.ext.removeSpaces
import to.bitkit.ext.setClipboardText
import to.bitkit.ext.toHex
import to.bitkit.ext.toUserMessage
import to.bitkit.ext.totalValue
import to.bitkit.ext.watchUntil
import to.bitkit.models.FeeRate
import to.bitkit.models.msatFloorOf
import to.bitkit.models.NewTransactionSheetDetails
import to.bitkit.models.NewTransactionSheetDirection
import to.bitkit.models.NewTransactionSheetType
import to.bitkit.models.NodeLifecycleState
import to.bitkit.models.Suggestion
import to.bitkit.models.Toast
import to.bitkit.models.TransactionSpeed
import to.bitkit.models.TransferType
import to.bitkit.models.safe
import to.bitkit.models.toActivityFilter
import to.bitkit.models.toLdkNetwork
import to.bitkit.models.toTxType
import to.bitkit.repositories.ActivityRepo
import to.bitkit.repositories.BackupRepo
import to.bitkit.repositories.BlocktankRepo
import to.bitkit.repositories.ConnectivityRepo
import to.bitkit.repositories.ConnectivityState
import to.bitkit.repositories.CurrencyRepo
import to.bitkit.repositories.HealthRepo
import to.bitkit.repositories.LightningRepo
import to.bitkit.repositories.PaymentPendingException
import to.bitkit.repositories.PendingPaymentNotification
import to.bitkit.repositories.PendingPaymentRepo
import to.bitkit.repositories.PendingPaymentResolution
import to.bitkit.repositories.PreActivityMetadataRepo
import to.bitkit.repositories.TransferRepo
import to.bitkit.repositories.WalletRepo
import to.bitkit.repositories.WidgetsRepo
import to.bitkit.services.AppUpdaterService
import to.bitkit.services.CoreService
import to.bitkit.services.MigrationService
import to.bitkit.ui.Routes
import to.bitkit.ui.components.Sheet
import to.bitkit.ui.shared.toast.ToastEventBus
import to.bitkit.ui.shared.toast.ToastQueueManager
import to.bitkit.ui.sheets.SendRoute
import to.bitkit.ui.theme.TRANSITION_SCREEN_MS
import to.bitkit.usecases.FormatMoneyValue
import to.bitkit.utils.AppError
import to.bitkit.utils.Bip21Utils
import to.bitkit.utils.Logger
import to.bitkit.utils.NetworkValidationHelper
import to.bitkit.utils.jsonLogOf
import to.bitkit.utils.timedsheets.TimedSheetManager
import to.bitkit.utils.timedsheets.sheets.AppUpdateTimedSheet
import to.bitkit.utils.timedsheets.sheets.BackupTimedSheet
import to.bitkit.utils.timedsheets.sheets.HighBalanceTimedSheet
import to.bitkit.utils.timedsheets.sheets.NotificationsTimedSheet
import to.bitkit.utils.timedsheets.sheets.QuickPayTimedSheet
import java.math.BigDecimal
import javax.inject.Inject
import kotlin.coroutines.cancellation.CancellationException
import kotlin.time.Duration
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.ExperimentalTime

@OptIn(ExperimentalTime::class)
@Suppress("TooManyFunctions", "LargeClass", "LongParameterList")
@HiltViewModel
class AppViewModel @Inject constructor(
    connectivityRepo: ConnectivityRepo,
    healthRepo: HealthRepo,
    toastManagerProvider: @JvmSuppressWildcards (CoroutineScope) -> ToastQueueManager,
    timedSheetManagerProvider: @JvmSuppressWildcards (CoroutineScope) -> TimedSheetManager,
    @ApplicationContext private val context: Context,
    @BgDispatcher private val bgDispatcher: CoroutineDispatcher,
    private val keychain: Keychain,
    private val lightningRepo: LightningRepo,
    private val pendingPaymentRepo: PendingPaymentRepo,
    private val walletRepo: WalletRepo,
    private val backupRepo: BackupRepo,
    private val settingsStore: SettingsStore,
    private val currencyRepo: CurrencyRepo,
    private val activityRepo: ActivityRepo,
    private val preActivityMetadataRepo: PreActivityMetadataRepo,
    private val blocktankRepo: BlocktankRepo,
    private val appUpdaterService: AppUpdaterService,
    private val notifyPaymentReceivedHandler: NotifyPaymentReceivedHandler,
    private val cacheStore: CacheStore,
    private val transferRepo: TransferRepo,
    private val migrationService: MigrationService,
    private val coreService: CoreService,
    private val appUpdateSheet: AppUpdateTimedSheet,
    private val backupSheet: BackupTimedSheet,
    private val notificationsSheet: NotificationsTimedSheet,
    private val quickPaySheet: QuickPayTimedSheet,
    private val highBalanceSheet: HighBalanceTimedSheet,
    private val formatMoneyValue: FormatMoneyValue,
    private val widgetsRepo: WidgetsRepo,
) : ViewModel() {
    val healthState = healthRepo.healthState

    val isOnline = connectivityRepo.isOnline
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), ConnectivityState.CONNECTED)

    var splashVisible by mutableStateOf(true)
        private set

    val isGeoBlocked = lightningRepo.lightningState.map { it.isGeoBlocked }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), false)

    val forceCloseRemainingDuration = transferRepo.forceCloseRemainingDuration
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), null)

    private val _sendUiState = MutableStateFlow(SendUiState())
    val sendUiState = _sendUiState.asStateFlow()

    private val _quickPayData = MutableStateFlow<QuickPayData?>(null)
    val quickPayData = _quickPayData.asStateFlow()

    private var activeScanJob: Job? = null

    @Volatile
    private var activeScanInput: String? = null

    private val _sendEffect = MutableSharedFlow<SendEffect>(extraBufferCapacity = 1)
    val sendEffect = _sendEffect.asSharedFlow()
    private fun setSendEffect(effect: SendEffect) = viewModelScope.launch { _sendEffect.emit(effect) }

    private val _mainScreenEffect = MutableSharedFlow<MainScreenEffect>(extraBufferCapacity = 1)
    val mainScreenEffect = _mainScreenEffect.asSharedFlow()
    private fun mainScreenEffect(effect: MainScreenEffect) = viewModelScope.launch { _mainScreenEffect.emit(effect) }

    private val sendEvents = MutableSharedFlow<SendEvent>()
    fun setSendEvent(event: SendEvent) = viewModelScope.launch { sendEvents.emit(event) }

    private val _isAuthenticated = MutableStateFlow(false)
    val isAuthenticated = _isAuthenticated.asStateFlow()

    private val _showForgotPinSheet = MutableStateFlow(false)
    val showForgotPinSheet = _showForgotPinSheet.asStateFlow()

    private val _currentSheet: MutableStateFlow<Sheet?> = MutableStateFlow(null)
    val currentSheet = _currentSheet.asStateFlow()

    private val processedPayments = mutableSetOf<String>()
    private val timedSheetManager = timedSheetManagerProvider(viewModelScope).apply {
        registerSheet(appUpdateSheet)
        registerSheet(backupSheet)
        registerSheet(notificationsSheet)
        registerSheet(quickPaySheet)
        registerSheet(highBalanceSheet)
    }
    private var isCompletingMigration = false
    private var addressValidationJob: Job? = null

    fun setShowForgotPin(value: Boolean) {
        _showForgotPinSheet.value = value
    }

    fun setIsAuthenticated(value: Boolean) {
        _isAuthenticated.value = value
    }

    val pinAttemptsRemaining = keychain.pinAttemptsRemaining()
        .map { attempts -> attempts ?: Env.PIN_ATTEMPTS }
        .stateIn(viewModelScope, SharingStarted.Lazily, Env.PIN_ATTEMPTS)

    fun addTagToSelected(newTag: String) {
        _sendUiState.update {
            it.copy(
                selectedTags = (it.selectedTags + newTag).distinct().toImmutableList()
            )
        }
        viewModelScope.launch {
            settingsStore.addLastUsedTag(newTag)
        }
    }

    fun removeTag(tag: String) {
        _sendUiState.update {
            it.copy(
                selectedTags = it.selectedTags.filterNot { tagItem -> tagItem == tag }.toImmutableList()
            )
        }
    }

    init {
        viewModelScope.launch {
            ToastEventBus.events.collect {
                toast(it)
            }
        }
        viewModelScope.launch {
            // Delays are required for auth check on launch functionality
            delay(AUTH_CHECK_INITIAL_DELAY_MS)
            resetIsAuthenticatedState()
            delay(AUTH_CHECK_SPLASH_DELAY_MS)
            splashVisible = false
        }
        viewModelScope.launch {
            lightningRepo.updateGeoBlockState()
        }
        viewModelScope.launch {
            widgetsRepo.refreshEnabledWidgets()
        }
        viewModelScope.launch {
            timedSheetManager.currentSheet.collect { sheetType ->
                if (sheetType != null) {
                    val currentSheet = _currentSheet.value
                    val isHighPrioritySheetShowing = currentSheet is Sheet.Gift ||
                        currentSheet is Sheet.Send ||
                        currentSheet is Sheet.LnurlAuth ||
                        currentSheet is Sheet.Pin
                    if (!isHighPrioritySheetShowing) {
                        showSheet(Sheet.TimedSheet(sheetType))
                    }
                } else {
                    // Clear the timed sheet when manager sets it to null
                    _currentSheet.update { current ->
                        if (current is Sheet.TimedSheet) null else current
                    }
                }
            }
        }
        observeLdkNodeEvents()
        observeSendEvents()
        viewModelScope.launch {
            checkCriticalAppUpdate()
        }
        viewModelScope.launch {
            migrationService.isShowingMigrationLoading.collect { isShowing ->
                if (isShowing) {
                    @Suppress("SwallowedException")
                    try {
                        withTimeout(MIGRATION_LOADING_TIMEOUT_MS) {
                            migrationService.isShowingMigrationLoading.first { !it }
                        }
                    } catch (e: TimeoutCancellationException) {
                        val timeoutSecs = MIGRATION_LOADING_TIMEOUT_MS / 1000
                        Logger.warn("Migration loading timeout (${timeoutSecs}s), dismissing", context = TAG)
                        migrationService.setShowingMigrationLoading(false)
                    }
                } else {
                    if (migrationService.needsPostMigrationSync()) {
                        ToastEventBus.send(
                            type = Toast.ToastType.WARNING,
                            title = context.getString(R.string.migration__network_required_title),
                            description = context.getString(R.string.migration__network_required_msg),
                        )
                    }
                }
            }
        }
    }

    private fun observeLdkNodeEvents() {
        viewModelScope.launch {
            lightningRepo.nodeEvents.collect { handleLdkEvent(it) }
        }
    }

    @Suppress("CyclomaticComplexMethod")
    private fun handleLdkEvent(event: Event) {
        if (!walletRepo.walletExists()) return
        Logger.debug("LDK-node event received in $TAG: ${jsonLogOf(event)}", context = TAG)

        viewModelScope.launch {
            runCatching {
                when (event) {
                    is Event.BalanceChanged -> handleBalanceChanged()
                    is Event.ChannelClosed -> handleChannelClosed(event)
                    is Event.ChannelPending -> handleChannelPending()
                    is Event.ChannelReady -> handleChannelReady(event)
                    is Event.OnchainTransactionConfirmed -> handleOnchainTransactionConfirmed(event)
                    is Event.OnchainTransactionEvicted -> handleOnchainTransactionEvicted(event)
                    is Event.OnchainTransactionReceived -> handleOnchainTransactionReceived(event)
                    is Event.OnchainTransactionReorged -> handleOnchainTransactionReorged(event)
                    is Event.OnchainTransactionReplaced -> handleOnchainTransactionReplaced(event)
                    is Event.PaymentClaimable -> Unit
                    is Event.PaymentFailed -> handlePaymentFailed(event)
                    is Event.PaymentForwarded -> Unit
                    is Event.PaymentReceived -> handlePaymentReceived(event)
                    is Event.PaymentSuccessful -> handlePaymentSuccessful(event)
                    is Event.SpliceFailed -> Unit
                    is Event.SplicePending -> Unit
                    is Event.SyncCompleted -> handleSyncCompleted()
                    is Event.SyncProgress -> Unit
                }
            }.onFailure { e ->
                if (e is CancellationException) throw e
                Logger.error("LDK event handler error", e, context = TAG)
            }
        }
    }

    private suspend fun handleBalanceChanged() {
        walletRepo.syncBalances()
        transferRepo.syncTransferStates()
    }

    private suspend fun handleChannelReady(event: Event.ChannelReady) {
        transferRepo.syncTransferStates()
        walletRepo.syncBalances()
        notifyChannelReady(event)
    }

    private suspend fun handleChannelPending() = transferRepo.syncTransferStates()

    private suspend fun handleChannelClosed(event: Event.ChannelClosed) {
        val reason = event.reason
        if (reason != null) {
            val (isCounterpartyClose, isForceClose) = classifyClosureReason(reason)
            if (isCounterpartyClose) {
                createTransferForCounterpartyClose(event.channelId, isForceClose)
                showSheet(Sheet.ConnectionClosed)
            }
        }
        transferRepo.syncTransferStates()
        walletRepo.syncBalances()
    }

    private suspend fun createTransferForCounterpartyClose(channelId: String, isForceClose: Boolean) {
        val transferType = if (isForceClose) TransferType.FORCE_CLOSE else TransferType.COOP_CLOSE

        val balances = lightningRepo.getBalancesAsync().getOrNull()
        val lightningBalance = balances?.lightningBalances?.find { it.channelId() == channelId }
        var channelBalance = lightningBalance?.amountSats() ?: 0uL

        if (channelBalance == 0uL) {
            val closedChannels = runCatching {
                coreService.activity.closedChannels(SortDirection.DESC)
            }.getOrNull()
            channelBalance = closedChannels
                ?.firstOrNull { it.channelId == channelId }
                ?.channelValueSats ?: 0uL
        }

        if (channelBalance > 0uL) {
            transferRepo.createTransfer(
                type = transferType,
                amountSats = channelBalance.toLong(),
                channelId = channelId,
                claimableAtHeight = lightningBalance?.claimableAtHeight(),
            )
        }
    }

    private fun classifyClosureReason(reason: ClosureReason): Pair<Boolean, Boolean> {
        return when (reason) {
            is ClosureReason.CounterpartyForceClosed -> true to true
            is ClosureReason.CommitmentTxConfirmed -> true to true
            is ClosureReason.CounterpartyInitiatedCooperativeClosure -> true to false
            is ClosureReason.CounterpartyCoopClosedUnfundedChannel -> true to false
            else -> false to false
        }
    }

    private suspend fun handleSyncCompleted() {
        val isShowingLoading = migrationService.isShowingMigrationLoading.value
        val isRestoringRemote = migrationService.isRestoringFromRNRemoteBackup.value
        val needsPostMigrationSync = migrationService.needsPostMigrationSync()
        val pendingPrune = settingsStore.data.first().pendingRestoreAddressTypePrune

        when {
            (isShowingLoading || needsPostMigrationSync) && !isCompletingMigration -> completeMigration()
            isRestoringRemote -> completeRNRemoteBackupRestore()
            pendingPrune -> {
                settingsStore.update { it.copy(pendingRestoreAddressTypePrune = false) }
                delay(POST_RESTORE_PRUNE_DELAY_MS)
                lightningRepo.pruneEmptyAddressTypesAfterRestore()
                walletRepo.debounceSyncByEvent()
            }

            !isShowingLoading && !needsPostMigrationSync && !isCompletingMigration -> walletRepo.debounceSyncByEvent()
            else -> Unit
        }
    }

    private suspend fun completeRNRemoteBackupRestore() {
        val channelMigration = buildChannelMigrationIfAvailable()

        if (channelMigration != null) {
            lightningRepo.stop().onFailure {
                Logger.error("Failed to stop node during remote restore restart", it, context = TAG)
            }
            delay(REMOTE_RESTORE_NODE_RESTART_DELAY_MS)
            lightningRepo.start(channelMigration = channelMigration, shouldRetry = false)
                .onSuccess {
                    migrationService.consumePendingChannelMigration()
                    walletRepo.syncNodeAndWallet()
                    walletRepo.syncBalances()
                }
                .onFailure { e ->
                    Logger.error("Failed to restart node after remote restore: $e", e, context = TAG)
                }
        }

        lightningRepo.getPayments().onSuccess { activityRepo.syncLdkNodePayments(it) }
        migrationService.reapplyMetadataAfterSync()
        activityRepo.syncActivities()
        walletRepo.syncBalances()

        if (migrationService.canCleanupAfterMigration) {
            migrationService.cleanupAfterMigration()
            migrationService.setRestoringFromRNRemoteBackup(false)
            migrationService.setShowingMigrationLoading(false)
        } else {
            Logger.info("Post-migration sync incomplete (remote restore), will retry on next sync", context = TAG)
            migrationService.setShowingMigrationLoading(false)
        }
    }

    private fun buildChannelMigrationIfAvailable(): ChannelDataMigration? {
        val migration = migrationService.peekPendingChannelMigration() ?: return null
        return ChannelDataMigration(
            channelManager = migration.channelManager.map { it.toUByte() },
            channelMonitors = migration.channelMonitors.map { monitor -> monitor.map { it.toUByte() } },
        )
    }

    private suspend fun completeMigration() {
        if (isCompletingMigration) return
        isCompletingMigration = true

        runCatching {
            lightningRepo.getPayments().onSuccess { payments ->
                activityRepo.syncLdkNodePayments(payments)
            }.onFailure { e ->
                Logger.warn("Failed to get payments during migration: $e", e, context = TAG)
            }
            activityRepo.markAllUnseenActivitiesAsSeen()

            migrationService.consumePendingChannelMigration()

            walletRepo.syncNodeAndWallet()
                .onSuccess { finishMigrationSuccessfully() }
                .onFailure { e ->
                    Logger.warn("Sync failed during migration: $e", e, context = TAG)
                    finishMigrationWithFallbackSync()
                }
        }.onFailure { e ->
            Logger.error("Migration completion error: $e", e, context = TAG)
            finishMigrationWithError()
        }.also {
            isCompletingMigration = false
        }
    }

    private suspend fun finishMigrationSuccessfully() {
        lightningRepo.getPayments().onSuccess { payments ->
            activityRepo.syncLdkNodePayments(payments)
        }
        transferRepo.syncTransferStates()
        migrationService.reapplyMetadataAfterSync()

        if (migrationService.canCleanupAfterMigration) {
            migrationService.cleanupAfterMigration()
            migrationService.setShowingMigrationLoading(false)
            delay(MIGRATION_AUTH_RESET_DELAY_MS)
            resetIsAuthenticatedStateInternal()
        } else {
            Logger.info("Post-migration sync incomplete, will retry on next sync", context = TAG)
            migrationService.setShowingMigrationLoading(false)
        }
    }

    private suspend fun finishMigrationWithFallbackSync() {
        walletRepo.syncBalances()
        lightningRepo.getPayments().onSuccess { payments ->
            activityRepo.syncLdkNodePayments(payments)
        }
        transferRepo.syncTransferStates()
        migrationService.reapplyMetadataAfterSync()

        if (migrationService.canCleanupAfterMigration) {
            migrationService.cleanupAfterMigration()
            migrationService.setShowingMigrationLoading(false)
            delay(MIGRATION_AUTH_RESET_DELAY_MS)
            resetIsAuthenticatedStateInternal()
        } else {
            Logger.info("Post-migration sync incomplete (fallback), will retry on next sync", context = TAG)
            migrationService.setShowingMigrationLoading(false)
        }
    }

    private suspend fun finishMigrationWithError() {
        migrationService.setShowingMigrationLoading(false)
        delay(MIGRATION_AUTH_RESET_DELAY_MS)
        resetIsAuthenticatedStateInternal()
        toast(
            type = Toast.ToastType.ERROR,
            title = "Migration Warning",
            description = "Migration completed but node restart failed. Please restart the app."
        )
    }

    private suspend fun handleOnchainTransactionConfirmed(event: Event.OnchainTransactionConfirmed) {
        activityRepo.handleOnchainTransactionConfirmed(event.txid, event.details)
    }

    private suspend fun handleOnchainTransactionEvicted(event: Event.OnchainTransactionEvicted) {
        activityRepo.handleOnchainTransactionEvicted(event.txid)
        notifyTransactionRemoved(event)
    }

    private suspend fun handleOnchainTransactionReceived(event: Event.OnchainTransactionReceived) {
        notifyPaymentReceived(event)
    }

    private suspend fun handleOnchainTransactionReorged(event: Event.OnchainTransactionReorged) {
        activityRepo.handleOnchainTransactionReorged(event.txid)
        notifyTransactionUnconfirmed()
    }

    private suspend fun handleOnchainTransactionReplaced(event: Event.OnchainTransactionReplaced) {
        // If the replaced transaction was just boosted via RBF from within the app, we already show a
        // dedicated boost success toast; suppress the generic "transaction replaced" toast to avoid
        // flakiness/noise (notably in E2E flows).
        val shouldSuppressReplacedToast = activityRepo
            .getOnchainActivityByTxId(event.txid)
            ?.let { it.isBoosted && it.txType == PaymentType.SENT } == true

        activityRepo.handleOnchainTransactionReplaced(event.txid, event.conflicts)
        if (!shouldSuppressReplacedToast) {
            notifyTransactionReplaced(event)
        }
    }

    private suspend fun handlePaymentFailed(event: Event.PaymentFailed) {
        event.paymentHash?.let { paymentHash ->
            activityRepo.handlePaymentEvent(paymentHash)
            if (pendingPaymentRepo.isPending(paymentHash)) {
                pendingPaymentRepo.resolve(PendingPaymentResolution.Failure(paymentHash))
                if (_currentSheet.value !is Sheet.Send || !pendingPaymentRepo.isActive(paymentHash)) {
                    notifyPendingPaymentFailed()
                }
                return
            }
        }
        notifyPaymentFailed(event.reason)
    }

    private suspend fun handlePaymentReceived(event: Event.PaymentReceived) {
        event.paymentHash.let { paymentHash ->
            activityRepo.handlePaymentEvent(paymentHash)
        }
        notifyPaymentReceived(event)
    }

    private suspend fun handlePaymentSuccessful(event: Event.PaymentSuccessful) {
        event.paymentHash.let { paymentHash ->
            activityRepo.handlePaymentEvent(paymentHash)
            if (pendingPaymentRepo.isPending(paymentHash)) {
                pendingPaymentRepo.resolve(PendingPaymentResolution.Success(paymentHash))
                if (_currentSheet.value !is Sheet.Send || !pendingPaymentRepo.isActive(paymentHash)) {
                    notifyPendingPaymentSucceeded()
                }
                return
            }
        }
        notifyPaymentSentOnLightning(event)
    }

    // region Notifications

    private suspend fun notifyChannelReady(event: Event.ChannelReady) {
        val channel = lightningRepo.getChannels()?.find { it.channelId == event.channelId }
        val cjitEntry = channel?.let { blocktankRepo.getCjitEntry(it) }
        if (cjitEntry != null) {
            val amount = channel.amountOnClose.toLong()
            showTransactionSheet(
                NewTransactionSheetDetails(
                    type = NewTransactionSheetType.LIGHTNING,
                    direction = NewTransactionSheetDirection.RECEIVED,
                    sats = amount,
                ),
            )
            activityRepo.insertActivityFromCjit(cjitEntry = cjitEntry, channel = channel)
            return
        }
        toast(
            type = Toast.ToastType.LIGHTNING,
            title = context.getString(R.string.lightning__channel_opened_title),
            description = context.getString(R.string.lightning__channel_opened_msg),
            testTag = "SpendingBalanceReadyToast",
        )
    }

    private suspend fun notifyTransactionRemoved(event: Event.OnchainTransactionEvicted) {
        if (activityRepo.wasTransactionReplaced(event.txid)) return
        toast(
            type = Toast.ToastType.WARNING,
            title = context.getString(R.string.wallet__toast_transaction_removed_title),
            description = context.getString(R.string.wallet__toast_transaction_removed_description),
            testTag = "TransactionRemovedToast",
        )
    }

    private suspend fun notifyPaymentReceived(event: Event) {
        if (migrationService.isShowingMigrationLoading.value || migrationService.needsPostMigrationSync()) {
            return
        }
        val command = NotifyPaymentReceived.Command.from(event) ?: return
        val result = notifyPaymentReceivedHandler(command).getOrNull()
        if (result !is NotifyPaymentReceived.Result.ShowSheet) return
        showTransactionSheet(result.sheet)
    }

    private fun notifyTransactionUnconfirmed() = toast(
        type = Toast.ToastType.WARNING,
        title = context.getString(R.string.wallet__toast_transaction_unconfirmed_title),
        description = context.getString(R.string.wallet__toast_transaction_unconfirmed_description),
        testTag = "TransactionUnconfirmedToast",
    )

    private suspend fun notifyTransactionReplaced(event: Event.OnchainTransactionReplaced) {
        val isReceive = activityRepo.isReceivedTransaction(event.txid)
        toast(
            type = Toast.ToastType.INFO,
            title = when (isReceive) {
                true -> R.string.wallet__toast_received_transaction_replaced_title
                else -> R.string.wallet__toast_transaction_replaced_title
            }.let { context.getString(it) },
            description = when (isReceive) {
                true -> R.string.wallet__toast_received_transaction_replaced_description
                else -> R.string.wallet__toast_transaction_replaced_description
            }.let { context.getString(it) },
            testTag = when (isReceive) {
                true -> "ReceivedTransactionReplacedToast"
                else -> "TransactionReplacedToast"
            },
        )
    }

    private fun notifyPendingPaymentSucceeded() = PendingPaymentNotification.success(context).let {
        toast(
            type = Toast.ToastType.LIGHTNING,
            title = it.title,
            description = it.body,
            testTag = "PendingPaymentSucceededToast",
        )
    }

    private fun notifyPendingPaymentFailed() = PendingPaymentNotification.error(context).let {
        toast(
            type = Toast.ToastType.ERROR,
            title = it.title,
            description = it.body,
            testTag = "PendingPaymentFailedToast",
        )
    }

    private fun notifyPaymentFailed(reason: PaymentFailureReason? = null) = toast(
        type = Toast.ToastType.ERROR,
        title = context.getString(R.string.wallet__toast_payment_failed_title),
        description = reason.toUserMessage(context),
        testTag = "PaymentFailedToast",
    )

    private suspend fun notifyPaymentSentOnLightning(event: Event.PaymentSuccessful): Result<Activity> {
        val paymentHash = event.paymentHash
        // TODO Temporary solution while LDK node doesn't return the sent value in the event
        return activityRepo.findActivityByPaymentId(
            paymentHashOrTxId = paymentHash,
            type = ActivityFilter.LIGHTNING,
            txType = PaymentType.SENT,
            retry = true
        ).onSuccess { activity ->
            onSendSuccess(
                NewTransactionSheetDetails(
                    type = NewTransactionSheetType.LIGHTNING,
                    direction = NewTransactionSheetDirection.SENT,
                    paymentHashOrTxId = event.paymentHash,
                    sats = activity.totalValue().toLong(),
                ),
            )
        }.onFailure {
            Logger.warn("Failed displaying sheet for event: $event", it, context = TAG)
        }
    }

    // endregion

    // region send

    @Suppress("CyclomaticComplexMethod")
    private fun observeSendEvents() {
        viewModelScope.launch {
            sendEvents.collect {
                when (it) {
                    SendEvent.EnterManually -> onEnterManuallyClick()
                    SendEvent.Paste -> onPasteClick()
                    SendEvent.Scan -> onScanClick()

                    is SendEvent.AddressChange -> onAddressChange(it.value)
                    SendEvent.AddressReset -> resetAddressInput()
                    is SendEvent.AddressContinue -> onAddressContinue(it.data)

                    is SendEvent.AmountChange -> onAmountChange(it.amount)
                    SendEvent.AmountReset -> resetAmountInput()
                    SendEvent.AmountContinue -> onAmountContinue()
                    SendEvent.PaymentMethodSwitch -> onPaymentMethodSwitch()

                    is SendEvent.CoinSelectionContinue -> onCoinSelectionContinue(it.utxos)

                    is SendEvent.CommentChange -> onCommentChange(it.value)

                    SendEvent.SpeedAndFee -> {
                        if (_sendUiState.value.fees.isEmpty()) {
                            viewModelScope.launch {
                                refreshFeeEstimates()
                                setSendEffect(SendEffect.NavigateToFee)
                            }
                        } else {
                            setSendEffect(SendEffect.NavigateToFee)
                        }
                    }
                    SendEvent.SwipeToPay -> onSwipeToPay()
                    is SendEvent.ConfirmAmountWarning -> onConfirmAmountWarning(it.warning)
                    SendEvent.DismissAmountWarning -> onDismissAmountWarning()
                    SendEvent.EstimateMaxRoutingFee -> viewModelScope.launch {
                        estimateMaxAmountRoutingFee()
                    }

                    SendEvent.PayConfirmed -> onConfirmPay()
                    SendEvent.ClearPayConfirmation -> _sendUiState.update { s -> s.copy(shouldConfirmPay = false) }
                    SendEvent.BackToAmount -> setSendEffect(SendEffect.PopBack(SendRoute.Amount))
                    SendEvent.NavToAddress -> setSendEffect(SendEffect.NavigateToAddress)
                    SendEvent.Contacts -> setSendEffect(SendEffect.NavigateToComingSoon)
                }
            }
        }
    }

    private val isMainScanner get() = currentSheet.value !is Sheet.Send

    private fun onEnterManuallyClick() {
        resetAddressInput()
        setSendEffect(SendEffect.NavigateToAddress)
    }

    private fun resetAddressInput() {
        addressValidationJob?.cancel()
        _sendUiState.update { state ->
            state.copy(
                addressInput = "",
                isAddressInputValid = false,
            )
        }
    }

    private fun onAddressChange(value: String) {
        val valueWithoutSpaces = value.removeSpaces()

        // Update text immediately, reset validity until validation completes
        _sendUiState.update {
            it.copy(
                addressInput = valueWithoutSpaces,
                isAddressInputValid = false,
            )
        }

        // Cancel pending validation
        addressValidationJob?.cancel()

        // Skip validation for empty input
        if (valueWithoutSpaces.isEmpty()) return

        // Start debounced validation
        addressValidationJob = viewModelScope.launch {
            delay(ADDRESS_VALIDATION_DEBOUNCE_MS)
            validateAddressWithFeedback(valueWithoutSpaces)
        }
    }

    private suspend fun validateAddressWithFeedback(input: String) = withContext(bgDispatcher) {
        // TODO Workaround for https://github.com/synonymdev/bitkit-core/issues/63
        if (Bip21Utils.isDuplicatedBip21(input)) {
            showAddressValidationError(
                titleRes = R.string.other__scan_err_decoding,
                descriptionRes = R.string.other__scan__error__generic,
                testTag = "DuplicatedBip21Toast",
            )
            return@withContext
        }

        val scanResult = runCatching { coreService.decode(input.removeLightningSchemes()) }

        if (scanResult.isFailure) {
            showAddressValidationError(
                titleRes = R.string.other__scan_err_decoding,
                descriptionRes = R.string.other__scan__error__generic,
                testTag = "InvalidAddressToast",
            )
            return@withContext
        }

        when (val decoded = scanResult.getOrNull()) {
            is Scanner.Lightning -> validateLightningInvoice(decoded.invoice)
            is Scanner.OnChain -> validateOnChainAddress(decoded.invoice)
            else -> _sendUiState.update { it.copy(isAddressInputValid = true) }
        }
    }

    private suspend fun validateLightningInvoice(invoice: LightningInvoice) {
        if (invoice.isExpired) {
            showAddressValidationError(
                titleRes = R.string.other__scan_err_decoding,
                descriptionRes = R.string.other__scan__error__expired,
                testTag = "ExpiredLightningToast",
            )
            return
        }

        if (invoice.amountSatoshis > 0uL) {
            val maxSendLightning = walletRepo.balanceState.value.maxSendLightningSats
            if (maxSendLightning == 0uL || !lightningRepo.canSend(invoice.amountSatoshis)) {
                val shortfall = invoice.amountSatoshis.safe() - maxSendLightning.safe()
                showAddressValidationError(
                    titleRes = R.string.other__pay_insufficient_spending,
                    descriptionRes = R.string.other__pay_insufficient_spending_amount_description,
                    descriptionArgs = mapOf("amount" to formatMoneyValue(shortfall)),
                    testTag = "InsufficientSpendingToast",
                )
                return
            }
        }

        _sendUiState.update { it.copy(isAddressInputValid = true) }
    }

    private suspend fun validateOnChainAddress(invoice: OnChainInvoice) {
        val validatedAddress = runCatching { validateBitcoinAddress(invoice.address) }
            .getOrElse {
                showAddressValidationError(
                    titleRes = R.string.other__scan_err_decoding,
                    descriptionRes = R.string.wallet__error_invalid_bitcoin_address,
                    testTag = "InvalidAddressToast",
                )
                return
            }

        if (NetworkValidationHelper.isNetworkMismatch(validatedAddress.network.toLdkNetwork(), Env.network)) {
            showAddressValidationError(
                titleRes = R.string.other__scan_err_decoding,
                descriptionRes = R.string.other__scan__error__generic,
                testTag = "InvalidAddressToast",
            )
            return
        }

        extractViableLightningInvoice(invoice.params)?.let { lnInvoice ->
            _sendUiState.update {
                it.copy(
                    isAddressInputValid = true,
                    isUnified = true,
                    decodedInvoice = lnInvoice,
                    payMethod = SendMethod.LIGHTNING,
                )
            }
            updateCanSwitchWallet()
            return
        }

        val maxSendOnchain = walletRepo.balanceState.value.maxSendOnchainSats

        if (maxSendOnchain == 0uL) {
            showAddressValidationError(
                titleRes = R.string.other__pay_insufficient_savings,
                descriptionRes = R.string.other__pay_insufficient_savings_description,
                testTag = "InsufficientSavingsToast",
            )
            return
        }

        if (invoice.amountSatoshis > 0uL && invoice.amountSatoshis > maxSendOnchain) {
            val shortfall = invoice.amountSatoshis - maxSendOnchain
            showAddressValidationError(
                titleRes = R.string.other__pay_insufficient_savings,
                descriptionRes = R.string.other__pay_insufficient_savings_amount_description,
                descriptionArgs = mapOf("amount" to formatMoneyValue(shortfall)),
                testTag = "InsufficientSavingsToast",
            )
            return
        }

        _sendUiState.update { it.copy(isAddressInputValid = true) }
    }

    private suspend fun extractViableLightningInvoice(params: Map<String, String>?): LightningInvoice? =
        params?.get("lightning")?.let { bolt11 ->
            runCatching { coreService.decode(bolt11) }.getOrNull()
                ?.let { it as? Scanner.Lightning }
                ?.invoice
                ?.takeIf { lnInv ->
                    if (lnInv.isExpired) {
                        Logger.debug(
                            "Lightning invoice expired in unified URI, defaulting to onchain-only",
                            context = TAG
                        )
                        return@takeIf false
                    }
                    val canSend = lightningRepo.canSend(lnInv.amountSatoshis.coerceAtLeast(1u))
                    if (!canSend) {
                        val nodeState = lightningRepo.lightningState.value.nodeLifecycleState
                        if (nodeState is NodeLifecycleState.Stopped) {
                            Logger.debug(
                                "Node stopped, optimistically including LN invoice in unified QR",
                                context = TAG,
                            )
                            return@takeIf true
                        }
                        Logger.debug(
                            "Cannot pay unified invoice using LN, defaulting to onchain-only",
                            context = TAG,
                        )
                    }
                    return@takeIf canSend
                }
        }

    private fun showAddressValidationError(
        @StringRes titleRes: Int,
        @StringRes descriptionRes: Int,
        descriptionArgs: Map<String, String> = emptyMap(),
        testTag: String? = null,
    ) {
        _sendUiState.update { it.copy(isAddressInputValid = false) }
        var description = context.getString(descriptionRes)
        descriptionArgs.forEach { (key, value) ->
            description = description.replace("{$key}", value)
        }
        toast(
            type = Toast.ToastType.ERROR,
            title = context.getString(titleRes),
            description = description,
            testTag = testTag,
        )
    }

    private fun launchScan(source: ScanSource, data: String, startDelay: Duration = Duration.ZERO) {
        val normalized = data.removeLightningSchemes()
        val scanId = if (data.length > 24) "${data.take(11)}…${data.takeLast(11)}" else data

        if (normalized == activeScanInput && activeScanJob?.isActive == true) {
            Logger.info("Skipping duplicate scan from '${source.label}': '$scanId'", context = TAG)
            return
        }

        activeScanJob?.let {
            Logger.info("Cancelling prior scan for new '${source.label}': '$scanId'", context = TAG)
            it.cancel()
        }

        activeScanInput = normalized
        Logger.debug("Starting scan from '${source.label}': '$scanId'", context = TAG)
        activeScanJob = viewModelScope.launch {
            if (startDelay > Duration.ZERO) delay(startDelay)
            handleScan(data)
        }.also { it.invokeOnCompletion { if (activeScanInput == normalized) activeScanInput = null } }
    }

    private fun onAddressContinue(data: String) {
        launchScan(source = ScanSource.ADDRESS_CONTINUE, data = data)
    }

    private suspend fun onAmountChange(amount: ULong) {
        _sendUiState.update {
            it.copy(
                amount = amount,
                isAmountInputValid = validateAmount(amount),
                confirmedWarnings = persistentListOf(),
            )
        }
        updateCanSwitchWallet()
    }

    private fun onCommentChange(comment: String) {
        // Apply maxLength from lnurlPay commentAllowed
        val maxLength = (_sendUiState.value.lnurl as? LnurlParams.LnurlPay)?.data?.commentAllowed ?: 0u
        val trimmed = comment.take(maxLength.toInt())
        _sendUiState.update {
            it.copy(comment = trimmed)
        }
    }

    fun onSelectSpeed(speed: TransactionSpeed) {
        if (speed is TransactionSpeed.Custom && speed.satsPerVByte == 0u) {
            setSendEffect(SendEffect.NavigateToFeeCustom)
        } else {
            setTransactionSpeed(speed)
        }
    }

    fun setTransactionSpeed(speed: TransactionSpeed) {
        viewModelScope.launch {
            val state = _sendUiState.value
            val shouldResetUtxos = when (settingsStore.data.first().coinSelectAuto) {
                true -> {
                    val currentSatsPerVByte = state.feeRates?.getSatsPerVByteFor(state.speed)
                    val newSatsPerVByte = state.feeRates?.getSatsPerVByteFor(speed)
                    currentSatsPerVByte != newSatsPerVByte
                }

                else -> false
            }
            val fee = when (speed is TransactionSpeed.Custom) {
                true -> getFeeEstimate(speed)
                else -> state.fees.getOrDefault(FeeRate.fromSpeed(speed), 0)
            }
            _sendUiState.update {
                it.copy(
                    payMethod = SendMethod.ONCHAIN,
                    speed = speed,
                    fee = SendFee.OnChain(fee),
                    selectedUtxos = if (shouldResetUtxos) null else it.selectedUtxos,
                )
            }
            updateCanSwitchWallet()
            refreshOnchainSendIfNeeded()
            setSendEffect(SendEffect.PopBack(SendRoute.Confirm))
        }
    }

    private fun updateCanSwitchWallet() {
        val state = _sendUiState.value
        if (!state.isUnified) {
            _sendUiState.update { it.copy(canSwitchWallet = false) }
            return
        }
        val amount = state.amount
        val balance = walletRepo.balanceState.value
        val canSwitch = amount > Defaults.dustLimit.toULong() &&
            amount <= balance.maxSendOnchainSats &&
            amount <= balance.maxSendLightningSats
        _sendUiState.update { it.copy(canSwitchWallet = canSwitch) }
    }

    private suspend fun onPaymentMethodSwitch() {
        val current = _sendUiState.value
        if (!current.isUnified) return

        val nextMethod = when (current.payMethod) {
            SendMethod.ONCHAIN -> SendMethod.LIGHTNING
            SendMethod.LIGHTNING -> SendMethod.ONCHAIN
        }
        _sendUiState.update {
            it.copy(
                payMethod = nextMethod,
                isAmountInputValid = validateAmount(it.amount, nextMethod),
                confirmedWarnings = persistentListOf(),
            )
        }
        when (nextMethod) {
            SendMethod.ONCHAIN -> {
                val defaultSpeed = settingsStore.data.first().defaultTransactionSpeed
                _sendUiState.update { it.copy(speed = defaultSpeed) }
                refreshFeeEstimates()
            }
            SendMethod.LIGHTNING -> {
                _sendUiState.update { it.copy(fee = SendFee.Lightning(0)) }
                estimateLightningRoutingFeesIfNeeded()
            }
        }
    }

    fun switchToLightning() {
        viewModelScope.launch {
            _sendUiState.update {
                it.copy(
                    payMethod = SendMethod.LIGHTNING,
                    fee = SendFee.Lightning(0),
                    isAmountInputValid = validateAmount(it.amount, SendMethod.LIGHTNING),
                    confirmedWarnings = persistentListOf(),
                )
            }
            estimateLightningRoutingFeesIfNeeded()
        }
    }

    private suspend fun onAmountContinue() {
        _sendUiState.update {
            it.copy(
                selectedUtxos = null,
            )
        }

        if (_sendUiState.value.payMethod != SendMethod.LIGHTNING && !settingsStore.data.first().coinSelectAuto) {
            setSendEffect(SendEffect.NavigateToCoinSelection)
            return
        }

        val lnurl = _sendUiState.value.lnurl
        if (lnurl is LnurlParams.LnurlPay) {
            val minSendable = lnurl.data.minSendableSat()
            if (_sendUiState.value.amount < minSendable) {
                toast(
                    type = Toast.ToastType.ERROR,
                    title = context.getString(R.string.wallet__lnurl_pay__error_min__title),
                    description = context.getString(R.string.wallet__lnurl_pay__error_min__description)
                        .replace("{amount}", formatMoneyValue(minSendable)),
                    testTag = "LnurlPayAmountTooLowToast",
                )
                return
            }
        }
        if (lnurl is LnurlParams.LnurlWithdraw) {
            setSendEffect(SendEffect.NavigateToWithdrawConfirm)
            return
        }

        _sendUiState.update { it.copy(isLoading = true) }
        refreshOnchainSendIfNeeded()
        estimateLightningRoutingFeesIfNeeded()
        _sendUiState.update { it.copy(isLoading = false) }
        updateCanSwitchWallet()

        setSendEffect(SendEffect.NavigateToConfirm)
    }

    private suspend fun onCoinSelectionContinue(utxos: List<SpendableUtxo>) {
        _sendUiState.update {
            it.copy(selectedUtxos = utxos.toImmutableList())
        }
        refreshFeeEstimates()
        setSendEffect(SendEffect.NavigateToConfirm)
    }

    private suspend fun validateAmount(
        amount: ULong,
        payMethod: SendMethod = _sendUiState.value.payMethod,
    ): Boolean {
        if (amount == 0uL) return false

        return when (payMethod) {
            SendMethod.LIGHTNING -> {
                val maxSendable = maxSendableLightningSats()
                when (val lnurl = _sendUiState.value.lnurl) {
                    null -> amount <= maxSendable && lightningRepo.canSend(amount)
                    is LnurlParams.LnurlWithdraw -> amount <= lnurl.data.maxWithdrawableSat()
                    is LnurlParams.LnurlPay -> {
                        val maxSat = lnurl.data.maxSendableSat()
                        amount <= maxSat && amount <= maxSendable && lightningRepo.canSend(amount)
                    }
                }
            }

            SendMethod.ONCHAIN -> {
                val maxSendable = walletRepo.balanceState.value.maxSendOnchainSats
                amount > Defaults.dustLimit.toULong() && amount <= maxSendable
            }
        }
    }

    private fun maxSendableLightningSats(): ULong {
        val max = walletRepo.balanceState.value.maxSendLightningSats
        val fee = _sendUiState.value.estimatedRoutingFee
        return max.safe() - fee.safe()
    }

    private fun onPasteClick() {
        val data = context.getClipboardText()?.trim()
        if (data.isNullOrBlank()) {
            toast(
                type = Toast.ToastType.WARNING,
                title = context.getString(R.string.wallet__send_clipboard_empty_title),
                description = context.getString(R.string.wallet__send_clipboard_empty_text),
            )
            return
        }
        launchScan(source = ScanSource.PASTE, data = data)
    }

    private fun onScanClick() {
        setSendEffect(SendEffect.NavigateToScan)
    }

    fun onScanResult(data: String, startDelay: Duration = Duration.ZERO) {
        launchScan(source = ScanSource.SCAN_RESULT, data = data, startDelay = startDelay)
    }

    private suspend fun handleScan(result: String) = withContext(bgDispatcher) {
        // always reset state on new scan
        resetSendState()
        resetQuickPay()

        val input = result.removeLightningSchemes()

        // TODO Workaround for https://github.com/synonymdev/bitkit-core/issues/63
        if (Bip21Utils.isDuplicatedBip21(input)) {
            toast(
                type = Toast.ToastType.ERROR,
                title = context.getString(R.string.other__scan_err_decoding),
                description = context.getString(R.string.other__scan__error__generic),
                testTag = "DuplicatedBip21Toast",
            )
            return@withContext
        }

        val scan = runCatching { coreService.decode(input) }
            .onFailure { Logger.error("Failed to decode scan data: '$input'", it, context = TAG) }
            .onSuccess { Logger.info("Handling decoded scan data: $it", context = TAG) }
            .getOrNull()

        when (scan) {
            is Scanner.OnChain -> onScanOnchain(scan.invoice, input)
            is Scanner.Lightning -> onScanLightning(scan.invoice, input)
            is Scanner.LnurlPay -> onScanLnurlPay(scan.data)
            is Scanner.LnurlWithdraw -> onScanLnurlWithdraw(scan.data)
            is Scanner.LnurlAuth -> onScanLnurlAuth(scan.data)
            is Scanner.LnurlChannel -> onScanLnurlChannel(scan.data)
            is Scanner.NodeId -> onScanNodeId(scan)
            is Scanner.Gift -> onScanGift(scan.code, scan.amount)
            else -> {
                Logger.warn("Unhandled scan data: $scan", context = TAG)
                toast(
                    type = Toast.ToastType.WARNING,
                    title = context.getString(R.string.other__qr_error_header),
                    description = context.getString(R.string.other__qr_error_text),
                )
            }
        }
    }

    @Suppress("LongMethod", "CyclomaticComplexMethod", "ReturnCount")
    private suspend fun onScanOnchain(invoice: OnChainInvoice, scanResult: String) {
        val validatedAddress = runCatching { validateBitcoinAddress(invoice.address) }
            .getOrElse {
                toast(
                    type = Toast.ToastType.ERROR,
                    title = context.getString(R.string.other__scan_err_decoding),
                    description = context.getString(R.string.wallet__error_invalid_bitcoin_address),
                    testTag = "InvalidAddressToast",
                )
                return
            }

        if (NetworkValidationHelper.isNetworkMismatch(validatedAddress.network.toLdkNetwork(), Env.network)) {
            toast(
                type = Toast.ToastType.ERROR,
                title = context.getString(R.string.other__scan_err_decoding),
                description = context.getString(R.string.other__scan__error__generic),
                testTag = "InvalidAddressToast",
            )
            return
        }
        val maxSendOnchain = walletRepo.balanceState.value.maxSendOnchainSats

        val lnInvoice = extractViableLightningInvoice(invoice.params)
        val amount = lnInvoice?.amountSatoshis?.takeIf { it > 0uL } ?: invoice.amountSatoshis
        _sendUiState.update {
            it.copy(
                address = invoice.address,
                addressInput = scanResult,
                isAddressInputValid = true,
                amount = amount,
                isUnified = lnInvoice != null && amount <= maxSendOnchain && maxSendOnchain > 0u,
                decodedInvoice = lnInvoice,
                payMethod = lnInvoice?.let { SendMethod.LIGHTNING } ?: SendMethod.ONCHAIN,
            )
        }
        updateCanSwitchWallet()

        val lnAmountSats = lnInvoice?.amountSatoshis ?: 0u
        if (lnAmountSats > 0u) {
            Logger.info("Found amount in unified invoice, checking QuickPay conditions", context = TAG)

            val quickPayHandled = handleQuickPayIfApplicable(
                amountSats = lnAmountSats,
                invoice = lnInvoice,
            )
            if (quickPayHandled) return

            refreshOnchainSendIfNeeded()
            estimateLightningRoutingFeesIfNeeded()
            if (isMainScanner) {
                showSheet(Sheet.Send(SendRoute.Confirm))
            } else {
                setSendEffect(SendEffect.NavigateToConfirm)
            }
            return
        }

        // Check on-chain balance before proceeding to amount screen
        if (maxSendOnchain == 0uL && _sendUiState.value.payMethod == SendMethod.ONCHAIN) {
            toast(
                type = Toast.ToastType.ERROR,
                title = context.getString(R.string.other__pay_insufficient_savings),
                description = context.getString(R.string.other__pay_insufficient_savings_description),
                testTag = "InsufficientSavingsToast",
            )
            return
        }

        // Check if on-chain invoice amount exceeds available balance
        if (
            invoice.amountSatoshis > 0uL &&
            invoice.amountSatoshis > maxSendOnchain &&
            _sendUiState.value.payMethod == SendMethod.ONCHAIN
        ) {
            val shortfall = invoice.amountSatoshis - maxSendOnchain
            toast(
                type = Toast.ToastType.ERROR,
                title = context.getString(R.string.other__pay_insufficient_savings),
                description = context.getString(R.string.other__pay_insufficient_savings_amount_description)
                    .replace("{amount}", formatMoneyValue(shortfall)),
                testTag = "InsufficientSavingsToast",
            )
            return
        }

        Logger.info(
            when (amount > 0u) {
                true -> "Found amount in invoice, proceeding to edit amount"
                else -> "No amount found in invoice, proceeding to enter amount"
            },
            context = TAG,
        )

        if (isMainScanner) {
            showSheet(Sheet.Send(SendRoute.Amount))
        } else {
            setSendEffect(SendEffect.NavigateToAmount)
        }
    }

    private suspend fun onScanLightning(invoice: LightningInvoice, scanResult: String) {
        if (invoice.isExpired) {
            toast(
                type = Toast.ToastType.ERROR,
                title = context.getString(R.string.other__scan_err_decoding),
                description = context.getString(R.string.other__scan__error__expired),
                testTag = "ExpiredLightningToast",
            )
            return
        }

        val quickPayHandled = handleQuickPayIfApplicable(amountSats = invoice.amountSatoshis, invoice = invoice)
        if (quickPayHandled) return

        if (!lightningRepo.canSend(invoice.amountSatoshis)) {
            val maxSendLightning = walletRepo.balanceState.value.maxSendLightningSats
            val shortfall = invoice.amountSatoshis.safe() - maxSendLightning.safe()
            toast(
                type = Toast.ToastType.ERROR,
                title = context.getString(R.string.other__pay_insufficient_spending),
                description = context.getString(R.string.other__pay_insufficient_spending_amount_description)
                    .replace("{amount}", formatMoneyValue(shortfall)),
                testTag = "InsufficientSpendingToast",
            )
            return
        }

        _sendUiState.update {
            it.copy(
                amount = invoice.amountSatoshis,
                addressInput = scanResult,
                isAddressInputValid = true,
                decodedInvoice = invoice,
                payMethod = SendMethod.LIGHTNING,
            )
        }

        if (invoice.amountSatoshis > 0uL) {
            Logger.info("Found amount in invoice, proceeding with payment", context = TAG)

            if (isMainScanner) {
                showSheet(Sheet.Send(SendRoute.Confirm))
            } else {
                setSendEffect(SendEffect.NavigateToConfirm)
            }
            return
        }
        Logger.info("No amount found in invoice, proceeding to enter amount", context = TAG)

        if (isMainScanner) {
            showSheet(Sheet.Send(SendRoute.Amount))
        } else {
            setSendEffect(SendEffect.NavigateToAmount)
        }
    }

    private suspend fun onScanLnurlPay(data: LnurlPayData) {
        Logger.debug("LNURL: $data", context = TAG)

        val isFixed = data.isFixedAmount()
        val displaySats = data.minSendableSat()

        if (!lightningRepo.canSend(displaySats.coerceAtLeast(1u))) {
            toast(
                type = Toast.ToastType.WARNING,
                title = context.getString(R.string.other__lnurl_pay_error),
                description = context.getString(R.string.other__lnurl_pay_error_no_capacity),
            )
            return
        }

        val initialAmount = if (isFixed) displaySats else 0u

        _sendUiState.update {
            it.copy(
                amount = initialAmount,
                payMethod = SendMethod.LIGHTNING,
                lnurl = LnurlParams.LnurlPay(data),
            )
        }

        if (isFixed) {
            Logger.info("Found fixed amount '$displaySats' sats in lnurlPay, proceeding with payment", context = TAG)

            val quickPayHandled = handleQuickPayIfApplicable(amountSats = displaySats, lnurlPay = data)
            if (quickPayHandled) return

            if (isMainScanner) {
                showSheet(Sheet.Send(SendRoute.Confirm))
            } else {
                setSendEffect(SendEffect.NavigateToConfirm)
            }
            return
        }

        Logger.info("No amount found in lnurlPay, proceeding to enter amount manually", context = TAG)
        if (isMainScanner) {
            showSheet(Sheet.Send(SendRoute.Amount))
        } else {
            setSendEffect(SendEffect.NavigateToAmount)
        }
    }

    private suspend fun onScanLnurlWithdraw(data: LnurlWithdrawData) {
        Logger.debug("LNURL: $data", context = TAG)

        val isFixed = data.isFixedAmount()
        val minWithdrawable = data.minWithdrawableSat()
        val maxWithdrawable = data.maxWithdrawableSat()

        if (!isFixed && minWithdrawable > maxWithdrawable) {
            toast(
                type = Toast.ToastType.WARNING,
                title = context.getString(R.string.other__lnurl_withdr_error),
                description = context.getString(R.string.other__lnurl_withdr_error_minmax)
            )
            return
        }

        val displayAmount = minWithdrawable

        _sendUiState.update {
            it.copy(
                payMethod = SendMethod.LIGHTNING,
                amount = displayAmount,
                lnurl = LnurlParams.LnurlWithdraw(data = data)
            )
        }

        if (isFixed || minWithdrawable == maxWithdrawable) {
            delay(TRANSITION_SCREEN_MS)
            if (isMainScanner) {
                showSheet(Sheet.Send(SendRoute.WithdrawConfirm))
            } else {
                setSendEffect(SendEffect.NavigateToWithdrawConfirm)
            }
            return
        }

        if (isMainScanner) {
            showSheet(Sheet.Send(SendRoute.Amount))
        } else {
            setSendEffect(SendEffect.NavigateToAmount)
        }
    }

    private suspend fun onScanLnurlAuth(data: LnurlAuthData) {
        Logger.debug("LNURL: $data", context = TAG)
        if (!isMainScanner) {
            hideSheet()
            delay(TRANSITION_SCREEN_MS)
        }
        showSheet(Sheet.LnurlAuth(domain = data.domain, lnurl = data.uri, k1 = data.k1))
    }

    fun requestLnurlAuth(callback: String, k1: String, domain: String) {
        viewModelScope.launch {
            lightningRepo.requestLnurlAuth(
                callback = callback,
                k1 = k1,
                domain = domain,
            ).onFailure {
                toast(
                    type = Toast.ToastType.WARNING,
                    title = context.getString(R.string.other__lnurl_auth_error),
                    description = context.getString(R.string.other__lnurl_auth_error_msg)
                        .replace("{raw}", it.message?.takeIf { m -> m.isNotBlank() } ?: it.javaClass.simpleName),
                )
            }.onSuccess {
                toast(
                    type = Toast.ToastType.SUCCESS,
                    title = context.getString(R.string.other__lnurl_auth_success_title),
                    description = when (domain.isNotBlank()) {
                        true -> context.getString(R.string.other__lnurl_auth_success_msg_domain)
                            .replace("{domain}", domain)

                        else -> context.getString(R.string.other__lnurl_auth_success_msg_no_domain)
                    },
                )
            }
            hideSheet()
        }
    }

    private fun onScanLnurlChannel(data: LnurlChannelData) {
        Logger.debug("LNURL: $data", context = TAG)
        hideSheet() // hide scan sheet if opened
        mainScreenEffect(
            MainScreenEffect.Navigate(
                Routes.LnurlChannel(uri = data.uri, callback = data.callback, k1 = data.k1)
            )
        )
    }

    private fun onScanNodeId(data: Scanner.NodeId) {
        // TODO uncomment when bitkit-core is no longer hardcoding MAINNET as network
        //  or remove this check altogether if it's not possible to implement it reliably in rust.
        //  see: https://github.com/synonymdev/bitkit-core/blob/fc432888016a1bf61aa9bfbee908513e9a33f9b9/src/modules/scanner/implementation.rs#L77
        // val network = data.network
        // val appNetwork = Env.network.toCoreNetworkType()
        // if (network != appNetwork) {
        //     toast(
        //         type = Toast.ToastType.WARNING,
        //         title = context.getString(R.string.other__qr_error_network_header),
        //         description = context.getString(R.string.other__qr_error_network_text)
        //             .replace("{selectedNetwork}", appNetwork.name)
        //             .replace("{dataNetwork}", network.name),
        //     )
        //     return
        // }
        hideSheet() // hide scan sheet if opened
        val nextRoute = Routes.ExternalConnection(data.url)
        mainScreenEffect(MainScreenEffect.Navigate(nextRoute))
    }

    private fun onScanGift(code: String, amount: ULong) {
        hideSheet() // hide scan sheet if opened
        showSheet(Sheet.Gift(code = code, amount = amount))
    }

    private suspend fun handleQuickPayIfApplicable(
        amountSats: ULong,
        lnurlPay: LnurlPayData? = null,
        invoice: LightningInvoice? = null,
    ): Boolean {
        val settings = settingsStore.data.first()
        if (!settings.isQuickPayEnabled || amountSats == 0uL) {
            return false
        }

        val quickPayAmountSats = currencyRepo.convertFiatToSats(settings.quickPayAmount.toDouble(), "USD").getOrNull()
            ?: return false

        if (amountSats <= quickPayAmountSats) {
            Logger.info("Using QuickPay: $amountSats sats <= $quickPayAmountSats sats threshold", context = TAG)

            val quickPayData: QuickPayData = when {
                lnurlPay != null -> {
                    QuickPayData.LnurlPay(
                        sats = amountSats,
                        callback = lnurlPay.callback,
                        amountMsats = lnurlPay.callbackAmountMsats(amountSats),
                    )
                }

                else -> {
                    val decodedInvoice = requireNotNull(invoice)
                    QuickPayData.Bolt11(sats = amountSats, bolt11 = decodedInvoice.bolt11)
                }
            }

            _quickPayData.update { quickPayData }

            Logger.debug("QuickPayData: $quickPayData", context = TAG)

            if (isMainScanner) {
                showSheet(Sheet.Send(SendRoute.QuickPay))
            } else {
                setSendEffect(SendEffect.NavigateToQuickPay)
            }
            return true
        }

        return false
    }

    private fun resetAmountInput() {
        _sendUiState.update { state ->
            state.copy(
                amount = 0u,
                isAmountInputValid = false,
            )
        }
    }

    private fun onSwipeToPay() {
        Logger.debug("Swipe to pay event, checking send confirmation conditions", context = TAG)
        viewModelScope.launch {
            val amount = _sendUiState.value.amount

            handleSanityChecks(amount)
            if (_sendUiState.value.showSanityWarningDialog != null) return@launch // await for dialog UI interaction

            _sendUiState.update { it.copy(shouldConfirmPay = true) }
        }
    }

    @Suppress("LongMethod", "CyclomaticComplexMethod", "ReturnCount")
    private suspend fun handleSanityChecks(amountSats: ULong) {
        if (_sendUiState.value.showSanityWarningDialog != null) return

        val settings = settingsStore.data.first()
        val balanceToCheck = when (_sendUiState.value.payMethod) {
            SendMethod.ONCHAIN -> walletRepo.balanceState.value.maxSendOnchainSats
            SendMethod.LIGHTNING -> walletRepo.balanceState.value.maxSendLightningSats
        }
        if (
            amountSats > BigDecimal.valueOf(balanceToCheck.toLong())
                .times(BigDecimal(MAX_BALANCE_FRACTION)).toLong().toUInt() &&
            SanityWarning.OVER_HALF_BALANCE !in _sendUiState.value.confirmedWarnings
        ) {
            _sendUiState.update {
                it.copy(showSanityWarningDialog = SanityWarning.OVER_HALF_BALANCE)
            }
            return
        }

        val amountInUsd = currencyRepo.convertSatsToFiat(amountSats.toLong(), "USD").getOrNull() ?: return
        if (
            amountInUsd.value > BigDecimal(SEND_AMOUNT_WARNING_THRESHOLD) &&
            settings.enableSendAmountWarning &&
            SanityWarning.VALUE_OVER_100_USD !in _sendUiState.value.confirmedWarnings
        ) {
            _sendUiState.update {
                it.copy(showSanityWarningDialog = SanityWarning.VALUE_OVER_100_USD)
            }
            return
        }

        if (_sendUiState.value.payMethod != SendMethod.ONCHAIN) return

        val totalFee = lightningRepo.calculateTotalFee(
            amountSats = amountSats,
            address = _sendUiState.value.address,
            speed = _sendUiState.value.speed,
            utxosToSpend = _sendUiState.value.selectedUtxos,
        ).getOrNull() ?: return

        if (
            totalFee > BigDecimal.valueOf(
                amountSats.toLong()
            ).times(BigDecimal(MAX_FEE_AMOUNT_RATIO)).toLong().toUInt() &&
            SanityWarning.FEE_OVER_HALF_VALUE !in _sendUiState.value.confirmedWarnings
        ) {
            _sendUiState.update {
                it.copy(showSanityWarningDialog = SanityWarning.FEE_OVER_HALF_VALUE)
            }
            return
        }

        val feeInUsd = currencyRepo.convertSatsToFiat(totalFee.toLong(), "USD").getOrNull() ?: return
        if (
            feeInUsd.value > BigDecimal(TEN_USD) &&
            SanityWarning.FEE_OVER_10_USD !in _sendUiState.value.confirmedWarnings
        ) {
            _sendUiState.update {
                it.copy(showSanityWarningDialog = SanityWarning.FEE_OVER_10_USD)
            }
            return
        }

        _sendUiState.update {
            it.copy(showSanityWarningDialog = null)
        }
    }

    @Suppress("LongMethod")
    private suspend fun proceedWithPayment() {
        delay(SCREEN_TRANSITION_DELAY) // wait for screen transitions when applicable

        val amount = _sendUiState.value.amount

        val lnurl = _sendUiState.value.lnurl
        val isLnurlPay = lnurl is LnurlParams.LnurlPay

        if (isLnurlPay) {
            val amountMsats = lnurl.data.callbackAmountMsats(amount)
            lightningRepo.fetchLnurlInvoice(
                callbackUrl = lnurl.data.callback,
                amountMsats = amountMsats,
                comment = _sendUiState.value.comment.takeIf { it.isNotEmpty() },
            ).onSuccess { invoice ->
                _sendUiState.update {
                    it.copy(decodedInvoice = invoice)
                }
            }.onFailure {
                toast(Exception(context.getString(R.string.wallet__error_lnurl_invoice_fetch)))
                hideSheet()
                return
            }
        }

        when (_sendUiState.value.payMethod) {
            SendMethod.ONCHAIN -> {
                val address = _sendUiState.value.address
                val tags = _sendUiState.value.selectedTags

                sendOnchain(address, amount, tags = tags)
                    .onSuccess { txId ->
                        Logger.info("Onchain send result txid: $txId", context = TAG)
                        onSendSuccess(
                            NewTransactionSheetDetails(
                                type = NewTransactionSheetType.ONCHAIN,
                                direction = NewTransactionSheetDirection.SENT,
                                paymentHashOrTxId = txId,
                                sats = amount.toLong(),
                                isLoadingDetails = true,
                            )
                        )
                        lightningRepo.sync()
                        activityRepo.syncActivities()
                        _successSendUiState.update { it.copy(isLoadingDetails = false) }
                    }.onFailure { e ->
                        Logger.error(msg = "Error sending onchain payment", e = e, context = TAG)
                        toast(
                            type = Toast.ToastType.ERROR,
                            title = context.getString(R.string.wallet__error_sending_title),
                            description = e.message ?: context.getString(R.string.common__error_body)
                        )
                        hideSheet()
                    }
            }

            SendMethod.LIGHTNING -> {
                val decodedInvoice = requireNotNull(_sendUiState.value.decodedInvoice)
                val bolt11 = decodedInvoice.bolt11

                val paymentAmount = if (decodedInvoice.amountSatoshis > 0uL) null else amount
                val displayAmountSats = decodedInvoice.amountSatoshis.takeIf { it > 0uL } ?: amount ?: 0uL

                val tags = _sendUiState.value.selectedTags
                var createdMetadataPaymentId: String? = null

                // Extract payment hash from invoice for pre-activity metadata
                val paymentHash = decodedInvoice.paymentHash.toHex()

                // Create pre-activity metadata before sending
                if (tags.isNotEmpty()) {
                    preActivityMetadataRepo.savePreActivityMetadata(
                        id = paymentHash,
                        paymentHash = paymentHash,
                        address = _sendUiState.value.address,
                        isReceive = false,
                        tags = tags,
                    ).onSuccess {
                        createdMetadataPaymentId = paymentHash
                    }
                }

                sendLightning(bolt11, paymentAmount).onSuccess { actualPaymentHash ->
                    Logger.info("Lightning send result payment hash: $actualPaymentHash", context = TAG)
                    onSendSuccess(
                        NewTransactionSheetDetails(
                            type = NewTransactionSheetType.LIGHTNING,
                            direction = NewTransactionSheetDirection.SENT,
                            paymentHashOrTxId = actualPaymentHash,
                            sats = displayAmountSats.toLong(), // TODO Add fee when available
                        ),
                    )
                }.onFailure {
                    if (it is PaymentPendingException) {
                        Logger.info("Lightning payment pending", context = TAG)
                        pendingPaymentRepo.track(it.paymentHash)
                        setSendEffect(SendEffect.NavigateToPending(it.paymentHash, displayAmountSats.toLong()))
                        return@onFailure
                    }
                    // Delete pre-activity metadata on failure
                    if (createdMetadataPaymentId != null) {
                        preActivityMetadataRepo.deletePreActivityMetadata(createdMetadataPaymentId)
                    }
                    Logger.error("Error sending lightning payment", it, context = TAG)
                    toast(it)
                    hideSheet()
                }
            }
        }
    }

    fun onConfirmWithdraw() {
        _sendUiState.update { it.copy(isLoading = true) }
        viewModelScope.launch {
            val lnurl = _sendUiState.value.lnurl as? LnurlParams.LnurlWithdraw

            if (lnurl == null) {
                setSendEffect(SendEffect.NavigateToWithdrawError)
                return@launch
            }

            val invoice = if (lnurl.data.isFixedAmount()) {
                lightningRepo.createInvoiceMsats(
                    amountMsats = lnurl.data.maxWithdrawable,
                    description = lnurl.data.defaultDescription,
                    expirySeconds = 3600u,
                )
            } else {
                val withdrawAmountSats = _sendUiState.value.amount.coerceAtLeast(
                    msatFloorOf(lnurl.data.minWithdrawable ?: 0u)
                )
                _sendUiState.update { it.copy(amount = withdrawAmountSats) }
                lightningRepo.createInvoice(
                    amountSats = withdrawAmountSats,
                    description = lnurl.data.defaultDescription,
                    expirySeconds = 3600u,
                )
            }.getOrNull()

            if (invoice == null) {
                setSendEffect(SendEffect.NavigateToWithdrawError)
                return@launch
            }

            lightningRepo.requestLnurlWithdraw(
                k1 = lnurl.data.k1,
                callback = lnurl.data.callback,
                paymentRequest = invoice
            ).onSuccess {
                toast(
                    type = Toast.ToastType.SUCCESS,
                    title = context.getString(R.string.other__lnurl_withdr_success_title),
                    description = context.getString(R.string.other__lnurl_withdr_success_msg),
                )
                hideSheet()
                _sendUiState.update { it.copy(isLoading = false) }
                mainScreenEffect(MainScreenEffect.Navigate(Routes.Home))
            }.onFailure {
                _sendUiState.update { it.copy(isLoading = false) }
                setSendEffect(SendEffect.NavigateToWithdrawError)
            }
        }
    }

    fun onClickActivityDetail() {
        val activityType = _transactionSheet.value.type.toActivityFilter()
        val txType = _transactionSheet.value.direction.toTxType()
        val paymentHashOrTxId = _transactionSheet.value.paymentHashOrTxId ?: return
        _transactionSheet.update { it.copy(isLoadingDetails = true) }
        viewModelScope.launch {
            activityRepo.findActivityByPaymentId(
                paymentHashOrTxId = paymentHashOrTxId,
                type = activityType,
                txType = txType,
                retry = true
            ).onSuccess { activity ->
                hideNewTransactionSheet()
                _transactionSheet.update { it.copy(isLoadingDetails = false) }
                val nextRoute = Routes.ActivityDetail(activity.rawId())
                mainScreenEffect(MainScreenEffect.Navigate(nextRoute))
            }.onFailure { e ->
                Logger.error(msg = "Activity not found", context = TAG)
                toast(e)
                _transactionSheet.update { it.copy(isLoadingDetails = false) }
            }
        }
    }

    fun onClickSendDetail() {
        val activityType = _successSendUiState.value.type.toActivityFilter()
        val txType = _successSendUiState.value.direction.toTxType()
        val paymentHashOrTxId = _successSendUiState.value.paymentHashOrTxId ?: return
        _successSendUiState.update { it.copy(isLoadingDetails = true) }
        viewModelScope.launch {
            activityRepo.findActivityByPaymentId(
                paymentHashOrTxId = paymentHashOrTxId,
                type = activityType,
                txType = txType,
                retry = true
            ).onSuccess { activity ->
                hideSheet()
                _successSendUiState.update { it.copy(isLoadingDetails = false) }
                val nextRoute = Routes.ActivityDetail(activity.rawId())
                mainScreenEffect(MainScreenEffect.Navigate(nextRoute))
            }.onFailure { e ->
                Logger.error(msg = "Activity not found", context = TAG)
                toast(e)
                _successSendUiState.update { it.copy(isLoadingDetails = false) }
            }
        }
    }

    private suspend fun sendOnchain(
        address: String,
        amount: ULong,
        tags: List<String> = emptyList(),
    ): Result<Txid> {
        return lightningRepo.sendOnChain(
            address = address,
            sats = amount,
            speed = _sendUiState.value.speed,
            utxosToSpend = _sendUiState.value.selectedUtxos,
            isMaxAmount = _sendUiState.value.payMethod == SendMethod.ONCHAIN &&
                amount == walletRepo.balanceState.value.maxSendOnchainSats,
            tags = tags,
        )
    }

    private suspend fun sendLightning(
        bolt11: String,
        amount: ULong? = null,
    ): Result<PaymentId> {
        return lightningRepo.payInvoice(bolt11 = bolt11, sats = amount).onSuccess { hash ->
            // Wait until matching payment event is received (with timeout for hold invoices)
            val result = lightningRepo.nodeEvents.watchUntil(LightningRepo.SEND_LN_TIMEOUT) {
                when (it) {
                    is Event.PaymentSuccessful if it.paymentHash == hash -> WatchResult.Complete(Result.success(hash))
                    is Event.PaymentFailed if it.paymentHash == hash -> WatchResult.Complete(
                        Result.failure(AppError(it.reason.toUserMessage(context)))
                    )

                    else -> WatchResult.Continue()
                }
            }
            return result ?: Result.failure(PaymentPendingException(hash))
        }
    }

    fun clearClipboardForAutoRead() {
        viewModelScope.launch {
            val isAutoReadClipboardEnabled = settingsStore.data.first().enableAutoReadClipboard
            if (isAutoReadClipboardEnabled) {
                context.setClipboardText("")
            }
        }
    }

    fun resetQuickPay() = _quickPayData.update { null }

    fun navigateToActivity(activityRawId: String) {
        viewModelScope.launch {
            hideSheet()
            mainScreenEffect(MainScreenEffect.Navigate(Routes.ActivityDetail(activityRawId)))
        }
    }

    /** Reselect utxos for current amount & speed then refresh fees using updated utxos */
    private fun refreshOnchainSendIfNeeded() {
        val currentState = _sendUiState.value
        if (currentState.payMethod != SendMethod.ONCHAIN ||
            currentState.amount == 0uL ||
            currentState.address.isEmpty()
        ) {
            return
        }

        // refresh in background
        viewModelScope.launch(bgDispatcher) {
            // preselect utxos for deterministic fee estimation
            if (settingsStore.data.first().coinSelectAuto && currentState.selectedUtxos == null) {
                lightningRepo.getFeeRateForSpeed(currentState.speed, currentState.feeRates)
                    .mapCatching { satsPerVByte ->
                        lightningRepo.determineUtxosToSpend(
                            sats = currentState.amount,
                            satsPerVByte = satsPerVByte,
                        )
                    }
                    .onSuccess { utxos ->
                        _sendUiState.update { it.copy(selectedUtxos = utxos?.toImmutableList()) }
                    }
            }
            refreshFeeEstimates()
        }
    }

    private suspend fun refreshFeeEstimates() = withContext(bgDispatcher) {
        val currentState = _sendUiState.value

        val speeds = listOf(
            TransactionSpeed.Fast,
            TransactionSpeed.Medium,
            TransactionSpeed.Slow,
            when (val speed = currentState.speed) {
                is TransactionSpeed.Custom -> speed
                else -> TransactionSpeed.Custom(0u)
            }
        )

        var currentFee = 0L
        val feesMap = coroutineScope {
            speeds.map { speed ->
                async {
                    val rate = FeeRate.fromSpeed(speed)
                    val fee = if (currentState.feeRates?.getSatsPerVByteFor(speed) != 0u) getFeeEstimate(speed) else 0

                    if (speed == currentState.speed) {
                        currentFee = fee
                    }

                    rate to fee
                }
            }.awaitAll().toMap()
        }

        _sendUiState.update {
            it.copy(
                fees = feesMap.toImmutableMap(),
                fee = if (it.payMethod == SendMethod.ONCHAIN) SendFee.OnChain(currentFee) else it.fee,
            )
        }
    }

    private suspend fun estimateLightningRoutingFeesIfNeeded() {
        val currentState = _sendUiState.value
        if (currentState.payMethod != SendMethod.LIGHTNING) return
        val decodedInvoice = currentState.decodedInvoice ?: return

        val feeResult = if (decodedInvoice.amountSatoshis > 0uL) {
            lightningRepo.estimateRoutingFees(decodedInvoice.bolt11)
        } else {
            lightningRepo.estimateRoutingFeesForAmount(decodedInvoice.bolt11, currentState.amount)
        }

        feeResult.onSuccess { fee ->
            _sendUiState.update {
                it.copy(
                    fee = SendFee.Lightning(fee.toLong()),
                    lastLightningFee = fee.toLong(),
                )
            }
        }
    }

    private suspend fun estimateMaxAmountRoutingFee() {
        val currentState = _sendUiState.value
        if (currentState.payMethod != SendMethod.LIGHTNING) return

        val decodedInvoice = currentState.decodedInvoice ?: return
        val bolt11 = decodedInvoice.bolt11

        val maxSendLightning = walletRepo.balanceState.value.maxSendLightningSats
        if (maxSendLightning == 0uL) {
            _sendUiState.update { it.copy(estimatedRoutingFee = 0uL) }
            return
        }

        val buffer = 2uL
        val amountToEstimate = maxSendLightning.safe() - buffer.safe()

        val feeResult = lightningRepo.estimateRoutingFeesForAmount(
            bolt11 = bolt11,
            amountSats = amountToEstimate
        )

        feeResult.onSuccess { fee ->
            _sendUiState.update {
                it.copy(estimatedRoutingFee = fee + buffer)
            }
        }.onFailure { e ->
            Logger.error("Failed to estimate routing fee for max amount", e, context = TAG)
            _sendUiState.update { it.copy(estimatedRoutingFee = 0uL) }
        }
    }

    private suspend fun getFeeEstimate(speed: TransactionSpeed? = null): Long {
        val currentState = _sendUiState.value
        return lightningRepo.calculateTotalFee(
            amountSats = currentState.amount,
            address = currentState.address,
            speed = speed ?: currentState.speed,
            utxosToSpend = currentState.selectedUtxos,
            feeRates = currentState.feeRates,
        ).getOrDefault(0u).toLong()
    }

    suspend fun resetSendState() {
        addressValidationJob?.cancel()
        val speed = settingsStore.data.first().defaultTransactionSpeed
        val rates = let {
            // Refresh blocktank info to get latest fee rates
            blocktankRepo.refreshInfo()
            blocktankRepo.blocktankState.value.info?.onchain?.feeRates
        }

        _sendUiState.update {
            SendUiState(
                speed = speed,
                feeRates = rates,
            )
        }
    }
    // endregion

    // region TxSheet
    private var _isTransactionSheetEnabled = true

    private val _transactionSheet = MutableStateFlow(NewTransactionSheetDetails.EMPTY)
    val transactionSheet = _transactionSheet.asStateFlow()

    private val _successSendUiState = MutableStateFlow(
        NewTransactionSheetDetails(
            type = NewTransactionSheetType.LIGHTNING,
            direction = NewTransactionSheetDirection.SENT,
        )
    )

    val successSendUiState = _successSendUiState.asStateFlow()

    fun enabledTransactionSheet(enabled: Boolean) {
        _isTransactionSheetEnabled = enabled
    }

    fun showTransactionSheet(
        details: NewTransactionSheetDetails,
    ) = viewModelScope.launch {
        if (backupRepo.isRestoring.value) return@launch

        if (!_isTransactionSheetEnabled) {
            Logger.verbose("NewTransactionSheet blocked by isNewTransactionSheetEnabled=false", context = TAG)
            return@launch
        }

        _transactionSheet.update { details }
    }

    fun hideNewTransactionSheet() {
        _transactionSheet.update { NewTransactionSheetDetails.EMPTY }
    }

    fun consumePaymentReceivedInBackground() = viewModelScope.launch(bgDispatcher) {
        val details = cacheStore.data.first().backgroundReceive ?: return@launch
        cacheStore.clearBackgroundReceive()
        showTransactionSheet(details)
    }
    // endregion

    // region Sheets
    private var scanResultHandler: ((String) -> Unit)? = null

    fun showScannerSheet(onResult: ((String) -> Unit)? = null) {
        scanResultHandler = onResult
        showSheet(Sheet.QrScanner)
    }

    fun onScannerSheetResult(data: String) {
        val handler = scanResultHandler
        scanResultHandler = null
        hideSheet()
        if (handler != null) {
            viewModelScope.launch {
                delay(SCREEN_TRANSITION_DELAY)
                handler(data)
            }
        } else {
            launchScan(source = ScanSource.SCANNER_SHEET, data = data, startDelay = SCREEN_TRANSITION_DELAY)
        }
    }

    fun hideScannerSheet() {
        scanResultHandler = null
        hideSheet()
    }

    fun showSheet(sheetType: Sheet) {
        viewModelScope.launch {
            _currentSheet.value?.let {
                _currentSheet.update { null }
                delay(SCREEN_TRANSITION_DELAY)
            }
            _currentSheet.update { sheetType }
        }
    }

    fun hideSheet() {
        scanResultHandler = null
        when {
            currentSheet.value is Sheet.TimedSheet -> {
                // Only dismiss if manager still has a sheet (user initiated)
                // If manager already cleared it, just update our state
                if (timedSheetManager.currentSheet.value != null) {
                    dismissTimedSheet()
                } else {
                    _currentSheet.update { null }
                }
            }

            else -> _currentSheet.update { null }
        }
    }

    // endregion

    // region Toasts
    private val toastManager = toastManagerProvider(viewModelScope)
    val currentToast: StateFlow<Toast?> = toastManager.currentToast

    fun toast(
        type: Toast.ToastType,
        title: String,
        description: String? = null,
        autoHide: Boolean = true,
        visibilityTime: Long = Toast.VISIBILITY_TIME_DEFAULT,
        testTag: String? = null,
    ) {
        toastManager.enqueue(
            Toast(
                type = type,
                title = title,
                description = description,
                autoHide = autoHide,
                visibilityTime = visibilityTime,
                testTag = testTag,
            )
        )
    }

    fun toast(error: Throwable) {
        toast(
            type = Toast.ToastType.ERROR,
            title = context.getString(R.string.common__error),
            description = error.message ?: context.getString(R.string.common__error_body)
        )
    }

    fun toast(toast: Toast) {
        toast(
            type = toast.type,
            title = toast.title,
            description = toast.description,
            autoHide = toast.autoHide,
            visibilityTime = toast.visibilityTime,
            testTag = toast.testTag,
        )
    }

    fun hideToast() = toastManager.dismissCurrentToast()

    fun pauseToast() = toastManager.pauseCurrentToast()

    fun resumeToast() = toastManager.resumeCurrentToast()
    // endregion

    // region security
    private suspend fun resetIsAuthenticatedStateInternal() {
        val settings = settingsStore.data.first()
        val needsAuth = settings.isPinEnabled
        _isAuthenticated.value = !needsAuth
    }

    fun resetIsAuthenticatedState() {
        viewModelScope.launch {
            resetIsAuthenticatedStateInternal()
        }
    }

    fun validatePin(pin: String): Boolean {
        val storedPin = keychain.loadString(Keychain.Key.PIN.name)
        val isValid = storedPin == pin

        if (isValid) {
            viewModelScope.launch {
                keychain.upsertString(Keychain.Key.PIN_ATTEMPTS_REMAINING.name, Env.PIN_ATTEMPTS.toString())
            }
            return true
        }

        viewModelScope.launch(bgDispatcher) {
            val newAttempts = pinAttemptsRemaining.value - 1
            keychain.upsertString(Keychain.Key.PIN_ATTEMPTS_REMAINING.name, newAttempts.toString())

            if (newAttempts <= 0) {
                toast(
                    type = Toast.ToastType.SUCCESS,
                    title = context.getString(R.string.security__wiped_title),
                    description = context.getString(R.string.security__wiped_message),
                )
                delay(250) // small delay for UI feedback
                mainScreenEffect(MainScreenEffect.WipeWallet)
            }
        }
        return false
    }

    fun addPin(pin: String) {
        viewModelScope.launch {
            settingsStore.addDismissedSuggestion(Suggestion.SECURE)
        }
        editPin(pin)
    }

    fun editPin(newPin: String) {
        viewModelScope.launch(bgDispatcher) {
            settingsStore.update { it.copy(isPinEnabled = true) }
            keychain.upsertString(Keychain.Key.PIN.name, newPin)
            keychain.upsertString(Keychain.Key.PIN_ATTEMPTS_REMAINING.name, Env.PIN_ATTEMPTS.toString())
        }
    }

    fun removePin() {
        viewModelScope.launch(bgDispatcher) {
            settingsStore.update {
                it.resetPin()
            }
            keychain.delete(Keychain.Key.PIN.name)
            keychain.upsertString(Keychain.Key.PIN_ATTEMPTS_REMAINING.name, Env.PIN_ATTEMPTS.toString())
        }
    }
    // endregion

    suspend fun canDecodeClipboard(text: String): Boolean = withContext(bgDispatcher) {
        runCatching { coreService.decode(text) }.isSuccess
    }

    fun onClipboardAutoRead(data: String) {
        viewModelScope.launch {
            mainScreenEffect(MainScreenEffect.ProcessClipboardAutoRead(data))
        }
    }

    private fun onConfirmAmountWarning(warning: SanityWarning) {
        viewModelScope.launch {
            _sendUiState.update {
                it.copy(
                    showSanityWarningDialog = null,
                    confirmedWarnings = (it.confirmedWarnings + warning).toImmutableList()
                )
            }
        }
        onSwipeToPay()
    }

    private fun onDismissAmountWarning() {
        _sendUiState.update {
            it.copy(showSanityWarningDialog = null)
        }
    }

    private fun onConfirmPay() {
        Logger.debug("Payment checks confirmed, proceeding…", context = TAG)
        viewModelScope.launch {
            _sendUiState.update { it.copy(shouldConfirmPay = false) }
            proceedWithPayment()
        }
    }

    fun onSendSuccess(details: NewTransactionSheetDetails) {
        details.paymentHashOrTxId?.let {
            if (!processedPayments.add(it)) {
                Logger.debug("Payment $it already processed, skipping duplicate", context = TAG)
                return
            }
        }

        _successSendUiState.update { details }
        setSendEffect(SendEffect.PaymentSuccess)
    }

    fun handleDeeplinkIntent(intent: Intent) {
        intent.data?.let { uri ->
            Logger.debug("Received deeplink: $uri")
            processDeeplink(uri)
        }
    }

    private fun processDeeplink(uri: Uri) = viewModelScope.launch {
        if (uri.toString().contains("recovery-mode")) {
            lightningRepo.setRecoveryMode(enabled = true)
            delay(SCREEN_TRANSITION_DELAY)
            mainScreenEffect(
                MainScreenEffect.Navigate(
                    route = Routes.RecoveryMode,
                    clearStack = true,
                )
            )
            return@launch
        }

        if (!walletRepo.walletExists()) return@launch

        launchScan(source = ScanSource.DEEPLINK, data = uri.toString(), startDelay = SCREEN_TRANSITION_DELAY)
    }

    // TODO Temporary fix while these schemes can't be decoded https://github.com/synonymdev/bitkit-core/issues/70
    private fun String.removeLightningSchemes(): String = LIGHTNING_SCHEME_PATTERNS.fold(this) { acc, regex ->
        acc.replace(regex, "")
    }

    fun checkTimedSheets() = timedSheetManager.onHomeScreenEntered()

    fun onLeftHome() = timedSheetManager.onHomeScreenExited()

    fun dismissTimedSheet() = timedSheetManager.dismissCurrentSheet()

    private suspend fun checkCriticalAppUpdate() = withContext(bgDispatcher) {
        if (Env.isDebug) return@withContext

        delay(SCREEN_TRANSITION_DELAY)

        runCatching {
            val androidReleaseInfo = appUpdaterService.getReleaseInfo().platforms.android
            val currentBuildNumber = BuildConfig.VERSION_CODE

            if (androidReleaseInfo.buildNumber <= currentBuildNumber) return@withContext

            if (androidReleaseInfo.isCritical) {
                mainScreenEffect(
                    MainScreenEffect.Navigate(
                        route = Routes.CriticalUpdate,
                        clearStack = true,
                    )
                )
            }
        }.onFailure { e ->
            Logger.warn("Failure fetching new releases", e = e, context = TAG)
        }
    }

    private enum class ScanSource(val label: String) {
        PASTE("paste"),
        SCAN_RESULT("scan result"),
        SCANNER_SHEET("scanner sheet"),
        ADDRESS_CONTINUE("address continue"),
        DEEPLINK("deeplink"),
    }

    companion object {
        private const val TAG = "AppViewModel"
        private val LIGHTNING_SCHEME_PATTERNS = listOf("lightning", "lnurl", "lnurlw", "lnurlc", "lnurlp")
            .map { Regex("^$it:", RegexOption.IGNORE_CASE) }
        private const val SEND_AMOUNT_WARNING_THRESHOLD = 100.0
        private const val TEN_USD = 10
        private const val MAX_BALANCE_FRACTION = 0.5
        private const val MAX_FEE_AMOUNT_RATIO = 0.5
        private val SCREEN_TRANSITION_DELAY = TRANSITION_SCREEN_MS.milliseconds
        private const val MIGRATION_LOADING_TIMEOUT_MS = 120_000L
        private const val POST_RESTORE_PRUNE_DELAY_MS = 30_000L
        private const val MIGRATION_AUTH_RESET_DELAY_MS = 500L
        private const val REMOTE_RESTORE_NODE_RESTART_DELAY_MS = 500L
        private const val AUTH_CHECK_INITIAL_DELAY_MS = 1000L
        private const val AUTH_CHECK_SPLASH_DELAY_MS = 500L
        private const val ADDRESS_VALIDATION_DEBOUNCE_MS = 1000L
    }
}

// region send contract
@Stable
data class SendUiState(
    val address: String = "",
    val bolt11: String? = null,
    val addressInput: String = "",
    val isAddressInputValid: Boolean = false,
    val amount: ULong = 0u,
    val isAmountInputValid: Boolean = false,
    val isUnified: Boolean = false,
    val canSwitchWallet: Boolean = false,
    val payMethod: SendMethod = SendMethod.ONCHAIN,
    val selectedTags: ImmutableList<String> = persistentListOf(),
    val decodedInvoice: LightningInvoice? = null,
    val showSanityWarningDialog: SanityWarning? = null,
    val confirmedWarnings: ImmutableList<SanityWarning> = persistentListOf(),
    val shouldConfirmPay: Boolean = false,
    val selectedUtxos: ImmutableList<SpendableUtxo>? = null,
    val lnurl: LnurlParams? = null,
    val isLoading: Boolean = false,
    val speed: TransactionSpeed = TransactionSpeed.default(),
    val comment: String = "",
    val feeRates: FeeRates? = null,
    val fee: SendFee? = null,
    val fees: ImmutableMap<FeeRate, Long> = persistentMapOf(),
    val estimatedRoutingFee: ULong = 0uL,
    val lastLightningFee: Long = 0L,
)

enum class SanityWarning(@StringRes val message: Int, val testTag: String) {
    VALUE_OVER_100_USD(R.string.wallet__send_dialog1, "SendDialog1"),
    OVER_HALF_BALANCE(R.string.wallet__send_dialog2, "SendDialog2"),
    FEE_OVER_HALF_VALUE(R.string.wallet__send_dialog3, "SendDialog3"),
    FEE_OVER_10_USD(R.string.wallet__send_dialog4, "SendDialog4"),
    // TODO SendDialog5 https://github.com/synonymdev/bitkit/blob/master/src/screens/Wallets/Send/ReviewAndSend.tsx#L457-L466
}

sealed class SendFee(open val value: Long) {
    data class OnChain(override val value: Long) : SendFee(value)
    data class Lightning(override val value: Long) : SendFee(value)
}

enum class SendMethod { ONCHAIN, LIGHTNING }

sealed class SendEffect {
    data class PopBack(val route: SendRoute) : SendEffect()
    data object NavigateToAddress : SendEffect()
    data object NavigateToAmount : SendEffect()
    data object NavigateToScan : SendEffect()
    data object NavigateToConfirm : SendEffect()
    data object NavigateToWithdrawConfirm : SendEffect()
    data object NavigateToWithdrawError : SendEffect()
    data object NavigateToCoinSelection : SendEffect()
    data object NavigateToQuickPay : SendEffect()
    data object NavigateToFee : SendEffect()
    data object NavigateToFeeCustom : SendEffect()
    data object NavigateToComingSoon : SendEffect()
    data object PaymentSuccess : SendEffect()
    data class NavigateToPending(val paymentHash: String, val amount: Long) : SendEffect()
}

sealed class MainScreenEffect {
    data class Navigate(
        val route: Routes,
        val clearStack: Boolean = false,
    ) : MainScreenEffect()

    data object WipeWallet : MainScreenEffect()
    data class ProcessClipboardAutoRead(val data: String) : MainScreenEffect()
}

sealed interface SendEvent {
    data object EnterManually : SendEvent
    data object Paste : SendEvent
    data object Scan : SendEvent

    data object AddressReset : SendEvent
    data class AddressChange(val value: String) : SendEvent
    data class AddressContinue(val data: String) : SendEvent

    data object AmountReset : SendEvent
    data object AmountContinue : SendEvent
    data class AmountChange(val amount: ULong) : SendEvent

    data class CoinSelectionContinue(val utxos: List<SpendableUtxo>) : SendEvent

    data class CommentChange(val value: String) : SendEvent

    data object SwipeToPay : SendEvent
    data object SpeedAndFee : SendEvent
    data object PaymentMethodSwitch : SendEvent
    data class ConfirmAmountWarning(val warning: SanityWarning) : SendEvent
    data object EstimateMaxRoutingFee : SendEvent
    data object DismissAmountWarning : SendEvent
    data object PayConfirmed : SendEvent
    data object ClearPayConfirmation : SendEvent
    data object BackToAmount : SendEvent
    data object NavToAddress : SendEvent
    data object Contacts : SendEvent
}

sealed interface LnurlParams {
    data class LnurlPay(val data: LnurlPayData) : LnurlParams
    data class LnurlWithdraw(val data: LnurlWithdrawData) : LnurlParams
}

@Stable
sealed interface QuickPayData {
    val sats: ULong

    @Stable
    data class Bolt11(override val sats: ULong, val bolt11: String) : QuickPayData

    @Stable
    data class LnurlPay(override val sats: ULong, val callback: String, val amountMsats: ULong) : QuickPayData
}
// endregion