YaniPay Watch

import WatchConnectivity

/// Bi-directional sync service for iPhone <-> Apple Watch communication
class WatchSyncService: NSObject, WCSessionDelegate {
    static let shared = WatchSyncService()

    private var session: WCSession?
    private var retryCount = 0
    private let maxRetries = 5

    // MARK: - Initialization

    override init() {
        super.init()
        if WCSession.isSupported() {
            session = WCSession.default
            session?.delegate = self
            session?.activate()
        }
    }

    // MARK: - Bi-directional Sync

    /// Sync all data with exponential backoff retry
    func syncData() async throws {
        guard let session, session.isReachable else {
            // Fallback to application context (queued delivery)
            try await syncViaApplicationContext()
            return
        }

        do {
            // iPhone -> Watch: balance, transactions, loyalty cards
            let context: [String: Any] = [
                "balance": try await fetchBalance(),
                "transactions": try await fetchRecentTransactions(),
                "loyaltyCards": try await fetchLoyaltyCards(),
                "lastSync": Date().timeIntervalSince1970
            ]

            try await session.sendMessage(context)
            retryCount = 0  // Reset on success

        } catch {
            retryCount += 1
            if retryCount <= maxRetries {
                // Exponential backoff: 1s, 2s, 4s, 8s, 16s
                let delay = pow(2.0, Double(retryCount - 1))
                try await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
                try await syncData()
            } else {
                retryCount = 0
                throw WatchSyncError.maxRetriesExceeded
            }
        }
    }

    // MARK: - Watch -> iPhone (Checkout Requests)

    /// Handle payment request from Watch
    func session(_ session: WCSession,
                 didReceiveMessage message: [String: Any],
                 replyHandler: @escaping ([String: Any]) -> Void) {

        guard let action = message["action"] as? String else { return }

        switch action {
        case "checkout":
            // Watch -> iPhone: process payment request
            let amount = message["amount"] as? Double ?? 0
            let currency = message["currency"] as? String ?? "EUR"
            processCheckout(amount: amount, currency: currency) { result in
                replyHandler(["status": result.status, "txId": result.transactionId])
            }

        case "quickAction":
            // Watch -> iPhone: trigger quick action
            let actionType = message["type"] as? String ?? ""
            handleQuickAction(actionType) { response in
                replyHandler(response)
            }

        default:
            replyHandler(["error": "Unknown action"])
        }
    }

    // MARK: - Deep Linking

    /// Handle deep links from complications & Siri
    func handleDeepLink(_ url: URL) {
        // yanipay://payment?amount=50
        // yanipay://transactions?id=TX123
        // yanipay://loyalty?cardId=CARD123
        // yanipay://qrcode

        guard let host = url.host else { return }
        let params = URLComponents(url: url, resolvingAgainstBaseURL: false)?
            .queryItems?
            .reduce(into: [String: String]()) { $0[$1.name] = $1.value }

        switch host {
        case "payment":
            navigateToPayment(amount: params?["amount"], currency: params?["currency"])
        case "transactions":
            navigateToTransactions(id: params?["id"])
        case "loyalty":
            navigateToLoyalty(cardId: params?["cardId"])
        case "qrcode":
            navigateToQRCode()
        default:
            break
        }
    }
}

extension WatchSyncService {

    /// Fallback sync via application context (queued delivery)
    func syncViaApplicationContext() async throws {
        guard let session else { throw WatchSyncError.sessionUnavailable }

        let context: [String: Any] = [
            "balance": CacheManager.shared.lastKnownBalance,
            "transactions": CacheManager.shared.cachedTransactions,
            "timestamp": Date().timeIntervalSince1970
        ]

        // Application context is delivered when Watch becomes reachable
        try session.updateApplicationContext(context)
    }

    /// Queue payment request for later processing
    func queuePaymentRequest(_ request: PaymentRequest) {
        // transferUserInfo guarantees delivery (FIFO queue)
        session?.transferUserInfo([
            "action": "checkout",
            "amount": request.amount,
            "currency": request.currency,
            "recipient": request.recipient,
            "queuedAt": Date().timeIntervalSince1970
        ])
    }
}

import SwiftUI
import WatchKit

@main
struct YaniPayWatchApp: App {
    @WKApplicationDelegateAdaptor(AppDelegate.self) var appDelegate

    var body: some Scene {
        WindowGroup {
            ContentView()
                .onOpenURL { url in
                    // Handle deep links from complications & Siri
                    WatchSyncService.shared.handleDeepLink(url)
                }
        }
    }
}

// Info.plist URL Scheme:
// <key>CFBundleURLTypes</key>
// <array>
//   <dict>
//     <key>CFBundleURLSchemes</key>
//     <array><string>yanipay</string></array>
//   </dict>
// </array>

import WidgetKit
import SwiftUI

struct YaniPayComplication: Widget {
    let kind = "com.yanipay.complication"

    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: ComplicationProvider()) { entry in
            ComplicationView(entry: entry)
        }
        .configurationDisplayName("YaniPay")
        .description("Solde et transactions en un coup d'oeil")
        .supportedFamilies([
            // ClockKit Legacy
            .accessoryCircular,
            .accessoryRectangular,
            .accessoryInline,
            .accessoryCorner,

            // WidgetKit (watchOS 10+)
            .graphicCorner,
            .graphicCircular,
            .graphicRectangular,
            .graphicExtraLarge,
        ])
    }
}

struct ComplicationProvider: TimelineProvider {
    typealias Entry = BalanceEntry

    func placeholder(in context: Context) -> BalanceEntry {
        BalanceEntry(date: .now, balance: 2450.00, currency: "EUR", trend: .up)
    }

    func getSnapshot(in context: Context, completion: @escaping (BalanceEntry) -> Void) {
        let entry = BalanceEntry(
            date: .now,
            balance: CacheManager.shared.lastKnownBalance,
            currency: "EUR",
            trend: CacheManager.shared.balanceTrend
        )
        completion(entry)
    }

    func getTimeline(in context: Context, completion: @escaping (Timeline<BalanceEntry>) -> Void) {
        Task {
            let balance = try await WatchSyncService.shared.fetchBalance()
            let entry = BalanceEntry(
                date: .now,
                balance: balance.amount,
                currency: balance.currency,
                trend: balance.trend
            )
            // Refresh every 15 minutes
            let nextUpdate = Calendar.current.date(byAdding: .minute, value: 15, to: .now)!
            let timeline = Timeline(entries: [entry], policy: .after(nextUpdate))
            completion(timeline)
        }
    }
}

struct BalanceEntry: TimelineEntry {
    let date: Date
    let balance: Double
    let currency: String
    let trend: BalanceTrend

    enum BalanceTrend {
        case up, down, stable
    }
}

struct ComplicationView: View {
    @Environment(\.widgetFamily) var family
    let entry: BalanceEntry

    var body: some View {
        switch family {
        case .accessoryCircular:
            ZStack {
                AccessoryWidgetBackground()
                VStack(spacing: 0) {
                    Image(systemName: "eurosign.circle.fill")
                        .font(.title3)
                    Text(entry.balance.formatted(.number.precision(.fractionLength(0))))
                        .font(.caption2)
                        .fontWeight(.bold)
                }
            }

        case .accessoryRectangular:
            VStack(alignment: .leading, spacing: 2) {
                Text("YaniPay")
                    .font(.caption2)
                    .foregroundStyle(.secondary)
                Text(entry.balance.formatted(.currency(code: entry.currency)))
                    .font(.headline)
                    .fontWeight(.bold)
                HStack(spacing: 4) {
                    Image(systemName: entry.trend == .up ? "arrow.up.right" : "arrow.down.right")
                        .font(.caption2)
                    Text("7 derniers jours")
                        .font(.caption2)
                        .foregroundStyle(.secondary)
                }
            }

        case .graphicRectangular:
            VStack(alignment: .leading) {
                Text("Solde YaniPay")
                    .font(.caption2)
                    .foregroundStyle(.secondary)
                Text(entry.balance.formatted(.currency(code: entry.currency)))
                    .font(.title3)
                    .fontWeight(.bold)
                // Mini sparkline chart would go here
            }

        default:
            Text(entry.balance.formatted(.number.precision(.fractionLength(0))))
                .font(.caption)
        }
    }
}

import UserNotifications

extension UNNotificationCategory {
    static var yanipayCategories: [UNNotificationCategory] {
        // Payment approval category
        let approveAction = UNNotificationAction(
            identifier: "APPROVE_PAYMENT",
            title: "Approuver",
            options: [.authenticationRequired]
        )
        let rejectAction = UNNotificationAction(
            identifier: "REJECT_PAYMENT",
            title: "Refuser",
            options: [.destructive, .authenticationRequired]
        )
        let paymentCategory = UNNotificationCategory(
            identifier: "PAYMENT_APPROVAL",
            actions: [approveAction, rejectAction],
            intentIdentifiers: [],
            options: .customDismissAction
        )

        // Transaction received category
        let viewAction = UNNotificationAction(
            identifier: "VIEW_TRANSACTION",
            title: "Voir le detail",
            options: .foreground
        )
        let transactionCategory = UNNotificationCategory(
            identifier: "TRANSACTION_RECEIVED",
            actions: [viewAction],
            intentIdentifiers: [],
            options: []
        )

        return [paymentCategory, transactionCategory]
    }
}

# Build watchOS app for simulator
xcodebuild build \
  -workspace YaniPay.xcworkspace \
  -scheme "YaniPay Watch App" \
  -destination 'platform=watchOS Simulator,name=Apple Watch Series 9 (45mm)' \
  -configuration Debug

# Run tests
xcodebuild test \
  -workspace YaniPay.xcworkspace \
  -scheme "YaniPay Watch App" \
  -destination 'platform=watchOS Simulator,name=Apple Watch Series 9 (45mm)'

# Build for device (requires signing)
xcodebuild build \
  -workspace YaniPay.xcworkspace \
  -scheme "YaniPay Watch App" \
  -destination 'generic/platform=watchOS' \
  -configuration Release \
  CODE_SIGN_IDENTITY="Apple Distribution" \
  DEVELOPMENT_TEAM="YOUR_TEAM_ID"

# Archive for App Store
xcodebuild archive \
  -workspace YaniPay.xcworkspace \
  -scheme "YaniPay Watch App" \
  -archivePath build/YaniPayWatch.xcarchive \
  -destination 'generic/platform=watchOS'

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "...">
<plist version="1.0">
<dict>
    <!-- NFC Tap-to-Pay -->
    <key>com.apple.developer.nfc.readersession.formats</key>
    <array>
        <string>NDEF</string>
        <string>TAG</string>
    </array>

    <!-- HealthKit (optional - spending habits tracking) -->
    <key>com.apple.developer.healthkit</key>
    <false/>

    <!-- Background Modes -->
    <key>com.apple.developer.background-modes</key>
    <array>
        <string>remote-notification</string>
        <string>background-fetch</string>
    </array>

    <!-- Keychain Sharing (shared with iPhone app) -->
    <key>keychain-access-groups</key>
    <array>
        <string>$(AppIdentifierPrefix)com.yanipay.shared</string>
    </array>

    <!-- App Groups (shared data with complications) -->
    <key>com.apple.security.application-groups</key>
    <array>
        <string>group.com.yanipay.watch</string>
    </array>
</dict>
</plist>

import Foundation
import YaniPayCore

@Observable
final class BalanceViewModel {
    var balance: Double = 0.0
    var currency: String = "EUR"
    var recentTransactions: [Transaction] = []
    var isLoading: Bool = false
    var error: WatchSyncError?

    private let syncService = WatchSyncService.shared
    private let cache = CacheManager.shared

    // MARK: - Data Loading

    func loadData() async {
        isLoading = true
        defer { isLoading = false }

        // Load from cache first (instant UI)
        balance = cache.lastKnownBalance
        recentTransactions = cache.cachedTransactions

        // Then sync from iPhone
        do {
            try await syncService.syncData()
            balance = cache.lastKnownBalance  // Updated by sync
            recentTransactions = cache.cachedTransactions
            error = nil
        } catch let syncError as WatchSyncError {
            error = syncError
            // UI still shows cached data
        }
    }

    // MARK: - Formatted Display

    var formattedBalance: String {
        balance.formatted(.currency(code: currency))
    }

    var balanceTrend: String {
        let trend = cache.balanceTrend
        switch trend {
        case .up: return "+\(cache.trendPercentage)%"
        case .down: return "-\(cache.trendPercentage)%"
        case .stable: return "~0%"
        }
    }
}

// Background refresh budget: ~4 per hour
// Complication updates: timeline-driven, not polling
// Network: use URLSession background tasks
// Sensor data: batch readings, avoid continuous

import WatchKit
import BackgroundTasks

class ExtensionDelegate: NSObject, WKExtensionDelegate {

    func applicationDidFinishLaunching() {
        scheduleBackgroundRefresh()
    }

    func scheduleBackgroundRefresh() {
        // Budget: ~4 background refreshes per hour
        let fireDate = Date().addingTimeInterval(15 * 60) // 15 min
        WKExtension.shared().scheduleBackgroundRefresh(
            withPreferredDate: fireDate,
            userInfo: nil
        ) { error in
            if let error {
                print("Background refresh scheduling failed: \(error)")
            }
        }
    }

    func handle(_ backgroundTasks: Set<WKRefreshBackgroundTask>) {
        for task in backgroundTasks {
            switch task {
            case let refreshTask as WKApplicationRefreshBackgroundTask:
                // Batch all updates in one pass
                Task {
                    await WalletManager.shared.refreshBalance()
                    await ComplicationUpdater.shared.updateTimeline()
                    refreshTask.setTaskCompletedWithSnapshot(false)
                    scheduleBackgroundRefresh() // Re-schedule
                }
            default:
                task.setTaskCompletedWithSnapshot(false)
            }
        }
    }
}