SwiftData

import SwiftData

//  @Model transforme cette classe en modèle persistant
@Model
final class Product {

    var name:     String
    var quantity: Int       //  Utilisez Int, pas String, pour les nombres
    var price:    Double
    var addedAt:  Date

    init(name: String, quantity: Int, price: Double) {
        self.name     = name
        self.quantity = quantity
        self.price    = price
        self.addedAt  = Date.now
    }
}

@Model
final class Product {

    // Valeur unique — SwiftData refuse les doublons sur ce champ
    @Attribute(.unique) var name: String

    // Stocké en dehors du fichier SQLite (recommandé pour les images > quelques Ko)
    @Attribute(.externalStorage) var thumbnail: Data?

    var quantity: Int
    var price:    Double

    init(name: String, quantity: Int, price: Double) {
        self.name     = name
        self.quantity = quantity
        self.price    = price
    }
}

@Model
final class Product {
    var name:     String
    var quantity: Int
    var price:    Double

    //  Cette propriété existe seulement en mémoire — jamais sauvegardée
    @Transient var isBeingEdited: Bool = false

    init(name: String, quantity: Int, price: Double) {
        self.name     = name
        self.quantity = quantity
        self.price    = price
    }
}

import SwiftUI
import SwiftData

@main
struct CoreDataDemoApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        //  Une seule ligne suffit pour configurer toute la persistance
        .modelContainer(for: [Product.self])
    }
}

// Pour plusieurs modèles :
.modelContainer(for: [Product.self, Category.self, Order.self])

// Stockage en mémoire (données perdues à la fermeture — utile pour les previews)
let config = ModelConfiguration(isStoredInMemoryOnly: true)
let container = try ModelContainer(for: Product.self,
                                    configurations: config)

// Emplacement personnalisé sur disque
let url    = URL.applicationSupportDirectory.appending(path: "myapp.store")
let config = ModelConfiguration(url: url)

// Lecture seule (utile pour des données pré-chargées)
let config = ModelConfiguration(isReadOnly: true)

import SwiftUI
import SwiftData

struct ContentView: View {

    //  ModelContext fourni automatiquement par le .modelContainer de l'App
    @Environment(\.modelContext) private var context

    var body: some View { ... }
}

//  Créer et insérer 
let product = Product(name: "Pomme", quantity: 12, price: 1.99)
context.insert(product)
try? context.save()

//  Modifier 
// Il suffit de modifier la propriété — @Model suit les changements automatiquement
product.quantity = 20
try? context.save()

//  Supprimer 
context.delete(product)
try? context.save()

//  Supprimer depuis une liste (avec .onDelete) 
private func deleteProducts(at offsets: IndexSet) {
    for index in offsets {
        context.delete(products[index])
    }
    try? context.save()
}

struct ContentView: View {

    // Récupère tous les produits, sans tri
    @Query var products: [Product]

    // Trié alphabétiquement par nom (A → Z)
    @Query(sort: \.name) var products: [Product]

    // Trié par date d'ajout, ordre décroissant (plus récent en premier)
    @Query(sort: \.addedAt, order: .reverse) var products: [Product]

    // Trié par plusieurs critères
    @Query(sort: [
        SortDescriptor(\.name),
        SortDescriptor(\.addedAt, order: .reverse)
    ]) var products: [Product]

    var body: some View {
        List(products) { product in
            Text(product.name)
        }
    }
}

// Produits dont le nom contient "pomme" (insensible à la casse)
let searchText = "pomme"
let pred = #Predicate<Product> {
    $0.name.localizedStandardContains(searchText)
}

// Produits dont la quantité est supérieure à 10
let pred = #Predicate<Product> { $0.quantity > 10 }

// Combinaison de critères
let minQty = 5
let pred = #Predicate<Product> {
    $0.name.localizedStandardContains(searchText) && $0.quantity > minQty
}

struct ContentView: View {
    @State private var searchText = ""

    var body: some View {
        FilteredProductsView(search: searchText)
    }
}

//  @Query ne peut pas utiliser des variables de la vue directement.
// On crée une sous-vue qui reçoit la valeur et initialise @Query dans son init.
struct FilteredProductsView: View {
    @Query private var products: [Product]

    init(search: String) {
        let predicate = #Predicate<Product> {
            search.isEmpty || $0.name.localizedStandardContains(search)
        }
        _products = Query(filter: predicate, sort: \.name)
    }

    var body: some View {
        List(products) { product in
            Text(product.name)
        }
    }
}

let predicate   = #Predicate<Product> { $0.quantity > 0 }
var descriptor  = FetchDescriptor<Product>(
    predicate:  predicate,
    sortBy:    [SortDescriptor(\.name)]
)
descriptor.fetchLimit = 20   // Limiter le nombre de résultats

let results = try? context.fetch(descriptor)

@Model
final class Category {
    var name: String

    // Une catégorie contient plusieurs produits (one-to-many)
    // deleteRule: .cascade → supprimer la catégorie supprime aussi ses produits
    @Relationship(deleteRule: .cascade) var products: [Product] = []

    init(name: String) { self.name = name }
}

@Model
final class Product {
    var name:     String
    var quantity: Int

    // Relation inverse — un produit appartient à une catégorie
    var category: Category?

    init(name: String, quantity: Int) {
        self.name     = name
        self.quantity = quantity
    }
}

// Utilisation :
let cat = Category(name: "Fruits")
let p   = Product(name: "Pomme", quantity: 10)
cat.products.append(p)
context.insert(cat)
try? context.save()