ArkoseChallengeView( isPresented: $isPresented,
                     delegate: self,
                     config: ArkoseConfig.Builder(withAPIKey: <YOUR_PUBLIC_KEY>)
                                             .with(language: "en") //optional
                                             .with(clientAPIRetryCount: 0) //optional
                                             .with(styleTheme: "") //optional
                                             .build())

struct PreloadedChallengeView: View {

  @State private var isPresented = false
  @State private var runEnforcement = false
  
  var body: some View {
    VStack {
        Button("Run Enforcement") {
            runEnforcement = true
        }
        ArkoseChallengeView(isPresented: $isPresented,
                            runEnforcement: $runEnforcement,
                            delegate: self,
                            withActivity: false,
                            config: ArkoseConfig
                                    .Builder(withAPIKey: YOUR_API_KEY)
                                    .with(inlineRunOnTrigger: true)
                                    .build())
    }.onAppear{
        isPresented = true
    }
  }
}

struct LoginView: View, ArkoseChallengeDelegate {
    @State private var isPresented = false
    
    var body: some View {
        ZStack {
            VStack {
                Button("Login") {
                    isPresented = true
                }
                .padding()
            }
            
            ArkoseChallengeView(
                isPresented: $isPresented,
                delegate: self,
                .. // other parameters
            )
        }
        .onAppear {
            // Set up background state observer
            NotificationCenter.default.addObserver(
                forName: UIApplication.willResignActiveNotification,
                object: nil,
                queue: .main
            ) { _ in
                // Dismiss the Enforcement Challenge by setting isPresented to false
                isPresented = false
            }
        }
    }
    
    func onForceDismissCompleted() {
        print("Challenge dismissed due to app lifecycle event")
    }
    
    // ... other implementation ...
}

public init(isPresented: Binding<Bool>,
            delegate: ArkoseChallengeDelegate,
            cancelActionConfig: ArkoseActionConfig? = nil,
            resetActionConfig: ArkoseActionConfig? = nil,
            withActivity: Bool? = nil,
            withActivityBackgroundAlpha: CGFloat = 0.2,
            config: ArkoseConfig? = nil)

import SwiftUI
import ArkoseLabsKit

struct LoginView: View, ArkoseChallengeDelegate {
    
    // MARK: - State Variables
    
    @State private var isPresented = false
    @State private var shouldNavigateToNext = false
    @State private var isDismissingChallenge = false
    @State private var username: String = ""
    @State private var password: String = ""
    
    // MARK: - ArkoseChallengeDelegate Methods
    
    func onCompleted(response: [String: Any?]) {
        print("onComplete received: \(response)")
        isPresented = false
        // Handle successful challenge completion
    }
    
    func onError(response: [String: Any?]) {
        print("onError received: \(response)")
        isPresented = false
        // Handle error during challenge
    }
    
    func onFailed(response: [String: Any?]) {
        print("onFailed received: \(response)")
        let isRecoverable: Bool = (response["recoverable"] as? Bool) ?? false
        if !isRecoverable {
            // Safe to dismiss - non-recoverable failure
            isPresented = false
        }
        // If recoverable, challenge will continue
    }
    
    func onForceDismissCompleted() {
        isDismissingChallenge = false
        
        // Now safe to trigger navigation
        // The shouldNavigateToNext binding will trigger the sheet presentation
        // after dismissal is complete
        if shouldNavigateToNext {
            // Navigation will be triggered by the sheet modifier
        }
    }
    
    // MARK: - Body
    
    var body: some View {
        ZStack {
            VStack {
                Text("SwiftUI App")
                    .padding()
                    .font(.largeTitle)
                    .foregroundColor(Color.black)
                
                TextField("Username", text: $username)
                    .font(.title3)
                    .disableAutocorrection(true)
                    .autocapitalization(.none)
                    .padding()
                
                SecureField("Password", text: $password)
                    .font(.title3)
                    .disableAutocorrection(true)
                    .autocapitalization(.none)
                    .padding()
                
                Button("Login") {
                    self.isPresented = true
                }
                .padding()
                
                Button("Navigate") {
                    // ❌ Bad: Setting navigation state immediately
                    // isPresented = false
                    // shouldNavigateToNext = true // May cause conflicts
                    
                    // ✅ Good: Wait for dismissal completion
                    if isDismissingChallenge {
                        // Already dismissing, wait for callback
                        return
                    }
                    
                    isDismissingChallenge = true
                    shouldNavigateToNext = true
                    isPresented = false
                    // Navigation will be triggered in onForceDismissCompleted()
                }
                .padding()
            }
            
            ArkoseChallengeView(
                isPresented: $isPresented,
                delegate: self,
                cancelActionConfig: ArkoseActionConfig(
                    title: "Cancel",
                    accessibilityHint: "Cancel the challenge"
                ),
                resetActionConfig: ArkoseActionConfig(
                    title: "Reset",
                    accessibilityHint: "Reset the challenge"
                ),
                config: ArkoseConfig.Builder(
                    withAPIKey: "<YOUR_PUBLIC_KEY>" // Replace <YOUR_PUBLIC_KEY> with the actual API key assigned to your account
                )
                .with(language: "fr")
                .build()
            )
        }
        .sheet(isPresented: $shouldNavigateToNext) {
            NextView()
        }
        .onAppear {
            // Set up background state observer
            NotificationCenter.default.addObserver(
                forName: UIApplication.willResignActiveNotification,
                object: nil,
                queue: .main
            ) { _ in
                // Dismiss the Enforcement Challenge when app goes to background
                if isPresented && !isDismissingChallenge {
                    isDismissingChallenge = true
                    isPresented = false
                }
            }
        }
    }
}

// MARK: - Preview

struct LoginView_Previews: PreviewProvider {
    static var previews: some View {
        LoginView()
    }
}