Questions entretien iOS accessibilité en 2026 : VoiceOver et Dynamic Type

// Vérifier si VoiceOver est actif
if UIAccessibility.isVoiceOverRunning {
    // Adapter l'interface pour VoiceOver
    showSimplifiedInterface()
}

// Vérifier si Reduce Motion est activé
if UIAccessibility.isReduceMotionEnabled {
    // Désactiver les animations complexes
    animationDuration = 0
}

// Vérifier si Bold Text est activé
if UIAccessibility.isBoldTextEnabled {
    // Utiliser des polices plus épaisses
    applyBoldFonts()
}

// Observer les changements de paramètres
NotificationCenter.default.addObserver(
    forName: UIAccessibility.voiceOverStatusDidChangeNotification,
    object: nil,
    queue: .main
) { _ in
    // Réagir au changement
    updateAccessibilityLayout()
}

// En UIKit : configurer un élément accessible
class CustomButton: UIButton {
    override var accessibilityLabel: String? {
        get { "Bouton de validation" }  // Ce que VoiceOver lit
        set { }
    }

    override var accessibilityHint: String? {
        get { "Double-tapez pour confirmer la commande" }  // Action possible
        set { }
    }

    override var accessibilityTraits: UIAccessibilityTraits {
        get { .button }  // Type d'élément
        set { }
    }

    override var isAccessibilityElement: Bool {
        get { true }  // Élément focusable par VoiceOver
        set { }
    }
}

// En SwiftUI : équivalent avec les modifiers
struct ValidateButton: View {
    var body: some View {
        Button("Valider") {
            confirmOrder()
        }
        .accessibilityLabel("Bouton de validation")
        .accessibilityHint("Double-tapez pour confirmer la commande")
    }
}

// Exemple avec un slider de volume
class VolumeSlider: UISlider {
    override var accessibilityLabel: String? {
        get { "Volume" }  // Identité fixe de l'élément
        set { }
    }

    override var accessibilityValue: String? {
        get { "\(Int(value * 100))%" }  // État actuel qui change
        set { }
    }
}
// VoiceOver lit : "Volume, 75%"

// En SwiftUI avec un Toggle
struct NotificationToggle: View {
    @Binding var isEnabled: Bool

    var body: some View {
        Toggle(isOn: $isEnabled) {
            Text("Notifications")
        }
        .accessibilityLabel("Notifications push")
        // accessibilityValue est automatique pour Toggle : "activé" ou "désactivé"
    }
}

// Pour un stepper personnalisé
struct QuantityStepper: View {
    @State private var quantity = 1

    var body: some View {
        Stepper("Quantité", value: $quantity, in: 1...99)
            .accessibilityLabel("Quantité d'articles")
            .accessibilityValue("\(quantity) article\(quantity > 1 ? "s" : "")")
    }
}

// Traits courants en UIKit
class CustomCell: UITableViewCell {
    override var accessibilityTraits: UIAccessibilityTraits {
        get {
            var traits: UIAccessibilityTraits = []

            // Type d'élément
            traits.insert(.button)           // Élément interactif

            // État actuel
            if isSelected {
                traits.insert(.selected)     // Actuellement sélectionné
            }

            // Caractéristiques spéciales
            if !isEnabled {
                traits.insert(.notEnabled)   // Désactivé
            }

            return traits
        }
        set { }
    }
}

// Traits disponibles
// .button         - Élément cliquable
// .link           - Lien hypertexte
// .header         - Titre de section
// .image          - Image
// .selected       - État sélectionné
// .notEnabled     - Désactivé
// .adjustable     - Valeur modifiable (slider)
// .staticText     - Texte non interactif
// .searchField    - Champ de recherche
// .playsSound     - Joue un son
// .startsMediaSession - Lance une lecture média

// En SwiftUI
struct SectionHeader: View {
    let title: String

    var body: some View {
        Text(title)
            .font(.headline)
            .accessibilityAddTraits(.isHeader)  // Annoncé comme titre
    }
}

struct SelectableRow: View {
    let isSelected: Bool

    var body: some View {
        HStack {
            Text("Option")
            if isSelected {
                Image(systemName: "checkmark")
            }
        }
        .accessibilityElement(children: .combine)
        .accessibilityAddTraits(isSelected ? .isSelected : [])
    }
}

// En UIKit : utiliser les styles de texte préférés
class ArticleCell: UITableViewCell {
    let titleLabel = UILabel()
    let bodyLabel = UILabel()

    func configure() {
        // Utiliser les styles de texte sémantiques
        titleLabel.font = UIFont.preferredFont(forTextStyle: .headline)
        bodyLabel.font = UIFont.preferredFont(forTextStyle: .body)

        // CRUCIAL : activer l'ajustement automatique
        titleLabel.adjustsFontForContentSizeCategory = true
        bodyLabel.adjustsFontForContentSizeCategory = true

        // Permettre le multiline pour les grandes tailles
        titleLabel.numberOfLines = 0
        bodyLabel.numberOfLines = 0
    }
}

// En SwiftUI : c'est automatique avec les styles
struct ArticleView: View {
    var body: some View {
        VStack(alignment: .leading) {
            Text("Titre de l'article")
                .font(.headline)  // S'adapte automatiquement

            Text("Contenu de l'article...")
                .font(.body)
        }
    }
}

// Police personnalisée avec Dynamic Type
extension UIFont {
    static func customFont(
        size: CGFloat,
        style: TextStyle
    ) -> UIFont {
        let customFont = UIFont(name: "CustomFont-Regular", size: size)!

        // Adapter à la catégorie de taille actuelle
        return UIFontMetrics(forTextStyle: style)
            .scaledFont(for: customFont)
    }
}

// Détecter les tailles d'accessibilité
struct AdaptiveLayout: View {
    @Environment(\.dynamicTypeSize) var dynamicTypeSize

    var body: some View {
        // Layout différent pour les grandes tailles
        if dynamicTypeSize.isAccessibilitySize {
            // Layout vertical pour grandes tailles
            VStack(alignment: .leading, spacing: 12) {
                iconAndTitle
                actionButtons
            }
        } else {
            // Layout horizontal standard
            HStack {
                iconAndTitle
                Spacer()
                actionButtons
            }
        }
    }

    var iconAndTitle: some View {
        HStack {
            Image(systemName: "bell.fill")
                .accessibilityHidden(true)  // Décoratif, ignorer
            Text("Notifications")
        }
    }

    var actionButtons: some View {
        HStack(spacing: 16) {
            Button("Activer") { }
            Button("Paramètres") { }
        }
    }
}

// En UIKit : observer les changements
class AdaptiveViewController: UIViewController {
    override func traitCollectionDidChange(
        _ previousTraitCollection: UITraitCollection?
    ) {
        super.traitCollectionDidChange(previousTraitCollection)

        // Vérifier si la catégorie de taille a changé
        if traitCollection.preferredContentSizeCategory !=
           previousTraitCollection?.preferredContentSizeCategory {
            updateLayoutForContentSize()
        }
    }

    func updateLayoutForContentSize() {
        let category = traitCollection.preferredContentSizeCategory

        if category.isAccessibilityCategory {
            // Activer le layout accessible
            stackView.axis = .vertical
            decorativeView.isHidden = true
        } else {
            // Layout standard
            stackView.axis = .horizontal
            decorativeView.isHidden = false
        }
    }
}

// Image informative : décrire le contenu
struct ProductImage: View {
    let product: Product

    var body: some View {
        AsyncImage(url: product.imageURL) { image in
            image
                .resizable()
                .accessibilityLabel(product.imageDescription)
                // "Photo du produit : iPhone 15 Pro, coloris titane"
        } placeholder: {
            ProgressView()
                .accessibilityLabel("Chargement de l'image")
        }
    }
}

// Image décorative : masquer de VoiceOver
struct DecorationView: View {
    var body: some View {
        Image(systemName: "sparkles")
            .accessibilityHidden(true)  // Ignorée par VoiceOver
    }
}

// Bouton image : décrire l'action, pas l'image
struct FavoriteButton: View {
    @Binding var isFavorite: Bool

    var body: some View {
        Button {
            isFavorite.toggle()
        } label: {
            Image(systemName: isFavorite ? "heart.fill" : "heart")
        }
        // Ne pas décrire l'icône, décrire l'action
        .accessibilityLabel(isFavorite ? "Retirer des favoris" : "Ajouter aux favoris")
    }
}

// En UIKit
class ProductImageView: UIImageView {
    override var isAccessibilityElement: Bool {
        get { true }
        set { }
    }

    func configure(with product: Product) {
        image = product.image
        accessibilityLabel = "Photo : \(product.name), \(product.color)"
    }
}

// Image avec texte intégré (infographie)
class InfographicView: UIImageView {
    override var accessibilityLabel: String? {
        get {
            // Transcrire le contenu textuel de l'infographie
            """
            Infographie statistiques 2026.
            Croissance : 45%.
            Utilisateurs actifs : 2.3 millions.
            Satisfaction : 4.8 sur 5.
            """
        }
        set { }
    }
}

// En SwiftUI : combiner les enfants
struct ProductCard: View {
    let product: Product

    var body: some View {
        VStack(alignment: .leading) {
            Text(product.name)
                .font(.headline)
            Text(product.price)
                .font(.subheadline)
            HStack {
                Image(systemName: "star.fill")
                Text(product.rating)
            }
        }
        // Combine tous les textes en un seul élément
        .accessibilityElement(children: .combine)
        // VoiceOver lit : "iPhone 15 Pro, 1199€, 4.8 étoiles"
    }
}

// En SwiftUI : ignorer les enfants et définir manuellement
struct OrderSummary: View {
    let order: Order

    var body: some View {
        HStack {
            Image(systemName: "bag")
            VStack(alignment: .leading) {
                Text(order.itemCount)
                Text(order.total)
            }
            Image(systemName: "chevron.right")
        }
        // Ignorer la hiérarchie des enfants
        .accessibilityElement(children: .ignore)
        // Définir un label personnalisé
        .accessibilityLabel("Commande de \(order.itemCount) articles pour \(order.total)")
        .accessibilityHint("Double-tapez pour voir les détails")
        .accessibilityAddTraits(.isButton)
    }
}

// En UIKit : conteneur accessible
class ProductCardView: UIView {
    let nameLabel = UILabel()
    let priceLabel = UILabel()
    let ratingLabel = UILabel()

    override var isAccessibilityElement: Bool {
        get { true }  // Le conteneur est l'élément accessible
        set { }
    }

    override var accessibilityLabel: String? {
        get {
            // Combiner les informations
            "\(nameLabel.text ?? ""), \(priceLabel.text ?? ""), \(ratingLabel.text ?? "")"
        }
        set { }
    }
}

// En SwiftUI : actions personnalisées
struct EmailRow: View {
    let email: Email
    let onArchive: () -> Void
    let onDelete: () -> Void
    let onFlag: () -> Void

    var body: some View {
        HStack {
            VStack(alignment: .leading) {
                Text(email.sender)
                    .font(.headline)
                Text(email.subject)
                    .font(.subheadline)
            }
            Spacer()
            if email.isFlagged {
                Image(systemName: "flag.fill")
            }
        }
        .accessibilityElement(children: .combine)
        .accessibilityLabel("\(email.sender), \(email.subject)")
        // Actions accessibles par balayage vertical
        .accessibilityAction(named: "Archiver") {
            onArchive()
        }
        .accessibilityAction(named: "Supprimer") {
            onDelete()
        }
        .accessibilityAction(named: email.isFlagged ? "Retirer le drapeau" : "Marquer d'un drapeau") {
            onFlag()
        }
    }
}

// En UIKit : override accessibilityCustomActions
class EmailCell: UITableViewCell {
    var email: Email!
    var onArchive: (() -> Void)?
    var onDelete: (() -> Void)?

    override var accessibilityCustomActions: [UIAccessibilityCustomAction]? {
        get {
            [
                UIAccessibilityCustomAction(
                    name: "Archiver",
                    target: self,
                    selector: #selector(archiveAction)
                ),
                UIAccessibilityCustomAction(
                    name: "Supprimer",
                    target: self,
                    selector: #selector(deleteAction)
                )
            ]
        }
        set { }
    }

    @objc private func archiveAction() -> Bool {
        onArchive?()
        return true  // true = action réussie
    }

    @objc private func deleteAction() -> Bool {
        onDelete?()
        return true
    }
}

// En SwiftUI avec @AccessibilityFocusState (iOS 15+)
struct SearchView: View {
    @State private var searchText = ""
    @State private var results: [Result] = []
    @AccessibilityFocusState private var focusedResult: Result?

    var body: some View {
        VStack {
            TextField("Rechercher", text: $searchText)
                .onSubmit {
                    performSearch()
                }

            List(results) { result in
                ResultRow(result: result)
                    .accessibilityFocused($focusedResult, equals: result)
            }
        }
    }

    func performSearch() {
        Task {
            results = await api.search(searchText)
            // Déplacer le focus sur le premier résultat
            if let first = results.first {
                focusedResult = first
            }
        }
    }
}

// En UIKit : poster une notification
class ModalViewController: UIViewController {
    @IBOutlet weak var titleLabel: UILabel!

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)

        // Annoncer et déplacer le focus
        UIAccessibility.post(
            notification: .screenChanged,  // Nouvelle écran
            argument: titleLabel           // Élément à focus
        )
    }

    func showError(_ message: String) {
        errorLabel.text = message
        errorLabel.isHidden = false

        // Annoncer le changement de layout
        UIAccessibility.post(
            notification: .layoutChanged,  // Changement dans l'écran actuel
            argument: errorLabel
        )
    }

    func showLoadingComplete() {
        // Annoncer sans déplacer le focus
        UIAccessibility.post(
            notification: .announcement,
            argument: "Chargement terminé"
        )
    }
}

// En SwiftUI : Slider est accessible par défaut
struct VolumeControl: View {
    @Binding var volume: Double

    var body: some View {
        Slider(value: $volume, in: 0...100, step: 5)
            .accessibilityLabel("Volume")
            .accessibilityValue("\(Int(volume)) pour cent")
    }
}

// Slider personnalisé accessible
struct CustomRatingSlider: View {
    @Binding var rating: Int

    var body: some View {
        HStack {
            ForEach(1...5, id: \.self) { star in
                Image(systemName: star <= rating ? "star.fill" : "star")
                    .onTapGesture { rating = star }
            }
        }
        .accessibilityElement(children: .ignore)
        .accessibilityLabel("Note")
        .accessibilityValue("\(rating) étoile\(rating > 1 ? "s" : "") sur 5")
        .accessibilityAdjustableAction { direction in
            switch direction {
            case .increment:
                rating = min(5, rating + 1)
            case .decrement:
                rating = max(1, rating - 1)
            @unknown default:
                break
            }
        }
    }
}

// En UIKit : trait ajustable
class StarRatingView: UIView {
    var rating: Int = 3 {
        didSet {
            updateStars()
            // Annoncer la nouvelle valeur
            UIAccessibility.post(
                notification: .announcement,
                argument: accessibilityValue
            )
        }
    }

    override var accessibilityTraits: UIAccessibilityTraits {
        get { .adjustable }  // Active les gestes d'ajustement
        set { }
    }

    override var accessibilityLabel: String? {
        get { "Note" }
        set { }
    }

    override var accessibilityValue: String? {
        get { "\(rating) étoiles sur 5" }
        set { }
    }

    // Appelé lors du balayage vers le haut
    override func accessibilityIncrement() {
        rating = min(5, rating + 1)
    }

    // Appelé lors du balayage vers le bas
    override func accessibilityDecrement() {
        rating = max(1, rating - 1)
    }
}

struct ImageCarousel: View {
    let images: [CarouselImage]
    @State private var currentIndex = 0

    var body: some View {
        TabView(selection: $currentIndex) {
            ForEach(images.indices, id: \.self) { index in
                CarouselItem(image: images[index])
                    .tag(index)
            }
        }
        .tabViewStyle(.page)
        .accessibilityElement(children: .contain)
        .accessibilityLabel("Carrousel d'images")
        .accessibilityValue("Image \(currentIndex + 1) sur \(images.count)")
        .accessibilityHint("Balayez pour changer d'image")
        .accessibilityAdjustableAction { direction in
            withAnimation {
                switch direction {
                case .increment:
                    currentIndex = min(images.count - 1, currentIndex + 1)
                case .decrement:
                    currentIndex = max(0, currentIndex - 1)
                @unknown default:
                    break
                }
            }
        }
    }
}

// En UIKit avec UIPageViewController
class CarouselAccessibilityContainer: UIView {
    var currentPage = 0
    var totalPages = 5

    override var isAccessibilityElement: Bool {
        get { true }
        set { }
    }

    override var accessibilityTraits: UIAccessibilityTraits {
        get { .adjustable }
        set { }
    }

    override var accessibilityLabel: String? {
        get { "Carrousel promotionnel" }
        set { }
    }

    override var accessibilityValue: String? {
        get { "Page \(currentPage + 1) sur \(totalPages)" }
        set { }
    }

    override func accessibilityIncrement() {
        guard currentPage < totalPages - 1 else { return }
        currentPage += 1
        delegate?.scrollToPage(currentPage)
    }

    override func accessibilityDecrement() {
        guard currentPage > 0 else { return }
        currentPage -= 1
        delegate?.scrollToPage(currentPage)
    }
}

struct RegistrationForm: View {
    @State private var email = ""
    @State private var password = ""
    @State private var emailError: String?
    @State private var passwordError: String?

    var body: some View {
        Form {
            Section {
                TextField("Email", text: $email)
                    .textContentType(.emailAddress)
                    .keyboardType(.emailAddress)
                    .accessibilityLabel("Adresse email")
                    .accessibilityHint(emailError != nil ? "Erreur : \(emailError!)" : nil)

                if let error = emailError {
                    Text(error)
                        .foregroundColor(.red)
                        .font(.caption)
                        .accessibilityLabel("Erreur email : \(error)")
                }
            }

            Section {
                SecureField("Mot de passe", text: $password)
                    .textContentType(.newPassword)
                    .accessibilityLabel("Mot de passe")
                    .accessibilityHint(passwordHint)

                PasswordStrengthIndicator(password: password)
            }

            Button("Créer le compte") {
                submitForm()
            }
            .disabled(!isFormValid)
            .accessibilityHint(isFormValid ? "Double-tapez pour créer votre compte" : "Formulaire incomplet")
        }
    }

    var passwordHint: String {
        if let error = passwordError {
            return "Erreur : \(error)"
        }
        return "Minimum 8 caractères avec majuscules et chiffres"
    }
}

// Indicateur de force du mot de passe accessible
struct PasswordStrengthIndicator: View {
    let password: String

    var strength: PasswordStrength {
        // Logique de calcul
        PasswordStrength.calculate(password)
    }

    var body: some View {
        HStack(spacing: 4) {
            ForEach(0..<4) { index in
                Rectangle()
                    .fill(index < strength.level ? strength.color : Color.gray.opacity(0.3))
                    .frame(height: 4)
            }
        }
        .accessibilityElement(children: .ignore)
        .accessibilityLabel("Force du mot de passe")
        .accessibilityValue(strength.description)  // "Faible", "Moyen", "Fort", "Très fort"
    }
}

// Test unitaire des propriétés d'accessibilité
import XCTest
@testable import MyApp

class AccessibilityTests: XCTestCase {

    func testProductCardAccessibility() {
        let product = Product(name: "iPhone", price: "999€", rating: "4.5")
        let view = ProductCardView(product: product)

        // Vérifier que l'élément est accessible
        XCTAssertTrue(view.isAccessibilityElement)

        // Vérifier le label
        XCTAssertEqual(
            view.accessibilityLabel,
            "iPhone, 999€, 4.5 étoiles"
        )

        // Vérifier les traits
        XCTAssertTrue(view.accessibilityTraits.contains(.button))
    }

    func testDynamicTypeSupport() {
        let label = UILabel()
        label.font = UIFont.preferredFont(forTextStyle: .body)

        // Vérifier l'ajustement automatique
        XCTAssertTrue(label.adjustsFontForContentSizeCategory)
    }
}

// Test UI avec VoiceOver simulé
class AccessibilityUITests: XCTestCase {

    func testLoginFlowAccessibility() {
        let app = XCUIApplication()
        app.launch()

        // Accéder aux éléments par label d'accessibilité
        let emailField = app.textFields["Adresse email"]
        XCTAssertTrue(emailField.exists)

        emailField.tap()
        emailField.typeText("test@example.com")

        let passwordField = app.secureTextFields["Mot de passe"]
        XCTAssertTrue(passwordField.exists)

        let loginButton = app.buttons["Se connecter"]
        XCTAssertTrue(loginButton.exists)
        XCTAssertTrue(loginButton.isEnabled)
    }

    // Audit automatique iOS 17+
    func testAccessibilityAudit() throws {
        let app = XCUIApplication()
        app.launch()

        // Audit automatique de l'écran
        try app.performAccessibilityAudit()
    }
}

// ❌ ERREUR : Bouton sans label accessible
Button {
    performAction()
} label: {
    Image(systemName: "plus")
}
// VoiceOver lit : "Bouton" - inutile

// ✅ CORRECT : Label explicite
Button {
    performAction()
} label: {
    Image(systemName: "plus")
}
.accessibilityLabel("Ajouter un article")


// ❌ ERREUR : Taille de police fixe
Text("Important")
    .font(.system(size: 16))  // Ne respecte pas Dynamic Type

// ✅ CORRECT : Style de texte sémantique
Text("Important")
    .font(.body)  // S'adapte aux préférences


// ❌ ERREUR : Image informative sans description
Image("product-photo")

// ✅ CORRECT : Description du contenu
Image("product-photo")
    .accessibilityLabel("Photo du produit : Casque audio noir")


// ❌ ERREUR : Élément cliquable sans trait button
Text("En savoir plus")
    .onTapGesture { showDetails() }
// VoiceOver ne sait pas que c'est interactif

// ✅ CORRECT : Traits appropriés
Text("En savoir plus")
    .onTapGesture { showDetails() }
    .accessibilityAddTraits(.isButton)
    .accessibilityHint("Double-tapez pour afficher les détails")


// ❌ ERREUR : Contraste insuffisant
Text("Texte gris clair")
    .foregroundColor(.gray.opacity(0.4))

// ✅ CORRECT : Ratio de contraste minimum 4.5:1
Text("Texte lisible")
    .foregroundColor(.secondary)  // Respecte les guidelines


// ❌ ERREUR : Zone tactile trop petite
Button { } label: {
    Image(systemName: "xmark")
        .font(.caption)  // Trop petit (< 44x44 points)
}

// ✅ CORRECT : Zone minimum de 44x44 points
Button { } label: {
    Image(systemName: "xmark")
}
.frame(minWidth: 44, minHeight: 44)