// For Kotlin Multiplatform projects
kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("io.sourlabs.btc:library:0.5.0")
        }
    }
}

// For single-platform projects (JVM/Android)
dependencies {
    implementation("io.sourlabs.btc:library-jvm:0.5.0")  // JVM
    implementation("io.sourlabs.btc:library-android:0.5.0")  // Android
}

repositories {
    mavenCentral()
}

import io.sourlabs.btc.wallet.api.BitcoinKit
import io.sourlabs.btc.wallet.core.WalletConfig
import io.sourlabs.btc.wallet.core.SyncConfig
import io.sourlabs.btc.wallet.keys.SeedManager
import io.sourlabs.btc.wallet.models.Network
import io.sourlabs.btc.wallet.models.Purpose
import kotlinx.coroutines.launch

// 1. Generate a new mnemonic (or use an existing one)
val mnemonic = SeedManager.generateMnemonicCode(SeedManager.MnemonicSize.Max)

// 2. Create wallet configuration
val config = WalletConfig.FromMnemonic(
    mnemonic = mnemonic,
    purpose = Purpose.BIP84,      // Native SegWit (bc1q... addresses)
    network = Network.MAINNET,
    gapLimit = 20
)

// 3. Build the wallet. The builder picks a sensible default sync source for
//    the network (Blockstream for mainnet/testnet/signet, Mempool.space for
//    Testnet4). Override with .syncConfig(...) when you want something else.
val wallet = BitcoinKit.builder(config).build()

// 4. Start the wallet (in a coroutine scope)
coroutineScope.launch {
    wallet.start()

    // Get a receive address
    val address = wallet.receiveAddress()
    println("Send Bitcoin to: $address")

    // Check balance
    val balance = wallet.getBalance()
    println("Balance: ${balance.spendable} satoshis")
}

val config = WalletConfig.FromMnemonic(
    mnemonic = listOf("abandon", "abandon", ..., "about"),  // 12, 15, 18, 21, or 24 words
    passphrase = "",                    // Optional BIP39 passphrase
    purpose = Purpose.BIP84,            // Address type
    network = Network.MAINNET,
    account = 0,                        // BIP44 account index
    gapLimit = 20,                      // Unused address buffer
    confirmationsThreshold = 1          // Min confirmations for spendable UTXOs
)

val config = WalletConfig.FromSeed(
    seed = seedBytes,                   // At least 16 bytes
    purpose = Purpose.BIP84,
    network = Network.MAINNET
)

val config = WalletConfig.FromExtendedPrivateKey(
    accountExtendedPrivateKey = "xprv9z...",  // at m/84'/0'/0' for this example
    purpose = Purpose.BIP84,
    network = Network.MAINNET,
    account = 0,
)

val config = WalletConfig.WatchOnly(
    extendedPublicKey = "zpub6rFR7...",   // account-level xpub/ypub/zpub
    purpose = Purpose.BIP84,
    network = Network.MAINNET,
    account = 0,
)

// Get a fresh receive address
val address = wallet.receiveAddress()

// Get all used addresses
val usedAddresses = wallet.usedAddresses()

// Validate an address
val isValid = wallet.validateAddress("bc1q...")

// Parse address details
val info = wallet.parseAddress("bc1q...")
// info?.scriptType, info?.scriptPubKey

val balance = wallet.getBalance()

println("Spendable: ${balance.spendable} sats")     // Confirmed, meets threshold
println("Unconfirmed: ${balance.unconfirmed} sats") // Pending confirmations
println("Locked: ${balance.locked} sats")           // Time-locked
println("Total: ${balance.total} sats")

// Get transaction info before sending
val sendInfo = wallet.sendInfo(
    toAddress = "bc1q...",
    amount = 100_000,           // Amount in satoshis
    feeRate = 25                // Fee rate in sat/vB
)
println("Fee: ${sendInfo?.fee} sats")

// Create and broadcast transaction
val result = wallet.send(
    toAddress = "bc1q...",
    amount = 100_000,
    feeRate = 25,
    rbfEnabled = true,                  // Enable Replace-By-Fee
    subtractFeeFromAmount = false       // Deduct fee from amount?
)

result.onSuccess { txId ->
    println("Transaction sent: $txId")
}.onFailure { error ->
    println("Failed: ${error.message}")
}

// Create a signed transaction without broadcasting
val createdTx = wallet.createTransaction(
    toAddress = "bc1q...",
    amount = 100_000,
    feeRate = 25
)

println("TxId: ${createdTx.txId}")
println("Size: ${createdTx.vSize} vBytes")
println("Fee: ${createdTx.fee} sats (${createdTx.feeRate} sat/vB)")
println("Raw: ${createdTx.rawTx.toHex()}")

// Broadcast later
val result = wallet.broadcastTransaction(createdTx.rawTx.toHex())

val sweepTx = wallet.createSweepTransaction(
    toAddress = "bc1q...",
    feeRate = 10
)
wallet.broadcastTransaction(sweepTx.rawTx.toHex())

import io.sourlabs.btc.wallet.utxo.SelectionStrategy

wallet.send(
    toAddress = "bc1q...",
    amount = 100_000,
    feeRate = 25,
    strategy = SelectionStrategy.AUTOMATIC       // Default: optimize for fees + privacy
    // strategy = SelectionStrategy.OLDEST_FIRST   // FIFO selection
    // strategy = SelectionStrategy.LARGEST_FIRST  // Minimize number of inputs
    // strategy = SelectionStrategy.SMALLEST_FIRST // Consolidate small UTXOs
    // strategy = SelectionStrategy.PRIVACY_OPTIMIZED // Avoid linking UTXOs
)

// Get all transactions
val transactions = wallet.transactions()

// Filter by type
val incoming = wallet.transactions(type = TransactionType.INCOMING)
val outgoing = wallet.transactions(type = TransactionType.OUTGOING)

// Limit results
val recent = wallet.transactions(limit = 10)

// Get specific transaction
val tx = wallet.getTransaction("txid...")
tx?.let {
    println("Amount: ${it.amount} sats")
    println("Fee: ${it.fee} sats")
    println("Status: ${it.status}")  // PENDING, RELAYED, CONFIRMED, FAILED
    println("Confirmations: ${it.confirmations(currentBlockHeight)}")
}

val fees = wallet.getRecommendedFees()
fees?.let {
    println("Fastest (next block): ${it.fastestFee} sat/vB")
    println("Half hour: ${it.halfHourFee} sat/vB")
    println("Hour: ${it.hourFee} sat/vB")
    println("Economy: ${it.economyFee} sat/vB")
    println("Minimum: ${it.minimumFee} sat/vB")
}

// Calculate max amount you can send at a given fee rate
val maxAmount = wallet.maximumSpendableValue(feeRate = 25)
println("Maximum spendable: $maxAmount sats")

// Observe sync state
wallet.syncState.collect { state ->
    when (state) {
        is SyncState.NotSynced -> println("Not synced")
        is SyncState.Syncing -> println("Syncing: ${(state.progress * 100).toInt()}%")
        is SyncState.Synced -> println("Synced at ${state.lastSyncTime}")
        is SyncState.Error -> println("Sync error: ${state.message}")
    }
}

// Observe wallet events
wallet.events.collect { event ->
    when (event) {
        is WalletEvent.BalanceUpdated ->
            println("New balance: ${event.balance.total}")
        is WalletEvent.TransactionReceived ->
            println("Received: ${event.transaction.amount} sats")
        is WalletEvent.TransactionSent ->
            println("Sent: ${event.transaction.txId}")
        is WalletEvent.TransactionStatusChanged ->
            println("Tx ${event.txId}: ${event.oldStatus} -> ${event.newStatus}")
        is WalletEvent.NewBlock ->
            println("New block: ${event.height}")
        is WalletEvent.WalletError ->
            println("Error: ${event.message}")
        is WalletEvent.SyncStateChanged -> { /* handled by syncState flow */ }
    }
}

class MyDatabaseStorage : WalletStorage {
    override val publicKeyStorage: PublicKeyStorage = MyPublicKeyStorage()
    override val transactionStorage: TransactionStorage = MyTransactionStorage()
    override val unspentOutputStorage: UnspentOutputStorage = MyUnspentOutputStorage()
    override val blockInfoStorage: BlockInfoStorage = MyBlockInfoStorage()

    override suspend fun clearAll() {
        // Clear all storage
    }
}

// Use custom storage
val wallet = BitcoinKit.builder(config)
    .storage(MyDatabaseStorage())
    .build()

// Blockstream (mainnet / testnet / signet)
val syncConfig = SyncConfig.BlockStream.forNetwork(Network.MAINNET)

// Mempool.space (mainnet / testnet / testnet4 / signet)
val syncConfig = SyncConfig.MempoolSpace.forNetwork(Network.TESTNET4)

// Custom BlockStream instance
val syncConfig = SyncConfig.BlockStream(
    baseUrl = "https://my-blockstream-instance.com/api",
    pollingIntervalMs = 30_000
)

// Custom API endpoint (regtest, self-hosted Esplora, etc.)
val syncConfig = SyncConfig.CustomApi(
    baseUrl = "https://my-api.com",
    pollingIntervalMs = 60_000
)

// Smart default per network — what BitcoinKit.builder uses when no
// .syncConfig() is supplied.
val syncConfig = SyncConfig.defaultForNetwork(Network.TESTNET4)

val syncConfig = SyncConfig.BlockStream.enterprise(
    network = Network.MAINNET,
    clientId = clientId,
    clientSecret = clientSecret
)

val wallet = BitcoinKit.builder(config)
    .syncConfig(SyncConfig.BlockStream.forNetwork(Network.MAINNET))
    .addFallbackSyncConfig(SyncConfig.MempoolSpace.forNetwork(Network.MAINNET))
    .addFallbackSyncConfig(SyncConfig.CustomApi("https://my-node.example.com/api"))
    .build()

val scanResult = BitcoinKit.scanWallet(
    mnemonic = mnemonic,
    passphrase = "",
    network = Network.MAINNET
)

// scanResult contains detected address types and balances

// Start wallet (initializes keys, starts sync). Suspends until the first
// sync attempt has finished — syncState is Synced or Error by the time
// start() returns. So you can immediately use getBalance() / transactions()
// / receiveAddress() without observing syncState yourself.
wallet.start()

// Manual refresh
wallet.refresh()

// Stop sync operations. Suspends until the sync coroutine has actually
// exited, so subsequent state mutations (clearData) don't race.
wallet.stop()

// Clear all wallet data
wallet.clearData()

try {
    wallet.send(...)
} catch (e: InvalidAddressException) {
    // Invalid destination address
} catch (e: InvalidAmountException) {
    // Amount is non-positive, below the destination's dust threshold,
    // or feeRate is below 1 sat/vB
} catch (e: InsufficientFundsException) {
    // Not enough balance
} catch (e: SigningException) {
    // Watch-only wallet or signing failed
} catch (e: BroadcastException) {
    // Network broadcast failed
} catch (e: ScanException) {
    // Wallet restoration scan aborted after too many consecutive API failures
    // (only thrown by BitcoinKit.scanWallet / MultiPurposeScanner)
} catch (e: WalletException) {
    // General wallet error
}

co.touchlab.kermit.Logger.setMinSeverity(co.touchlab.kermit.Severity.Warn)

BitcoinKit.generateMnemonic(wordCount = 24)  // Generate new mnemonic
BitcoinKit.validateMnemonic(mnemonic)        // Validate mnemonic words
BitcoinKit.scanWallet(mnemonic, ...)         // Scan for existing activity