actor Session {
    private(set) lazy var session = URLSession(configuration: .default, delegate: sessionDelegate, delegateQueue: nil)
    private(set) lazy var sessionDelegate = SessionDelegate(self)
    
    private(set) var requests: [URLSessionTask: DataRequest] = [:]
    
    func request() async throws -> DataRequest {
        let request = DataRequest()
        let task = await request.task(using: session)
        requests[task] = request
        task.resume()
        
        return request
    }
    
    func request(for task: URLSessionTask) -> DataRequest? {
        requests[task]
    }
}

actor SessionDelegate: NSObject {
    private weak var owner: Session?
    
    init(_ owner: Session) {
        self.owner = owner
    }
}

extension SessionDelegate: URLSessionTaskDelegate {
    @asyncHandler
    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
        await owner?.request(for: task)?.didComplete(error)
    }
}

extension SessionDelegate: URLSessionDataDelegate {
    @asyncHandler
    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
        await owner?.request(for: dataTask)?.didReceive(data)
    }
}

actor DataRequest {
    private(set) var data = Data()
    private(set) var error: Error?
    private var completion: ((Data, Error?) -> Void)?
    
    func task(using session: URLSession) -> URLSessionTask {
        session.dataTask(with: URLRequest(url: URL(string: "https://httpbin.org/get")!))
    }
    
    func didComplete(_ error: Error?) {
        self.error = error
        print("didComplete")
        completion?(data, self.error)
    }
    
    func didReceive(_ data: Data) {
        self.data.append(data)
    }
    
    func awaitCompletion() async throws -> Data {
        try await withUnsafeThrowingContinuation { continuation in
            self.completion = { data, error in
                if let error = error {
                    continuation.resume(throwing: error)
                } else {
                    continuation.resume(returning: data)
                }
            }
        }
    }
}

runAsyncAndBlock {
    let session = Session()
    do {
        let data = try await session.request().awaitCompletion()
        print(String(decoding: data, as: UTF8.self))
    } catch {
        print(error)
    }
}