import Foundation
import NIOCore

actor SDLUDPHoleV6Service {
    typealias EventHandler = SDLUDPHoleService.EventHandler
    typealias DataHandler = SDLUDPHoleService.DataHandler

    private var onEvent: EventHandler = { _ in }
    private var onData: DataHandler = { _ in }
    private var currentSession: SDLUDPHoleV6Session?
    private var generation: UInt64 = 0

    func updateHandlers(onEvent: @escaping EventHandler, onData: @escaping DataHandler) {
        self.onEvent = onEvent
        self.onData = onData
    }

    func run() async throws {
        let generation = self.nextGeneration()
        let session = SDLUDPHoleV6Session(
            onEvent: { [weak self] event in
                await self?.handleEvent(event, generation: generation)
            },
            onData: self.onData
        )

        self.currentSession = session

        do {
            try await session.run()
            self.clearCurrent(session, generation: generation)
            await session.stop()
        } catch is CancellationError {
            self.clearCurrent(session, generation: generation)
            await session.stop()
            throw CancellationError()
        } catch {
            self.clearCurrent(session, generation: generation)
            await session.stop()
            throw error
        }
    }

    func stop() async {
        self.generation &+= 1

        let session = self.currentSession
        self.currentSession = nil

        await session?.stop()
    }

    func recoverAfterWake() async {
        await self.stop()
    }

    func send(type: SDLPacketType, data: Data, remoteAddress: SocketAddress) async {
        await self.currentSession?.send(type: type, data: data, remoteAddress: remoteAddress)
    }

    private func nextGeneration() -> UInt64 {
        self.generation &+= 1
        return self.generation
    }

    private func clearCurrent(_ session: SDLUDPHoleV6Session, generation: UInt64) {
        guard self.generation == generation else {
            return
        }

        if self.currentSession === session {
            self.currentSession = nil
        }
    }

    private func handleEvent(_ event: SDLUDPHoleService.Event, generation: UInt64) async {
        guard self.generation == generation else {
            return
        }

        await self.onEvent(event)
    }
}