import Foundation
import TruoraValidationsSDK

/// A standalone implementation of TruoraAPIKeyGetter in Swift.
/// This handles the asynchronous retrieval of the API key for the Validations SDK.
public class SecureApiKeyProvider: TruoraAPIKeyGetter {
    private let apiKey: String
    
    public init(apiKey: String) {
        self.apiKey = apiKey
    }
    
    /**
     * Retrieves the API key. 
     * Marked as 'async throws' to support secure network-based or 
     * disk-encrypted (Keychain) lookups that might fail or take time.
     */
    public func getApiKeyFromSecureStorage() async throws -> String {
        // In a production app, you might fetch this from the iOS Keychain
        // using a library like SwiftKeychainWrapper or LocalAuthentication.
        return apiKey
    }
}

            

                
Key: Privacy - Camera Usage DescriptionValue: We need camera access to verify your identity.

            

                
  pod 'TruoraValidationsSDK', '1.0.0'

            

                
import UIKit
import TruoraValidationsSDK

class ViewController: UIViewController, TruoraAPIKeyGetter {

    // 1. Implement the Key Getter
    func getApiKeyFromSecureStorage() async throws -> String {
        // In a production app, you might fetch this from the iOS Keychain
        // using a library like SwiftKeychainWrapper or LocalAuthentication.
    }

    func startValidation() {
        Task {
            // 2. Build the SDK
            let validation = TruoraValidationsSDK.Builder(
                apiKeyGenerator: self, 
                userId: "user_unique_id"
            )
            .withValidation { (face: Face) in
                // Configure Face specific settings
                face
                    .useAutocapture(true)
                    .setSimilarityThreshold(0.95)
                    .setTimeout(60)
			.waitForResults(false)
            }
            .build() // Returns a TruoraValidation<Face> object

            // 3. Start the flow
            await validation.start(from: self) { [weak self] result in
                self?.handleResult(result)
            }
        }
    }

    func handleResult(_ result: TruoraValidationResult<ValidationResult>) {
        switch result {
        case .completed(let validationResult):
            print("Success! ID: \(validationResult.validationId)")
            print("Status: \(validationResult.status)")
            
        case .error(let error):
            print("Validation failed: \(error.localizedDescription)")
            // You can check for specific errors like user cancellation
        }
    }
}

            

                
// 1. Build the SDK
let validation = TruoraValidationsSDK.Builder(
    apiKeyGenerator: self,
    userId: "user_unique_id"
)
.withValidation { (face: Face) in
    // Configure Face specific settings
    face
        .useAutocapture(true)
        .setSimilarityThreshold(0.95)
        .setTimeout(60)
        .waitForResults(false)
}
.build() // Returns a TruoraValidation<Face> object

            

                
// 1. Build the SDK
let validation = TruoraValidationsSDK.Builder(
    apiKeyGenerator: self,
    userId: "user_unique_id"
)
.withValidation { (doc: Document) in
    doc.useAutocapture(true)
        .setSimilarityThreshold(0.95)
        .setTimeout(60)
        .waitForResults(false)
        .setCountry(.co) // Country code (e.g., co, mx, pe)
        .setDocumentType(.national_id) // Type of document
}
.build() // Returns a TruoraValidation<Document> object

            

                
public struct ValidationResult: Codable, Equatable {
    public let validationId: String // Unique ID for this validation
    public let status: ValidationStatus // Status of the validation
    public let confidence: Double?

    /// Full validation detail from the API response.
    /// Available when the result comes from polling (not for canceled/pending results).
    public let detail: ValidationDetail?
}

            

                
func handleResult(result: ValidationResult) {
switch result {
  case .completed(let validation):
      print('Validation ID: \(validation.validationId)');
      print('Status: \(validation.status.rawValue)');
      if (validation.status ==.success) {
        // User passed the validation
        navigateToSuccessScreen();
      } else if (validation.status == ValidationStatus.failure) {
        // User did not pass the validation criteria
        showRetryDialog();
      }
      break;

  case .error(let err):
      // SDK error occurred - handle based on error type 
      handleSdkError(err)
	break
  case .canceled(let partialResult):
      // User cancelled - just go back 
      goToPrevScreen()
	break
  }
}


private func handleSDKError(_ error: TruoraException) {
    switch error {
    case .sdk(let sdkError):
        switch sdkError.type {
        case .cameraPermissionError:
            // Camera permission denied — prompt user to grant it
            showAlert(
                title: "Camera Permission Required",
                message: "Please enable camera access in Settings to continue."
            )
        default:
            showAlert(
                title: "SDK Error (\(sdkError.code))",
                message: sdkError.errorDescription ?? "Unknown SDK error"
            )
        }

    case .network(let message, _):
        showAlert(
            title: "Connection Error",
            message: "Connection error: \(message)"
        )

    case .validationApi(let apiError):
        showAlert(
            title: "API Error",
            message: "API error: \(apiError.errorDescription ?? "Unknown API error")"
        )
    }
}

            

                
import SwiftUI
import TruoraValidationsSDK

struct ValidationScreen: View {
    @StateObject private var viewModel = ValidationViewModel()

    var body: some View {
        VStack(spacing: 40) {
            Text(viewModel.validationStatus)
                .font(.title3)
                .multilineTextAlignment(.center)
                .padding(.horizontal)

            Button {
                viewModel.startFaceValidation()
            } label: {
                if viewModel.isValidating {
                    ProgressView()
                        .tint(.white)
                } else {
                    Text("Start Face Validation")
                }
            }
            .disabled(viewModel.isValidating)
            .padding(.horizontal, 32)
            .padding(.vertical, 16)
            .background(viewModel.isValidating ? Color.gray : Color.blue)
            .foregroundColor(.white)
            .cornerRadius(8)
        }
        .alert(isPresented: $viewModel.showAlert) {
            Alert(
                title: Text(viewModel.alertTitle),
                message: Text(viewModel.alertMessage),
                dismissButton: .default(Text("OK"))
            )
        }
    }
}

// MARK: - ViewModel

@MainActor
class ValidationViewModel: ObservableObject {
    @Published var validationStatus = "Ready to start validation"
    @Published var isValidating = false
    @Published var showAlert = false
    @Published var alertTitle = ""
    @Published var alertMessage = ""

    private let apiKey = "YOUR_API_KEY"

    func startFaceValidation() {
        isValidating = true
        validationStatus = "Starting face validation..."

        let validation = TruoraValidationsSDK.Builder(
            apiKeyGenerator: self,
            userId: "ios-test-user"
        )
        .withConfig { config in
            config
                .setPrimaryColor("#435AE0")
                .setSurfaceColor("#FFFFFF")
                .setErrorColor("#FF5454")
                .setLogo("https://your-cdn.com/logo.png", width: 120, height: 40)
        }
        .withValidation { (face: Face) in
            face
                .useAutocapture(true)
                .setSimilarityThreshold(0.8)
                .waitForResults(true)
            return face
        }
        .build()

        Task { @MainActor in
            defer { isValidating = false }

            guard let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
                  let rootViewController = windowScene.windows.first?.rootViewController else {
                validationStatus = "Could not find root view controller"
                return
            }

            await validation.start(from: rootViewController) { [weak self] result in
                self?.handleValidationResult(result)
            }
        }
    }

    private func handleValidationResult(_ result: TruoraValidationResult<ValidationResult>) {
        switch result {
        case .completed(let validation):
            switch validation.status {
            case .success:
                validationStatus = "Success! ID: \(validation.validationId)"
            case .failure:
                validationStatus = "Validation failed. Please try again."
            case .pending:
                validationStatus = "Processing..."
            default:
                validationStatus = "Status: \(validation.status.rawValue)"
            }

        case .error(let error):
            // Detailed error handling using pattern matching
            switch error {
            case .sdk(let sdkError):
                switch sdkError.type {
                case .cameraPermissionError:
                    validationStatus = "Camera permission required"
                case .networkError:
                    validationStatus = "Connection error: \(sdkError.errorDescription ?? "")"
                default:
                    validationStatus = "Error: \(sdkError.errorDescription ?? "Unknown")"
                }

            case .network(let message, _):
                validationStatus = "Connection error: \(message)"

            case .validationApi(let apiError):
                validationStatus = "API error: \(apiError.errorDescription ?? "Unknown")"
            }

        case .canceled(let partialResult):
            if let partialResult {
                validationStatus = "Canceled. Partial ID: \(partialResult.validationId)"
            } else {
                validationStatus = "Validation canceled by user"
            }
        }
    }

    private func showAlert(title: String, message: String) {
        alertTitle = title
        alertMessage = message
        showAlert = true
    }
}

// MARK: - API Key Provider

extension ValidationViewModel: TruoraAPIKeyGetter {
    func getApiKeyFromSecureLocation() async throws -> String {
        apiKey
    }
}

            

                
    func startDocumentValidation() {
        isValidating = true
        validationStatus = "Starting document validation..."

        let validation = TruoraValidationsSDK.Builder(
            apiKeyGenerator: self,
            userId: "ios-test-user"
        )
        .withConfig { config in
            config
                .setPrimaryColor("#435AE0")
                .setSurfaceColor("#FFFFFF")
                .setErrorColor("#FF5454")
                .setLogo("https://your-cdn.com/logo.png", width: 120, height: 40)
        }
        .withValidation { (face: Face) in
            face
                .useAutocapture(true)
                .waitForResults(true)
            return face
        }
        .build()

        Task { @MainActor in
            defer { isValidating = false }

            guard let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
                  let rootViewController = windowScene.windows.first?.rootViewController else {
                validationStatus = "Could not find root view controller"
                return
            }

            await validation.start(from: rootViewController) { [weak self] result in
                self?.handleValidationResult(result)
            }
        }
    }