Handling API Errors and Network Failures

sealed interface AppError {
    data object Offline : AppError
    data object Timeout : AppError
    data object Unauthorized : AppError
    data object NotFound : AppError
    data class Validation(val fieldErrors: Map<String, String>) : AppError
    data class Server(val code: Int) : AppError
    data class Unexpected(val cause: Throwable) : AppError
}

class AppException(val error: AppError) : Exception(error.toString())

@Serializable data class ApiErrorBody(val errors: Map<String, String> = emptyMap())

fun Throwable.toAppError(json: Json): AppError = when (this) {
    is AppException -> error
    is SocketTimeoutException -> AppError.Timeout
    is IOException -> AppError.Offline                    // includes UnknownHostException
    is HttpException -> when (code()) {
        401, 403 -> AppError.Unauthorized
        404 -> AppError.NotFound
        422 -> AppError.Validation(
            response()?.errorBody()?.string()
                ?.let { runCatching { json.decodeFromString<ApiErrorBody>(it).errors }.getOrNull() }
                .orEmpty()
        )
        in 500..599 -> AppError.Server(code())
        else -> AppError.Unexpected(this)
    }
    else -> AppError.Unexpected(this)
}

class ProfileRepository(private val api: ProfileApi, private val json: Json) {
    suspend fun updateProfile(input: ProfileInput): Profile =
        try {
            api.update(input.toDto()).toDomain()
        } catch (e: CancellationException) {
            throw e
        } catch (e: Exception) {
            throw AppException(e.toAppError(json))      // callers see only AppError
        }
}

@StringRes
fun AppError.messageRes(): Int = when (this) {
    AppError.Offline -> R.string.error_offline            // "You're offline. We'll retry when you're back."
    AppError.Timeout -> R.string.error_timeout            // "This is taking longer than usual."
    AppError.Unauthorized -> R.string.error_session       // "Please sign in again."
    AppError.NotFound -> R.string.error_not_found
    is AppError.Validation -> R.string.error_check_fields
    is AppError.Server -> R.string.error_server           // "Our servers are having trouble."
    is AppError.Unexpected -> R.string.error_generic
}

fun Context.observeOnline(): Flow<Boolean> = callbackFlow {
    val cm = getSystemService(ConnectivityManager::class.java)
    val callback = object : ConnectivityManager.NetworkCallback() {
        override fun onAvailable(network: Network) { trySend(true) }
        override fun onLost(network: Network) { trySend(cm.activeNetwork != null) }
    }
    trySend(cm.activeNetwork != null)
    cm.registerDefaultNetworkCallback(callback)
    awaitClose { cm.unregisterNetworkCallback(callback) }
}.distinctUntilChanged()