/// Central dependency injection container
/// Builds and owns all app-wide singletons and factories
@MainActor
@available(iOS 17.0, *)
public final class CompositionRoot {
    
    // MARK: - Singletons
    
    /// SwiftData model container
    public let modelContainer: ModelContainer
    
    /// HTTP client with interceptors
    public let httpClient: HTTPClient
    
    /// Keychain storage
    public let keychainStore: KeychainStore
    
    /// Auth client (SessionManager or MockAuthClient)
    public let sessionManager: AuthClient
    .
    .
    .
    // MARK: - Factory Methods
    
    /// Create ChatViewModel with injected dependencies
    public func makeChatViewModel(conversationID: UUID) -> ChatViewModel {
        ChatViewModel(
            conversationID: conversationID,
            messageRepository: messageRepository,
            llmClient: llmClient
        )
    }
}

/// Main authentication client protocol
@available(iOS 17.0, *)
@preconcurrency
public protocol AuthClient: Sendable {
    /// Sign in with Apple ID
    func signInWithApple() async throws -> AuthUser
    
    /// Sign in with Google
    func signInWithGoogle() async throws -> AuthUser

// Implementations:
// - SupabaseAuthClient (production)
// - MockAuthClient (testing)

1. User types message → ChatView
2. ChatView calls → ChatViewModel.sendMessage()
3. ChatViewModel:
   - Saves message → MessageRepository
   - Streams AI response → LLMClient
   - Updates @Published state
4. View automatically re-renders

1. User enters credentials → SignInView
2. View calls → AuthViewModel.signIn()
3. AuthViewModel calls → AuthClient.signInWithEmail()
4. AuthClient:
   - Calls Supabase API
   - Saves token → Keychain (via SessionStore)
   - Returns AuthUser
5. CompositionRoot observes auth state change
6. Navigation switches to authenticated content

@MainActor
@Observable
public final class ChatViewModel {
    private let messageRepository: any MessageRepository
    private let llmClient: any LLMClient
    ...
}

/// Send current input text
    public func send() async {
        // 1. Validate input
        .
        .
        .

func testSendMessage() async throws {
    let mockLLM = MockLLMClient()
    let viewModel = ChatViewModel(llmClient: mockLLM, ...)
    
    await viewModel.sendMessage("Hello")
    
    XCTAssertEqual(viewModel.messages.count, 2) // user + AI
}

func testCompositionRoot() {
    let composition = CompositionRoot()
    
    // Verify all dependencies created
    XCTAssertNotNil(composition.httpClient)
    XCTAssertNotNil(composition.sessionManager)
    
    // Verify factories work
    let chatVM = composition.makeChatViewModel(conversationID: uuid)
    XCTAssertNotNil(chatVM)
}

func testChatFlow() throws {
    let app = XCUIApplication()
    app.launch()
    
    // Navigate to chat
    app.buttons["Start Chat"].tap()
    
    // Send message
    let textField = app.textFields["messageInput"]
    textField.tap()
    textField.typeText("Hello AI")
    app.buttons["send"].tap()
    
    // Verify response appears
    XCTAssertTrue(app.staticTexts["Hello AI"].exists)
}

// Want to use Firebase instead of Supabase?
class FirebaseAuthClient: AuthClient {
    func signIn(email: String, password: String) async throws -> AuthUser {
        // Firebase implementation
    }
    // ... implement other methods
}

// Update CompositionRoot:
self.sessionManager = FirebaseAuthClient(...)