Dependency injection

protocol RecipesAPI: Sendable {
    func recipes() async throws -> [Recipe]
}

struct LiveRecipesAPI: RecipesAPI {
    let session: URLSession
    let baseURL: URL
    func recipes() async throws -> [Recipe] {
        let (data, _) = try await session.data(from: baseURL.appending(path: "recipes"))
        return try JSONDecoder().decode([Recipe].self, from: data)
    }
}

// A struct of closures: an alternative to a protocol, easy to override per test
struct FavoritesClient: Sendable {
    var load: @Sendable () -> Set<Recipe.ID>
    var save: @Sendable (Set<Recipe.ID>) -> Void
}

extension FavoritesClient {
    static func live(defaults: UserDefaults) -> FavoritesClient {
        FavoritesClient(
            load: { Set(defaults.stringArray(forKey: "favorites") ?? []) },
            save: { defaults.set(Array($0), forKey: "favorites") }
        )
    }
    static let inMemory = FavoritesClient(load: { [] }, save: { _ in })
}

// Everything the app needs, created once
@MainActor
final class AppDependencies {
    let recipesAPI: RecipesAPI
    let favorites: FavoritesClient
    let now: @Sendable () -> Date

    init(recipesAPI: RecipesAPI, favorites: FavoritesClient, now: @escaping @Sendable () -> Date) {
        self.recipesAPI = recipesAPI
        self.favorites = favorites
        self.now = now
    }

    static func live() -> AppDependencies {
        AppDependencies(
            recipesAPI: LiveRecipesAPI(session: .shared, baseURL: URL(string: "https://api.example.com")!),
            favorites: .live(defaults: .standard),
            now: { Date() }
        )
    }
}

// The composition root
@main
struct RecipesApp: App {
    @State private var dependencies = ProcessInfo.processInfo.arguments.contains("--ui-testing")
        ? AppDependencies.uiTesting()                      // fakes for UI tests
        : AppDependencies.live()

    var body: some Scene {
        WindowGroup {
            RecipeListScreen(api: dependencies.recipesAPI, favorites: dependencies.favorites)
        }
    }
}

// A value dependency with a safe default
extension EnvironmentValues {
    @Entry var recipesClient: RecipesClient = .unimplemented     // previews and tests must set it
}

// A shared, observable object
@Observable @MainActor
final class Cart {
    private(set) var items: [CartItem] = []
    func add(_ recipe: Recipe) { items.append(CartItem(recipe: recipe)) }
}

@main
struct RecipesApp: App {
    @State private var cart = Cart()
    private let client = RecipesClient.live

    var body: some Scene {
        WindowGroup {
            RootView()
                .environment(cart)                              // type-keyed object
                .environment(\.recipesClient, client)           // keyed value
        }
    }
}

struct AddToCartButton: View {
    let recipe: Recipe
    @Environment(Cart.self) private var cart                    // crashes if not provided

    var body: some View {
        Button("Add ingredients to cart") { cart.add(recipe) }
    }
}

struct RecipeListScreen: View {
    @Environment(\.recipesClient) private var client
    @State private var viewModel: RecipeListViewModel?

    var body: some View {
        Group {
            if let viewModel { RecipeList(viewModel: viewModel) } else { ProgressView() }
        }
        .task {
            // Environment values are available in body and tasks, not in init
            if viewModel == nil { viewModel = RecipeListViewModel(client: client) }
            await viewModel?.load()
        }
    }
}

#Preview {
    RecipeListScreen()
        .environment(Cart())
        .environment(\.recipesClient, .preview(recipes: .samples))
}