// commonMain/kotlin/com/runanywhere/sdk/infrastructure/network/NetworkReachability.kt
interface NetworkReachability {
    val isReachable: Boolean
    val networkType: NetworkType
    val reachabilityFlow: Flow<NetworkState>
}

enum class NetworkType {
    NONE, WIFI, CELLULAR, ETHERNET
}

data class NetworkState(
    val isReachable: Boolean,
    val type: NetworkType,
    val timestamp: Long
)

// androidMain/kotlin/com/runanywhere/sdk/infrastructure/network/AndroidNetworkReachability.kt
class AndroidNetworkReachability(
    private val context: Context
) : NetworkReachability {
    
    private val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    
    private val _reachabilityFlow = MutableStateFlow(getCurrentNetworkState())
    override val reachabilityFlow: StateFlow<NetworkState> = _reachabilityFlow.asStateFlow()
    
    init {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            connectivityManager.registerDefaultNetworkCallback(object : ConnectivityManager.NetworkCallback() {
                override fun onAvailable(network: Network) {
                    _reachabilityFlow.value = getCurrentNetworkState()
                }
                
                override fun onLost(network: Network) {
                    _reachabilityFlow.value = getCurrentNetworkState()
                }
            })
        }
    }
    
    override val isReachable: Boolean
        get() = connectivityManager.activeNetworkInfo?.isConnected == true
    
    override val networkType: NetworkType
        get() {
            val activeNetwork = connectivityManager.activeNetworkInfo
            return when (activeNetwork?.type) {
                ConnectivityManager.TYPE_WIFI -> NetworkType.WIFI
                ConnectivityManager.TYPE_MOBILE -> NetworkType.CELLULAR
                ConnectivityManager.TYPE_ETHERNET -> NetworkType.ETHERNET
                else -> NetworkType.NONE
            }
        }
    
    private fun getCurrentNetworkState(): NetworkState {
        return NetworkState(
            isReachable = isReachable,
            type = networkType,
            timestamp = System.currentTimeMillis()
        )
    }
}

// jvmMain/kotlin/com/runanywhere/sdk/infrastructure/network/JvmNetworkReachability.kt
class JvmNetworkReachability : NetworkReachability {
    
    private val _reachabilityFlow = MutableStateFlow(getCurrentNetworkState())
    override val reachabilityFlow: StateFlow<NetworkState> = _reachabilityFlow.asStateFlow()
    
    init {
        // Poll network state periodically
        CoroutineScope(Dispatchers.IO).launch {
            while (true) {
                delay(5000) // Check every 5 seconds
                _reachabilityFlow.value = getCurrentNetworkState()
            }
        }
    }
    
    override val isReachable: Boolean
        get() {
            return try {
                val url = URL("https://www.google.com")
                val connection = url.openConnection()
                connection.connectTimeout = 3000
                connection.connect()
                true
            } catch (e: Exception) {
                false
            }
        }
    
    override val networkType: NetworkType
        get() = if (isReachable) NetworkType.ETHERNET else NetworkType.NONE
    
    private fun getCurrentNetworkState(): NetworkState {
        return NetworkState(
            isReachable = isReachable,
            type = networkType,
            timestamp = System.currentTimeMillis()
        )
    }
}