import Foundation
@preconcurrency import Combine

// 以 @unchecked Sendable 包装 Future 的 promise，安全地跨并发域传递
private final class PromiseBox<Output, Failure: Error>: @unchecked Sendable {
    private let fulfill: (Result<Output, Failure>) -> Void
    init(_ fulfill: @escaping (Result<Output, Failure>) -> Void) { self.fulfill = fulfill }
    func complete(_ result: Result<Output, Failure>) { fulfill(result) }
}

extension APIServiceProtocol {
    /// 将 async/await 的请求桥接为 Combine Publisher
    /// - Parameter request: 符合 APIRequestProtocol 的请求对象
    /// - Returns: AnyPublisher<T.Response, APIError>
    func requestPublisher<T: APIRequestProtocol>(_ request: T) -> AnyPublisher<T.Response, APIError> {
        Deferred {
            Future { promise in
                let box = PromiseBox<T.Response, APIError>(promise)
                Task(priority: .userInitiated) {
                    let result: Result<T.Response, APIError>
                    do {
                        let value = try await self.request(request)
                        result = .success(value)
                    } catch let apiError as APIError {
                        result = .failure(apiError)
                    } catch {
                        result = .failure(.unknown(error.localizedDescription))
                    }
                    box.complete(result)
                }
            }
        }
        .subscribe(on: DispatchQueue.global(qos: .userInitiated))
        .eraseToAnyPublisher()
    }
}