18. Trade-offs: Pure VIP vs Observable VIP

// Ini adalah PERINTAH — dipanggil sekali, dieksekusi sekali, selesai.
viewController?.displayError(message: "Koneksi gagal")
// Tidak ada state yang tersimpan — tidak mungkin error ini muncul lagi
// kecuali Presenter memanggil displayError() lagi.

// Ini adalah STATE — disimpan di displayState.pendingError
displayState.pendingError = "Koneksi gagal"

// Masalah: applyState() bisa dipanggil lagi oleh perubahan property LAIN.
// Misal: isLoading berubah → applyState() → pendingError masih ada → double alert!
//
// Solusi wajib: reset SEGERA setelah dikonsumsi.
if let message = state.pendingError {
    displayState?.pendingError = nil   // ← WAJIB, atau bug
    showErrorAlert(message: message)
}

// Alternatif: bungkus one-time event dalam wrapper yang auto-consume
@Observable
@MainActor
final class UserListDisplayState {
    var displayedUsers: [UserList.FetchUsers.ViewModel.DisplayedUser] = []
    var isLoading: Bool = false

    // Gunakan array sebagai queue — multiple events tidak saling menimpa
    private(set) var errorQueue: [String] = []
    private(set) var navigationQueue: [UserList.SelectUser.ViewModel] = []

    // Hanya Presenter yang boleh enqueue
    fileprivate func enqueueError(_ message: String) {
        errorQueue.append(message)
    }

    fileprivate func enqueueNavigation(_ viewModel: UserList.SelectUser.ViewModel) {
        navigationQueue.append(viewModel)
    }

    // ViewController yang dequeue saat mengkonsumsi
    func dequeueError() -> String? {
        guard !errorQueue.isEmpty else { return nil }
        return errorQueue.removeFirst()
    }

    func dequeueNavigation() -> UserList.SelectUser.ViewModel? {
        guard !navigationQueue.isEmpty else { return nil }
        return navigationQueue.removeFirst()
    }
}

// applyState() lebih aman:
private func applyState() {
    guard let state = displayState else { return }
    // ...regular state...

    // Queue — ambil semua yang pending
    while let message = state.dequeueError() {
        showErrorAlert(message: message)
    }
    while let nav = state.dequeueNavigation() {
        router?.routeToUserDetail(userId: nav.userId, userName: nav.userName)
    }
}

Configurator: presenter.viewController = viewController  (strong)
                        ↑
Agar tidak retain cycle, harus weak:
Presenter: weak var viewController: (any UserListDisplayLogic)?
                                    ↑
Jika lupa weak → retain cycle → memory leak yang sulit dideteksi
Jika weak → viewController bisa nil saat dipanggil → silent failure

Presenter: let displayState = UserListDisplayState()  (owns)
ViewController: var displayState: UserListDisplayState?  (non-owning reference, tidak retain Presenter)

Ownership linear: Presenter → DisplayState ← ViewController
Tidak ada circular reference. Tidak ada yang perlu weak.
Configurator: viewController.configure(displayState: presenter.displayState)
              presenter TIDAK tahu keberadaan ViewController — DI lebih bersih.

// Stack trace saat error muncul di layar:
// 1. UserListInteractor.fetchUsers() — throw
// 2. UserListPresenter.presentError(_:) ← breakpoint di sini
// 3. UserListViewController.displayError(message:) ← atau di sini
// Jelas, linear, mudah di-trace

// Stack trace saat applyState() dipanggil:
// 1. withObservationTracking.onChange ← dipanggil oleh runtime
// 2. continuation.yield(())
// 3. AsyncStream for-await loop
// 4. self?.applyState()  ← breakpoint di sini, tapi TIDAK JELAS property mana yang berubah

// Untuk mengetahui property mana yang trigger, harus tambahkan logging manual:
private func applyState() {
    guard let state = displayState else { return }
    // Debugging: print apa yang berubah
    // (ini tidak bisa otomatis karena withObservationTracking tidak memberitahu PROPERTY mana)
    if state.displayedUsers != currentDisplayedUsers { print("users changed") }
    if state.isLoading { print("loading changed") }
    // ...
}

// Mock yang harus dibuat hanya untuk test
@MainActor
final class MockUserListViewController: UserListDisplayLogic {
    var displayedUsers: [UserList.FetchUsers.ViewModel.DisplayedUser] = []
    var loadingStates: [Bool] = []
    var errorMessages: [String] = []

    func displayUsers(_ viewModel: UserList.FetchUsers.ViewModel) {
        displayedUsers = viewModel.displayedUsers
    }
    func displayLoading(_ isLoading: Bool) { loadingStates.append(isLoading) }
    func displayError(message: String) { errorMessages.append(message) }
    func displaySelectedUser(_ viewModel: UserList.SelectUser.ViewModel) {}
}

// Test
@Test func testPresentUsers() async {
    let mockVC = MockUserListViewController()
    let presenter = UserListPresenter()
    presenter.viewController = mockVC

    let response = UserList.FetchUsers.Response(users: [User(id: "1", name: "Ari", email: "a@b.com", avatarURL: nil)])
    presenter.presentUsers(response)

    #expect(mockVC.displayedUsers.first?.fullName == "Ari")
}

// Tidak perlu mock apapun — cukup cek state
@Test func testPresentUsers() async {
    let presenter = UserListPresenter()

    let response = UserList.FetchUsers.Response(users: [User(id: "1", name: "ari supriatna", email: "a@b.com", avatarURL: nil)])
    await MainActor.run { presenter.presentUsers(response) }

    // Assert langsung ke displayState — lebih intuitif
    let users = await MainActor.run { presenter.displayState.displayedUsers }
    #expect(users.first?.fullName == "Ari Supriatna")  // test format capitalize
    #expect(users.first?.emailLabel == "a@b.com")
}

// Test display logic VC dengan memanggil method langsung
@Test @MainActor func testDisplayUsersUpdatesTable() {
    let vc = UserListViewController()
    vc.loadViewIfNeeded()

    let viewModel = UserList.FetchUsers.ViewModel(displayedUsers: [
        .init(id: "1", fullName: "Ari Supriatna", emailLabel: "ari@test.com", avatarURL: nil)
    ])
    vc.displayUsers(viewModel)  // panggil langsung — synchronous

    #expect(vc.tableView.numberOfRows(inSection: 0) == 1)
}

// Harus setup displayState dan tunggu observation cycle
@Test @MainActor func testDisplayUsersUpdatesTable() async {
    let displayState = UserListDisplayState()
    let vc = UserListViewController()
    vc.configure(displayState: displayState)
    vc.loadViewIfNeeded()

    // Harus tunggu observasi selesai setup
    try? await Task.sleep(for: .milliseconds(50))

    displayState.displayedUsers = [
        .init(id: "1", fullName: "Ari Supriatna", emailLabel: "ari@test.com", avatarURL: nil)
    ]

    // Harus tunggu observation cycle dan applyState() dipanggil
    try? await Task.sleep(for: .milliseconds(50))

    #expect(vc.tableView.numberOfRows(inSection: 0) == 1)
}

1. displayState.isLoading = true       → applyState() #1
2. displayState.displayedUsers = [...]  → applyState() #2
3. displayState.isLoading = false      → applyState() #3