//
//  PacketInboundActor.swift
//  Tun
//
//  Created by Codex on 2026/5/20.
//

import Foundation
import NetworkExtension

actor PacketInboundActor {
    private let provider: NEPacketTunnelProvider
    private let policyService: PolicyService
    private let packetOutboundActor: PacketOutboundActor
    private let arpServer: ArpServer
    private let superServiceProxy: SDLSuperServiceProxy
    private let flowTracer: SDLFlowTracer

    private var networkAddress: SDLConfiguration.NetworkAddress
    private var identityId: UInt32
    private var dataCipher: CCDataCipher?

    init(provider: NEPacketTunnelProvider,
         config: SDLConfiguration,
         dataCipher: CCDataCipher?,
         policyService: PolicyService,
         packetOutboundActor: PacketOutboundActor,
         arpServer: ArpServer,
         superServiceProxy: SDLSuperServiceProxy,
         flowTracer: SDLFlowTracer) {
        self.provider = provider
        self.networkAddress = config.networkAddress
        self.identityId = config.identityId
        self.dataCipher = dataCipher
        self.policyService = policyService
        self.packetOutboundActor = packetOutboundActor
        self.arpServer = arpServer
        self.superServiceProxy = superServiceProxy
        self.flowTracer = flowTracer
    }

    func updateRuntime(config: SDLConfiguration, dataCipher: CCDataCipher?) {
        self.networkAddress = config.networkAddress
        self.identityId = config.identityId
        self.dataCipher = dataCipher
    }

    func handleData(_ data: SDLData) async {
        let processor = SDLHoleDataProcessor(
            networkAddress: self.networkAddress,
            dataCipher: self.dataCipher,
            policyService: self.policyService
        )

        guard let plan = try? await processor.makeProcessingPlan(data: data) else {
            return
        }

        self.flowTracer.inc(num: plan.inboundBytes, type: .inbound)

        switch plan.action {
        case .sendARPReply(let dstMac, let responseData):
            SDLLogger.log("[PacketInboundActor] get arp request packet")
            await self.packetOutboundActor.routeLayerPacket(dstMac: dstMac, type: .arp, data: responseData)
        case .appendARP(let ip, let mac):
            SDLLogger.log("[PacketInboundActor] get arp response packet")
            await self.arpServer.append(ip: ip, mac: mac)
        case .writeToTun(let packetData, let identityID):
            let packet = NEPacket(data: packetData, protocolFamily: 2)
            self.provider.packetFlow.writePacketObjects([packet])
            SDLLogger.log("[PacketInboundActor] hole identity: \(identityID), allow, data count: \(packetData.count)", for: .trace)
        case .requestPolicy(let srcIdentityID):
            SDLLogger.log("[PacketInboundActor] not found identity: \(srcIdentityID) ruleMap", for: .debug)
            if let queryData = await self.policyService.identifyStore.makePolicyRequest(srcIdentityId: srcIdentityID, dstIdentityId: self.identityId) {
                await self.superServiceProxy.send(type: .policyRequest, data: queryData)
            }
        case .none:
            ()
        }
    }
}