import Foundation
import NetworkExtension

actor SDLPacketReaderService {
    enum Event {
        case packet(IPPacket)
    }

    typealias EventHandler = @Sendable (Event) async -> Void

    private let provider: NEPacketTunnelProvider
    private let onEvent: EventHandler
    private var readTask: Task<Void, Never>?

    init(provider: NEPacketTunnelProvider, onEvent: @escaping EventHandler) {
        self.provider = provider
        self.onEvent = onEvent
    }

    func start() {
        guard self.readTask == nil else {
            return
        }

        let provider = self.provider
        let onEvent = self.onEvent
        self.readTask = Task(priority: .high) {
            while !Task.isCancelled {
                let (packets, numbers) = await provider.packetFlow.readPackets()
                if Task.isCancelled {
                    break
                }

                for (data, number) in zip(packets, numbers) where number == 2 {
                    if let packet = IPPacket(data) {
                        await onEvent(.packet(packet))
                    }
                }
            }
            SDLLogger.log("[SDLPacketReaderService] readTask finished")
        }
    }

    func stop() {
        let readTask = self.readTask
        self.readTask = nil
        readTask?.cancel()
    }
}