Sami Omar

// Beispiel aus Lernprojekt: Reactive Programming with Combine
// Debounce, Fehlerbehandlung und Main-Thread-Delivery
class SearchViewModel: ObservableObject {
    @Published var searchText = ""
    @Published private(set) var results: [SearchResult] = []
    
    private let searchService: SearchService
    private var cancellables = Set<AnyCancellable>()
    
    init(searchService: SearchService) {
        self.searchService = searchService
        
        // Debounce search input and filter empty strings
        $searchText
            .debounce(for: .milliseconds(300), scheduler: DispatchQueue.main)
            .removeDuplicates()
            .filter { !$0.isEmpty }
            .flatMap { [weak self] query -> AnyPublisher<[SearchResult], Never> in
                guard let self = self else {
                    return Just([]).eraseToAnyPublisher()
                }
                
                return self.searchService
                    .search(query: query)
                    .catch { _ in Just([]) }
                    .eraseToAnyPublisher()
            }
            .receive(on: DispatchQueue.main)
            .assign(to: &$results)
    }
}

// Beispiel aus Lernprojekt: Test-Driven Development
// Unit-Tests für ViewModel-State und Repository-Interaktionen
import XCTest
@testable import MyApp

class UserViewModelTests: XCTestCase {
    var sut: UserViewModel!
    var mockRepository: MockUserRepository!
    
    override func setUp() {
        super.setUp()
        mockRepository = MockUserRepository()
        sut = UserViewModel(repository: mockRepository)
    }
    
    func testLoadUserSuccess() async {
        // Given
        let expectedUser = User(id: "123", name: "Test User")
        mockRepository.userToReturn = expectedUser
        
        // When
        await sut.loadUser(id: "123")
        
        // Then
        switch sut.state {
        case .loaded(let user):
            XCTAssertEqual(user.id, expectedUser.id)
            XCTAssertEqual(user.name, expectedUser.name)
        default:
            XCTFail("Expected loaded state")
        }
    }
}

// Beispiel aus Lernprojekt: Efficient List Rendering with Lazy Loading
// Performance: Prefetching, Lazy-Stacks und bedingtes Laden
struct OptimizedListView: View {
    @StateObject private var viewModel = ListViewModel()
    @State private var visibleRows = Set<Int>()
    
    var body: some View {
        ScrollView {
            LazyVStack(spacing: 0) {
                ForEach(viewModel.items.indices, id: \.self) { index in
                    ItemRow(item: viewModel.items[index])
                        .onAppear {
                            visibleRows.insert(index)
                            // Prefetch next batch when approaching end
                            if index == viewModel.items.count - 5 {
                                Task {
                                    await viewModel.loadMoreItems()
                                }
                            }
                        }
                        .onDisappear {
                            visibleRows.remove(index)
                        }
                        .task {
                            // Load high-res image only when visible
                            if visibleRows.contains(index) {
                                await viewModel.loadHighResImage(for: index)
                            }
                        }
                }
            }
        }
        .scrollIndicators(.hidden)
    }
}