AppViewModel.swift

import BitkitCore
import Combine
import LDKNode
import SwiftUI

/// Published when a payment shown on the pending screen succeeds or fails.
/// SendPendingScreen observes this and navigates accordingly.
struct SendSheetPendingResolution: Equatable {
    let paymentHash: String
    let success: Bool
}

struct ContactPaymentContext: Equatable {
    let publicKey: String
}

enum ManualEntryValidationResult: Equatable {
    case valid
    case empty
    case invalid
    case insufficientSavings
    case insufficientSpending
    case expiredLightningOnly
}

@MainActor
class AppViewModel: ObservableObject {
    // Send flow
    @Published var scannedLightningInvoice: LightningInvoice?
    @Published var scannedOnchainInvoice: OnChainInvoice?
    @Published var selectedWalletToPayFrom: WalletType = .onchain
    @Published var manualEntryInput: String = ""
    @Published var isManualEntryInputValid: Bool = false
    @Published var manualEntryValidationResult: ManualEntryValidationResult = .empty
    @Published var contactPaymentContext: ContactPaymentContext?

    // LNURL
    @Published var lnurlPayData: LnurlPayData?
    @Published var lnurlWithdrawData: LnurlWithdrawData?

    // Onboarding
    @AppStorage("hasDismissedWidgetsOnboardingHint") var hasDismissedWidgetsOnboardingHint: Bool = false
    @AppStorage("hasSeenContactsIntro") var hasSeenContactsIntro: Bool = false
    @AppStorage("hasSeenProfileIntro") var hasSeenProfileIntro: Bool = false
    @AppStorage("hasSeenNotificationsIntro") var hasSeenNotificationsIntro: Bool = false
    @AppStorage("hasSeenQuickpayIntro") var hasSeenQuickpayIntro: Bool = false
    @AppStorage("hasSeenShopIntro") var hasSeenShopIntro: Bool = false
    @AppStorage("hasSeenTransferIntro") var hasSeenTransferIntro: Bool = false
    @AppStorage("hasSeenTransferToSpendingIntro") var hasSeenTransferToSpendingIntro: Bool = false
    @AppStorage("hasSeenTransferToSavingsIntro") var hasSeenTransferToSavingsIntro: Bool = false
    @AppStorage("hasSeenWidgetsIntro") var hasSeenWidgetsIntro: Bool = false

    /// App update tracking
    @AppStorage("appUpdateIgnoreTimestamp") var appUpdateIgnoreTimestamp: TimeInterval = 0

    // Backup warning tracking
    @AppStorage("backupVerified") var backupVerified: Bool = false
    @AppStorage("backupIgnoreTimestamp") var backupIgnoreTimestamp: TimeInterval = 0

    // High balance warning tracking
    @AppStorage("highBalanceIgnoreCount") var highBalanceIgnoreCount: Int = 0
    @AppStorage("highBalanceIgnoreTimestamp") var highBalanceIgnoreTimestamp: TimeInterval = 0

    /// Drawer menu
    @Published var showDrawer = false

    /// Payment hashes for which we navigated to the pending screen.
    /// When payment succeeds/fails, we show toast and publish resolution so SendPendingScreen can navigate.
    private var pendingPaymentHashes: Set<String> = []
    private var pendingContactPaymentContexts: [String: ContactPaymentContext] = [:]

    /// When a payment that was shown on the pending screen succeeds or fails, this is set so SendPendingScreen can navigate.
    /// Consumed by SendPendingScreen via consumeSendSheetPendingResolution.
    @Published var sendSheetPendingResolution: SendSheetPendingResolution?

    /// App status init - shows "ready" until node is actually running
    /// This prevents flashing error status during startup/background transitions
    @Published var appStatusInit: Bool = false

    /// Called when node reaches running state
    func markAppStatusInit() {
        appStatusInit = true
    }

    /// Called when app goes to background to reset the status facade
    func resetAppStatusInit() {
        appStatusInit = false
    }

    private let lightningService: LightningService
    private let coreService: CoreService
    private let sheetViewModel: SheetViewModel
    private let navigationViewModel: NavigationViewModel
    private var manualEntryValidationSequence: UInt64 = 0

    // Combine infrastructure for debounced validation
    private var manualEntryValidationCancellable: AnyCancellable?
    private let manualEntryValidationSubject = PassthroughSubject<(String, Int, Int, UInt64), Never>()

    init(
        lightningService: LightningService = .shared,
        coreService: CoreService = .shared,
        sheetViewModel: SheetViewModel,
        navigationViewModel: NavigationViewModel
    ) {
        self.lightningService = lightningService
        self.coreService = coreService
        self.sheetViewModel = sheetViewModel
        self.navigationViewModel = navigationViewModel

        setupManualEntryValidationDebounce()

        Task {
            await checkGeoStatus()
            // Check for app updates on startup
            await AppUpdateService.shared.checkForAppUpdate()
        }
    }

    private func setupManualEntryValidationDebounce() {
        manualEntryValidationCancellable = manualEntryValidationSubject
            .debounce(for: .milliseconds(1000), scheduler: DispatchQueue.main)
            .sink { [weak self] rawValue, savingsBalanceSats, spendingBalanceSats, queuedSequence in
                guard let self else { return }
                // Skip if sequence changed (reset was called or new validation queued)
                guard queuedSequence == manualEntryValidationSequence else { return }
                Task {
                    await self.performValidation(rawValue, savingsBalanceSats: savingsBalanceSats, spendingBalanceSats: spendingBalanceSats)
                }
            }
    }

    /// Shows insufficient spending balance toast with amount-specific or generic description
    private func showInsufficientSpendingToast(invoiceAmount: UInt64, spendingBalance: UInt64) {
        let amountNeeded = invoiceAmount > spendingBalance ? invoiceAmount - spendingBalance : 0
        let description = amountNeeded > 0
            ? t(
                "other__pay_insufficient_spending_amount_description",
                variables: ["amount": CurrencyFormatter.formatSats(amountNeeded)]
            )
            : t("other__pay_insufficient_spending_description")

        toast(
            type: .error,
            title: t("other__pay_insufficient_spending"),
            description: description,
            accessibilityIdentifier: "InsufficientSpendingToast"
        )
    }

    /// Validates onchain balance and shows toast if insufficient. Returns true if sufficient.
    private func validateOnchainBalance(invoiceAmount: UInt64, onchainBalance: UInt64) -> Bool {
        if invoiceAmount > 0 {
            guard onchainBalance >= invoiceAmount else {
                let amountNeeded = invoiceAmount - onchainBalance
                toast(
                    type: .error,
                    title: t("other__pay_insufficient_savings"),
                    description: t(
                        "other__pay_insufficient_savings_amount_description",
                        variables: ["amount": CurrencyFormatter.formatSats(amountNeeded)]
                    ),
                    accessibilityIdentifier: "InsufficientSavingsToast"
                )
                return false
            }
        } else {
            // Zero-amount invoice: user must have some balance to proceed
            guard onchainBalance > 0 else {
                toast(
                    type: .error,
                    title: t("other__pay_insufficient_savings"),
                    description: t("other__pay_insufficient_savings_description"),
                    accessibilityIdentifier: "InsufficientSavingsToast"
                )
                return false
            }
        }
        return true
    }

    private func showValidationErrorToast(for result: ManualEntryValidationResult) {
        switch result {
        case .invalid:
            toast(
                type: .error,
                title: t("other__scan_err_decoding"),
                description: t("other__scan__error__generic"),
                accessibilityIdentifier: "InvalidAddressToast"
            )
        case .insufficientSavings:
            toast(
                type: .error,
                title: t("other__pay_insufficient_savings"),
                description: t("other__pay_insufficient_savings_description"),
                accessibilityIdentifier: "InsufficientSavingsToast"
            )
        case .insufficientSpending:
            toast(
                type: .error,
                title: t("other__pay_insufficient_spending"),
                description: t("other__pay_insufficient_savings_description"),
                accessibilityIdentifier: "InsufficientSpendingToast"
            )
        case .expiredLightningOnly:
            toast(
                type: .error,
                title: t("other__scan_err_decoding"),
                description: t("other__scan__error__expired"),
                accessibilityIdentifier: "ExpiredLightningToast"
            )
        case .valid, .empty:
            break
        }
    }

    /// Convenience initializer for previews and testing
    convenience init() {
        self.init(sheetViewModel: SheetViewModel(), navigationViewModel: NavigationViewModel())
    }

    deinit {}

    func checkGeoStatus() async {
        // Delegate to GeoService singleton for centralized geo-blocking management
        await GeoService.shared.checkGeoStatus()
    }

    func wipe() async throws {
        hasSeenContactsIntro = false
        hasSeenProfileIntro = false
        hasSeenNotificationsIntro = false
        hasSeenQuickpayIntro = false
        hasSeenShopIntro = false
        hasSeenTransferToSpendingIntro = false
        hasSeenTransferToSavingsIntro = false
        hasSeenWidgetsIntro = false
        hasDismissedWidgetsOnboardingHint = false
        appUpdateIgnoreTimestamp = 0
        backupVerified = false
        backupIgnoreTimestamp = 0
        highBalanceIgnoreCount = 0
        highBalanceIgnoreTimestamp = 0
    }
}

// MARK: Toast notifications

extension AppViewModel {
    func toast(
        type: Toast.ToastType,
        title: String,
        description: String? = nil,
        autoHide: Bool = true,
        visibilityTime: Double = 4.0,
        accessibilityIdentifier: String? = nil
    ) {
        switch type {
        case .error:
            Haptics.notify(.error)
        case .success:
            Haptics.notify(.success)
        case .info:
            Haptics.play(.heavy)
        case .lightning:
            Haptics.play(.rigid)
        case .warning:
            Haptics.notify(.warning)
        }

        let toast = Toast(
            type: type,
            title: title,
            description: description,
            autoHide: autoHide,
            visibilityTime: visibilityTime,
            accessibilityIdentifier: accessibilityIdentifier
        )
        ToastWindowManager.shared.showToast(toast)
    }

    func toast(_ error: Error) {
        if error is CancellationError {
            return
        }
        toast(type: .error, title: "Error", description: error.localizedDescription)
    }

    func hideToast() {
        ToastWindowManager.shared.hideToast()
    }
}

// MARK: Pending payment tracking

extension AppViewModel {
    func addPendingPaymentHash(_ hash: String, contactPublicKey: String? = nil) {
        pendingPaymentHashes.insert(hash)

        if let contactPublicKey {
            pendingContactPaymentContexts[hash] = ContactPaymentContext(publicKey: contactPublicKey)
        }
    }

    func addPendingContactPaymentContext(_ hash: String, contactPublicKey: String?) {
        guard let contactPublicKey else { return }
        pendingContactPaymentContexts[hash] = ContactPaymentContext(publicKey: contactPublicKey)
    }

    func contactPaymentContext(forPendingPaymentHash hash: String) -> ContactPaymentContext? {
        pendingContactPaymentContexts[hash]
    }

    func consumeContactPaymentContext(forPendingPaymentHash hash: String) {
        pendingContactPaymentContexts.removeValue(forKey: hash)
    }

    /// Called by SendPendingScreen when it consumes a resolution. Clears the published value.
    func consumeSendSheetPendingResolution(paymentHash hash: String) {
        guard sendSheetPendingResolution?.paymentHash == hash else { return }
        sendSheetPendingResolution = nil
    }
}

// MARK: Scanning/pasting handling

extension AppViewModel {
    func handleScannedData(_ uri: String) async throws {
        // Reset send state before handling new data
        resetSendState()

        // Workaround for duplicated BIP21 URIs (bitkit-core#63)
        if Bip21Utils.isDuplicatedBip21(uri) {
            toast(
                type: .error,
                title: t("other__scan_err_decoding"),
                description: t("other__scan__error__generic"),
                accessibilityIdentifier: "InvalidAddressToast"
            )
            return
        }

        let data = try await decode(invoice: uri)

        switch data {
        // BIP21 (Unified) invoice handling
        case let .onChain(invoice):
            // Check network first - treat wrong network as decoding error
            let addressValidation = try? validateBitcoinAddress(address: invoice.address)
            let addressNetwork: LDKNode.Network? = addressValidation.map { NetworkValidationHelper.convertNetworkType($0.network) }
            if NetworkValidationHelper.isNetworkMismatch(addressNetwork: addressNetwork, currentNetwork: Env.network) {
                toast(
                    type: .error,
                    title: t("other__scan_err_decoding"),
                    description: t("other__scan__error__generic"),
                    accessibilityIdentifier: "InvalidAddressToast"
                )
                return
            }

            if let lnInvoice = invoice.params?["lightning"] {
                // Lightning invoice param found, prefer lightning payment if invoice is valid
                if case let .lightning(lightningInvoice) = try await decode(invoice: lnInvoice) {
                    // Check lightning invoice network
                    let lnNetwork = NetworkValidationHelper.convertNetworkType(lightningInvoice.networkType)
                    let lnNetworkMatch = !NetworkValidationHelper.isNetworkMismatch(addressNetwork: lnNetwork, currentNetwork: Env.network)

                    if lnNetworkMatch, !lightningInvoice.isExpired {
                        let nodeIsRunning = lightningService.status?.isRunning == true

                        if nodeIsRunning {
                            // Node is running → we have fresh balances; validate immediately.
                            // Prefer lightning; if insufficient or no channels/capacity, fall back to onchain.
                            let canSendLightning = lightningService.canSend(amountSats: lightningInvoice.amountSatoshis)

                            if canSendLightning {
                                handleScannedLightningInvoice(lightningInvoice, bolt11: lnInvoice, onchainInvoice: invoice)
                                return
                            }

                            // Lightning insufficient for any reason (no channels, no capacity, etc).
                            // Fall back to onchain and validate onchain balance immediately.
                            let onchainBalance = lightningService.balances?.spendableOnchainBalanceSats ?? 0
                            guard validateOnchainBalance(invoiceAmount: invoice.amountSatoshis, onchainBalance: onchainBalance) else {
                                return
                            }

                            // Onchain is sufficient → proceed with onchain flow, do not open lightning flow.
                            handleScannedOnchainInvoice(invoice)
                            return
                        }

                        // Node not running: proceed with lightning; validation/fallback will happen in SendSheet after sync.
                        handleScannedLightningInvoice(lightningInvoice, bolt11: lnInvoice, onchainInvoice: invoice)
                        return
                    }

                    // If Lightning is expired or wrong network, fall back to on-chain silently (no toast)
                }
            }

            // Fallback to on-chain if address is available
            guard !invoice.address.isEmpty else { return }

            // If node is running, validate balance immediately
            if lightningService.status?.isRunning == true {
                let onchainBalance = lightningService.balances?.spendableOnchainBalanceSats ?? 0
                guard validateOnchainBalance(invoiceAmount: invoice.amountSatoshis, onchainBalance: onchainBalance) else {
                    return
                }
            }

            handleScannedOnchainInvoice(invoice)
        case let .lightning(invoice):
            // Check network first - treat wrong network as decoding error
            let invoiceNetwork = NetworkValidationHelper.convertNetworkType(invoice.networkType)
            if NetworkValidationHelper.isNetworkMismatch(addressNetwork: invoiceNetwork, currentNetwork: Env.network) {
                toast(
                    type: .error,
                    title: t("other__scan_err_decoding"),
                    description: t("other__scan__error__generic"),
                    accessibilityIdentifier: "InvalidAddressToast"
                )
                return
            }

            guard !invoice.isExpired else {
                toast(
                    type: .error,
                    title: t("other__scan_err_decoding"),
                    description: t("other__scan__error__expired"),
                    accessibilityIdentifier: "ExpiredLightningToast"
                )
                return
            }

            // If node is running, we can check for channels and validate immediately
            if lightningService.status?.isRunning == true {
                // If user has no channels at all, they can never pay a pure lightning invoice.
                // Show insufficient spending toast and do not navigate to the send flow.
                let hasAnyChannels = (lightningService.channels?.isEmpty == false)
                if !hasAnyChannels {
                    let spendingBalance = lightningService.balances?.totalLightningBalanceSats ?? 0
                    showInsufficientSpendingToast(invoiceAmount: invoice.amountSatoshis, spendingBalance: spendingBalance)
                    return
                }

                // If channels are usable, validate capacity immediately
                if let channels = lightningService.channels, channels.contains(where: \.isUsable) {
                    guard lightningService.canSend(amountSats: invoice.amountSatoshis) else {
                        let spendingBalance = lightningService.balances?.totalLightningBalanceSats ?? 0
                        showInsufficientSpendingToast(invoiceAmount: invoice.amountSatoshis, spendingBalance: spendingBalance)
                        return
                    }
                }
            }

            // Proceed with lightning payment (validation will happen in SendSheet if node not ready)
            handleScannedLightningInvoice(invoice, bolt11: uri)
        case let .lnurlPay(data: lnurlPayData):
            Logger.debug("LNURL: \(lnurlPayData)")
            handleLnurlPayInvoice(lnurlPayData)
        case let .lnurlWithdraw(data: lnurlWithdrawData):
            Logger.debug("LNURL: \(lnurlWithdrawData)")
            handleLnurlWithdraw(lnurlWithdrawData)
        case let .lnurlChannel(data: lnurlChannelData):
            Logger.debug("LNURL: \(lnurlChannelData)")
            handleLnurlChannel(lnurlChannelData)
        case let .lnurlAuth(data: lnurlAuthData):
            Logger.debug("LNURL: \(lnurlAuthData)")
            handleLnurlAuth(lnurlAuthData, lnurl: uri)
        case let .nodeId(url, _):
            guard lightningService.status?.isRunning == true else {
                toast(type: .error, title: "Lightning not running", description: "Please try again later.")
                return
            }

            handleNodeUri(url)
        case let .pubkyAuth(data: authUrl):
            handlePubkyAuthApproval(authUrl)
        case let .gift(code, amount):
            sheetViewModel.showSheet(.gift, data: GiftConfig(code: code, amount: Int(amount)))
        default:
            Logger.warn("Unhandled invoice type: \(data)")
            toast(type: .error, title: "Unsupported", description: "This type of invoice is not supported yet")
        }
    }

    private func handleScannedLightningInvoice(_ invoice: LightningInvoice, bolt11: String, onchainInvoice: OnChainInvoice? = nil) {
        scannedLightningInvoice = invoice
        scannedOnchainInvoice = onchainInvoice // Keep onchain invoice if provided
        selectedWalletToPayFrom = .lightning

        if invoice.amountSatoshis > 0 {
            Logger.debug("Found amount in invoice, proceeding with payment")
        } else {
            Logger.debug("No amount found in invoice, proceeding entering amount manually")
        }
    }

    private func handleScannedOnchainInvoice(_ invoice: OnChainInvoice) {
        selectedWalletToPayFrom = .onchain
        scannedOnchainInvoice = invoice
        scannedLightningInvoice = nil
    }

    private func handleLnurlPayInvoice(_ data: LnurlPayData) {
        guard lightningService.status?.isRunning == true else {
            toast(type: .error, title: "Lightning not running", description: "Please try again later.")
            return
        }

        let lightningBalance = lightningService.balances?.totalLightningBalanceSats ?? 0
        if lightningBalance < max(1, data.minSendableSat) {
            toast(
                type: .warning,
                title: t("other__lnurl_pay_error"),
                description: t("other__lnurl_pay_error_no_capacity")
            )
            return
        }

        selectedWalletToPayFrom = .lightning
        lnurlPayData = data
    }

    private func handleLnurlWithdraw(_ data: LnurlWithdrawData) {
        guard lightningService.status?.isRunning == true else {
            toast(type: .error, title: "Lightning not running", description: "Please try again later.")
            return
        }

        if (data.minWithdrawable ?? 0) > data.maxWithdrawable {
            toast(
                type: .warning,
                title: t("other__lnurl_withdr_error"),
                description: t("other__lnurl_withdr_error_minmax")
            )
            return
        }

        let lightningBalance = lightningService.balances?.totalLightningBalanceSats ?? 0
        if lightningBalance < max(1, data.minWithdrawableSat) {
            toast(
                type: .warning,
                title: t("other__lnurl_withdr_error"),
                description: t("other__lnurl_withdr_error_no_capacity")
            )
            return
        }

        lnurlWithdrawData = data
    }

    private func handleLnurlChannel(_ data: LnurlChannelData) {
        // Check if lightning service is running
        guard lightningService.status?.isRunning == true else {
            toast(type: .error, title: "Lightning not running", description: "Please try again later.")
            return
        }

        sheetViewModel.hideSheet()
        navigationViewModel.navigate(.lnurlChannel(channelData: data))
    }

    private func handleLnurlAuth(_ data: LnurlAuthData, lnurl: String) {
        // Check if lightning service is running
        guard lightningService.status?.isRunning == true else {
            toast(type: .error, title: "Lightning not running", description: "Please try again later.")
            return
        }

        sheetViewModel.showSheet(.lnurlAuth, data: LnurlAuthConfig(lnurl: lnurl, authData: data))
    }

    private func handlePubkyAuthApproval(_ authUrl: String) {
        // State 1: No Pubky identity at all
        guard (try? Keychain.loadString(key: .paykitSession))?.isEmpty == false else {
            toast(type: .warning, title: t("pubky_auth__no_identity"), description: t("pubky_auth__no_identity_desc"))
            return
        }

        // State 2: Ring-authenticated (has session but no local secret key)
        guard let secretKey = try? Keychain.loadString(key: .pubkySecretKey),
              !secretKey.isEmpty
        else {
            toast(type: .info, title: t("pubky_auth__use_ring"), description: t("pubky_auth__use_ring_desc"))
            return
        }

        // State 3: Bitkit-generated identity — can approve
        do {
            let request = try PubkyAuthRequest.parse(url: authUrl)
            sheetViewModel.showSheet(.pubkyAuthApproval, data: PubkyAuthApprovalConfig(authUrl: authUrl, request: request))
        } catch {
            Logger.error("Failed to parse pubky auth URL: \(error)", context: "AppViewModel")
            toast(type: .error, title: t("pubky_auth__invalid_request"))
        }
    }

    private func handleNodeUri(_ url: String) {
        sheetViewModel.hideSheet()
        navigationViewModel.navigate(.fundManual(nodeUri: url))
    }

    func resetSendState() {
        scannedLightningInvoice = nil
        scannedOnchainInvoice = nil
        selectedWalletToPayFrom = .onchain // Reset to default
        lnurlPayData = nil
        lnurlWithdrawData = nil
        contactPaymentContext = nil
    }
}

// MARK: Manual entry validation

extension AppViewModel {
    func normalizeManualEntry(_ value: String) -> String {
        value.filter { !$0.isWhitespace }
    }

    func resetManualEntryInput() {
        manualEntryValidationSequence &+= 1
        manualEntryInput = ""
        isManualEntryInputValid = false
        manualEntryValidationResult = .empty
    }

    /// Queue validation with debounce
    func validateManualEntryInput(_ rawValue: String, savingsBalanceSats: Int, spendingBalanceSats: Int) {
        // Increment sequence first so any pending debounced requests become stale
        manualEntryValidationSequence &+= 1
        let currentSequence = manualEntryValidationSequence

        let normalized = normalizeManualEntry(rawValue)

        // Immediately update state for empty input (no debounce needed)
        guard !normalized.isEmpty else {
            manualEntryValidationResult = .empty
            isManualEntryInputValid = false
            return
        }

        // Queue the validation with debounce, including the sequence to detect stale requests
        manualEntryValidationSubject.send((rawValue, savingsBalanceSats, spendingBalanceSats, currentSequence))
    }

    /// Perform the actual validation
    private func performValidation(_ rawValue: String, savingsBalanceSats: Int, spendingBalanceSats: Int) async {
        let currentSequence = manualEntryValidationSequence

        let normalized = normalizeManualEntry(rawValue)

        guard !normalized.isEmpty else {
            manualEntryValidationResult = .empty
            isManualEntryInputValid = false
            return
        }

        // Workaround for duplicated BIP21 URIs (bitkit-core#63)
        if Bip21Utils.isDuplicatedBip21(normalized) {
            guard currentSequence == manualEntryValidationSequence else { return }
            manualEntryValidationResult = .invalid
            isManualEntryInputValid = false
            showValidationErrorToast(for: .invalid)
            return
        }

        if PubkyPublicKeyFormat.normalized(normalized) != nil {
            guard currentSequence == manualEntryValidationSequence else { return }
            manualEntryValidationResult = .valid
            isManualEntryInputValid = true
            return
        }

        // Try to decode the invoice
        guard let decodedData = try? await decode(invoice: normalized) else {
            guard currentSequence == manualEntryValidationSequence else { return }
            manualEntryValidationResult = .invalid
            isManualEntryInputValid = false
            showValidationErrorToast(for: .invalid)
            return
        }

        guard currentSequence == manualEntryValidationSequence else { return }

        // Determine validation result based on invoice type and balance
        var result: ManualEntryValidationResult = .valid

        switch decodedData {
        case let .lightning(invoice):
            // Priority 0: Check network first - treat wrong network as invalid
            let invoiceNetwork = NetworkValidationHelper.convertNetworkType(invoice.networkType)
            if NetworkValidationHelper.isNetworkMismatch(addressNetwork: invoiceNetwork, currentNetwork: Env.network) {
                result = .invalid
                break
            }

            // Lightning-only invoice: check spending balance and expiry
            let amountSats = invoice.amountSatoshis

            // Priority 1: Insufficient spending balance (only check if amount > 0)
            if amountSats > 0 && spendingBalanceSats < Int(amountSats) {
                result = .insufficientSpending
            } else if invoice.isExpired {
                // Priority 2: Expired invoice (only after balance check passes)
                result = .expiredLightningOnly
            }

        case let .onChain(invoice):
            // Priority 0: Check network first - treat wrong network as invalid
            let addressValidation = try? validateBitcoinAddress(address: invoice.address)
            let addressNetwork: LDKNode.Network? = addressValidation.map { NetworkValidationHelper.convertNetworkType($0.network) }
            if NetworkValidationHelper.isNetworkMismatch(addressNetwork: addressNetwork, currentNetwork: Env.network) {
                result = .invalid
                break
            }

            // BIP21 with potential lightning parameter
            var canPayLightning = false
            if let lnInvoice = invoice.params?["lightning"],
               case let .lightning(lightningInvoice) = try? await decode(invoice: lnInvoice)
            {
                // Check for stale request after async decode
                guard currentSequence == manualEntryValidationSequence else { return }

                // Check lightning invoice network too
                let lnNetwork = NetworkValidationHelper.convertNetworkType(lightningInvoice.networkType)
                let lnNetworkMatch = !NetworkValidationHelper.isNetworkMismatch(addressNetwork: lnNetwork, currentNetwork: Env.network)

                // Has lightning fallback - check if lightning is viable
                canPayLightning = lnNetworkMatch && !lightningInvoice.isExpired &&
                    (lightningInvoice.amountSatoshis == 0 || spendingBalanceSats >= Int(lightningInvoice.amountSatoshis))
            }

            if !canPayLightning {
                // On-chain: check savings balance
                if invoice.amountSatoshis > 0 && savingsBalanceSats < Int(invoice.amountSatoshis) {
                    result = .insufficientSavings
                } else if invoice.amountSatoshis == 0 && savingsBalanceSats == 0 {
                    // Zero-amount invoice: user must have some balance to proceed
                    result = .insufficientSavings
                }
            }

        case .lnurlPay, .lnurlWithdraw, .lnurlChannel, .lnurlAuth, .nodeId, .gift:
            // These types are valid if decoded successfully
            result = .valid

        default:
            result = .invalid
        }

        guard currentSequence == manualEntryValidationSequence else { return }

        manualEntryValidationResult = result
        isManualEntryInputValid = (result == .valid)

        // Show toast for error results
        if result != .valid && result != .empty {
            showValidationErrorToast(for: result)
        }
    }
}

// MARK: LDK Node Events

extension AppViewModel {
    func handleLdkNodeEvent(_ event: Event) {
        switch event {
        case let .paymentReceived(paymentId, _, amountMsat, _):
            Task {
                if let paymentId {
                    if await CoreService.shared.activity.isActivitySeen(id: paymentId) {
                        return
                    }
                    await CoreService.shared.activity.markActivityAsSeen(id: paymentId)
                }

                await MainActor.run {
                    let sats = LightningAmountConversion.satsCeil(fromMsats: amountMsat)
                    sheetViewModel.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .lightning, sats: sats))
                }
            }
        case .channelPending(channelId: _, userChannelId: _, formerTemporaryChannelId: _, counterpartyNodeId: _, fundingTxo: _):
            // Only relevant for channels to external nodes
            break
        case .channelReady(let channelId, userChannelId: _, counterpartyNodeId: _, fundingTxo: _):
            Task {
                // Use channelCache instead of cachedChannels array, as it's updated immediately
                if let channel = await lightningService.getChannelFromCache(channelId: channelId) {
                    let cjitOrder = await CoreService.shared.blocktank.getCjit(channel: channel)
                    if cjitOrder != nil {
                        let amount = channel.balanceOnCloseSats
                        let now = UInt64(Date().timeIntervalSince1970)

                        let ln = LightningActivity(
                            id: channel.fundingTxo?.txid ?? "",
                            txType: .received,
                            status: .succeeded,
                            value: amount,
                            fee: 0,
                            invoice: cjitOrder?.invoice.request ?? "",
                            message: "",
                            timestamp: now,
                            preimage: nil,
                            contact: nil,
                            createdAt: now,
                            updatedAt: nil,
                            seenAt: nil
                        )

                        try await CoreService.shared.activity.insert(.lightning(ln))

                        // Show receivedTx sheet for CJIT payment
                        await MainActor.run {
                            sheetViewModel.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .lightning, sats: amount))
                        }
                    } else if await shouldShowFirstChannelReadyToast() {
                        toast(
                            type: .lightning,
                            title: t("lightning__channel_opened_title"),
                            description: t("lightning__channel_opened_msg"),
                            visibilityTime: 5.0,
                            accessibilityIdentifier: "SpendingBalanceReadyToast"
                        )
                    }
                } else {
                    Logger.warn("Channel not found in cache: \(channelId)")
                    if await shouldShowFirstChannelReadyToast() {
                        toast(
                            type: .lightning,
                            title: t("lightning__channel_opened_title"),
                            description: t("lightning__channel_opened_msg"),
                            visibilityTime: 5.0,
                            accessibilityIdentifier: "SpendingBalanceReadyToast"
                        )
                    }
                }
            }
        case .channelClosed(channelId: _, userChannelId: _, counterpartyNodeId: _, reason: _):
            break
        case let .paymentSuccessful(paymentId, paymentHash, _, _):
            let hash = paymentId ?? paymentHash
            if pendingPaymentHashes.contains(hash) {
                pendingPaymentHashes.remove(hash)
                sendSheetPendingResolution = SendSheetPendingResolution(paymentHash: hash, success: true)
                toast(
                    type: .lightning,
                    title: t("wallet__toast_payment_success_title"),
                    description: t("wallet__toast_payment_success_description"),
                    accessibilityIdentifier: "PaymentSuccessToast"
                )
            }
        case let .paymentFailed(paymentId, paymentHash, _):
            let hash = paymentId ?? paymentHash
            if let hash, pendingPaymentHashes.contains(hash) {
                pendingPaymentHashes.remove(hash)
                sendSheetPendingResolution = SendSheetPendingResolution(paymentHash: hash, success: false)
                toast(
                    type: .error,
                    title: t("wallet__toast_payment_failed_title"),
                    description: t("wallet__toast_payment_failed_description"),
                    accessibilityIdentifier: "PaymentFailedToast"
                )
            }
        case .paymentClaimable:
            break
        case .paymentForwarded:
            break
        case .probeSuccessful(paymentId: _, paymentHash: _):
            break
        case .probeFailed(paymentId: _, paymentHash: _, shortChannelId: _):
            break

        // MARK: New Onchain Transaction Events

        case let .onchainTransactionReceived(txid, details):
            // Show notification for incoming transactions
            if details.amountSats > 0 {
                let sats = UInt64(abs(Int64(details.amountSats)))

                Task {
                    // Show sheet for new transactions or replacements with value changes
                    try? await Task.sleep(nanoseconds: 500_000_000) // 500ms delay

                    if await CoreService.shared.activity.isOnchainActivitySeen(txid: txid) {
                        return
                    }

                    let shouldShow = await CoreService.shared.activity.shouldShowReceivedSheet(txid: txid, value: sats)
                    guard shouldShow else { return }

                    await CoreService.shared.activity.markOnchainActivityAsSeen(txid: txid)

                    await MainActor.run {
                        sheetViewModel.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, sats: sats))
                    }
                }
            }
        case let .onchainTransactionConfirmed(txid, _, blockHeight, _, _):
            Logger.info("Transaction confirmed: \(txid) at block \(blockHeight)")
        case let .onchainTransactionReplaced(txid, conflicts):
            Logger.info("Transaction replaced: \(txid) by \(conflicts.count) conflict(s)")
            Task {
                if await CoreService.shared.activity.isReceivedTransaction(txid: txid) {
                    await MainActor.run {
                        toast(
                            type: .info,
                            title: t("wallet__toast_received_transaction_replaced_title"),
                            description: t("wallet__toast_received_transaction_replaced_description"),
                            accessibilityIdentifier: "ReceivedTransactionReplacedToast"
                        )
                    }
                } else {
                    await MainActor.run {
                        toast(
                            type: .info,
                            title: t("wallet__toast_transaction_replaced_title"),
                            description: t("wallet__toast_transaction_replaced_description"),
                            accessibilityIdentifier: "TransactionReplacedToast"
                        )
                    }
                }
            }
        case let .onchainTransactionReorged(txid):
            Logger.warn("Transaction reorged: \(txid)")
            toast(
                type: .warning,
                title: t("wallet__toast_transaction_unconfirmed_title"),
                description: t("wallet__toast_transaction_unconfirmed_description"),
                accessibilityIdentifier: "TransactionUnconfirmedToast"
            )
        case let .onchainTransactionEvicted(txid):
            Task {
                let wasReplaced = await CoreService.shared.activity.wasTransactionReplaced(txid: txid)

                await MainActor.run {
                    if wasReplaced {
                        Logger.info("Transaction \(txid) was replaced, skipping evicted toast", context: "AppViewModel")
                        return
                    }

                    Logger.warn("Transaction removed from mempool: \(txid)")
                    toast(
                        type: .warning,
                        title: t("wallet__toast_transaction_removed_title"),
                        description: t("wallet__toast_transaction_removed_description"),
                        accessibilityIdentifier: "TransactionRemovedToast"
                    )
                }
            }

        // MARK: Splice Events

        case .splicePending, .spliceFailed:
            break

        // MARK: Sync Events

        case let .syncProgress(syncType, progressPercent, _, _):
            Logger.debug("Sync progress: \(syncType) \(progressPercent)%")
        case let .syncCompleted(syncType, syncedBlockHeight):
            Logger.info("Sync completed: \(syncType) at height \(syncedBlockHeight)")

            // After mnemonic restore, prune empty address types once sync has completed
            if SettingsViewModel.shared.pendingRestoreAddressTypePrune {
                SettingsViewModel.shared.pendingRestoreAddressTypePrune = false
                Task { @MainActor in
                    try? await Task.sleep(nanoseconds: 30 * 1_000_000_000) // 30s delay after sync
                    await SettingsViewModel.shared.pruneEmptyAddressTypesAfterRestore()
                }
            }

            if MigrationsService.shared.needsPostMigrationSync {
                Task { @MainActor in
                    try? await CoreService.shared.activity.syncLdkNodePayments(LightningService.shared.payments ?? [])
                    await CoreService.shared.activity.markAllUnseenActivitiesAsSeen()
                    await MigrationsService.shared.reapplyMetadataAfterSync()

                    if MigrationsService.shared.canCleanupAfterMigration {
                        if MigrationsService.shared.isShowingMigrationLoading {
                            try? await LightningService.shared.restart()
                        }

                        SettingsViewModel.shared.updatePinEnabledState()
                        MigrationsService.shared.cleanupAfterMigration()
                        MigrationsService.shared.needsPostMigrationSync = false
                        MigrationsService.shared.isRestoringFromRNRemoteBackup = false
                    } else {
                        Logger.info("Post-migration sync incomplete, will retry on next sync", context: "AppViewModel")
                    }

                    if MigrationsService.shared.isShowingMigrationLoading {
                        MigrationsService.shared.isShowingMigrationLoading = false
                    }
                }
            }

        // MARK: Balance Events

        case let .balanceChanged(oldSpendableOnchain, newSpendableOnchain, _, _, oldLightning, newLightning):
            Logger.debug("Balance changed: onchain \(oldSpendableOnchain)->\(newSpendableOnchain) lightning \(oldLightning)->\(newLightning)")
        }
    }

    private func shouldShowFirstChannelReadyToast() async -> Bool {
        await MainActor.run {
            max(lightningService.channelCacheCount, lightningService.channels?.count ?? 0) == 1
        }
    }
}

// MARK: - Timed Sheets

extension AppViewModel {
    func ignoreAppUpdate() {
        appUpdateIgnoreTimestamp = Date().timeIntervalSince1970
    }

    func ignoreBackup() {
        backupIgnoreTimestamp = Date().timeIntervalSince1970
    }

    func ignoreHighBalance() {
        highBalanceIgnoreCount += 1
        highBalanceIgnoreTimestamp = Date().timeIntervalSince1970
    }
}