// try-catch 방식 (작동하지만 Flow스럽지 않음)
try {
    dataFlow.collect { data -> process(data) }
} catch (e: Exception) {
    handleError(e)
}

// Flow 방식 (권장)
dataFlow
    .catch { e -> handleError(e) }
    .collect { data -> process(data) }

flow {
    emit(1)
    throw IOException("네트워크 오류")
    emit(2)  // 실행되지 않음
}
.catch { e ->
    println("에러 처리: ${e.message}")
    emit(-1)  // 에러 발생 시 대체 값 방출 가능
}
.collect { value ->
    println("수집: $value")
}

// 출력:
// 수집: 1
// 에러 처리: 네트워크 오류
// 수집: -1

flow { emit(loadData()) }           // 에러 발생 가능
    .map { transform(it) }          // 에러 발생 가능
    .catch { e ->                   // 위의 모든 업스트림 에러를 처리
        emit(defaultValue)
    }
    .collect { value ->
        riskyOperation(value)       // 여기서 발생하는 에러는 catch가 잡지 않음!
    }

// collect 내 에러를 처리하려면 try-catch 사용
.collect { value ->
    try {
        riskyOperation(value)
    } catch (e: Exception) {
        handleError(e)
    }
}

apiFlow
    .catch { e ->
        when (e) {
            is IOException -> emit(Result.failure(NetworkException("네트워크 오류")))
            is HttpException -> when (e.code()) {
                401 -> emit(Result.failure(AuthException("인증 실패")))
                404 -> emit(Result.failure(NotFoundException("리소스 없음")))
                else -> emit(Result.failure(e))
            }
            is CancellationException -> throw e  // 취소는 반드시 재전파
            else -> emit(Result.failure(e))
        }
    }

// 에러 발생 시 캐시 데이터로 대체
remoteDataFlow
    .catch { e ->
        if (e is IOException) {
            emitAll(localCacheFlow)  // 캐시 Flow 전체를 방출
        } else {
            throw e  // 다른 에러는 재전파
        }
    }
    .collect { data -> updateUI(data) }

flow {
    emit(1)
    emit(2)
}
.onCompletion { cause ->
    if (cause != null) {
        println("에러로 종료: ${cause.message}")
    } else {
        println("정상 완료")
    }
}
.collect { println("수집: $it") }

// 출력:
// 수집: 1
// 수집: 2
// 정상 완료

flow {
    emit(1)
    throw RuntimeException("오류 발생")
}
.onCompletion { cause ->
    println("종료 이유: $cause")  // cause = RuntimeException("오류 발생")
}
.catch { e ->
    println("catch 처리: ${e.message}")
}
.collect { println("수집: $it") }

// 출력:
// 수집: 1
// 종료 이유: java.lang.RuntimeException: 오류 발생
// catch 처리: 오류 발생

flow { throw IOException("에러") }
    .onCompletion { cause -> println("onCompletion: $cause") }  // 1번째
    .catch { e -> println("catch: ${e.message}") }              // 2번째
    .collect { }

// 출력:
// onCompletion: java.io.IOException: 에러
// catch: 에러

flow {
    emit("데이터1")
    emit("데이터2")
}
.onCompletion { cause ->
    if (cause == null) {
        emit("모든 데이터 로드 완료")  // 정상 완료 시에만 추가 방출
    }
}
.collect { println(it) }

// 출력:
// 데이터1
// 데이터2
// 모든 데이터 로드 완료

class ProductViewModel(private val repo: ProductRepository) : ViewModel() {

    private val _isLoading = MutableStateFlow(false)
    val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()

    private val _products = MutableStateFlow<List<Product>>(emptyList())
    val products: StateFlow<List<Product>> = _products.asStateFlow()

    private val _error = MutableStateFlow<String?>(null)
    val error: StateFlow<String?> = _error.asStateFlow()

    fun loadProducts() {
        viewModelScope.launch {
            repo.getProductsFlow()
                .onStart { _isLoading.value = true }
                .onCompletion { _isLoading.value = false }  // 항상 로딩 해제
                .catch { e -> _error.value = e.message }
                .collect { products -> _products.value = products }
        }
    }
}

fun readFileFlow(path: String): Flow<String> = flow {
    val reader = BufferedReader(FileReader(path))
    reader.forEachLine { emit(it) }
    reader.close()  // 정상 완료 시 닫힘
}
.onCompletion { cause ->
    // 에러/취소 포함 어떤 경우에도 리소스 정리 보장
    println("파일 읽기 종료, 에러: $cause")
}

// 로딩 인디케이터 + 에러 스낵바 조합
dataFlow
    .onStart { showLoading() }
    .onCompletion { hideLoading() }
    .catch { e ->
        showErrorSnackbar(e.message)
        emit(emptyList())
    }
    .collect { data -> renderData(data) }

flow {
    emit(loadData())
}
.onStart {
    // Flow 수집 시작 직전, 값 방출 가능
    emit(CachedData)
    _isLoading.value = true
}
.map { transform(it) }
.catch { e ->
    // 업스트림 에러 처리, emit 가능
    emit(defaultValue)
}
.onCompletion { cause ->
    // 종료 시 항상 실행 (정상/에러/취소 무관), emit 가능
    _isLoading.value = false
}
.collect { data ->
    // 최종 소비, 여기서의 에러는 catch가 못 잡음
    updateUI(data)
}

flow { emit(loadData()) }
    .catch { e ->
        if (e is CancellationException) throw e  // 취소는 반드시 재전파!
        handleError(e)
    }