NetworkMonitor.swift

//
//  NetworkMonitor.swift
//
//  Created by Ben Gohlke on August 27, 2025
//
//  Copyright ©2025 Adapty. All rights reserved.
//
//  Permission is hereby granted, free of charge, to any person obtaining a copy
//  of this software and associated documentation files (the "Software"), to deal
//  in the Software without restriction, including without limitation the rights
//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//  copies of the Software, and to permit persons to whom the Software is
//  furnished to do so, subject to the following conditions:
//
//  The above copyright notice and this permission notice shall be included in all
//  copies or substantial portions of the Software.
//
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//  SOFTWARE.
//

import Foundation
import Network

enum NetworkQuality: Int, Comparable, CustomStringConvertible {
  case excellent = 0
  case good
  case poor
  case unavailable
  
  var description: String {
    switch self {
      case .excellent: "Excellent"
      case .good: "Good"
      case .poor: "Poor"
      case .unavailable: "Unavailable"
    }
  }
  
  static func < (lhs: NetworkQuality, rhs: NetworkQuality) -> Bool {
    return lhs.rawValue < rhs.rawValue
  }
}

@Observable
class NetworkMonitor {
  private(set) var quality: NetworkQuality = .unavailable
  
  private let pathMonitor = NWPathMonitor()
  private let monitorQueue = DispatchQueue(label: "NetworkMonitor", qos: .background)
  
  init() {
    startMonitoring()
  }
  
  deinit {
    stopMonitoring()
  }
    
  private func startMonitoring() {
    pathMonitor.pathUpdateHandler = { [weak self] path in
      Task { @MainActor in
        let quality = self?.assessNetworkQuality(path: path) ?? .unavailable
        self?.quality = quality
      }
    }
    pathMonitor.start(queue: monitorQueue)
  }
  
  private nonisolated func stopMonitoring() {
    pathMonitor.cancel()
  }
  
  private nonisolated func assessNetworkQuality(path: NWPath) -> NetworkQuality {
    guard path.status == .satisfied else {
      return .unavailable
    }
    
    // WiFi and wired connections are generally excellent
    if path.usesInterfaceType(.wifi) || path.usesInterfaceType(.wiredEthernet) {
      return .excellent
    }
    
    // Cellular connections need more assessment
    if path.usesInterfaceType(.cellular) {
      return assessCellularQuality(path: path)
    }
    
    // Other connection types (like hotspot) default to good
    return .good
  }
  
  private nonisolated func assessCellularQuality(path: NWPath) -> NetworkQuality {
    // Check for expensive connection (often indicates limited data)
    if path.isExpensive {
      return .poor
    }
    
    // Check for constrained connection (iOS may limit usage)
    if path.isConstrained {
      return .poor
    }
    
    // If we have cellular without constraints, assume good quality
    return .good
  }
}