// Package.swift
dependencies: [
    .package(url: "https://github.com/arcaresearch/arca-swift-sdk.git", from: "0.1.0"),
],
targets: [
    .target(name: "MyApp", dependencies: ["ArcaSDK"]),
]

import ArcaSDK

// Recommended: with automatic token refresh
let arca = try Arca(
    token: scopedJwt,
    tokenProvider: {
        try await myBackend.getArcaToken()
    }
)

// Or provider-only (fetches the first token automatically)
let arca = try await Arca.withTokenProvider {
    try await myBackend.getArcaToken()
}

// Static token (manual refresh via updateToken())
let arca = try Arca(token: scopedJwt)

// Explicit realm override (if the token doesn't contain realmId)
let arca = try Arca(token: scopedJwt, realmId: "rlm_01abc")

await arca.updateToken(newScopedJwt)

let id = await arca.onAuthError { error in
    showSessionExpiredUI()
}

// Remove the listener when no longer needed
await arca.removeAuthErrorHandler(id: id)

// Custom cache size
let arca = try Arca(token: scopedJwt, cache: CacheConfig(maxEntries: 100))

// Disable caching entirely
let arca = try Arca(token: scopedJwt, cache: .disabled)

// Manually clear the cache (e.g. after a known data change)
await arca.clearHistoryCache()

// Await full settlement in one line
try await arca.fundAccount(arcaRef: "/wallets/main", amount: "1000").settled

let handle = arca.fundAccount(arcaRef: "/wallets/main", amount: "1000")

// Get the HTTP response immediately (operation may still be pending)
let response = try await handle.submitted
print(response.poolAddress ?? "no pool")

// Wait for full settlement
try await handle.settled

// Or with an explicit timeout
try await handle.settled(timeoutSeconds: 15)

async let d1 = arca.fundAccount(arcaRef: "/wallets/main", amount: "500").settled
async let d2 = arca.fundAccount(arcaRef: "/wallets/savings", amount: "300").settled
let (r1, r2) = try await (d1, d2)

let order = arca.placeOrder(
    path: "/op/order/btc-1", objectId: exchangeId,
    coin: "hl:BTC", side: .buy, orderType: .market, size: "0.01"
)

// Wait for placement
try await order.settled

// Wait for fill
let filled = try await order.filled(timeoutSeconds: 30)
print(filled.order.avgFillPrice ?? "")

// Stream fills as they arrive
for try await fill in order.fills() {
    print("Filled \(fill.size) @ \(fill.price)")
}

// Get structured fill summary (P&L, fee breakdown, direction, resulting position)
let summary = try await order.fillSummary()
print(summary?.realizedPnl ?? "", summary?.dir ?? "", summary?.feeBreakdown ?? "")

// Callback-based fills
let unsub = order.onFill { fill in
    print("Got fill: \(fill.size)")
}
// later: unsub()

// Cancel the order
try await order.cancel().settled

try await arca.ensureDenominatedArca(
    ref: "/wallets/main",
    denomination: "USD",
    operationPath: "/op/create/wallets/main:1" // optional idempotency key
).settled

try await arca.ensureArca(
    ref: "/deposits/d1",
    type: .deposit,
    denomination: "USD"
).settled

let obj = try await arca.getObject(path: "/wallets/main")
print(obj.denomination, obj.status)

let list = try await arca.listObjects(prefix: "/wallets")
print(list.total)

let detail = try await arca.getObjectDetail(objectId: obj.id.rawValue)
print(detail.operations.count)
print(detail.balances)
print(detail.reservedBalances)

let balances = try await arca.getBalances(objectId: obj.id.rawValue)
for balance in balances {
    print(balance.denomination, balance.amount)
}

// Or by path
let balances = try await arca.getBalancesByPath(path: "/wallets/main")

let result = try await arca.browseObjects(prefix: "/users/")

let versions = try await arca.getObjectVersions(objectId: obj.id.rawValue)

let snapshot = try await arca.getSnapshotBalances(
    objectId: obj.id.rawValue,
    asOf: "2026-02-18T18:00:00Z"
)

// Simple deletion
try await arca.ensureDeleted(ref: "/wallets/old").settled

// Deletion with balance sweep
try await arca.ensureDeleted(
    ref: "/wallets/old",
    sweepTo: "/wallets/main"
).settled

// Exchange deletion with position liquidation
try await arca.ensureDeleted(
    ref: "/exchanges/hl1",
    sweepTo: "/wallets/main",
    liquidatePositions: true
).settled

let result = try await arca.transfer(
    path: "/op/transfer/alice-to-bob-1",
    from: "/wallets/alice",
    to: "/wallets/bob",
    amount: "250.00"
).settled
print(result.operation.state) // .completed

// Wait for full settlement
try await arca.fundAccount(arcaRef: "/wallets/main", amount: "1000").settled

// Or get the HTTP response first, then wait
let handle = arca.fundAccount(arcaRef: "/wallets/main", amount: "1000")
let response = try await handle.submitted
print(response.poolAddress ?? "simulated")
try await handle.settled

try await arca.defundAccount(
    arcaPath: "/wallets/main",
    amount: "500.00",
    destinationAddress: "0xabc..."
).settled

let response = try await arca.createPaymentLink(
    type: .deposit,
    arcaRef: "/wallets/main",
    amount: "100.00",
    returnUrl: "https://example.com/thanks",
    expiresInMinutes: 60
).submitted // .submitted for the link URL; .settled to wait for payment
print(response.paymentLink.url)    // shareable link
print(response.paymentLink.status) // "pending"

let response = try await arca.listPaymentLinks(type: .deposit, status: "pending")
for link in response.paymentLinks {
    print(link.id, link.status, link.amount, link.denomination)
}

let detail = try await arca.getOperation(operationId: "op_01abc")
print(detail.operation.type, detail.operation.state)
print(detail.events.count, detail.deltas.count)

// Single type
let list = try await arca.listOperations(type: .transfer)

// Multiple types with inline context
let history = try await arca.listOperations(
    types: [.fill, .transfer],
    includeContext: true
)

// Transfer direction relative to an object
let dir = op.transferDirection(for: "/exchanges/strat-1") // .incoming or .outgoing

// Friendly counterparty label
let label = op.counterpartyLabel(for: "/exchanges/strat-1") // "Vault"

// Context accessors
let amount = op.context?.transferAmount       // "5000"
let fee = op.context?.transferFee             // "0.05"
let denom = op.context?.transferDenomination  // "USD"

let events = try await arca.listEvents()
let detail = try await arca.getEventDetail(eventId: events.events[0].id.rawValue)

let deltas = try await arca.listDeltas(arcaPath: "/wallets/main")

let nonce = try await arca.nonce(prefix: "/op/transfer/fund")
try await arca.transfer(
    path: nonce.path,
    from: "/wallets/alice",
    to: "/wallets/bob",
    amount: "100"
).settled

let summary = try await arca.summary()
print(summary.objectCount, summary.operationCount, summary.eventCount)

do {
    let completed = try await arca.waitForOperation(
        operationId: "op_01abc",
        timeoutSeconds: 30
    )
    print(completed.state) // .completed
} catch ArcaError.operationFailed(let op) {
    print("Failed:", op.failureMessage ?? op.state.rawValue)
}

// Aggregate all objects under a prefix
let agg = try await arca.getPathAggregation(prefix: "/users/alice/")
print(agg.totalEquityUsd, agg.breakdown.count)

// Single object
let single = try await arca.getPathAggregation(prefix: "/users/alice/exchanges/hl1")

// Historical aggregation at a past timestamp
let hist = try await arca.getPathAggregation(
    prefix: "/users/",
    asOf: "2026-02-15T00:00:00Z"
)

let pnl = try await arca.getPnl(
    prefix: "/users/alice/",
    from: "2026-02-01T00:00:00Z",
    to: "2026-03-01T00:00:00Z"
)
print(pnl.pnlUsd) // e.g. "1200.00"

let history = try await arca.getEquityHistory(
    prefix: "/users/",
    from: "2026-02-01T00:00:00Z",
    to: "2026-03-01T00:00:00Z",
    points: 100
)

// Track all objects under a user prefix
let watch = try await arca.createAggregationWatch(sources: [
    AggregationSource(type: .prefix, value: "/users/alice/"),
])
print(watch.aggregation.totalEquityUsd)

// Combine multiple source types
let combo = try await arca.createAggregationWatch(sources: [
    AggregationSource(type: .prefix, value: "/users/alice/"),
    AggregationSource(type: .paths, value: "/treasury/usd,/treasury/btc"),
    AggregationSource(type: .pattern, value: "/users/*/exchanges/hl/*"),
])

let stream = try await arca.watchAggregation(sources: [
    AggregationSource(type: .prefix, value: "/users/alice/"),
])

for await agg in stream.updates {
    print("Equity:", agg.totalEquityUsd)
    print("Breakdown entries:", agg.breakdown.count)
}

// With flow tracking from a specific time
let flowStream = try await arca.watchAggregation(
    sources: [AggregationSource(type: .prefix, value: "/users/alice/")],
    flowsSince: "2026-03-01T00:00:00Z"
)
for await agg in flowStream.updates {
    print("Inflows:", agg.cumInflowsUsd ?? "n/a")
    print("Outflows:", agg.cumOutflowsUsd ?? "n/a")
}

// Clean up when done
await stream.stop()

// 1. Create the watch
let watch = try await arca.createAggregationWatch(sources: [
    AggregationSource(type: .prefix, value: "/users/alice/"),
])
var portfolio = watch.aggregation

// 2. Listen for structural updates
let aggStream = await arca.ws.aggregationEvents()
Task {
    for await (_, agg, _) in aggStream {
        if let agg = agg {
            portfolio = agg
        }
    }
}

// 3. Revalue on mid price ticks
let prices = try await arca.watchPrices()
for await mids in prices.updates {
    portfolio = portfolio.revalued(with: mids)
    renderPortfolio(portfolio)
}

// Get current aggregation on demand
let agg = try await arca.getWatchAggregation(watchId: watch.watchId)

// Destroy when done (also auto-evicted after 5 min of inactivity)
try await arca.destroyAggregationWatch(watchId: watch.watchId)

// Equity-anchored P&L chart (portfolio value view)
let chart = try await arca.watchPnlChart(
    path: "/users/alice/",
    from: "2026-02-01T00:00:00Z",
    to: "2026-03-01T00:00:00Z",
    anchor: .equity
)

for await update in chart.updates {
    // Use valueUsd for the y-axis — the live point equals current equity
    for point in update.points {
        print(point.timestamp, point.valueUsd ?? point.pnlUsd)
    }
}

try await arca.ensurePerpsExchange(ref: "/exchanges/hl1").settled

let state = try await arca.getExchangeState(objectId: exchangeId)
print(state.marginSummary.equity)              // total equity (deposited + unrealized PnL)
print(state.marginSummary.totalRawUsd)         // total deposited USD (before PnL)
print(state.marginSummary.availableToWithdraw) // withdrawable (equity minus maintenance margin)
print(state.positions)
print(state.openOrders)

// Set leverage
let result = try await arca.updateLeverage(
    objectId: exchangeId,
    coin: "hl:BTC",
    leverage: 10
)

// Get leverage for a coin
let setting = try await arca.getLeverage(objectId: exchangeId, coin: "hl:BTC")

let order = arca.placeOrder(
    path: "/op/order/btc-buy-1",
    objectId: exchangeId,
    coin: "hl:BTC",
    side: .buy,
    orderType: .market,
    size: "0.01",
    leverage: 5
)
try await order.settled                             // wait for placement
let filled = try await order.filled(timeoutSeconds: 30)  // wait for fill
for try await fill in order.fills() { /* ... */ }   // stream fills
try await order.cancel().settled                    // cancel

try await arca.placeOrder(
    path: "/op/order/btc-close-1",
    objectId: exchangeId,
    coin: "hl:BTC",
    side: .sell,
    orderType: .market,
    size: "0.01",
    reduceOnly: true
).settled

// List orders
let orders = try await arca.listOrders(objectId: exchangeId)

// Get a specific order with fill history
let detail = try await arca.getOrder(objectId: exchangeId, orderId: orderId)
print(detail.order.status, detail.fills.count)

// Cancel an open order (returns OperationHandle)
try await arca.cancelOrder(
    path: "/op/cancel/btc-1",
    objectId: exchangeId,
    orderId: orderId
).settled

// Start a TWAP
let twap = try await arca.placeTwap(
    exchangeId: exchangeId,
    path: "/wallets/main/twap/btc-accumulate",
    coin: "hl:BTC",
    side: .buy,
    totalSize: "10.0",
    durationMinutes: 120,
    intervalSeconds: 30
)
print(twap.twap.status) // .active

// Cancel
try await arca.cancelTwap(exchangeId: exchangeId, operationId: twap.operationId)

// Get status
let status = try await arca.getTwap(exchangeId: exchangeId, operationId: twap.operationId)
print(status.twap.executedSize, status.twap.filledSlices)

// List active TWAPs
let active = try await arca.listTwaps(exchangeId: exchangeId, activeOnly: true)

// Get limits (local, no network)
let limits = arca.twapLimits

let positions = try await arca.listPositions(objectId: exchangeId)
for pos in positions {
    print(pos.coin, pos.side, pos.size, pos.unrealizedPnl ?? "0")
    print("ROE:", pos.returnOnEquity ?? "N/A", "Value:", pos.positionValue ?? "N/A")
}

let data = try await arca.getActiveAssetData(objectId: exchangeId, coin: "hl:BTC")
// Use maxBuySize / maxSellSize for order size sliders
let maxLong  = Double(data.maxBuySize) ?? 0
let maxShort = Double(data.maxSellSize) ?? 0

// Pass leverage to override the stored setting
let data10x = try await arca.getActiveAssetData(
    objectId: exchangeId, coin: "hl:BTC", leverage: 10
)

let b = Arca.orderBreakdown(options: OrderBreakdownOptions(
    amount: "200", amountType: .spend,
    leverage: 10, feeRate: data.feeRate,
    price: data.markPx, side: .buy, szDecimals: 5
))
// b.tokens         — position size (committed quantity)
// b.notionalUsd    — position exposure (~$1,991)
// b.marginRequired — margin from balance (~$199)
// b.estimatedFee   — fee from balance (~$0.90)
// b.totalSpend     — total from balance (~$200)

let meta = try await arca.getMarketMeta()
for asset in meta.universe {
    print(asset.name, asset.maxLeverage, asset.szDecimals)
}

// Current mid prices
let mids = try await arca.getMarketMids()

// L2 order book
let book = try await arca.getOrderBook(coin: "hl:BTC")

// OHLCV candles
let candles = try await arca.getCandles(coin: "hl:BTC", interval: .oneMinute)
// candles.candles[0].t, .o, .h, .l, .c, .v, .n

// Sparklines — 24 hourly close prices for all coins in one request.
// Pre-computed every ~5 minutes in the background; all tracked coins are
// always included. For real-time price info, use mid prices or candle subscriptions.
let sparklines = try await arca.getSparklines()
// sparklines.sparklines["hl:BTC"] => [60100.5, 60200.1, ...] (24 hourly close prices)
// Newly listed coins may have fewer points until candle history accumulates.

arca.ws.acquireCandles(coins: ["hl:BTC", "hl:ETH"], intervals: [.oneMinute, .fiveMinutes])

for await event in await arca.ws.candleEvents() {
    print(event.coin, event.interval, event.candle)
}

arca.ws.releaseCandles(coins: ["hl:BTC", "hl:ETH"], intervals: [.oneMinute, .fiveMinutes])

// Watch all balances
let stream = try await arca.watchBalances()

// Or filter by path prefix
let stream = try await arca.watchBalances(arcaRef: "/wallets/main")

// Initial snapshot is available immediately
let snapshot = stream.balances.value
// [String: BalanceSnapshot] — keyed by object ID

// React to updates via structured concurrency
for await (entityId, event) in stream.updates {
    let path = event.entityPath ?? entityId
    print("Balance changed on \(path)")
}

// Stop when the view disappears
await stream.stop()

let stream = try await arca.watchOperations()
print(stream.operations.value.count) // initial operations

for await (operation, event) in stream.updates {
    guard operation.state.isTerminal else { continue }
    if operation.state == .failed || operation.state == .expired {
        print("Failed:", operation.failureMessage ?? "unknown")
    } else {
        print("Completed:", operation.type, operation.path)
    }
}

await stream.stop()

let valuation = try await arca.getObjectValuation(path: "/strategies/alpha")
print("Equity:", valuation.valueUsd)

let stream = try await arca.watchObject(path: "/strategies/alpha")

for await valuation in stream.updates {
    print("Equity:", valuation.valueUsd)
    print("Positions:", valuation.positions ?? [])
}

await stream.stop()

let stream = try await arca.watchObjects(paths: [
    "/users/alice/main",
    "/users/bob/main",
])

for await valuationsByPath in stream.updates {
    for (path, valuation) in valuationsByPath {
        print(path, valuation.valueUsd)
    }
}

await stream.stop()

let revalued = valuation.revalued(with: ["hl:BTC": "60000", "hl:ETH": "3000"])
let revaluedAgg = aggregation.revalued(with: mids)

let stream = try await arca.watchCandleChart(
    coin: "hl:BTC",
    interval: .oneMinute,
    count: 300  // historical candles to load
)

for await update in stream.updates {
    // update.candles — full sorted array (historical + live)
    // update.latestCandle — the candle that triggered this update
    renderChart(update.candles)
}

await stream.stop()

// Chart zoom-out — tell the SDK what range is now visible:
let result = await stream.ensureRange(newVisibleStart, newVisibleEnd)
// result.loadedCount == 0 means the range was already loaded, or an overlapping
// in-flight ensureRange finished covering it before this call completed.
// result.reachedStart == true means no more history exists

let result = await stream.loadMore(200)
if result.reachedStart {
    // No more history available
}

let stream = try await arca.watchCandles(
    coins: ["hl:BTC", "hl:ETH"],
    intervals: [.oneMinute, .fiveMinutes]
)

for await event in stream.updates {
    print(event.coin, event.interval, event.candle.close)
}

await stream.stop()

let stream = try await arca.watchMaxOrderSize(options: MaxOrderSizeWatchOptions(
    objectId: exchangeId,
    coin: "hl:BTC",
    side: .buy,
    leverage: 5,
    builderFeeBps: 40, // 4.0 bps (tenths of a bps)
    szDecimals: 5
))

for await data in stream.updates {
    print("max buy size", data.maxBuySize)
    print("mark", data.markPx)
}

await stream.stop()

// Connect and watch a path
await arca.ws.connect()
await arca.ws.watchPath("/")

// Iterate over all events
for await event in await arca.ws.events {
    print(event.type, event.entityId ?? "")
}

// Operation events
for await (operation, event) in await arca.ws.operationEvents() {
    print(operation.type, operation.state)
}

// Balance updates
for await (entityId, event) in await arca.ws.balanceEvents() {
    print("Balance changed on", entityId)
}

// Exchange state updates
for await (state, event) in await arca.ws.exchangeEvents() {
    print(state.marginSummary.equity)
}

// Mid price updates
for await mids in await arca.ws.midsEvents() {
    print("BTC:", mids["hl:BTC"] ?? "n/a")
}

// Exchange fill events
for await (fill, event) in await arca.ws.fillEvents() {
    print("Fill:", fill.coin, fill.size, "@", fill.price)
}

for await status in await arca.ws.statusStream {
    switch status {
    case .connecting: print("Connecting...")
    case .connected:  print("Connected")
    case .disconnected: print("Disconnected")
    }
}

// Watch specific paths (ref-counted)
await arca.ws.watchPath("/users/alice")
await arca.ws.unwatchPath("/users/alice")

// Mid price subscriptions (ref-counted)
arca.ws.acquireMids(exchange: "sim-hl")
arca.ws.releaseMids()

// Disconnect
await arca.ws.disconnect()

do {
    try await arca.transfer(
        path: "/op/transfer/fund-1",
        from: "/wallets/alice",
        to: "/wallets/bob",
        amount: "250.00"
    ).settled
} catch let error as ArcaError {
    switch error {
    case .validation(let message, _):
        print("Invalid input:", message)
    case .notFound(_, let message, _):
        print("Not found:", message)
    case .conflict(_, let message, _):
        print("Conflict:", message)
    case .unauthorized(let message, _):
        print("Auth failed:", message)
    default:
        print("Error:", error.localizedDescription)
    }
}

// Package.swift
targets: [
    .target(name: "MyApp", dependencies: ["ArcaSDK", "ArcaUI"]),
]

import ArcaUI

struct CheckoutView: View {
    @State private var showPayment = false
    let paymentURL: URL  // from createPaymentLink().paymentLink.url

    var body: some View {
        Button("Pay Now") {
            showPayment = true
        }
        .paymentLinkSheet(
            isPresented: $showPayment,
            url: paymentURL,
            onDismiss: {
                // Refresh state after payment
            }
        )
    }
}

PaymentLinkView(url: paymentURL) {
    // Called when the user dismisses the Safari view
    print("Payment flow dismissed")
}