LightningService.swift

import BitkitCore
import Combine
import Foundation
import LDKNode

// TODO: catch all errors and pass a readable error message to the UI

class LightningService {
    private var node: Node?
    var currentWalletIndex: Int = 0

    // MARK: - Stale monitor recovery (one-time recovery for channel monitor desync)

    private static let staleMonitorRecoveryAttemptedKey = "staleMonitorRecoveryAttempted"

    /// Whether we've already attempted stale monitor recovery (prevents infinite retry).
    /// Persisted so the retry only happens once, even across app restarts.
    private static var staleMonitorRecoveryAttempted: Bool {
        get { UserDefaults.standard.bool(forKey: staleMonitorRecoveryAttemptedKey) }
        set { UserDefaults.standard.set(newValue, forKey: staleMonitorRecoveryAttemptedKey) }
    }

    private let syncStatusChangedSubject = PassthroughSubject<UInt64, Never>()

    private var channelCache: [String: ChannelDetails] = [:]

    // Cached values to avoid blocking LDK calls on main thread
    // MainActor isolated to prevent data races between background writes and UI reads
    @MainActor private var cachedStatus: NodeStatus?
    @MainActor private var cachedBalances: BalanceDetails?
    @MainActor private var cachedPeers: [PeerDetails]?
    @MainActor private var cachedChannels: [ChannelDetails]?

    private var storedEventCallback: ((Event) -> Void)?

    var syncStatusChangedPublisher: AnyPublisher<UInt64, Never> {
        syncStatusChangedSubject.eraseToAnyPublisher()
    }

    static var shared = LightningService()

    private init() {}

    /// Flag and lock to prevent concurrent setup calls
    private var isSettingUp = false
    private let setupLock = NSLock()

    func setup(
        walletIndex: Int,
        electrumServerUrl: String? = nil,
        rgsServerUrl: String? = nil,
        channelMigration: ChannelDataMigration? = nil
    ) async throws {
        // Guard against concurrent setup calls
        let shouldProceed: Bool = setupLock.withLock {
            guard !isSettingUp && node == nil else {
                Logger.debug("Node already setting up or already set up, skipping")
                return false
            }
            isSettingUp = true
            return true
        }
        guard shouldProceed else { return }
        defer { setupLock.withLock { isSettingUp = false } }

        Logger.debug("Checking lightning process lock...")
        try await StateLocker.lock(.lightning, wait: 30) // Wait 30 seconds to lock because maybe extension is still running

        guard var mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: walletIndex)) else {
            throw CustomServiceError.mnemonicNotFound
        }

        // Normalize empty strings to nil - empty passphrase should be treated as no passphrase
        let passphraseRaw = try Keychain.loadString(key: .bip39Passphrase(index: walletIndex))
        var passphrase = passphraseRaw?.isEmpty == true ? nil : passphraseRaw

        currentWalletIndex = walletIndex

        var config = defaultConfig()
        let ldkStoragePath = Env.ldkStorage(walletIndex: walletIndex).path
        config.storageDirPath = ldkStoragePath
        config.network = Env.network

        Logger.debug("Using LDK storage path: \(ldkStoragePath)")

        let trustedPeersIds = Env.trustedLnPeers.map(\.nodeId)

        config.trustedPeers0conf = trustedPeersIds
        config.anchorChannelsConfig = .init(
            trustedPeersNoReserve: trustedPeersIds,
            perChannelReserveSats: 1
        )
        config.includeUntrustedPendingInSpendable = true

        let (selectedAddressType, monitoredTypes) = Self.addressTypeStateFromUserDefaults()
        config.addressType = selectedAddressType
        config.addressTypesToMonitor = monitoredTypes.filter { $0 != selectedAddressType }

        let builder = Builder.fromConfig(config: config)
        builder.setCustomLogger(logWriter: LdkLogWriter())

        let resolvedElectrumServerUrl = electrumServerUrl ?? Env.electrumServerUrl

        let electrumConfig = ElectrumSyncConfig(
            backgroundSyncConfig: .init(
                onchainWalletSyncIntervalSecs: Env.walletSyncIntervalSecs,
                lightningWalletSyncIntervalSecs: Env.walletSyncIntervalSecs,
                feeRateCacheUpdateIntervalSecs: Env.walletSyncIntervalSecs
            )
        )
        builder.setChainSourceElectrum(serverUrl: resolvedElectrumServerUrl, config: electrumConfig)

        // Set pathfinding scores source from external scorer
        if let scorerUrl = Env.ldkScorerUrl {
            Logger.info("Setting pathfinding scores source from scorer url: \(scorerUrl)")
            builder.setPathfindingScoresSource(url: scorerUrl)
        }

        // Configure gossip source from current settings
        configureGossipSource(builder: builder, rgsServerUrl: rgsServerUrl)

        Logger.debug("Building node...")
        let storeId = try await VssStoreIdProvider.shared.getVssStoreId(walletIndex: walletIndex)

        let vssUrl = Env.vssServerUrl
        let lnurlAuthServerUrl = Env.lnurlAuthServerUrl
        Logger.debug("Building ldk-node with vssUrl: '\(vssUrl)'")
        Logger.debug("Building ldk-node with lnurlAuthServerUrl: '\(lnurlAuthServerUrl)'")

        if let channelMigration {
            builder.setChannelDataMigration(migration: channelMigration)
            Logger.info("Applied channel migration: \(channelMigration.channelMonitors.count) monitors", context: "Migration")
        }

        builder.setEntropyBip39Mnemonic(mnemonic: mnemonic, passphrase: passphrase)

        try await ServiceQueue.background(.ldk) {
            do {
                if !lnurlAuthServerUrl.isEmpty {
                    self.node = try builder.buildWithVssStore(
                        vssUrl: vssUrl,
                        storeId: storeId,
                        lnurlAuthServerUrl: lnurlAuthServerUrl,
                        fixedHeaders: [:]
                    )
                } else {
                    self.node = try builder.buildWithVssStoreAndFixedHeaders(
                        vssUrl: vssUrl,
                        storeId: storeId,
                        fixedHeaders: [:]
                    )
                }
            } catch let error as BuildError {
                guard case .ReadFailed = error, !Self.staleMonitorRecoveryAttempted else {
                    throw error
                }

                // Build failed with ReadFailed — likely a stale ChannelMonitor (DangerousValue).
                // Retry once with accept_stale_channel_monitors to recover.
                Logger.warn(
                    "Build failed with ReadFailed. Retrying with accept_stale_channel_monitors for one-time recovery.",
                    context: "Recovery"
                )
                Self.staleMonitorRecoveryAttempted = true
                builder.setAcceptStaleChannelMonitors(accept: true)

                if !lnurlAuthServerUrl.isEmpty {
                    self.node = try builder.buildWithVssStore(
                        vssUrl: vssUrl,
                        storeId: storeId,
                        lnurlAuthServerUrl: lnurlAuthServerUrl,
                        fixedHeaders: [:]
                    )
                } else {
                    self.node = try builder.buildWithVssStoreAndFixedHeaders(
                        vssUrl: vssUrl,
                        storeId: storeId,
                        fixedHeaders: [:]
                    )
                }
                Logger.info("Stale monitor recovery: build succeeded with accept_stale", context: "Recovery")
            }
        }

        // Mark recovery as attempted after any successful build (whether recovery was needed or not).
        // This ensures unaffected users never trigger the retry path on future startups.
        if !Self.staleMonitorRecoveryAttempted {
            Self.staleMonitorRecoveryAttempted = true
        }

        Logger.info("LDK node setup")

        // Clear memory
        mnemonic = ""
        passphrase = nil
    }

    func restart(electrumServerUrl: String? = nil, rgsServerUrl: String? = nil) async throws {
        Logger.info("Restarting node with current configuration")

        // Stop the current node if it exists, ignore errors if already stopped
        if node != nil {
            do {
                try await stop()
            } catch {
                Logger.debug("Node was already stopped or failed to stop: \(error)")
                // Clear the node reference anyway
                node = nil
                try? StateLocker.unlock(.lightning)
            }
        }

        // Restart the node with the current configuration
        do {
            try await setup(walletIndex: currentWalletIndex, electrumServerUrl: electrumServerUrl, rgsServerUrl: rgsServerUrl)
            try await start()
            Logger.info("Node restarted successfully")
        } catch {
            Logger.warn("Failed ldk-node config change, attempting recovery…")
            // Attempt to restart with previous config
            // If recovery fails, log it but still throw the original error
            do {
                try await restartWithPreviousConfig()
            } catch {
                Logger.error("Recovery attempt also failed: \(error)")
            }
            // Always re-throw the original error that caused the restart failure
            throw error
        }
    }

    /// Restarts the node with the previous stored configuration (recovery method)
    /// This is called when a config change fails to restore the node to a working state
    private func restartWithPreviousConfig() async throws {
        Logger.debug("Stopping node for recovery attempt")

        // Stop the current node if it exists
        if node != nil {
            do {
                try await stop()
            } catch {
                Logger.error("Failed to stop node during recovery: \(error)")
                node = nil
                try? StateLocker.unlock(.lightning)
            }
        }

        Logger.debug("Starting node with previous config for recovery")

        do {
            // Restart with nil URLs to use stored/default configuration
            try await setup(walletIndex: currentWalletIndex, electrumServerUrl: nil, rgsServerUrl: nil)
            try await start()
            Logger.debug("Successfully started node with previous config")
        } catch {
            Logger.error("Failed starting node with previous config: \(error)")
            throw error
        }
    }

    /// Pass onEvent when being used in the background to listen for payments, channels, closes, etc
    /// - Parameter onEvent: Triggered on any LDK node event
    func start(onEvent: ((Event) -> Void)? = nil) async throws {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        if let onEvent {
            storedEventCallback = onEvent
        }

        listenForEvents(onEvent: storedEventCallback)

        Logger.debug("Starting node...")
        try await ServiceQueue.background(.ldk) {
            try node.start()
        }

        await refreshChannelCache()
        await refreshCache()

        Logger.info("Node started")
    }

    private func refreshChannelCache() async {
        guard let node else { return }

        let channels = try? await ServiceQueue.background(.ldk) {
            node.listChannels()
        }

        await MainActor.run {
            let newChannels = Dictionary(uniqueKeysWithValues: (channels ?? []).map { ($0.channelId.description, $0) })
            for (key, value) in newChannels {
                channelCache[key] = value
            }
        }
    }

    func stop(clearEventCallback: Bool = false) async throws {
        defer {
            // Always try to unlock, even if stopping fails
            try? StateLocker.unlock(.lightning)
        }

        guard let node else {
            Logger.warn("Node not started, nothing to stop")
            return
        }

        Logger.debug("Stopping node...")
        try await ServiceQueue.background(.ldk) {
            try node.stop()
        }
        self.node = nil

        if clearEventCallback {
            storedEventCallback = nil
        }

        await MainActor.run {
            channelCache.removeAll()
        }

        Logger.info("Node stopped")
    }

    func wipeStorage(walletIndex: Int) async throws {
        guard node == nil else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        let directory = Env.ldkStorage(walletIndex: walletIndex)
        guard FileManager.default.fileExists(atPath: directory.path) else {
            Logger.warn("No directory found to wipe: \(directory.path)")
            return
        }

        Logger.warn("Wiping on lighting wallet...")
        try FileManager.default.removeItem(at: directory)

        await MainActor.run {
            clearCache()
            channelCache.removeAll()
        }

        Logger.info("Lightning wallet wiped")
    }

    func deleteNetworkGraph() async throws {
        let graphPath = Env.ldkStorage(walletIndex: currentWalletIndex).appendingPathComponent("network_graph_cache")
        guard FileManager.default.fileExists(atPath: graphPath.path) else {
            Logger.warn("Network graph cache not found at: \(graphPath.path)")
            return
        }
        try FileManager.default.removeItem(at: graphPath)
        Logger.info("Deleted network graph cache at: \(graphPath.path)")
    }

    func connectToTrustedPeers(remotePeers: [LnPeer]? = nil) async throws {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        let peers: [LnPeer]
        let usingRemotePeers: Bool
        if let remotePeers, !remotePeers.isEmpty {
            Logger.info("Using \(remotePeers.count) trusted peers from Blocktank API")
            peers = remotePeers
            usingRemotePeers = true
        } else {
            Logger.warn("No remote peers available, falling back to preconfigured env peers")
            peers = Env.trustedLnPeers
            usingRemotePeers = false
        }

        try await ServiceQueue.background(.ldk) {
            for peer in peers {
                do {
                    try node.connect(nodeId: peer.nodeId, address: peer.address, persist: true)
                    Logger.info("Connected to trusted peer: \(peer.nodeId)")
                } catch {
                    Logger.error(error, context: "Peer: \(peer.nodeId)")
                }
            }

            if usingRemotePeers {
                self.verifyTrustedPeersOrFallback(node: node, trustedPeers: peers)
            }
        }
    }

    private func verifyTrustedPeersOrFallback(node: Node, trustedPeers: [LnPeer]) {
        let connectedPeerIds = Set(node.listPeers().filter(\.isConnected).map(\.nodeId))
        let trustedConnected = trustedPeers.filter { connectedPeerIds.contains($0.nodeId) }.count
        let trustedPeerIds = Set(trustedPeers.map(\.nodeId))

        if trustedConnected == 0, !trustedPeers.isEmpty {
            let fallbackPeers = Env.trustedLnPeers.filter { !trustedPeerIds.contains($0.nodeId) }
            if fallbackPeers.isEmpty {
                Logger.warn("No trusted peers connected. All preconfigured env peers overlap with API peers (not retrying with stale addresses).")
            } else {
                Logger.warn("No trusted peers connected, trying \(fallbackPeers.count) preconfigured env peer(s) not in API list")
                for peer in fallbackPeers {
                    do {
                        try node.connect(nodeId: peer.nodeId, address: peer.address, persist: true)
                        Logger.info("Connected to fallback peer: \(peer.nodeId)")
                    } catch {
                        Logger.error(error, context: "Fallback peer: \(peer.nodeId)")
                    }
                }
            }
        } else {
            Logger.info("Connected to \(trustedConnected)/\(trustedPeers.count) trusted peers")
        }
    }

    func connectPeer(peer: LnPeer, persist: Bool = true) async throws {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        do {
            try await ServiceQueue.background(.ldk) {
                try node.connect(nodeId: peer.nodeId, address: peer.address, persist: persist)
            }
            Logger.info("Connected to peer: \(peer.nodeId)@\(peer.address)")
        } catch {
            Logger.error(error, context: "Failed to connect peer: \(peer.nodeId)@\(peer.address)")
            throw error
        }
    }

    /// Temp fix for regtest where nodes might not agree on current fee rates
    private func setMaxDustHtlcExposureForCurrentChannels() throws {
        guard Env.network == .regtest else {
            Logger.debug("Not updating channel config for non-regtest network")
            return
        }

        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        for channel in node.listChannels() {
            var config = channel.config
            config.maxDustHtlcExposure = .fixedLimit(limitMsat: 999_999 * 1000)
            try? node.updateChannelConfig(userChannelId: channel.userChannelId, counterpartyNodeId: channel.counterpartyNodeId, channelConfig: config)
            Logger.info("Updated channel config for: \(channel.userChannelId)")
        }
    }

    func sync() async throws {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        Logger.debug("Syncing LDK...")
        try await ServiceQueue.background(.ldk) {
            try node.syncWallets()
            // try? self.setMaxDustHtlcExposureForCurrentChannels()
        }
        Logger.info("LDK synced")

        await refreshChannelCache()
        await refreshCache()

        // Emit state change with sync timestamp from node status
        let nodeStatus = node.status()
        if let latestSyncTimestamp = nodeStatus.latestLightningWalletSyncTimestamp {
            let syncTimestamp = UInt64(latestSyncTimestamp)
            syncStatusChangedSubject.send(syncTimestamp)
        } else {
            let syncTimestamp = UInt64(Date().timeIntervalSince1970)
            syncStatusChangedSubject.send(syncTimestamp)
        }
    }

    func newAddress() async throws -> String {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            try node.onchainPayment().newAddress()
        }
    }

    func newAddressForType(_ addressType: LDKNode.AddressType) async throws -> String {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            try node.onchainPayment().newAddressForType(addressType: addressType)
        }
    }

    func receive(amountSats: UInt64? = nil, description: String, expirySecs: UInt32 = 3600) async throws -> String {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        let bolt11 = try await ServiceQueue.background(.ldk) {
            if let amountSats {
                try node
                    .bolt11Payment()
                    .receive(
                        amountMsat: amountSats * 1000,
                        description: Bolt11InvoiceDescription.direct(description: description),
                        expirySecs: expirySecs
                    )
            } else {
                try node
                    .bolt11Payment()
                    .receiveVariableAmount(
                        description: Bolt11InvoiceDescription.direct(description: description),
                        expirySecs: expirySecs
                    )
            }
        }

        return bolt11.description
    }

    /// Checks if we have the correct outbound capacity to send the amount
    /// - Parameter amountSats: Amount to send in satoshis
    /// - Returns: True if we can send the amount
    /// Note: Uses cached channels for fast, non-blocking checks
    @MainActor
    func canSend(amountSats: UInt64) -> Bool {
        guard let channels else {
            return false
        }

        let usableChannels = channels.filter(\.isUsable)
        guard !usableChannels.isEmpty else {
            return false
        }

        let totalNextOutboundHtlcLimitSats = usableChannels
            .map(\.nextOutboundHtlcLimitMsat)
            .reduce(0, +) / 1000

        guard totalNextOutboundHtlcLimitSats > amountSats else {
            Logger.warn("canSend: insufficient capacity: \(totalNextOutboundHtlcLimitSats) < \(amountSats)", context: "LightningService")
            return false
        }

        return true
    }

    private static func convertVByteToKwu(satsPerVByte: UInt32) -> FeeRate {
        // 1 vbyte = 4 weight units, so 1 sats/vbyte = 250 sats/kwu
        let satPerKwu = UInt64(satsPerVByte * 250)
        // Ensure we're above the minimum relay fee
        return .fromSatPerKwu(satKwu: max(satPerKwu, 253)) // FEERATE_FLOOR_SATS_PER_KW is 253 in LDK
    }

    func send(
        address: String,
        sats: UInt64,
        satsPerVbyte: UInt32,
        utxosToSpend: [SpendableUtxo]? = nil,
        isMaxAmount: Bool = false
    ) async throws -> Txid {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        Logger.info("Sending \(sats) sats to \(address) with fee rate \(satsPerVbyte) sats/vbyte (isMaxAmount: \(isMaxAmount))")

        do {
            return try await ServiceQueue.background(.ldk) {
                if isMaxAmount {
                    // For max amount sends, use sendAllToAddress to send all available funds
                    try node.onchainPayment().sendAllToAddress(
                        address: address,
                        retainReserve: true,
                        feeRate: Self.convertVByteToKwu(satsPerVByte: satsPerVbyte)
                    )
                } else {
                    // For normal sends, use sendToAddress with specific amount
                    try node.onchainPayment().sendToAddress(
                        address: address,
                        amountSats: sats,
                        feeRate: Self.convertVByteToKwu(satsPerVByte: satsPerVbyte),
                        utxosToSpend: utxosToSpend
                    )
                }
            }
        } catch {
            dumpLdkLogs()
            throw error
        }
    }

    func send(bolt11: String, sats: UInt64? = nil, params: RouteParametersConfig? = nil) async throws -> PaymentHash {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        Logger.info("Paying bolt11: \(bolt11)")

        do {
            return try await ServiceQueue.background(.ldk) {
                if let sats {
                    try node.bolt11Payment().sendUsingAmount(
                        invoice: .fromStr(invoiceStr: bolt11), amountMsat: sats * 1000, routeParameters: params
                    )
                } else {
                    try node.bolt11Payment().send(invoice: .fromStr(invoiceStr: bolt11), routeParameters: params)
                }
            }
        } catch {
            dumpLdkLogs()
            dumpNetworkGraphInfo(bolt11: bolt11)
            throw error
        }
    }

    func closeChannel(userChannelId: ChannelId, counterpartyNodeId: PublicKey, force: Bool = false, forceCloseReason: String? = nil) async throws {
        guard let node else {
            throw AppError(serviceError: .nodeNotStarted)
        }

        return try await ServiceQueue.background(.ldk) {
            Logger.debug("Initiating channel close (force=\(force)): userChannelId=\(userChannelId)", context: "LightningService")

            if force {
                try node.forceCloseChannel(
                    userChannelId: userChannelId,
                    counterpartyNodeId: counterpartyNodeId,
                    reason: forceCloseReason ?? ""
                )
            } else {
                try node.closeChannel(
                    userChannelId: userChannelId,
                    counterpartyNodeId: counterpartyNodeId
                )
            }
        }
    }

    func closeChannel(_ channel: ChannelDetails, force: Bool = false, forceCloseReason: String? = nil) async throws {
        guard let node else {
            throw AppError(serviceError: .nodeNotStarted)
        }

        Logger.debug("closeChannel called to channel=\(channel), force=\(force)", context: "LightningService")

        // Prevent force closing channels with trusted peers (LSP nodes)
        if force {
            let trustedPeerIds = Set(getLspPeerNodeIds())
            if trustedPeerIds.contains(channel.counterpartyNodeId.description) {
                throw AppError(
                    message: "Cannot force close channel with trusted peer",
                    debugMessage: "Force close is disabled for Blocktank LSP channels. Please use cooperative close instead."
                )
            }
        }

        return try await closeChannel(
            userChannelId: channel.userChannelId,
            counterpartyNodeId: channel.counterpartyNodeId,
            force: force,
            forceCloseReason: forceCloseReason
        )
    }

    func disconnectPeer(peer: PeerDetails) async throws {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        let uri = "\(peer.nodeId)@\(peer.address)"
        Logger.debug("Disconnecting peer: \(uri)")

        do {
            try await ServiceQueue.background(.ldk) {
                try node.disconnect(nodeId: peer.nodeId)
            }
            Logger.info("Peer disconnected: \(uri)")
        } catch {
            Logger.warn("Peer disconnect error: \(uri)")
            throw error
        }
    }

    func sign(message: String) async throws -> String {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        guard let msg = message.data(using: .utf8) else {
            throw AppError(serviceError: .invalidNodeSigningMessage)
        }

        return try await ServiceQueue.background(.ldk) {
            node.signMessage(msg: [UInt8](msg))
        }
    }

    func openChannel(peer: LnPeer, channelAmountSats: UInt64, pushToCounterpartySats: UInt64? = nil, channelConfig: ChannelConfig? = nil) async throws
        -> UserChannelId
    {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            try node.openChannel(
                nodeId: peer.nodeId,
                address: peer.address,
                channelAmountSats: channelAmountSats,
                pushToCounterpartyMsat: pushToCounterpartySats == nil ? nil : pushToCounterpartySats! * 1000,
                channelConfig: channelConfig
            )
        }
    }

    func dumpLdkLogs() {
        let logFilePath = Logger.sessionLogFile
        let fileURL = URL(fileURLWithPath: logFilePath)

        do {
            let text = try String(contentsOf: fileURL, encoding: .utf8)
            let lines = text.components(separatedBy: "\n").map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
            print("*****LDK-NODE LOG******")
            for line in lines.suffix(20) {
                print(line)
            }
        } catch {
            Logger.error(error, context: "failed to load ldk log file: \(logFilePath)")
        }
    }

    func dumpNetworkGraphInfo(bolt11: String) {
        guard let node else {
            Logger.error("Node not available for network graph dump", context: "LightningService")
            return
        }

        let nodeIdPreviewLength = 20
        var sb = ""

        sb += "\n\n=== NETWORK GRAPH DUMP ===\n"

        // 1. Invoice Info
        do {
            let invoice = try Bolt11Invoice.fromStr(invoiceStr: bolt11)
            sb += "\nInvoice Info:\n"
            sb += "  - Payment Hash: \(invoice.paymentHash())\n"
            sb += "  - Invoice: \(bolt11)\n"
        } catch {
            sb += "\nFailed to parse bolt11 invoice: \(error)\n"
        }

        // 2. Our Node Info
        sb += "\nOur Node Info:\n"
        sb += "  - Node ID: \(node.nodeId())\n"

        // 3. Our Channels
        sb += "\nOur Channels:\n"
        let channels = node.listChannels()
        sb += "  Total channels: \(channels.count)\n"

        var totalOutboundMsat: UInt64 = 0
        var totalInboundMsat: UInt64 = 0
        var usableChannels = 0
        var announcedChannels = 0

        for (index, channel) in channels.enumerated() {
            totalOutboundMsat += channel.outboundCapacityMsat
            totalInboundMsat += channel.inboundCapacityMsat
            if channel.isUsable { usableChannels += 1 }
            if channel.isAnnounced { announcedChannels += 1 }

            sb += "  Channel \(index + 1):\n"
            sb += "    - Channel ID: \(channel.channelId)\n"
            sb += "    - Counterparty: \(channel.counterpartyNodeId)\n"
            sb += "    - Ready: \(channel.isChannelReady), Usable: \(channel.isUsable), Announced: \(channel.isAnnounced)\n"
            sb += "    - Outbound: \(channel.outboundCapacityMsat) msat, Inbound: \(channel.inboundCapacityMsat) msat\n"
        }

        sb += "\n  Channel Summary:\n"
        sb += "    - Usable channels: \(usableChannels)/\(channels.count)\n"
        sb += "    - Announced channels: \(announcedChannels)/\(channels.count)\n"
        sb += "    - Total Outbound: \(totalOutboundMsat) msat\n"
        sb += "    - Total Inbound: \(totalInboundMsat) msat\n"

        // 4. Our Peers
        sb += "\nOur Peers:\n"
        let peers = node.listPeers()
        sb += "  Total peers: \(peers.count)\n"

        for (index, peer) in peers.enumerated() {
            let nodeIdPreview = String(peer.nodeId.prefix(nodeIdPreviewLength))
            sb += "  Peer \(index + 1): \(nodeIdPreview)... @ \(peer.address)\n"
        }

        // 5. RGS Configuration
        sb += "\nRGS Configuration:\n"
        sb += "  - RGS Server URL: \(Env.ldkRgsServerUrl ?? "Not configured")\n"

        let nodeStatus = node.status()
        if let rgsTimestamp = nodeStatus.latestRgsSnapshotTimestamp {
            let date = Date(timeIntervalSince1970: TimeInterval(rgsTimestamp))
            let timeAgo = Date().timeIntervalSince(date)
            let hoursAgo = Int(timeAgo / 3600)
            let minutesAgo = Int((timeAgo.truncatingRemainder(dividingBy: 3600)) / 60)

            let formatter = DateFormatter()
            formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
            formatter.timeZone = TimeZone(abbreviation: "UTC")

            sb += "  - Last RGS Snapshot: \(formatter.string(from: date))\n"
            if hoursAgo > 0 {
                sb += "  - Time since update: \(hoursAgo)h \(minutesAgo)m ago\n"
            } else {
                sb += "  - Time since update: \(minutesAgo)m ago\n"
            }
            sb += "  - Timestamp: \(rgsTimestamp)\n"
        } else {
            sb += "  - Last RGS Snapshot: Never synced\n"
            sb += "  - WARNING: Network graph may be empty or stale!\n"
        }

        // 6. Network Graph Data
        sb += "\nRGS Network Graph Data:\n"
        let networkGraph = node.networkGraph()
        let allNodes = networkGraph.listNodes()
        let allChannels = networkGraph.listChannels()

        sb += "  Total nodes: \(allNodes.count)\n"
        sb += "  Total channels: \(allChannels.count)\n"

        // Check for trusted peers in graph
        sb += "\n  Checking for trusted peers in network graph:\n"
        let trustedPeers = Env.trustedLnPeers
        var foundTrustedNodes = 0
        let allNodeStrings = allNodes.map(\.description)

        for peer in trustedPeers {
            let nodeId = peer.nodeId
            if allNodeStrings.contains(nodeId) {
                foundTrustedNodes += 1
                let nodeIdPreview = String(nodeId.prefix(nodeIdPreviewLength))
                sb += "    OK: \(nodeIdPreview)... found in graph\n"
            } else {
                let nodeIdPreview = String(nodeId.prefix(nodeIdPreviewLength))
                sb += "    MISSING: \(nodeIdPreview)... NOT in graph\n"
            }
        }
        sb += "  Summary: \(foundTrustedNodes)/\(trustedPeers.count) trusted peers found in graph\n"

        // Show first 10 nodes
        let nodesToShow = min(10, allNodes.count)
        sb += "\n  First \(nodesToShow) nodes:\n"
        for (index, nodeId) in allNodes.prefix(nodesToShow).enumerated() {
            sb += "    \(index + 1). \(nodeId.description)\n"
        }
        if allNodes.count > nodesToShow {
            sb += "    ... and \(allNodes.count - nodesToShow) more nodes\n"
        }

        sb += "\n=== END NETWORK GRAPH DUMP ===\n"

        Logger.info(sb, context: "LightningService")
    }

    func logNetworkGraphInfo() async throws -> String {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        let nodeStatus = node.status()
        let networkGraph = node.networkGraph()
        let allNodes = networkGraph.listNodes()
        let lastRgsSync = nodeStatus.latestRgsSnapshotTimestamp

        var lastRgsSyncString = "Never"
        if let lastRgsSync {
            let dateFormatter = DateFormatter()
            dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
            dateFormatter.timeZone = TimeZone(abbreviation: "UTC")
            lastRgsSyncString = dateFormatter.string(from: Date(timeIntervalSince1970: TimeInterval(lastRgsSync)))
        }

        return "Nodes: \(allNodes.count), Last Synced: \(lastRgsSyncString)"
    }

    // MARK: - Configuration Helpers

    private func configureGossipSource(builder: Builder, rgsServerUrl: String?) {
        let rgsUrl = rgsServerUrl ?? Env.ldkRgsServerUrl
        if let rgsUrl, !rgsUrl.isEmpty {
            Logger.info("Using gossip source rgs url: \(rgsUrl)")
            builder.setGossipSourceRgs(rgsServerUrl: rgsUrl)
        } else {
            Logger.info("Using gossip source p2p")
            builder.setGossipSourceP2p()
        }
    }
}

// MARK: UI Helpers (Published via WalletViewModel)

extension LightningService {
    var nodeId: String? { node?.nodeId() }

    // Use cached values to avoid blocking LDK calls on main thread
    @MainActor var balances: BalanceDetails? { cachedBalances }
    @MainActor var status: NodeStatus? { cachedStatus }
    @MainActor var peers: [PeerDetails]? { cachedPeers }
    @MainActor var channels: [ChannelDetails]? { cachedChannels }
    var payments: [PaymentDetails]? { node?.listPayments() }

    /// Refresh all cached values asynchronously
    /// Fetches from LDK on background queue, updates cache on main actor
    func refreshCache() async {
        // Skip if node isn't set up yet - don't block on the LDK queue
        guard node != nil else { return }

        do {
            // Fetch all values in a single background queue call
            let (newStatus, newBalances, newPeers, newChannels) = try await ServiceQueue.background(.ldk) { [self] in
                (
                    node?.status(),
                    node?.listBalances(),
                    node?.listPeers(),
                    node?.listChannels()
                )
            }

            // Update cache on main actor
            await MainActor.run {
                cachedStatus = newStatus
                cachedBalances = newBalances
                cachedPeers = newPeers
                cachedChannels = newChannels
            }
        } catch {
            Logger.error("Failed to refresh cache: \(error)", context: "LightningService")
        }
    }

    /// Clear cached values - only call when wiping storage or resetting the wallet.
    @MainActor
    func clearCache() {
        cachedStatus = nil
        cachedBalances = nil
        cachedPeers = nil
        cachedChannels = nil
    }

    /// Get balance for a specific address in satoshis
    /// - Parameter address: The Bitcoin address to check
    /// - Returns: The current balance in satoshis
    /// - Throws: AppError if node is not setup
    func getAddressBalance(address: String) async throws -> UInt64 {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            try node.getAddressBalance(addressStr: address)
        }
    }

    func getBalanceForAddressType(_ addressType: LDKNode.AddressType) async throws -> AddressTypeBalance {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            try node.getBalanceForAddressType(addressType: addressType)
        }
    }

    func addAddressTypeToMonitor(_ addressType: LDKNode.AddressType) async throws {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }
        guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: currentWalletIndex)) else {
            throw CustomServiceError.mnemonicNotFound
        }
        let passphraseRaw = try? Keychain.loadString(key: .bip39Passphrase(index: currentWalletIndex))
        let passphrase = passphraseRaw?.isEmpty == true ? nil : passphraseRaw

        try await ServiceQueue.background(.ldk) {
            try node.addAddressTypeToMonitorWithMnemonic(addressType: addressType, mnemonic: mnemonic, passphrase: passphrase)
        }
    }

    func removeAddressTypeFromMonitor(_ addressType: LDKNode.AddressType) async throws {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        try await ServiceQueue.background(.ldk) {
            try node.removeAddressTypeFromMonitor(addressType: addressType)
        }
    }

    func listMonitoredAddressTypes() -> [LDKNode.AddressType] {
        guard let node else { return [] }
        return node.listMonitoredAddressTypes()
    }

    func setPrimaryAddressType(_ addressType: LDKNode.AddressType) async throws {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }
        guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: currentWalletIndex)) else {
            throw CustomServiceError.mnemonicNotFound
        }
        let passphraseRaw = try? Keychain.loadString(key: .bip39Passphrase(index: currentWalletIndex))
        let passphrase = passphraseRaw?.isEmpty == true ? nil : passphraseRaw

        try await ServiceQueue.background(.ldk) {
            try node.setPrimaryAddressTypeWithMnemonic(addressType: addressType, mnemonic: mnemonic, passphrase: passphrase)
        }
    }

    /// Sum of spendable on-chain balance for non-legacy address types (selected + monitored), for channel funding.
    /// - Parameters:
    ///   - selectedType: Current primary address type.
    ///   - monitoredTypes: Address types currently monitored (from settings).
    func getChannelFundableBalance(selectedType: LDKNode.AddressType, monitoredTypes: [LDKNode.AddressType]) async throws -> UInt64 {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        var typesToSum = Set<LDKNode.AddressType>()
        if selectedType != .legacy {
            typesToSum.insert(selectedType)
        }
        for type in monitoredTypes where type != .legacy {
            typesToSum.insert(type)
        }

        var totalFundable: UInt64 = 0

        for addressType in typesToSum {
            do {
                let balance = try await ServiceQueue.background(.ldk) {
                    try node.getBalanceForAddressType(addressType: addressType)
                }
                totalFundable += balance.spendableSats
            } catch {
                Logger.warn("Failed to get balance for \(addressType) when calculating channel fundable balance: \(error)")
            }
        }

        return totalFundable
    }

    /// Reads selected and monitored address types from UserDefaults. Use when calling from UI/balance flow.
    static func addressTypeStateFromUserDefaults(_ defaults: UserDefaults = .standard)
        -> (selectedType: LDKNode.AddressType, monitoredTypes: [LDKNode.AddressType])
    {
        let selectedType = LDKNode.AddressType.fromStorage(defaults.string(forKey: "selectedAddressType"))
        let monitoredString = defaults.string(forKey: "addressTypesToMonitor") ?? "nativeSegwit"
        let monitoredTypes = LDKNode.AddressType.parseCommaSeparated(monitoredString)
        return (selectedType, monitoredTypes)
    }

    /// Returns LSP (Blocktank) peer node IDs
    func getLspPeerNodeIds() -> [String] {
        return Env.trustedLnPeers.map(\.nodeId)
    }

    /// Separates channels into trusted (LSP) and non-trusted peers
    func separateTrustedChannels(_ channels: [ChannelDetails]) -> (trusted: [ChannelDetails], nonTrusted: [ChannelDetails]) {
        let trustedPeerIds = Set(getLspPeerNodeIds())
        let trusted = channels.filter { channel in
            trustedPeerIds.contains(channel.counterpartyNodeId.description)
        }
        let nonTrusted = channels.filter { channel in
            !trustedPeerIds.contains(channel.counterpartyNodeId.description)
        }
        return (trusted: trusted, nonTrusted: nonTrusted)
    }

    /// Get a channel by ID from the channel cache
    /// This is more reliable than using the cachedChannels array when handling events,
    /// as the channelCache is updated immediately when channel events occur
    func getChannelFromCache(channelId: ChannelId) async -> ChannelDetails? {
        let channelIdString = channelId.description
        return await MainActor.run {
            channelCache[channelIdString]
        }
    }
}

// MARK: Events

extension LightningService {
    func listenForEvents(onEvent: ((Event) -> Void)? = nil) {
        Task {
            while true {
                guard let node = self.node else {
                    Logger.error("LDK node not started")
                    return
                }

                let event = await node.nextEventAsync()

                do {
                    try node.eventHandled()
                } catch {
                    Logger.error(error, context: "node.eventHandled()")
                }

                onEvent?(event)

                switch event {
                case let .paymentSuccessful(paymentId, paymentHash, paymentPreimage, feePaidMsat):
                    Logger.info("✅ Payment successful: paymentId: \(paymentId ?? "?") paymentHash: \(paymentHash) feePaidMsat: \(feePaidMsat ?? 0)")
                    Task {
                        let hash = paymentId ?? paymentHash
                        do {
                            try await CoreService.shared.activity.handlePaymentEvent(paymentHash: hash)
                        } catch {
                            Logger.error("Failed to handle payment success for \(hash): \(error)", context: "LightningService")
                        }
                    }
                case let .paymentFailed(paymentId, paymentHash, reason):
                    Logger.info(
                        "❌ Payment failed: paymentId: \(paymentId ?? "?") paymentHash: \(paymentHash ?? "") reason: \(reason.debugDescription)"
                    )
                    Task {
                        if let hash = paymentId ?? paymentHash {
                            do {
                                try await CoreService.shared.activity.handlePaymentEvent(paymentHash: hash)
                            } catch {
                                Logger.error("Failed to handle payment failure for \(hash): \(error)", context: "LightningService")
                            }
                        } else {
                            Logger.warn("No paymentId or paymentHash available for failed payment", context: "LightningService")
                        }
                    }
                case let .paymentReceived(paymentId, paymentHash, amountMsat, feePaidMsat):
                    Logger.info("🤑 Payment received: paymentId: \(paymentId ?? "?") paymentHash: \(paymentHash) amountMsat: \(amountMsat)")
                    Task {
                        let hash = paymentId ?? paymentHash
                        do {
                            try await CoreService.shared.activity.handlePaymentEvent(paymentHash: hash)
                        } catch {
                            Logger.error("Failed to handle payment received for \(hash): \(error)", context: "LightningService")
                        }
                    }
                case let .paymentClaimable(paymentId, paymentHash, claimableAmountMsat, claimDeadline, customRecords):
                    Logger.info(
                        "🫰 Payment claimable: paymentId: \(paymentId) paymentHash: \(paymentHash) claimableAmountMsat: \(claimableAmountMsat)"
                    )
                // Payment claimable doesn't need activity update - it's still pending
                // The payment will be updated when it succeeds or fails via paymentSuccessful/paymentFailed events
                case let .channelPending(channelId, userChannelId, formerTemporaryChannelId, counterpartyNodeId, fundingTxo):
                    Logger.info(
                        "⏳ Channel pending: channelId: \(channelId) userChannelId: \(userChannelId) formerTemporaryChannelId: \(formerTemporaryChannelId) counterpartyNodeId: \(counterpartyNodeId) fundingTxo: \(fundingTxo)"
                    )
                    await refreshChannelCache()
                case let .channelReady(channelId, userChannelId, counterpartyNodeId, fundingTxo):
                    Logger.info(
                        "👐 Channel ready: channelId: \(channelId) userChannelId: \(userChannelId) counterpartyNodeId: \(counterpartyNodeId ?? "?") fundingTxo: \(fundingTxo != nil ? "\(fundingTxo!.txid):\(fundingTxo!.vout)" : "nil")"
                    )
                    await refreshChannelCache()
                case let .channelClosed(channelId, userChannelId, counterpartyNodeId, reason):
                    let reasonString = reason.map { String(describing: $0) } ?? ""
                    Logger.info(
                        "⛔ Channel closed: channelId: \(channelId) userChannelId: \(userChannelId) counterpartyNodeId: \(counterpartyNodeId ?? "?") reason: \(reasonString)"
                    )

                    let channelIdString = channelId.description
                    let channel = await MainActor.run {
                        channelCache[channelIdString]
                    }

                    if let channel {
                        await registerClosedChannel(channel: channel, reason: reasonString)
                        await MainActor.run {
                            channelCache.removeValue(forKey: channelIdString)
                        }
                    } else {
                        Logger.error(
                            "Could not find channel details for closed channel: channelId=\(channelIdString) userChannelId=\(userChannelId) in cache",
                            context: "LightningService"
                        )
                    }
                case .paymentForwarded:
                    break

                // MARK: New Onchain Transaction Events

                case let .onchainTransactionReceived(txid, details):
                    Logger.info("📥 Onchain transaction received: txid=\(txid) amountSats=\(details.amountSats)")
                    Task {
                        do {
                            try await CoreService.shared.activity.handleOnchainTransactionReceived(txid: txid, details: details)
                        } catch {
                            Logger.error("Failed to handle transaction received for \(txid): \(error)", context: "LightningService")
                        }
                    }
                case let .onchainTransactionConfirmed(txid, blockHash, blockHeight, confirmationTime, details):
                    Logger.info("✅ Onchain transaction confirmed: txid=\(txid) blockHeight=\(blockHeight) amountSats=\(details.amountSats)")
                    Task {
                        do {
                            try await CoreService.shared.activity.handleOnchainTransactionConfirmed(
                                txid: txid,
                                details: details
                            )
                        } catch {
                            Logger.error("Failed to handle transaction confirmed for \(txid): \(error)", context: "LightningService")
                        }
                    }
                case let .onchainTransactionReplaced(txid, conflicts):
                    Logger.info("🔄 Onchain transaction replaced (RBF): txid=\(txid) by \(conflicts.count) conflict(s)")
                    Task {
                        do {
                            try await CoreService.shared.activity.handleOnchainTransactionReplaced(txid: txid, conflicts: conflicts)
                        } catch {
                            Logger.error("Failed to handle transaction replaced for \(txid): \(error)", context: "LightningService")
                        }
                    }
                case let .onchainTransactionReorged(txid):
                    Logger.warn("⚠️ Onchain transaction reorged (unconfirmed): txid=\(txid)")
                    Task {
                        do {
                            try await CoreService.shared.activity.handleOnchainTransactionReorged(txid: txid)
                        } catch {
                            Logger.error("Failed to handle transaction reorged for \(txid): \(error)", context: "LightningService")
                        }
                    }
                case let .onchainTransactionEvicted(txid):
                    Logger.warn("🗑️ Onchain transaction removed from mempool: txid=\(txid)")
                    Task {
                        do {
                            try await CoreService.shared.activity.handleOnchainTransactionEvicted(txid: txid)
                        } catch {
                            Logger.error("Failed to handle transaction evicted for \(txid): \(error)", context: "LightningService")
                        }
                    }

                // MARK: Sync Events

                case let .syncProgress(syncType, progressPercent, currentBlockHeight, targetBlockHeight):
                    Logger
                        .debug(
                            "🔄 Sync progress: type=\(syncType) progress=\(progressPercent)% current=\(currentBlockHeight) target=\(targetBlockHeight)"
                        )
                case let .syncCompleted(syncType, syncedBlockHeight):
                    Logger.info("✅ Sync completed: type=\(syncType) height=\(syncedBlockHeight)")
                    // Send sync status update - PassthroughSubject is thread-safe
                    syncStatusChangedSubject.send(UInt64(Date().timeIntervalSince1970))

                // MARK: Balance Events

                case let .balanceChanged(oldSpendableOnchain, newSpendableOnchain, oldTotalOnchain, newTotalOnchain, oldLightning, newLightning):
                    Logger
                        .info("💰 Balance changed: onchain=\(oldSpendableOnchain)->\(newSpendableOnchain) lightning=\(oldLightning)->\(newLightning)")

                // MARK: Splice Events

                case let .splicePending(channelId, userChannelId, counterpartyNodeId, newFundingTxo):
                    Logger
                        .info(
                            "🔀 Splice pending: channelId=\(channelId) userChannelId=\(userChannelId) counterpartyNodeId=\(counterpartyNodeId) newFundingTxo=\(newFundingTxo)"
                        )
                    await refreshChannelCache()
                case let .spliceFailed(channelId, userChannelId, counterpartyNodeId, abandonedFundingTxo):
                    Logger
                        .warn(
                            "❌ Splice failed: channelId=\(channelId) userChannelId=\(userChannelId) counterpartyNodeId=\(counterpartyNodeId) abandonedFundingTxo=\(abandonedFundingTxo != nil ? "\(abandonedFundingTxo!.txid):\(abandonedFundingTxo!.vout)" : "nil")"
                        )
                }
            }
        }
    }

    private func registerClosedChannel(
        channel: ChannelDetails,
        reason: String
    ) async {
        do {
            let channelName: String
            if let scidAlias = channel.inboundScidAlias {
                channelName = String(scidAlias)
            } else {
                let channelIdString = channel.channelId.description
                let prefix = String(channelIdString.prefix(10))
                channelName = "\(prefix)…"
            }

            guard let fundingTxo = channel.fundingTxo else {
                Logger.error("Channel has no funding transaction", context: "LightningService")
                return
            }

            let closedChannel = ClosedChannelDetails(
                channelId: channel.channelId.description,
                counterpartyNodeId: channel.counterpartyNodeId.description,
                fundingTxoTxid: fundingTxo.txid.description,
                fundingTxoIndex: fundingTxo.vout,
                channelValueSats: channel.channelValueSats,
                closedAt: UInt64(Date().timeIntervalSince1970),
                outboundCapacityMsat: channel.outboundCapacityMsat,
                inboundCapacityMsat: channel.inboundCapacityMsat,
                counterpartyUnspendablePunishmentReserve: channel.counterpartyUnspendablePunishmentReserve,
                unspendablePunishmentReserve: channel.unspendablePunishmentReserve ?? 0,
                forwardingFeeProportionalMillionths: channel.config.forwardingFeeProportionalMillionths,
                forwardingFeeBaseMsat: channel.config.forwardingFeeBaseMsat,
                channelName: channelName,
                channelClosureReason: reason
            )

            try await CoreService.shared.activity.upsertClosedChannel(closedChannel)
            Logger.info("Registered closed channel: \(channel.userChannelId)", context: "LightningService")
        } catch {
            Logger.error("Failed to register closed channel: \(error)", context: "LightningService")
        }
    }
}

// MARK: UTXO selection

extension LightningService {
    func listSpendableOutputs() async throws -> [SpendableUtxo] {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            try node.onchainPayment().listSpendableOutputs()
        }
    }

    func selectUtxosWithAlgorithm(
        targetAmountSats: UInt64, satsPerVbyte: UInt32, coinSelectionAlgorythm: CoinSelectionAlgorithm, utxos: [SpendableUtxo]?
    ) async throws -> [SpendableUtxo] {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            try node.onchainPayment()
                .selectUtxosWithAlgorithm(
                    targetAmountSats: targetAmountSats,
                    feeRate: Self.convertVByteToKwu(satsPerVByte: satsPerVbyte),
                    algorithm: coinSelectionAlgorythm,
                    utxos: utxos
                )
        }
    }
}

// MARK: Boost txs

extension LightningService {
    func bumpFeeByRbf(txid: String, satsPerVbyte: UInt32) async throws -> Txid {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            try node.onchainPayment()
                .bumpFeeByRbf(
                    txid: txid,
                    feeRate: Self.convertVByteToKwu(satsPerVByte: satsPerVbyte)
                )
        }
    }

    func accelerateByCpfp(txid: String, satsPerVbyte: UInt32? = nil, destinationAddress: String? = nil) async throws -> Txid {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            try node.onchainPayment()
                .accelerateByCpfp(
                    txid: txid,
                    feeRate: satsPerVbyte != nil ? Self.convertVByteToKwu(satsPerVByte: satsPerVbyte!) : nil,
                    destinationAddress: destinationAddress
                )
        }
    }

    func calculateCpfpFeeRate(parentTxid: String, urgent: Bool) async throws -> FeeRate {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            try node.onchainPayment()
                .calculateCpfpFeeRate(
                    parentTxid: parentTxid,
                    urgent: urgent
                )
        }
    }
}

// MARK: Fees

extension LightningService {
    /// Calculates the total fee for a transaction
    /// - Parameters:
    ///   - address: The destination address
    ///   - amountSats: The amount to send in satoshis
    ///   - satsPerVByte: The fee rate in satoshis per virtual byte
    ///   - utxosToSpend: Optional specific UTXOs to spend
    /// - Returns: The total fee in satoshis
    /// - Throws: ServiceError if node is not setup or calculation fails
    func calculateTotalFee(
        address: String,
        amountSats: UInt64,
        satsPerVByte: UInt32,
        utxosToSpend: [SpendableUtxo]? = nil
    ) async throws -> UInt64 {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            let fee = try node.onchainPayment().calculateTotalFee(
                address: address,
                amountSats: amountSats,
                feeRate: Self.convertVByteToKwu(satsPerVByte: satsPerVByte),
                utxosToSpend: utxosToSpend
            )

            return fee
        }
    }

    /// Estimates the mining fee for a send-all (drain) transaction.
    func estimateSendAllFee(
        address: String,
        satsPerVByte: UInt32
    ) async throws -> UInt64 {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            try node.onchainPayment().calculateSendAllFee(
                address: address,
                retainReserves: true,
                feeRate: Self.convertVByteToKwu(satsPerVByte: satsPerVByte)
            )
        }
    }

    func estimateRoutingFees(bolt11: String, amountSats: UInt64? = nil) async throws -> UInt64 {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        return try await ServiceQueue.background(.ldk) {
            let invoice = try Bolt11Invoice.fromStr(invoiceStr: bolt11)
            let feesMsat: UInt64

            if let amountSats {
                let amountMsat = amountSats * 1000
                feesMsat = try node.bolt11Payment().estimateRoutingFeesUsingAmount(invoice: invoice, amountMsat: amountMsat)
            } else {
                feesMsat = try node.bolt11Payment().estimateRoutingFees(invoice: invoice)
            }

            let feeSat = feesMsat / 1000

            return feeSat
        }
    }

    // MARK: - Probing

    /// Sends a probe to test if a payment route exists for the given invoice.
    /// - Parameters:
    ///   - bolt11: The Lightning invoice string (BOLT 11)
    ///   - amountSats: Optional amount in sats for variable-amount invoices
    func sendProbe(bolt11: String, amountSats: UInt64? = nil) async throws {
        guard let node else {
            throw AppError(serviceError: .nodeNotSetup)
        }

        try await ServiceQueue.background(.ldk) {
            let invoice = try Bolt11Invoice.fromStr(invoiceStr: bolt11)
            if let amountSats {
                let amountMsat = amountSats * 1000
                try node.bolt11Payment().sendProbesUsingAmount(invoice: invoice, amountMsat: amountMsat, routeParameters: nil)
            } else {
                try node.bolt11Payment().sendProbes(invoice: invoice, routeParameters: nil)
            }
        }
    }
}