Deferred Deep Linking

struct AttributionResponse: Codable {
    let success:  Bool
    let data:     AttributionData
}

struct AttributionData: Codable {
    let attributed:          Bool
    let referrerIdentifier:  String?
    let campaign:            String?
    let source:              String?
    let customPayload:       [String: String]?
}

final class AttributionService {

    private let apiKey  = "YOUR_API_KEY"
    private let baseURL = "https://api.linktrace.in"

    func fetchAttribution(userId: String) async throws -> AttributionData {
        guard let url = URL(string: "\(baseURL)/api/v1/attributions") else {
            throw URLError(.badURL)
        }

        var request = URLRequest(url: url)
        request.httpMethod          = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue(apiKey,           forHTTPHeaderField: "x-api-key")
        request.httpBody = try JSONEncoder().encode(["userId": userId])

        let (data, _) = try await URLSession.shared.data(for: request)
        let response  = try JSONDecoder().decode(AttributionResponse.self, from: data)
        return response.data
    }
}

// 1. Define your app's navigable routes
enum AppRoute: Hashable {
    case promoScreen(promoCode: String?)
    case onboardingVariantB
    case productDetail(id: String)
    case challengeInvite
    case referralSuccess(referrerName: String?)
    // add more routes as needed
}

// 2. Root view owning the NavigationStack
struct RootView: View {
    @StateObject private var router = AppRouter()

    var body: some View {
        NavigationStack(path: $router.path) {
            HomeView()
                .navigationDestination(for: AppRoute.self) { route in
                    switch route {
                    case .promoScreen(let code):
                        PromoView(promoCode: code)
                    case .onboardingVariantB:
                        OnboardingVariantBView()
                    case .productDetail(let id):
                        ProductDetailView(productId: id)
                    case .challengeInvite:
                        ChallengeInviteView()
                    case .referralSuccess(let name):
                        ReferralSuccessView(referrerName: name)
                    }
                }
        }
        .environmentObject(router)
    }
}

// 3. Router class — holds path and resolution logic
@MainActor
final class AppRouter: ObservableObject {

    @Published var path = NavigationPath()

    private let service  = AttributionService()
    private let defaults = UserDefaults.standard

    func checkDeferredDeepLink(userId: String) {
        // Guard: only run once per user
        guard !defaults.bool(forKey: "lt_attribution_checked") else { return }

        Task {
            do {
                let data = try await service.fetchAttribution(userId: userId)
                defaults.set(true, forKey: "lt_attribution_checked")

                guard data.attributed,
                      let payload    = data.customPayload,
                      let screenName = payload["screenName"] else { return }

                navigate(to: screenName, payload: payload)
            } catch {
                // Attribution failure is non-fatal; continue default flow
            }
        }
    }

    private func navigate(to screenName: String, payload: [String: String]) {
        switch screenName {
        case "promo_screen":
            path.append(AppRoute.promoScreen(promoCode: payload["promoCode"]))
        case "onboarding_variant_b":
            path.append(AppRoute.onboardingVariantB)
        case "product_detail":
            guard let id = payload["productId"] else { return }
            path.append(AppRoute.productDetail(id: id))
        case "challenge_invite":
            path.append(AppRoute.challengeInvite)
        case "referral_success":
            path.append(AppRoute.referralSuccess(referrerName: nil))
        default:
            break
        }
    }
}

struct SignUpView: View {
    @EnvironmentObject private var router: AppRouter
    @State private var isLoading = false

    var body: some View {
        VStack {
            // ... sign-up form UI ...

            Button("Create Account") {
                Task { await handleSignUp() }
            }
        }
    }

    private func handleSignUp() async {
        isLoading = true
        defer { isLoading = false }

        // 1. Create the user account in your backend
        let userId = try await AuthService.signUp(...)

        // 2. Check for a deferred deep link — navigates if attributed
        router.checkDeferredDeepLink(userId: userId)
    }
}