# Podfile
pod 'PrimerSDK'

pod install --repo-update

import PrimerSDK
import SwiftUI

struct CheckoutView: View {
    let clientToken: String

    var body: some View {
        PrimerCheckout(clientToken: clientToken)
    }
}

import PrimerSDK
import SwiftUI

private let primerSettings = PrimerSettings(paymentHandling: .auto)

struct CheckoutView: View {
    let clientToken: String
    @State private var paymentCompleted = false
    @State private var paymentResult: PaymentResult?

    var body: some View {
        if paymentCompleted, let result = paymentResult {
            ConfirmationView(result: result)
        } else {
            PrimerCheckout(
                clientToken: clientToken,
                primerSettings: primerSettings,
                onCompletion: { state in
                    switch state {
                    case .success(let result):
                        paymentResult = result
                        paymentCompleted = true
                    case .failure(let error):
                        print("Payment failed: \(error.errorId)")
                    case .dismissed:
                        break
                    default:
                        break
                    }
                }
            )
        }
    }
}

import PrimerSDK
import UIKit

class CheckoutViewController: UIViewController, PrimerCheckoutPresenterDelegate {

    func showCheckout() {
        PrimerCheckoutPresenter.shared.delegate = self

        PrimerCheckoutPresenter.presentCheckout(
            clientToken: clientToken,
            from: self,
            primerSettings: PrimerSettings(paymentHandling: .auto),
            primerTheme: PrimerCheckoutTheme()
        )
    }

    // MARK: - PrimerCheckoutPresenterDelegate

    func primerCheckoutPresenterDidCompleteWithSuccess(_ result: PaymentResult) {
        let confirmationVC = ConfirmationViewController(result: result)
        navigationController?.pushViewController(confirmationVC, animated: true)
    }

    func primerCheckoutPresenterDidFailWithError(_ error: PrimerError) {
        print("Payment failed: \(error.errorId)")
    }

    func primerCheckoutPresenterDidDismiss() {
        print("Checkout dismissed")
    }
}

PrimerCheckout (SwiftUI View)
  └── PrimerCheckoutScope (top-level protocol)
        ├── state: AsyncStream<PrimerCheckoutState>
        ├── paymentMethodSelection: PrimerPaymentMethodSelectionScope
        │     ├── state: AsyncStream<PrimerPaymentMethodSelectionState>
        │     └── (customization: screen, paymentMethodItem, categoryHeader, emptyStateView)
        └── getPaymentMethodScope() → payment method scopes:
              ├── PrimerCardFormScope (cards)
              │     ├── selectCountry: PrimerSelectCountryScope
              │     └── (field configs, ViewBuilder fields, submit/cancel)
              ├── PrimerApplePayScope (Apple Pay)
              ├── PrimerPayPalScope (PayPal)
              ├── PrimerKlarnaScope (Klarna — multi-step)
              ├── PrimerAchScope (ACH — multi-step)
              ├── PrimerWebRedirectScope (Twint, etc.)
              ├── PrimerFormRedirectScope (BLIK, MBWay)
              └── PrimerQRCodeScope (PromptPay, Xfers)

PrimerCheckout(
    clientToken: clientToken,
    scope: { checkoutScope in
        // Direct access to payment method selection
        let selection = checkoutScope.paymentMethodSelection

        // Access payment method scopes by protocol type
        let cardScope: PrimerCardFormScope? = checkoutScope.getPaymentMethodScope(PrimerCardFormScope.self)

        // Access by payment method type enum
        let applePayScope: PrimerApplePayScope? = checkoutScope.getPaymentMethodScope(for: .applePay)

        // Access by payment method type string
        let paypalScope: PrimerPayPalScope? = checkoutScope.getPaymentMethodScope(for: "PAYPAL")
    }
)

scope: { checkoutScope in
    Task {
        for await state in checkoutScope.state {
            if case .ready = state {
                // Safe to access scopes now
                if let cardScope = checkoutScope.getPaymentMethodScope(PrimerCardFormScope.self) {
                    // Configure card form
                }
            }
        }
    }
}

@MainActor
protocol PrimerPaymentMethodScope: AnyObject {
    associatedtype State: Equatable

    var state: AsyncStream<State> { get }
    var presentationContext: PresentationContext { get }   // default: .fromPaymentSelection
    var dismissalMechanism: [DismissalMechanism] { get }  // default: []

    func start()
    func submit()
    func cancel()
    func onBack()
    func onDismiss()
}

@available(iOS 15.0, *)
public struct PrimerCheckout: View

PrimerCheckout(
    clientToken: String,
    primerSettings: PrimerSettings = PrimerSettings(),
    primerTheme: PrimerCheckoutTheme = PrimerCheckoutTheme(),
    scope: ((PrimerCheckoutScope) -> Void)? = nil,
    onCompletion: ((PrimerCheckoutState) -> Void)? = nil
)

@MainActor
public protocol PrimerCheckoutScope: AnyObject

public struct PrimerSettings {
    public init(
        paymentHandling: PrimerPaymentHandling = .auto,
        uiOptions: PrimerUIOptions? = nil,
        paymentMethodOptions: PrimerPaymentMethodOptions? = nil
    )
}

public enum PrimerPaymentHandling {
    case auto    // Primer handles the full payment flow (recommended)
    case manual  // Primer returns a token for server-side processing
}

PrimerCheckout(
    clientToken: clientToken,
    primerSettings: PrimerSettings(paymentHandling: .auto),
    onCompletion: { state in
        if case .success(let result) = state {
            print("Payment complete: \(result.payment?.id ?? "")")
        }
    }
)

PrimerCheckout(
    clientToken: clientToken,
    primerSettings: PrimerSettings(paymentHandling: .manual),
    onCompletion: { state in
        if case .success(let result) = state {
            if let token = result.paymentMethodData?.token {
                createPaymentOnServer(token: token)
            }
        }
    }
)

[*] --> initializing
initializing --> ready
ready --> success
ready --> failure
success --> dismissed
failure --> dismissed
dismissed --> [*]

public enum PrimerCheckoutState {
    case initializing
    case ready(totalAmount: Int, currencyCode: String)
    case success(PaymentResult)
    case dismissed
    case failure(PrimerError)
}

PrimerCheckout(
    clientToken: clientToken,
    scope: { checkoutScope in
        Task {
            for await state in checkoutScope.state {
                switch state {
                case .initializing:
                    print("Loading checkout...")
                case .ready(let totalAmount, let currencyCode):
                    print("Ready: \(totalAmount) \(currencyCode)")
                case .success(let result):
                    print("Success: \(result.payment?.id ?? "")")
                case .failure(let error):
                    print("Failed: \(error.errorId)")
                case .dismissed:
                    print("Dismissed")
                }
            }
        }
    }
)

PrimerCheckout(
    clientToken: clientToken,
    onCompletion: { state in
        switch state {
        case .success(let result):
            navigateToConfirmation(result: result)
        case .failure(let error):
            logError(error)
        case .dismissed:
            navigateBack()
        default:
            break
        }
    }
)

@MainActor
public protocol PrimerCardFormScope: PrimerPaymentMethodScope where State == PrimerCardFormState

func updateValidationState(_ field: WritableKeyPath<FieldValidationStates, Bool>, isValid: Bool)

// Mark the CVV field as valid
scope.updateValidationState(\.cvv, isValid: true)

// Mark the card number field as invalid
scope.updateValidationState(\.cardNumber, isValid: false)

public struct PrimerCardFormState: Equatable {
    var configuration: CardFormConfiguration
    var data: FormData
    var fieldErrors: [FieldError]
    var isLoading: Bool
    var isValid: Bool
    var selectedCountry: PrimerCountry?
    var selectedNetwork: PrimerCardNetwork?
    var availableNetworks: [PrimerCardNetwork]
    var surchargeAmountRaw: Int?
    var surchargeAmount: String?
    var displayFields: [PrimerInputElementType]
}

PrimerCheckout(
    clientToken: clientToken,
    scope: { checkoutScope in
        Task {
            for await state in checkoutScope.state {
                if case .ready = state {
                    if let cardScope = checkoutScope.getPaymentMethodScope(PrimerCardFormScope.self) {
                        // Custom screen
                        cardScope.screen = { scope in
                            AnyView(
                                VStack(spacing: 16) {
                                    scope.PrimerCardNumberField(label: "Card Number", styling: nil)
                                    HStack(spacing: 12) {
                                        scope.PrimerExpiryDateField(label: "Expiry", styling: nil)
                                        scope.PrimerCvvField(label: "CVV", styling: nil)
                                    }
                                    scope.PrimerCardholderNameField(label: "Name on Card", styling: nil)

                                    Button("Pay") {
                                        scope.submit()
                                    }
                                    .disabled(!scope.state.isValid) // Note: use latest state from observation
                                }
                                .padding()
                            )
                        }
                    }
                }
            }
        }
    }
)

@MainActor
public protocol PrimerPaymentMethodSelectionScope: AnyObject

public struct PrimerPaymentMethodSelectionState {
    var paymentMethods: [CheckoutPaymentMethod]
    var isLoading: Bool
    var selectedPaymentMethod: CheckoutPaymentMethod?
    var searchQuery: String
    var filteredPaymentMethods: [CheckoutPaymentMethod]
    var error: String?
    var selectedVaultedPaymentMethod: VaultedPaymentMethod?
    var isVaultPaymentLoading: Bool
    var requiresCvvInput: Bool
    var cvvInput: String
    var isCvvValid: Bool
    var cvvError: String?
    var isPaymentMethodsExpanded: Bool
}

// Observe vaulted methods
Task {
    for await state in checkoutScope.paymentMethodSelection.state {
        if let vaulted = state.selectedVaultedPaymentMethod {
            print("Selected vaulted: \(vaulted)")
        }
        if state.requiresCvvInput {
            // Show CVV input for vault re-use
        }
    }
}

// Pay with vaulted method
checkoutScope.paymentMethodSelection.payWithVaultedPaymentMethod()

// Pay with CVV
checkoutScope.paymentMethodSelection.payWithVaultedPaymentMethodAndCvv("123")

@MainActor
public protocol PrimerApplePayScope: PrimerPaymentMethodScope where State == PrimerApplePayState

public struct PrimerApplePayState: Equatable {
    var isLoading: Bool
    var isAvailable: Bool
    var availabilityError: String?
    var buttonStyle: PKPaymentButtonStyle
    var buttonType: PKPaymentButtonType
    var cornerRadius: CGFloat
}

if let applePayScope: PrimerApplePayScope = checkoutScope.getPaymentMethodScope(PrimerApplePayScope.self) {
    // Check availability
    Task {
        for await state in applePayScope.state {
            if state.isAvailable {
                print("Apple Pay is available")
            }
        }
    }

    // Use SDK's button
    let button = applePayScope.PrimerApplePayButton {
        applePayScope.submit()
    }

    // Or custom button
    applePayScope.applePayButton = { action in
        AnyView(
            Button(action: action) {
                HStack {
                    Image(systemName: "apple.logo")
                    Text("Pay")
                }
                .frame(maxWidth: .infinity, minHeight: 50)
                .background(.black)
                .foregroundColor(.white)
                .cornerRadius(10)
            }
        )
    }
}

@MainActor
public protocol PrimerPayPalScope: PrimerPaymentMethodScope where State == PrimerPayPalState

public struct PrimerPayPalState: Equatable {
    public enum Status: Equatable {
        case idle
        case loading
        case redirecting
        case processing
        case success
        case failure(String)
    }

    var status: Status
    var paymentMethod: CheckoutPaymentMethod?
    var surchargeAmount: String?
}

@MainActor
public protocol PrimerKlarnaScope: PrimerPaymentMethodScope where State == PrimerKlarnaState

public struct PrimerKlarnaState: Equatable {
    public enum Step: Equatable {
        case loading
        case categorySelection
        case viewReady
        case authorizationStarted
        case awaitingFinalization
    }

    var step: Step
    var categories: [KlarnaPaymentCategory]
    var selectedCategoryId: String?
}

[*] --> loading --> categorySelection --> viewReady --> authorizationStarted --> awaitingFinalization --> [*]

if let klarnaScope: PrimerKlarnaScope = checkoutScope.getPaymentMethodScope(PrimerKlarnaScope.self) {
    Task {
        for await state in klarnaScope.state {
            switch state.step {
            case .loading:
                print("Loading Klarna...")
            case .categorySelection:
                // Auto-select first category
                if let firstCategory = state.categories.first {
                    klarnaScope.selectPaymentCategory(firstCategory.id)
                }
            case .viewReady:
                klarnaScope.authorizePayment()
            case .authorizationStarted:
                print("Authorizing...")
            case .awaitingFinalization:
                klarnaScope.finalizePayment()
            }
        }
    }
}

@MainActor
public protocol PrimerAchScope: PrimerPaymentMethodScope where State == PrimerAchState

public struct PrimerAchState: Equatable {
    public enum Step: Equatable {
        case loading
        case userDetailsCollection
        case bankAccountCollection
        case mandateAcceptance
        case processing
    }

    var step: Step
    var userDetails: UserDetails
    var fieldValidation: FieldValidation?
    var mandateText: String?
    var isSubmitEnabled: Bool
}

[*] --> loading --> userDetailsCollection --> bankAccountCollection --> mandateAcceptance --> processing --> [*]

public struct UserDetails: Equatable {
    let firstName: String
    let lastName: String
    let emailAddress: String
}

public struct FieldValidation: Equatable {
    let firstNameError: String?
    let lastNameError: String?
    let emailError: String?
    var hasErrors: Bool
}

@MainActor
public protocol PrimerWebRedirectScope: PrimerPaymentMethodScope where State == PrimerWebRedirectState

public struct PrimerWebRedirectState: Equatable {
    public enum Status: Equatable {
        case idle
        case loading
        case redirecting
        case polling
        case success
        case failure(String)
    }

    var status: Status
    var paymentMethod: CheckoutPaymentMethod?
    var surchargeAmount: String?
}

[*] --> idle --> loading --> redirecting --> polling --> success/failure

@MainActor
public protocol PrimerFormRedirectScope: PrimerPaymentMethodScope where State == PrimerFormRedirectState

public struct PrimerFormRedirectState: Equatable {
    public enum Status: Equatable {
        case ready
        case submitting
        case awaitingExternalCompletion
        case success
        case failure(String)
    }

    var status: Status
    var fields: [PrimerFormFieldState]
    var isSubmitEnabled: Bool        // Computed: all fields valid
    var pendingMessage: String?
    var surchargeAmount: String?

    // Convenience
    var otpField: PrimerFormFieldState?
    var phoneField: PrimerFormFieldState?
    var isLoading: Bool
    var isTerminal: Bool
}

[*] --> ready --> submitting --> awaitingExternalCompletion --> success/failure

public struct PrimerFormFieldState: Equatable, Identifiable {
    public enum FieldType: String, Equatable, Sendable {
        case otpCode       // BLIK 6-digit code
        case phoneNumber   // MBWay phone number
    }

    public enum KeyboardType: Equatable, Sendable {
        case numberPad
        case phonePad
        case `default`
    }

    var id: String { fieldType.rawValue }
    let fieldType: FieldType
    var value: String
    var isValid: Bool
    var errorMessage: String?
    let placeholder: String
    let label: String
    let helperText: String?
    let keyboardType: KeyboardType
    let maxLength: Int?
    var countryCodePrefix: String?
    var dialCode: String?
}

@MainActor
public protocol PrimerQRCodeScope: PrimerPaymentMethodScope where State == PrimerQRCodeState

public struct PrimerQRCodeState: Equatable {
    public enum Status: Equatable {
        case loading
        case displaying
        case success
        case failure(String)
    }

    var status: Status
    var paymentMethod: CheckoutPaymentMethod?
    var qrCodeImageData: Data?
}

[*] --> loading --> displaying --> success/failure

@MainActor
public protocol PrimerSelectCountryScope

public struct PrimerSelectCountryState: Equatable {
    var countries: [PrimerCountry]
    var filteredCountries: [PrimerCountry]
    var searchQuery: String
    var isLoading: Bool
    var selectedCountry: PrimerCountry?
}

public struct PrimerCountry: Equatable {
    let code: String      // ISO 3166-1 alpha-2 (e.g., "US")
    let name: String      // Localized name
    let flag: String?     // Flag emoji
    let dialCode: String? // Dialing code
}

if let cardScope: PrimerCardFormScope = checkoutScope.getPaymentMethodScope(PrimerCardFormScope.self) {
    let countryScope = cardScope.selectCountry

    countryScope.countryItem = { country, onSelect in
        AnyView(
            Button(action: onSelect) {
                HStack {
                    if let flag = country.flag {
                        Text(flag)
                    }
                    Text(country.name)
                    Spacer()
                    Text(country.code)
                        .foregroundColor(.secondary)
                }
                .padding(.vertical, 8)
            }
        )
    }
}

@available(iOS 15.0, *)
public struct PrimerCheckoutTheme {
    public init(
        colors: ColorOverrides? = nil,
        radius: RadiusOverrides? = nil,
        spacing: SpacingOverrides? = nil,
        sizes: SizeOverrides? = nil,
        typography: TypographyOverrides? = nil,
        borderWidth: BorderWidthOverrides? = nil
    )
}

public struct ColorOverrides {
    // Brand
    public var primerColorBrand: Color?
    public var primerColorFocus: Color?
    public var primerColorLoader: Color?

    // Background
    public var primerColorBackground: Color?

    // Text
    public var primerColorTextPrimary: Color?
    public var primerColorTextSecondary: Color?
    public var primerColorTextPlaceholder: Color?
    public var primerColorTextDisabled: Color?
    public var primerColorTextNegative: Color?
    public var primerColorTextLink: Color?

    // Borders (outlined)
    public var primerColorBorderOutlinedDefault: Color?
    public var primerColorBorderOutlinedHover: Color?
    public var primerColorBorderOutlinedActive: Color?
    public var primerColorBorderOutlinedFocus: Color?
    public var primerColorBorderOutlinedDisabled: Color?
    public var primerColorBorderOutlinedError: Color?
    public var primerColorBorderOutlinedSelected: Color?
    public var primerColorBorderOutlinedLoading: Color?

    // Borders (transparent)
    public var primerColorBorderTransparentDefault: Color?
    public var primerColorBorderTransparentHover: Color?
    public var primerColorBorderTransparentActive: Color?
    public var primerColorBorderTransparentFocus: Color?
    public var primerColorBorderTransparentDisabled: Color?
    public var primerColorBorderTransparentSelected: Color?

    // Icons
    public var primerColorIconPrimary: Color?
    public var primerColorIconDisabled: Color?
    public var primerColorIconNegative: Color?
    public var primerColorIconPositive: Color?

    // Gray scale
    public var primerColorGray000: Color?
    public var primerColorGray100: Color?
    public var primerColorGray200: Color?
    public var primerColorGray300: Color?
    public var primerColorGray400: Color?
    public var primerColorGray500: Color?
    public var primerColorGray600: Color?
    public var primerColorGray700: Color?
    public var primerColorGray900: Color?

    // Semantic
    public var primerColorGreen500: Color?
    public var primerColorRed100: Color?
    public var primerColorRed500: Color?
    public var primerColorRed900: Color?
    public var primerColorBlue500: Color?
    public var primerColorBlue900: Color?
}

public struct RadiusOverrides {
    public var primerRadiusXsmall: CGFloat?  // Default: 2
    public var primerRadiusSmall: CGFloat?   // Default: 4
    public var primerRadiusMedium: CGFloat?  // Default: 8
    public var primerRadiusLarge: CGFloat?   // Default: 12
    public var primerRadiusBase: CGFloat?    // Default: 4
}

public struct SpacingOverrides {
    public var primerSpaceXxsmall: CGFloat?  // Default: 2
    public var primerSpaceXsmall: CGFloat?   // Default: 4
    public var primerSpaceSmall: CGFloat?    // Default: 8
    public var primerSpaceMedium: CGFloat?   // Default: 12
    public var primerSpaceLarge: CGFloat?    // Default: 16
    public var primerSpaceXlarge: CGFloat?   // Default: 20
    public var primerSpaceXxlarge: CGFloat?  // Default: 24
    public var primerSpaceBase: CGFloat?     // Default: 4
}

public struct SizeOverrides {
    public var primerSizeSmall: CGFloat?     // Default: 16
    public var primerSizeMedium: CGFloat?    // Default: 20
    public var primerSizeLarge: CGFloat?     // Default: 24
    public var primerSizeXlarge: CGFloat?    // Default: 32
    public var primerSizeXxlarge: CGFloat?   // Default: 44
    public var primerSizeXxxlarge: CGFloat?  // Default: 56
    public var primerSizeBase: CGFloat?      // Default: 4
}

public struct TypographyOverrides {
    public var titleXlarge: TypographyStyle?  // 24pt, weight 550
    public var titleLarge: TypographyStyle?   // 16pt, weight 550
    public var bodyLarge: TypographyStyle?    // 16pt, weight 400
    public var bodyMedium: TypographyStyle?   // 14pt, weight 400
    public var bodySmall: TypographyStyle?    // 12pt, weight 400
}

public struct TypographyStyle {
    public var font: String?             // Font family name
    public var letterSpacing: CGFloat?   // Letter spacing in points
    public var weight: Font.Weight?      // Font weight
    public var size: CGFloat?            // Font size in points
    public var lineHeight: CGFloat?      // Line height in points
}

public struct BorderWidthOverrides {
    public var primerBorderWidthThin: CGFloat?    // Default: 1
    public var primerBorderWidthMedium: CGFloat?  // Default: 2
    public var primerBorderWidthThick: CGFloat?   // Default: 3
}

public struct PrimerFieldStyling {
    // Typography
    let fontName: String?
    let fontSize: CGFloat?
    let fontWeight: CGFloat?
    let labelFontName: String?
    let labelFontSize: CGFloat?
    let labelFontWeight: CGFloat?

    // Colors
    let textColor: Color?
    let labelColor: Color?
    let backgroundColor: Color?
    let borderColor: Color?
    let focusedBorderColor: Color?
    let errorBorderColor: Color?
    let placeholderColor: Color?

    // Layout
    let cornerRadius: CGFloat?
    let borderWidth: CGFloat?
    let padding: EdgeInsets?
    let fieldHeight: CGFloat?
}

public struct InputFieldConfig {
    public init(
        label: String? = nil,
        placeholder: String? = nil,
        styling: PrimerFieldStyling? = nil,
        component: Component? = nil
    )
}

private let primerTheme = PrimerCheckoutTheme(
    colors: ColorOverrides(
        primerColorBrand: .blue,
        primerColorBackground: Color(.systemBackground),
        primerColorTextPrimary: .primary
    ),
    radius: RadiusOverrides(
        primerRadiusMedium: 12
    ),
    spacing: SpacingOverrides(
        primerSpaceLarge: 20
    ),
    typography: TypographyOverrides(
        titleLarge: TypographyStyle(
            font: "Avenir",
            weight: .semibold,
            size: 18
        )
    ),
    borderWidth: BorderWidthOverrides(
        primerBorderWidthThin: 1.5
    )
)

PrimerCheckout(
    clientToken: clientToken,
    primerTheme: primerTheme
)

struct ContentView: View {
    @State private var path = NavigationPath()
    let clientToken: String

    var body: some View {
        NavigationStack(path: $path) {
            CartView(onCheckout: {
                path.append("checkout")
            })
            .navigationDestination(for: String.self) { destination in
                if destination == "checkout" {
                    PrimerCheckout(
                        clientToken: clientToken,
                        onCompletion: { state in
                            if case .success = state {
                                path.append("confirmation")
                            }
                        }
                    )
                    .navigationTitle("Payment")
                    .navigationBarTitleDisplayMode(.inline)
                }
            }
        }
    }
}

struct ContentView: View {
    @State private var showCheckout = false
    let clientToken: String

    var body: some View {
        Button("Checkout") {
            showCheckout = true
        }
        .sheet(isPresented: $showCheckout) {
            PrimerCheckout(
                clientToken: clientToken,
                onCompletion: { state in
                    if case .success = state {
                        showCheckout = false
                    }
                }
            )
        }
    }
}

struct ContentView: View {
    @State private var showCheckout = false
    let clientToken: String

    var body: some View {
        Button("Checkout") {
            showCheckout = true
        }
        .fullScreenCover(isPresented: $showCheckout) {
            NavigationView {
                PrimerCheckout(
                    clientToken: clientToken,
                    onCompletion: { state in
                        if case .success = state, case .dismissed = state {
                            showCheckout = false
                        }
                    }
                )
                .navigationTitle("Payment")
                .navigationBarTitleDisplayMode(.inline)
                .toolbar {
                    ToolbarItem(placement: .cancellationAction) {
                        Button("Cancel") {
                            showCheckout = false
                        }
                    }
                }
            }
        }
    }
}

PrimerCheckout(
    clientToken: clientToken,
    onCompletion: { state in
        switch state {
        case .success:
            showCheckout = false
            showConfirmation = true
        case .dismissed:
            showCheckout = false
        case .failure:
            // Error is shown in the checkout UI -- don't dismiss
            break
        default:
            break
        }
    }
)

struct CheckoutView: View {
    let clientToken: String
    @State private var paymentCompleted = false
    @State private var paymentResult: PaymentResult?

    var body: some View {
        if paymentCompleted, let result = paymentResult {
            ConfirmationView(result: result)
        } else {
            PrimerCheckout(
                clientToken: clientToken,
                onCompletion: { state in
                    switch state {
                    case .success(let result):
                        paymentResult = result
                        paymentCompleted = true
                    case .failure(let error):
                        print("Payment failed: \(error.errorId)")
                    case .dismissed:
                        break
                    default:
                        break
                    }
                }
            )
        }
    }
}

struct CheckoutView: View {
    let clientToken: String
    @State private var path = NavigationPath()

    var body: some View {
        NavigationStack(path: $path) {
            PrimerCheckout(
                clientToken: clientToken,
                onCompletion: { state in
                    if case .success(let result) = state {
                        path.append(result)
                    }
                }
            )
            .navigationDestination(for: PaymentResult.self) { result in
                ConfirmationView(result: result)
            }
        }
    }
}

@available(iOS 15.0, *)
public final class PrimerCheckoutPresenter {
    public static let shared: PrimerCheckoutPresenter
    public weak var delegate: PrimerCheckoutPresenterDelegate?
    public static var isAvailable: Bool
    public static var isPresenting: Bool

    public static func presentCheckout(
        clientToken: String,
        from viewController: UIViewController,
        primerSettings: PrimerSettings,
        primerTheme: PrimerCheckoutTheme,
        scope: ((PrimerCheckoutScope) -> Void)? = nil,
        completion: (() -> Void)? = nil
    )

    public static func dismiss(animated: Bool = true, completion: (() -> Void)? = nil)
}

public protocol PrimerCheckoutPresenterDelegate: AnyObject {
    // Required
    func primerCheckoutPresenterDidCompleteWithSuccess(_ result: PaymentResult)
    func primerCheckoutPresenterDidFailWithError(_ error: PrimerError)
    func primerCheckoutPresenterDidDismiss()

    // Optional (3DS)
    func primerCheckoutPresenterWillPresent3DSChallenge(_ paymentMethodTokenData: PrimerPaymentMethodTokenData)
    func primerCheckoutPresenterDidDismiss3DSChallenge()
    func primerCheckoutPresenterDidComplete3DSChallenge(success: Bool, resumeToken: String?, error: Error?)
}

class CheckoutViewController: UIViewController, PrimerCheckoutPresenterDelegate {

    func showCheckout() {
        PrimerCheckoutPresenter.shared.delegate = self

        PrimerCheckoutPresenter.presentCheckout(
            clientToken: clientToken,
            from: self,
            primerSettings: PrimerSettings(paymentHandling: .auto),
            primerTheme: PrimerCheckoutTheme(
                colors: ColorOverrides(primerColorBrand: .systemBlue)
            ),
            scope: { checkoutScope in
                checkoutScope.splashScreen = {
                    AnyView(
                        VStack {
                            ProgressView()
                            Text("Loading...")
                        }
                    )
                }
            }
        )
    }

    // MARK: - PrimerCheckoutPresenterDelegate

    func primerCheckoutPresenterDidCompleteWithSuccess(_ result: PaymentResult) {
        let confirmationVC = ConfirmationViewController(result: result)
        navigationController?.pushViewController(confirmationVC, animated: true)
    }

    func primerCheckoutPresenterDidFailWithError(_ error: PrimerError) {
        print("Payment failed: \(error.errorId)")
    }

    func primerCheckoutPresenterDidDismiss() {
        print("Checkout dismissed")
    }

    // 3DS (optional)
    func primerCheckoutPresenterWillPresent3DSChallenge(_ paymentMethodTokenData: PrimerPaymentMethodTokenData) {
        print("3DS challenge starting")
    }

    func primerCheckoutPresenterDidDismiss3DSChallenge() {
        print("3DS challenge dismissed")
    }

    func primerCheckoutPresenterDidComplete3DSChallenge(success: Bool, resumeToken: String?, error: Error?) {
        print("3DS result: \(success)")
    }
}

// Minimal
PrimerCheckoutPresenter.presentCheckout(clientToken: clientToken)

// With view controller
PrimerCheckoutPresenter.presentCheckout(clientToken: clientToken, from: self)

// Check availability before presenting
guard !PrimerCheckoutPresenter.isPresenting else { return }
PrimerCheckoutPresenter.presentCheckout(clientToken: clientToken, from: self)

// Dismiss programmatically
PrimerCheckoutPresenter.dismiss(animated: true) {
    print("Checkout dismissed")
}

public struct PaymentResult {
    let payment: Payment?
    let paymentMethodData: PrimerPaymentMethodTokenData?
}

public struct PrimerError {
    let errorId: String
    let errorDescription: String?
    let diagnosticsId: String?
}

public enum PresentationContext {
    case direct               // Show cancel button
    case fromPaymentSelection // Show back button
}

public enum DismissalMechanism {
    case gestures    // Swipe-down dismissal
    case closeButton // Close/cancel button
}

public struct CheckoutPaymentMethod {
    let id: String
    let type: String                  // e.g., "PAYMENT_CARD", "PAYPAL"
    let name: String                  // Display name
    let icon: UIImage?
    let metadata: [String: Any]?
    let surcharge: Int?               // Minor units
    let hasUnknownSurcharge: Bool
    let formattedSurcharge: String?
    let backgroundColor: UIColor?
}

public struct FieldError: Equatable, Identifiable {
    let id: UUID
    let fieldType: PrimerInputElementType
    let message: String
    let errorCode: String?
}

public struct CardFormConfiguration: Equatable {
    let cardFields: [PrimerInputElementType]
    let billingFields: [PrimerInputElementType]
    let requiresBillingAddress: Bool
    var allFields: [PrimerInputElementType]
}

public struct FormData: Equatable {
    subscript(fieldType: PrimerInputElementType) -> String { get set }
    var dictionary: [PrimerInputElementType: String]
}

public struct FieldValidationStates: Equatable {
    // Card fields
    public var cardNumber: Bool
    public var cvv: Bool
    public var expiry: Bool
    public var cardholderName: Bool

    // Billing address fields
    public var postalCode: Bool
    public var countryCode: Bool
    public var city: Bool
    public var state: Bool
    public var addressLine1: Bool
    public var addressLine2: Bool
    public var firstName: Bool
    public var lastName: Bool
    public var email: Bool
    public var phoneNumber: Bool
}

PrimerCheckout(
    clientToken: clientToken,
    scope: { checkoutScope in
        Task {
            for await state in checkoutScope.state {
                print("[Primer] Checkout state: \(state)")
            }
        }
    },
    onCompletion: { state in
        print("[Primer] Terminal state: \(state)")
    }
)

Task {
    for await state in checkoutScope.paymentMethodSelection.state {
        for method in state.paymentMethods {
            print("[Primer] Available: \(method.type) (\(method.name))")
        }
    }
}

let cardScope = checkoutScope.getPaymentMethodScope(PrimerCardFormScope.self)
let applePayScope = checkoutScope.getPaymentMethodScope(PrimerApplePayScope.self)
let paypalScope = checkoutScope.getPaymentMethodScope(PrimerPayPalScope.self)

print("[Primer] Card form available: \(cardScope != nil)")
print("[Primer] Apple Pay available: \(applePayScope != nil)")
print("[Primer] PayPal available: \(paypalScope != nil)")

if case .failure(let error) = state {
    print("[Primer] Error ID: \(error.errorId)")
    print("[Primer] Description: \(error.errorDescription ?? "N/A")")
    print("[Primer] Diagnostics ID: \(error.diagnosticsId)")
}

// CORRECT: Constants outside body
private let primerSettings = PrimerSettings(paymentHandling: .auto)
private let primerTheme = PrimerCheckoutTheme(
    colors: ColorOverrides(primerColorBrand: .blue)
)

struct CheckoutView: View {
    let clientToken: String

    var body: some View {
        PrimerCheckout(
            clientToken: clientToken,
            primerSettings: primerSettings,
            primerTheme: primerTheme
        )
    }
}

// WRONG: Recreated on every render
struct CheckoutView: View {
    var body: some View {
        PrimerCheckout(
            clientToken: clientToken,
            primerSettings: PrimerSettings(paymentHandling: .auto), // recreated every render
            primerTheme: PrimerCheckoutTheme(colors: ColorOverrides(primerColorBrand: .blue)) // recreated
        )
    }
}

scope: { checkoutScope in
    Task {
        for await state in checkoutScope.state {
            if case .ready = state {
                // NOW safe to access scopes
                let cardScope = checkoutScope.getPaymentMethodScope(PrimerCardFormScope.self)
            }
        }
    }
}

// WRONG: NavigationLink recreates the destination on push/pop
NavigationStack {
    NavigationLink("Checkout") {
        PrimerCheckout(clientToken: clientToken)
    }
}

// CORRECT: Sheet is a stable container
Button("Checkout") { showCheckout = true }
    .sheet(isPresented: $showCheckout) {
        PrimerCheckout(clientToken: clientToken)
    }

// CORRECT: Set delegate BEFORE presenting
PrimerCheckoutPresenter.shared.delegate = self
PrimerCheckoutPresenter.presentCheckout(clientToken: clientToken, from: self)

// WRONG: Setting delegate after presenting may miss early callbacks
PrimerCheckoutPresenter.presentCheckout(clientToken: clientToken, from: self)
PrimerCheckoutPresenter.shared.delegate = self // Too late!

onCompletion: { state in
    switch state {
    case .success(let result):
        // Navigate to confirmation
    case .failure(let error):
        // Log error (UI shows error automatically)
    case .dismissed:
        // Clean up navigation state
    default:
        break
    }
}