//
//  StoreKitService.swift
//  StoreKit2Manager
//
//  Created by xiaopin on 2025/12/6.
//

import Foundation
import StoreKit
import Combine
#if os(iOS)
import UIKit
#elseif os(macOS)
import AppKit
#endif

/// StoreKit 内部服务类
/// 负责与 StoreKit API 交互，处理产品加载、购买、交易监听等核心功能
internal class StoreKitService: ObservableObject {
    private let config: StoreKitConfig
    weak var delegate: StoreKitServiceDelegate?
    
    /// 所有产品
    @Published private(set) var allProducts: [Product] = []
    /// 所有有效的非消耗和订阅交易记录集合
    @Published private(set) var purchasedTransactions: [Transaction] = []
    /// 每个产品的最新交易记录集合
    @Published private(set) var latestTransactions: [Transaction] = []
    
    // 后台任务
    private var transactionListener: Task<Void, Error>?
    private var subscriberTasks: [Task<Void, Never>] = []
    private var cancellables = Set<AnyCancellable>()
    
    // 并发购买保护
    private var isPurchasing = false
    private let purchasingQueue = DispatchQueue(label: "com.storekit.purchasing")
    
    // MARK: - 订阅状态监听相关属性
    
    /// 订阅状态缓存（产品ID -> 上次的订阅状态）
    /// 
    /// 用途：
    /// - 存储每个订阅产品上次检查时的 RenewalState（已订阅/已过期/宽限期等）
    /// - 用于比较状态变化，只有变化时才触发通知
    /// - 避免重复通知相同的状态
    private var lastSubscriptionStatus: [String: Product.SubscriptionInfo.RenewalState] = [:]
    
    /// 续订信息缓存（产品ID -> 上次的续订信息）
    /// 
    /// 用途：
    /// - 存储每个订阅产品上次检查时的 RenewalInfo（包含 willAutoRenew、expirationDate 等）
    /// - 用于检测订阅取消：比较 willAutoRenew 从 true 变为 false
    /// - 避免重复通知相同的续订信息
    private var lastRenewalInfo: [String: Product.SubscriptionInfo.RenewalInfo] = [:]
    
    /// 订阅状态检查间隔（秒），默认30秒
    /// 
    /// 说明：
    /// - 自动监听任务会每隔此时间间隔检查一次订阅状态
    /// - 可以根据应用需求调整（例如：更频繁的检查需要更小的值）
    /// - 注意：过于频繁的检查可能会影响性能和电池寿命
    private let subscriptionCheckInterval: TimeInterval = 30
    
    // 当前状态
    private var currentState: StoreKitState = .idle {
        didSet {
            // 确保在主线程调用 delegate
            let state = currentState
            Task { @MainActor [weak self] in
                guard let self = self else { return }
                self.notifyStateChanged(state)
            }
        }
    }
    
    init(config: StoreKitConfig, delegate: StoreKitServiceDelegate) {
        self.config = config
        self.delegate = delegate
        setupSubscribers()
    }
    
    deinit {
        stop()
    }
    
    // MARK: - 公共方法
    
    /// 启动服务
    func start() {
        guard transactionListener == nil else { return }
        
        transactionListener = transactionStatusStream()
        
        // 启动订阅状态监听
        startSubscriptionStatusListener()
        
        Task {
            await clearUnfinishedTransactions()
            await loadProducts()
            await loadPurchasedTransactions()
            
            // 初始检查订阅状态
            await checkSubscriptionStatus()
        }
    }
    
    /// 停止服务
    func stop() {
        transactionListener?.cancel()
        transactionListener = nil
        
        subscriberTasks.forEach { $0.cancel() }
        subscriberTasks.removeAll()
        
        cancellables.removeAll()
    }
    
    /// 从商店获取所有有效产品
    /// - Returns: 加载的产品列表，如果加载失败返回 nil
    @MainActor
    func loadProducts() async -> [Product]? {
        currentState = .loadingProducts
        
        do {
            let storeProducts = try await Product.products(for: config.productIds)
            
            var products: [Product] = []
            for product in storeProducts {
                products.append(product)
            }
            
            // 如果需要，按价格排序
            if config.autoSortProducts {
                products = sortByPrice(products)
            }

            self.allProducts = products
            return products
        } catch {
            currentState = .error(error)
            return nil
        }
    }
    
    /// 获取所有有效的非消耗品和订阅交易信息集合
    @MainActor
    func loadPurchasedTransactions() async {
        currentState = .loadingPurchases
        
        // 使用 TaskGroup 并行获取所有产品的最新交易记录
        var latestTransactions: [Transaction] = []
        await withTaskGroup(of: Transaction?.self) { group in
            // 为每个产品ID创建任务
            for productId in config.productIds {
                group.addTask {
                    if let latestTransaction = await Transaction.latest(for: productId) {
                        switch latestTransaction {
                        case .verified(let transaction):
                            return transaction
                        case .unverified:
                            return nil
                        }
                    }
                    return nil
                }
            }
            
            // 收集所有结果
            for await transaction in group {
                if let transaction = transaction {
                    latestTransactions.append(transaction)
                }
            }
        }
        self.latestTransactions = latestTransactions

        // 将当前有效记录并转换成 purchasedTransactions
        var purchasedTransactions: [Transaction] = []
        for await result in Transaction.currentEntitlements {
            if case .verified(let transaction) = result {
                purchasedTransactions.append(transaction)
            }
        }
        self.purchasedTransactions = purchasedTransactions
        
        currentState = .purchasesLoaded
    }

    /// 完成所有未完成的交易记录
    @MainActor
    func clearUnfinishedTransactions() async {
        for await result in Transaction.unfinished {
            do {
                // 使用统一的验证方法
                let transaction = try verifyPurchase(result)
                
                // 验证成功，完成交易
                await transaction.finish()
                print("未完成交易，完成交易处理: \(transaction.productID)")
                
            } catch {
                // 验证失败，记录错误但不完成交易
                if case .unverified(let transaction, _) = result {
                    print("未完成交易，交易验证失败，产品ID: \(transaction.productID) 错误\(error.localizedDescription)")
                    
                    // 更新状态
                    currentState = .error(StoreKitError.verificationFailed)
                }
                
                // 注意：验证失败时不要调用 finish()
            }
        }
    }
    
    /// 购买产品（带并发保护）
    func purchase(_ product: Product) async throws {
        // 并发购买保护
        return try await withCheckedThrowingContinuation { continuation in
            purchasingQueue.async { [weak self] in
                guard let self = self else {
                    continuation.resume(throwing: StoreKitError.unknownError)
                    return
                }
                
                guard !self.isPurchasing else {
                    continuation.resume(throwing: StoreKitError.purchaseInProgress)
                    return
                }
                
                self.isPurchasing = true
                
                Task {
                    defer {
                        self.purchasingQueue.async {
                            self.isPurchasing = false
                        }
                    }
                    
                    await self.performPurchase(product, continuation: continuation)
                }
            }
        }
    }
    
    /// 执行购买
    private func performPurchase(_ product: Product, continuation: CheckedContinuation<Void, Error>) async {
        await MainActor.run {
            currentState = .purchasing(product.id)
        }
        
        do {
            let result = try await product.purchase()
            
            switch result {
            case .success(let verification):
                do {
                    let payload = verification.jwsRepresentation
                    let transaction = try verifyPurchase(verification)
                    
                    await printProductDetails(product)
                    // 打印详细的交易信息
                    await printTransactionDetails(transaction)
                    
                    await MainActor.run {
                        self.delegate?.service(self, didCompletePurchaseFor: transaction.productID, payload: payload)
                    }
                    
                    // 先完成交易
                    await transaction.finish()
                    
                    // 然后刷新购买列表（消耗品不需要）
                    if product.type != .consumable {
                        await loadPurchasedTransactions()
                    }
                    
                    await MainActor.run {
                        currentState = .purchaseSuccess(transaction.productID)
                    }
                    continuation.resume()
                } catch {
                    await MainActor.run {
                        currentState = .purchaseFailed(product.id, error)
                    }
                    continuation.resume(throwing: error)
                }
                
            case .pending:
                await MainActor.run {
                    currentState = .purchasePending(product.id)
                }
                continuation.resume()
                
            case .userCancelled:
                await MainActor.run {
                    currentState = .purchaseCancelled(product.id)
                }
                continuation.resume()
                
            @unknown default:
                let error = StoreKitError.unknownError
                await MainActor.run {
                    currentState = .purchaseFailed(product.id, error)
                }
                continuation.resume(throwing: error)
            }
        } catch {
            await MainActor.run {
                currentState = .purchaseFailed(product.id, error)
            }
            continuation.resume(throwing: error)
        }
    }
    
    /// 恢复购买
    @MainActor
    func restorePurchases() async throws {
        currentState = .restoringPurchases
        
        do {
            /// 将已签名的交易信息和续订详情与应用商店进行同步。
            /// StoreKit 会自动更新已签订单交易及续费信息，因此只有在用户表示已购买的产品无法正常使用时才应使用此功能。
            /// - 重要提示：此操作会提示用户进行身份验证，仅在用户交互时调用此函数。
            /// - 异常情况：如果用户身份验证不成功，或者 StoreKit 无法连接到 App Store。
            try await AppStore.sync()
            await loadPurchasedTransactions()
            currentState = .restorePurchasesSuccess
        } catch {
            currentState = .restorePurchasesFailed(error)
            throw StoreKitError.restorePurchasesFailed(error)
        }
    }
    
    /// 刷新同步最新的订阅信息
    @MainActor
    func refreshPurchasesSync() async {
        // 同步 App Store 的购买状态
        do {
            try await AppStore.sync()
        } catch {
            print("同步 App Store 状态失败: \(error)")
        }
        
        // 重新获取已购买产品（会更新订阅状态）
        await loadPurchasedTransactions()
    }
    
    
    /// 获取所有或指定产品ID的交易历史记录
    func getTransactionHistory(for productId: String? = nil) async -> [TransactionHistory] {
        var histories: [TransactionHistory] = []
        
        // 查询所有历史交易
        for await verificationResult in Transaction.all {
            do {
                let transaction = try verifyPurchase(verificationResult)
                
                // 如果指定了产品ID，则过滤
                if let productId = productId, transaction.productID != productId {
                    continue
                }
                
                // 查找对应的产品对象
                let product = allProducts.first(where: { $0.id == transaction.productID })
                
                let history = TransactionHistory.from(transaction, product: product)
                histories.append(history)
                
                // 检查是否退款或撤销
                // 注意：在查询交易历史时，如果发现撤销的交易，也会触发状态通知
                // 这样可以确保应用能够及时响应历史交易中的撤销事件
                if transaction.revocationDate != nil {
                    await MainActor.run {
                        if transaction.productType == .autoRenewable {
                            // 订阅产品被撤销/退款
                            // 检查是否在免费试用期（通过交易中的 offer 信息判断）
                            // 如果用户在免费试用期内退款，isFreeTrialCancelled 应该为 true
                            let isFreeTrialCancelled = self.isFreeTrialTransaction(transaction)
                            
                            // 触发订阅取消通知（虽然实际上是撤销，但使用相同的状态）
                            // 外部可以通过 isFreeTrialCancelled 来区分是否在免费试用期
                            currentState = .subscriptionCancelled(transaction.productID, isFreeTrialCancelled: isFreeTrialCancelled)
                        } else {
                            // 非订阅产品被退款
                            currentState = .purchaseRefunded(transaction.productID)
                        }
                    }
                }
            } catch {
                continue
            }
        }
        
        // 按购买日期倒序排列
        return histories.sorted(by: { $0.purchaseDate > $1.purchaseDate })
    }
    
    /// 获取消耗品的购买历史记录
    func getConsumablePurchaseHistory(for productId: String) async -> [TransactionHistory] {
        let allHistory = await getTransactionHistory(for: productId)
        return allHistory.filter { history in
            history.product?.type == .consumable
        }
    }
    
  
    // MARK: - 私有方法

    /// 设置订阅者
    private func setupSubscribers() {
        // 监听产品变化
        $allProducts
            .receive(on: DispatchQueue.main)
            .sink { [weak self] products in
                guard let self = self else { return }
                Task { @MainActor in
                    self.notifyProductsLoaded(products)
                }
            }
            .store(in: &cancellables)
        
        // 监听已购买产品变化
        $purchasedTransactions
            .receive(on: DispatchQueue.main)
            .sink { [weak self] transactions in
                guard let self = self else { return }
                Task { @MainActor in
                    self.notifyPurchasedTransactionsUpdated(transactions, self.latestTransactions)
                }
            }
            .store(in: &cancellables)
    }
    
    /// 验证购买
    private func verifyPurchase<T>(_ verificationResult: VerificationResult<T>) throws -> T {
        switch verificationResult {
        case .unverified(_, let error):
            throw StoreKitError.verificationFailed
        case .verified(let result):
            return result
        }
    }
    
    /// 检查交易是否在免费试用期
    /// 
    /// 功能说明：
    /// - 通过检查交易中的优惠信息（offer）来判断该交易是否使用了免费试用优惠
    /// - 判断标准：优惠类型是介绍性优惠（introductory）且支付模式是免费试用（freeTrial）
    /// 
    /// 使用场景：
    /// 1. 订阅取消检测：判断用户是否在免费试用期内取消订阅
    /// 2. 订阅撤销检测：判断用户是否在免费试用期内撤销/退款订阅
    /// 3. 交易历史分析：统计免费试用期的交易数量
    /// 
    /// - Parameter transaction: 交易对象
    /// - Returns: 如果交易使用的是免费试用优惠返回 true，否则返回 false
    /// 
    /// - Note: 
    ///   - 此方法检查的是交易创建时使用的优惠，而不是当前时间点
    ///   - 如果交易使用了免费试用优惠，即使试用期已过，此方法仍返回 true
    ///   - 要判断"当前是否还在试用期内"，需要结合购买日期和试用期长度来计算
    private func isFreeTrialTransaction(_ transaction: Transaction) -> Bool {
        // iOS 17.2+ 使用新的 offer 属性
        if #available(iOS 17.2, macOS 14.2, tvOS 17.2, watchOS 10.2, *) {
            if let offer = transaction.offer {
                // 检查优惠类型和支付模式
                // 判断标准：
                // 1. 优惠类型必须是介绍性优惠（introductory）
                // 2. 支付模式必须是免费试用（freeTrial）
                // 同时满足这两个条件，说明交易使用了免费试用优惠
                if offer.type == .introductory,
                   offer.paymentMode == .freeTrial {
                    return true
                }
            }
        } else {
            // iOS 15.0 - iOS 17.1 使用已废弃的属性
            if let offerType = transaction.offerType,
               let paymentMode = transaction.offerPaymentModeStringRepresentation {
                // 检查是否是介绍性优惠且支付模式是免费试用
                // 注意：paymentMode 是字符串类型，需要与 "freeTrial" 比较
                if offerType == .introductory,
                   paymentMode == "freeTrial" {
                    return true
                }
            }
        }
        
        // 没有优惠信息或不是免费试用，返回 false
        // 可能的情况：
        // 1. 交易没有使用任何优惠（正常付费订阅）
        // 2. 交易使用了其他类型的优惠（促销优惠、预付优惠等）
        // 3. 交易使用了介绍性优惠但支付模式不是免费试用（如预付优惠）
        return false
    }
    
    /// 监听交易状态流
    private func transactionStatusStream() -> Task<Void, Error> {
        return Task.detached { [weak self] in
            guard let self = self else { return }
            
            for await result in Transaction.updates {
                do {
                    let transaction = try self.verifyPurchase(result)
                    
                    await printTransactionDetails(transaction)
                    
                    // 检查是否退款或撤销
                    // 注意：revocationDate 表示撤销/退款，与订阅取消（cancellation）不同
                    // - 撤销（revocation）：通常是退款或违规导致的，会立即失效，通过 Transaction.updates 触发
                    // - 取消（cancellation）：用户主动取消，订阅仍然有效直到过期，通过定期检查 subscription.status 检测
                    if transaction.revocationDate != nil {
                        await MainActor.run {
                            if transaction.productType == .autoRenewable {
                                // 订阅产品被撤销/退款
                                // 检查是否在免费试用期（通过交易中的 offer 信息判断）
                                // 如果用户在免费试用期内退款，isFreeTrialCancelled 应该为 true
                                let isFreeTrialCancelled = self.isFreeTrialTransaction(transaction)
                                
                                // 触发订阅取消通知（虽然实际上是撤销，但使用相同的状态）
                                // 外部可以通过 isFreeTrialCancelled 来区分是否在免费试用期
                                print("🔔 检测到订阅取消: \(transaction.productID), isFreeTrialCancelled: \(isFreeTrialCancelled)")
                                self.currentState = .subscriptionCancelled(transaction.productID, isFreeTrialCancelled: isFreeTrialCancelled)
                            } else {
                                // 非订阅产品被退款
                                // 有撤销日期通常表示退款
                                print("🔔 检测到订阅退款: \(transaction.productID)")
                                self.currentState = .purchaseRefunded(transaction.productID)
                            }
                        }
                    }
                    
                    await self.loadPurchasedTransactions()
                    
                    await transaction.finish()
                } catch {
                    print("交易处理失败: \(error)")
                }
            }
        }
    }
    
    /// 按价格排序产品
    private func sortByPrice(_ products: [Product]) -> [Product] {
        products.sorted(by: { $0.price < $1.price })
    }
    
    // MARK: - 订阅状态监听
    
    /// 启动订阅状态监听（定期检查）
    /// 
    /// 功能说明：
    /// - 创建一个后台任务，定期检查所有已购买订阅的状态
    /// - 检查间隔：默认30秒（可通过 subscriptionCheckInterval 调整）
    /// - 检测内容：
    ///   1. 订阅取消：通过比较 willAutoRenew 从 true 变为 false
    ///   2. 订阅状态变化：通过比较 RenewalState 的变化（已订阅/已过期/宽限期等）
    ///   3. 订阅撤销：检测到 revoked 状态时触发通知
    /// - 通知机制：只有检测到变化时才触发状态通知，避免重复通知
    /// - 生命周期：任务会在服务停止时自动取消
    private func startSubscriptionStatusListener() {
        // 创建新的监听任务（使用 weak self 避免循环引用）
        let task = Task { [weak self] in
            guard let self = self else { return }
            
            // 持续监听，直到任务被取消
            while !Task.isCancelled {
                // 检查所有订阅的状态（并行检查，提高效率）
                if self.config.showLog {
                    let now = Date()
                    let formatter = DateFormatter()
                    formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
                    formatter.timeZone = TimeZone.current
                    print("当前订阅检测时间: \(formatter.string(from: now))")
                }
                await self.checkSubscriptionStatus()
                
                // 等待指定间隔（默认30秒）后再次检查
                // 使用 try? 忽略取消错误，因为任务取消是正常情况
                try? await Task.sleep(nanoseconds: UInt64(self.subscriptionCheckInterval * 1_000_000_000))
            }
        }
        
        // 将任务添加到任务列表，以便在停止服务时统一取消
        subscriberTasks.append(task)
    }
    
    /// 检查所有订阅的状态
    /// 功能说明：
    /// 1. 并行检查所有已购买的自动续订订阅的状态
    /// 2. 比较续订信息（willAutoRenew）的变化，检测订阅取消
    /// 3. 比较订阅状态（RenewalState）的变化，检测状态变更
    /// 4. 更新缓存，只有变化时才通知，避免重复通知
    /// 5. 触发相应的状态通知（subscriptionCancelled、subscriptionStatusChanged 等）
    @MainActor
    private func checkSubscriptionStatus() async {
        // 获取所有已购买的自动续订订阅
        let purchasedSubscriptions = allProducts.filter { product in
            product.type == .autoRenewable && 
            purchasedTransactions.contains(where: { $0.productID == product.id })
        }
        
        // 如果没有订阅，直接返回
        guard !purchasedSubscriptions.isEmpty else { return }
        
        // 使用 TaskGroup 并行检查所有订阅，提高效率
        // 返回类型：(产品ID, 订阅状态, 续订信息, 过期日期, 是否在免费试用期)
        await withTaskGroup(of: (String, Product.SubscriptionInfo.RenewalState?, Product.SubscriptionInfo.RenewalInfo?, Date?, Bool?).self) { group in
            // 为每个订阅产品创建检查任务
            for product in purchasedSubscriptions {
                group.addTask { [weak self] in
                    guard let self = self else { return (product.id, nil, nil, nil, nil) }
                    guard let subscription = product.subscription else { return (product.id, nil, nil, nil, nil) }
                    
                    do {
                        // 获取订阅状态数组（通常只有一个当前状态）
                        let statuses = try await subscription.status
                        guard let currentStatus = statuses.first else { return (product.id, nil, nil, nil, nil) }
                        
                        let currentState = currentStatus.state
                        var renewalInfo: Product.SubscriptionInfo.RenewalInfo?
                        var expirationDate: Date?
                        var isFreeTrial: Bool? = nil
                        
                        // 获取续订信息（包含 willAutoRenew、expirationDate 等）
                        if case .verified(let info) = currentStatus.renewalInfo {
                            renewalInfo = info
                        }
                        
                        // 从 Transaction 中获取过期日期和优惠信息
                        // 注意：subscription.status 中的 transaction 是当前有效的交易
                        // 如果用户取消了订阅，这个交易仍然是当前有效的，直到过期
                        if case .verified(let transaction) = currentStatus.transaction {
                            expirationDate = transaction.expirationDate
                            
                            // ========== 判断是否在免费试用期 ==========
                            // 判断逻辑：
                            // 1. 检查交易中的优惠信息（offer）
                            // 2. 如果优惠类型是介绍性优惠（introductory）且支付模式是免费试用（freeTrial）
                            // 3. 则说明当前订阅使用的是免费试用优惠，即用户在免费试用期内
                            // 
                            // 注意：
                            // - 如果用户取消了订阅，但还在免费试用期内，isFreeTrial 应该为 true
                            // - 如果用户取消了订阅，但已经过了免费试用期，isFreeTrial 应该为 false
                            // - 这个判断基于当前有效交易的优惠信息，是准确的
                            
                            // iOS 17.2+ 使用新的 offer 属性
                            if #available(iOS 17.2, macOS 14.2, tvOS 17.2, watchOS 10.2, *) {
                                if let offer = transaction.offer {
                                    // 检查优惠类型和支付模式
                                    // 如果是介绍性优惠且支付模式是免费试用，则是在免费试用期
                                    if offer.type == .introductory,
                                       offer.paymentMode == .freeTrial {
                                        isFreeTrial = true
                                    } else {
                                        // 其他情况：没有优惠、促销优惠、或其他支付模式，都不算免费试用期
                                        isFreeTrial = false
                                    }
                                } else {
                                    // 没有优惠信息，说明不在免费试用期（可能是正常付费订阅）
                                    isFreeTrial = false
                                }
                            } else {
                                // iOS 15.0 - iOS 17.1 使用已废弃的属性
                                if let offerType = transaction.offerType,
                                   let paymentMode = transaction.offerPaymentModeStringRepresentation {
                                    // 检查是否是介绍性优惠且支付模式是免费试用
                                    if offerType == .introductory,
                                       paymentMode == "freeTrial" {
                                        isFreeTrial = true
                                    } else {
                                        // 其他情况：没有优惠、促销优惠、或其他支付模式，都不算免费试用期
                                        isFreeTrial = false
                                    }
                                } else {
                                    // 没有优惠信息，说明不在免费试用期（可能是正常付费订阅）
                                    isFreeTrial = false
                                }
                            }
                        } else {
                            // 如果无法获取交易信息，默认不在免费试用期
                            isFreeTrial = false
                        }
                        
                        return (product.id, currentState, renewalInfo, expirationDate, isFreeTrial)
                    } catch {
                        print("获取订阅状态失败: \(product.id), 错误: \(error)")
                        return (product.id, nil, nil, nil, nil)
                    }
                }
            }
            
            // 收集所有任务的结果并处理状态变化
            for await (productId, currentRenewalState, renewalInfo, expirationDate, isFreeTrial) in group {
                // 跳过无效结果
                guard let currentRenewalState = currentRenewalState else { continue }
                
                // 获取上次缓存的续订信息和状态
                let lastInfo = self.lastRenewalInfo[productId]
                let lastState = self.lastSubscriptionStatus[productId]
                
                // ========== 检测订阅取消 ==========
                // 订阅取消的判断标准：willAutoRenew 从 true 变为 false
                // 这表示用户主动取消了订阅，但订阅在过期日期前仍然有效
                // 注意：订阅取消后，订阅仍然可以使用直到过期日期
                if let lastInfo = lastInfo,
                   let currentInfo = renewalInfo {
                    // 检查 willAutoRenew 是否从 true 变为 false
                    if lastInfo.willAutoRenew == true && currentInfo.willAutoRenew == false {
                        // ========== 判断是否在免费试用期取消 ==========
                        // 判断逻辑：
                        // 1. isFreeTrial 为 true 表示当前有效交易使用的是免费试用优惠
                        // 2. 如果用户在免费试用期内取消订阅，isFreeTrial 应该为 true
                        // 3. 如果用户在付费订阅期内取消订阅，isFreeTrial 应该为 false
                        // 
                        // 使用场景：
                        // - isFreeTrialCancelled = true：用户在免费试用期内取消，可以：
                        //   * 显示"免费试用已取消"的提示
                        //   * 提供重新订阅的引导
                        //   * 统计免费试用取消率
                        // - isFreeTrialCancelled = false：用户在付费订阅期内取消，可以：
                        //   * 显示"订阅已取消，将在XX日期过期"的提示
                        //   * 提供续订或重新订阅的引导
                        //   * 统计付费订阅取消率
                        let isFreeTrialCancelled = isFreeTrial ?? false
                        
                        // 订阅已取消，触发通知（包含是否在免费试用期取消的信息）
                        if isFreeTrialCancelled {
                            print("🔔 检测到订阅取消（免费试用期）: \(productId)")
                            print("   说明：用户在免费试用期内取消了订阅，订阅将在试用期结束时失效")
                        } else {
                            print("🔔 检测到订阅取消（付费订阅期）: \(productId)")
                            print("   说明：用户在付费订阅期内取消了订阅，订阅将在当前周期结束时失效")
                        }
                        
                        // 触发状态通知，包含是否在免费试用期取消的信息
                        // 外部可以通过这个信息来区分不同的取消场景，提供不同的处理逻辑
                        self.currentState = .subscriptionCancelled(productId, isFreeTrialCancelled: isFreeTrialCancelled)
                        
                        // 打印过期日期信息，告知用户订阅何时失效
                        if let expirationDate = expirationDate {
                            let formatter = DateFormatter()
                            formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
                            if isFreeTrialCancelled {
                                print("   免费试用将在 \(formatter.string(from: expirationDate)) 过期")
                            } else {
                                print("   订阅将在 \(formatter.string(from: expirationDate)) 过期")
                            }
                        }
                    }
                }
                
                // ========== 检测订阅状态变化 ==========
                // 比较当前状态和上次状态，如果不同则触发通知
                // 这样可以检测到订阅从已订阅 -> 已过期、已订阅 -> 宽限期等状态变化
                if let lastState = lastState, lastState != currentRenewalState {
                    // 状态发生变化，根据不同的状态类型进行处理
                    switch currentRenewalState {
                    case .subscribed:
                        // 订阅已激活（可能是新订阅或从其他状态恢复）
                        print("📱 订阅状态变化: \(productId) -> 已订阅")
                        // 注意：这里不触发状态通知，因为 subscribed 是正常状态
                        
                    case .expired:
                        // 订阅已过期（用户无法再使用订阅功能）
                        print("⏰ 订阅状态变化: \(productId) -> 已过期")
                        // 注意：过期状态通常不需要额外通知，因为用户已经知道
                        
                    case .inGracePeriod:
                        // 订阅在宽限期内（支付失败但仍在宽限期内，功能仍可用）
                        print("⚠️ 订阅状态变化: \(productId) -> 宽限期")
                        // 可以在这里触发通知，提醒用户更新支付方式
                        
                    case .inBillingRetryPeriod:
                        // 订阅在计费重试期（支付失败，正在重试，功能仍可用）
                        print("🔄 订阅状态变化: \(productId) -> 计费重试期")
                        // 可以在这里触发通知，提醒用户更新支付方式
                        
                    case .revoked:
                        // 订阅已撤销（可能是退款或违规，功能立即失效）
                        print("❌ 订阅状态变化: \(productId) -> 已撤销")
                        self.currentState = .purchaseRevoked(productId)
                        
                    default:
                        print("❓ 订阅状态变化: \(productId) -> 未知状态: \(currentRenewalState)")
                    }
                }
                
                // ========== 更新缓存 ==========
                // 更新续订信息缓存（用于下次比较 willAutoRenew 的变化）
                if let renewalInfo = renewalInfo {
                    self.lastRenewalInfo[productId] = renewalInfo
                }
                
                // 更新订阅状态缓存（用于下次比较 RenewalState 的变化）
                self.lastSubscriptionStatus[productId] = currentRenewalState
            }
        }
    }
    
    /// 手动检查订阅状态（供外部调用，在关键时机使用）
    /// 
    /// 使用场景：
    /// - 应用启动时：确保订阅状态是最新的
    /// - 应用进入前台时：检查是否有状态变化
    /// - 用户打开订阅页面时：显示最新的订阅信息
    /// - 购买/恢复购买后：立即检查订阅状态
    /// - 用户从订阅管理页面返回时：检查是否有变化
    /// 
    /// 注意：
    /// - 此方法会立即执行一次完整的订阅状态检查
    /// - 与自动监听不同，此方法不会定期重复执行
    /// - 建议在关键时机调用，避免频繁调用影响性能
    @MainActor
    func checkSubscriptionStatusManually() async {
        await checkSubscriptionStatus()
    }
    
   
}

//MARK: 订阅管理
extension StoreKitService{
    /// 打开订阅管理页面（使用 URL）
    @MainActor
    func openSubscriptionManagement() {
        guard let url = URL(string: "https://apps.apple.com/account/subscriptions") else { return }
        
        #if os(iOS)
        if UIApplication.shared.canOpenURL(url) {
            UIApplication.shared.open(url)
        }
        #elseif os(macOS)
        NSWorkspace.shared.open(url)
        #endif
    }
    
    /// 显示应用内订阅管理界面（iOS 15.0+ / macOS 12.0+）
    /// - Returns: 是否成功显示（如果系统不支持则返回 false）
    @MainActor
    func showManageSubscriptionsSheet() async -> Bool {
        #if os(iOS)
        if #available(iOS 15.0, *) {
            do {
                // 获取当前的 windowScene
                let windowScene = UIApplication.shared.connectedScenes
                    .compactMap { $0 as? UIWindowScene }
                    .first
                
                if let windowScene = windowScene {
                    try await AppStore.showManageSubscriptions(in: windowScene)
                    
                    await loadPurchasedTransactions()
                    
                    return true
                } else {
                    // 如果无法获取 windowScene，回退到打开 URL
                    openSubscriptionManagement()
                    return false
                }
            } catch {
                print("显示订阅管理界面失败: \(error)")
                // 如果失败，回退到打开 URL
                openSubscriptionManagement()
                return false
            }
        } else {
            // iOS 15.0 以下使用 URL
            openSubscriptionManagement()
            return false
        }
        #elseif os(macOS)
        if #available(macOS 12.0, *) {
            do {
                try await AppStore.showManageSubscriptions()
                
                // 订阅管理界面关闭后，刷新订阅状态
                await loadPurchasedTransactions()
                
                return true
            } catch {
                print("显示订阅管理界面失败: \(error)")
                openSubscriptionManagement()
                return false
            }
        } else {
            openSubscriptionManagement()
            return false
        }
        #else
        openSubscriptionManagement()
        return false
        #endif
    }
    
    /// 显示优惠代码兑换界面（iOS 16.0+）
    /// - Throws: StoreKitError 如果显示失败
    /// - Note: 兑换后的交易会通过 Transaction.updates 发出
    @MainActor
    @available(iOS 16.0, visionOS 1.0, *)
    @available(macOS, unavailable)
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    func presentOfferCodeRedeemSheet() async throws {
        #if os(iOS)
        // 获取当前的 windowScene
        let windowScene = UIApplication.shared.connectedScenes
            .compactMap { $0 as? UIWindowScene }
            .first
        
        guard let windowScene = windowScene else {
            throw StoreKitError.unknownError
        }
        
        do {
            try await AppStore.presentOfferCodeRedeemSheet(in: windowScene)
            // 兑换后的交易会通过 Transaction.updates 自动处理
            // 这里可以刷新购买列表以确保数据同步
            await loadPurchasedTransactions()
        } catch {
            throw StoreKitError.purchaseFailed(error)
        }
        #else
        throw StoreKitError.unknownError
        #endif
    }
    
    /// 请求应用评价
    /// - Note: 兼容 iOS 15.0+ 和 iOS 16.0+
    ///   - iOS 15.0: 使用 SKStoreReviewController.requestReview() (StoreKit 1)
    ///   - iOS 16.0+: 使用 AppStore.requestReview(in:) (StoreKit 2)
    @MainActor
    func requestReview() {
        #if os(iOS)
        if #available(iOS 16.0, *) {
            // iOS 16.0+ 使用 StoreKit 2 的新 API
            if let windowScene = UIApplication.shared.connectedScenes
                .compactMap({ $0 as? UIWindowScene })
                .first {
                AppStore.requestReview(in: windowScene)
            }
        } else {
            // iOS 15.0 (以及 iOS 10.3-15.x) 使用 StoreKit 1 的 API
            // 在 iOS 15 中，StoreKit 2 存在，但 AppStore.requestReview 需要 iOS 16+
            // 所以回退到 StoreKit 1 的 SKStoreReviewController
            SKStoreReviewController.requestReview()
        }
        #elseif os(macOS)
        if #available(macOS 13.0, *) {
            // macOS 13.0+ 使用 StoreKit 2 的新 API
            if let windowScene = NSApplication.shared.windows.first?.windowScene {
                AppStore.requestReview(in: windowScene)
            }
        } else if #available(macOS 10.14, *) {
            // macOS 12.0+ (以及 macOS 10.14-12.x) 使用 StoreKit 1 的 API
            SKStoreReviewController.requestReview()
        }
        #endif
    }
}

//MARK: 代理通知
extension StoreKitService{
    /// 通知产品加载（在主线程执行）
    @MainActor
    private func notifyProductsLoaded(_ products: [Product]) {
        delegate?.service(self, didLoadProducts: products)
    }
    
    /// 通知已购买交易订单更新（在主线程执行）
    @MainActor
    private func notifyPurchasedTransactionsUpdated(_ efficient: [Transaction], _ latests: [Transaction]) {
        delegate?.service(self, didUpdatePurchasedTransactions: efficient, latests: latests)
    }
    
    /// 通知状态变化（在主线程执行）
    @MainActor
    private func notifyStateChanged(_ state: StoreKitState) {
        delegate?.service(self, didUpdateState: state)
    }
    
}

//MARK: 打印调试方法
extension StoreKitService{
    private  func printProductDetails(_ product:Product) async{
        // 时间格式化为东八区（北京时间）
        let beijingTimeZone = TimeZone(secondsFromGMT: 8 * 3600) ?? .current
        let formatter = DateFormatter()
        formatter.timeZone = beijingTimeZone
        formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"

        print("════════════════════════════════════════")
        print("✅ 购买成功 - 交易详细信息")
        print("════════════════════════════════════════")
        print("📦 产品信息:")
        print("   - 产品ID: \(product.id)")
        print("   - 产品类型: \(product.type)")
        print("   - 产品名称: \(product.displayName)")
        print("   - 产品描述: \(product.description)")
        print("   - 产品价格: \(product.displayPrice)")
        print("   - 价格数值: \(product.price)")
        print("   - 家庭共享: \(product.isFamilyShareable)")
        //print("   - 产品JSON: \(String.init(data: product.jsonRepresentation, encoding: .utf8))")
         // 如果是订阅产品，打印订阅相关信息
        if let subscription = product.subscription {
            print("📱 订阅信息:")
            print("   - 订阅组ID: \(subscription.subscriptionGroupID)")
            
            // 打印订阅周期
            let period = subscription.subscriptionPeriod
            let periodName: String
            switch period.unit {
            case .day:
                periodName = "\(period.value) 天"
            case .week:
                periodName = "\(period.value) 周"
            case .month:
                periodName = "\(period.value) 月"
            case .year:
                periodName = "\(period.value) 年"
            @unknown default:
                periodName = "未知"
            }
            print("   - 订阅周期: \(periodName)")
            
            // 检查是否有资格使用介绍性优惠（异步）
            let isEligibleForIntroOffer = await subscription.isEligibleForIntroOffer
            print("   - 是否有资格使用介绍性优惠: \(isEligibleForIntroOffer ? "是" : "否")")
            
            // 介绍性优惠详细信息
            if let introductoryOffer = subscription.introductoryOffer {
                print("   - 介绍性优惠: 有")
                printOfferDetails(introductoryOffer, indent: "     ")
            } else {
                print("   - 介绍性优惠: 无")
            }
            
            // 促销优惠列表
            if !subscription.promotionalOffers.isEmpty {
                print("   - 促销优惠: 有 (\(subscription.promotionalOffers.count) 个)")
                for (index, promotionalOffer) in subscription.promotionalOffers.enumerated() {
                    print("     [促销优惠 \(index + 1)]")
                    printOfferDetails(promotionalOffer, indent: "       ")
                }
            } else {
                print("   - 促销优惠: 无")
            }
            
            // 赢回优惠列表（iOS 18.0+）
            if #available(iOS 18.0, macOS 15.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, *) {
                if !subscription.winBackOffers.isEmpty {
                    print("   - 赢回优惠: 有 (\(subscription.winBackOffers.count) 个)")
                    for (index, winBackOffer) in subscription.winBackOffers.enumerated() {
                        print("     [赢回优惠 \(index + 1)]")
                        printOfferDetails(winBackOffer, indent: "       ")
                    }
                } else {
                    print("   - 赢回优惠: 无")
                }
            }
        }
        
        let productJSON = ProductConverter.toDictionary(product)
        print("   - JSON表示: \(productJSON)")
    }
    
    /// 打印优惠详细信息
    /// - Parameters:
    ///   - offer: 优惠对象
    ///   - indent: 缩进字符串
    private func printOfferDetails(_ offer: Product.SubscriptionOffer, indent: String) {
        // 优惠ID（介绍性优惠为 nil，其他类型不为 nil）
        if let offerID = offer.id {
            print("\(indent)* 优惠ID: \(offerID)")
        } else {
            print("\(indent)* 优惠ID: 无（介绍性优惠）")
        }
        
        // 优惠类型（不是可选的）
        let typeName: String
        if offer.type == .introductory {
            typeName = "介绍性优惠"
        } else if offer.type == .promotional {
            typeName = "促销优惠"
        } else {
            if #available(iOS 18.0, macOS 15.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, *) {
                if offer.type == .winBack {
                    typeName = "赢回优惠"
                } else {
                    typeName = "未知类型(\(offer.type.rawValue))"
                }
            } else {
                typeName = "未知类型(\(offer.type.rawValue))"
            }
        }
        print("\(indent)* 优惠类型: \(typeName)")
        
        // 价格信息
        print("\(indent)* 显示价格: \(offer.displayPrice)")
        print("\(indent)* 价格数值: \(offer.price)")
        
        // 支付模式（显示中文名称）
        let paymentModeName: String
        switch offer.paymentMode {
        case .freeTrial:
            paymentModeName = "免费试用"
        case .payAsYouGo:
            paymentModeName = "按需付费"
        case .payUpFront:
            paymentModeName = "预付"
        default:
            paymentModeName = "未知模式(\(offer.paymentMode.rawValue))"
        }
        print("\(indent)* 支付模式: \(paymentModeName)")
        
        // 优惠周期（不是可选的）
        let offerPeriod = offer.period
        let offerPeriodName: String
        switch offerPeriod.unit {
        case .day:
            offerPeriodName = "\(offerPeriod.value) 天"
        case .week:
            offerPeriodName = "\(offerPeriod.value) 周"
        case .month:
            offerPeriodName = "\(offerPeriod.value) 月"
        case .year:
            offerPeriodName = "\(offerPeriod.value) 年"
        @unknown default:
            offerPeriodName = "未知"
        }
        print("\(indent)* 优惠周期: \(offerPeriodName)")
        
        // 周期数量（总是 1，除了 .payAsYouGo）
        print("\(indent)* 周期数量: \(offer.periodCount)")
    }
    
    /// 打印详细的产品和交易信息
    private func printTransactionDetails(_ transaction: Transaction) async {
        // 时间格式化为东八区（北京时间）
        let beijingTimeZone = TimeZone(secondsFromGMT: 8 * 3600) ?? .current
        let formatter = DateFormatter()
        formatter.timeZone = beijingTimeZone
        formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
       
        print("")
        print("💳 交易信息:")
        print("   - 交易ID: \(transaction.id)") // 当前交易的唯一标识符
        print("   - 产品ID: \(transaction.productID)") // 购买的产品ID
        print("   - 产品类型: \(transaction.productType)") // 产品类型（消耗品/非消耗品/非续订订阅/自动续订订阅）
        print("   - 购买日期: \(formatter.string(from: transaction.purchaseDate))") // 购买时间（UTC时间）
        print("   - 所有权类型: \(transaction.ownershipType)") // 所有权类型（purchased/familyShared）
        print("   - 原始交易ID: \(transaction.originalID)") // 首次购买的交易ID（用于订阅续订）
        print("   - 原始购买日期: \(formatter.string(from: transaction.originalPurchaseDate))") // 首次购买时间
        
        // 过期日期（仅订阅产品有）
        if let expirationDate = transaction.expirationDate {
            let dateStr = formatter.string(from: expirationDate)
            print("   - 过期日期: \(dateStr)") // 订阅过期时间
        } else {
            print("   - 过期日期: 无")
        }
        
        // 撤销日期（如果已退款/撤销）
        if let revocationDate = transaction.revocationDate {
            let dateStr = formatter.string(from: revocationDate)
            print("   - 撤销日期: \(dateStr)") // 退款或撤销的时间
        } else {
            print("   - 撤销日期: 无")
        }
        
        // 撤销原因
        if let revocationReason = transaction.revocationReason {
            print("   - 撤销原因: \(revocationReason)") // 退款/撤销的原因代码
        }
        if #available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *){
            // 购买原因（purchased/upgraded/renewed等）
            print("   - 购买理由: \(transaction.reason)")
        }else{
            print("   - 购买理由: 无")
        }
        print("   - 是否升级: \(transaction.isUpgraded)") // 是否为升级购买
        
        // 购买数量
        print("   - 购买数量: \(transaction.purchasedQuantity)") // 购买的数量
        
        // 价格
        if let price = transaction.price {
            print("   - 交易价格: \(price)") // 实际支付的价格
        }
        
        // 货币代码
        if #available(iOS 16.0, *) {
            if let currency = transaction.currency {
                print("   - 货币代码: \(currency)") // 货币代码（如CNY、USD）
            }
        } else {
            // Fallback on earlier versions
        }
        if #available(iOS 16.0, *) {
            print("   - 环境: \(transaction.environment.rawValue)")
        } else {
            // Fallback on earlier versions
        } // 交易环境（sandbox/production）
        print("   - 应用交易ID: \(transaction.appTransactionID)") // 应用级别的交易ID
        print("   - 应用Bundle ID: \(transaction.appBundleID )") // 应用的Bundle标识符
        // 应用账户Token（用于关联用户账户）
        if let appAccountToken = transaction.appAccountToken {
            print("   - 应用账户Token: \(appAccountToken)") // 用于关联用户账户的Token
        }
        // 订阅组ID（仅订阅产品）
        if let subscriptionGroupID = transaction.subscriptionGroupID {
            print("   - 订阅组ID: \(subscriptionGroupID)") // 订阅所属的组ID
        }
        
        // 订阅状态（仅订阅产品）
        //if let subscriptionStatus = await transaction.subscriptionStatus {
        //    print("   - 订阅状态: \(subscriptionStatus)") // 订阅的当前状态
        //}
        
        print("   - 签名日期: \(formatter.string(from: transaction.signedDate))") // 交易签名的日期
        if #available(iOS 17.0, *) {
            print("   - 商店区域: \(transaction.storefront)")
        } else {
            // Fallback on earlier versions
        } // 商店区域代码
        
        // Web订单行项目ID
        if let webOrderLineItemID = transaction.webOrderLineItemID {
            print("   - Web订单行项目ID: \(webOrderLineItemID)") // Web订单的行项目ID
        }
        print("   - 设备验证: \(transaction.deviceVerification)") // 设备验证数据
        print("   - 设备验证Nonce: \(transaction.deviceVerificationNonce)") // 设备验证的Nonce值
        
        // 优惠信息
        if #available(iOS 17.2, macOS 14.2, tvOS 17.2, watchOS 10.2, *) {
            // iOS 17.2+ 使用新的 offer 属性
            if let offer = transaction.offer {
                print("   - 优惠信息:")
                print("     * 优惠类型: \(offer.type)")
                if let offerID = offer.id {
                    print("     * 优惠ID: \(offerID)")
                }
                print("     * 支付模式: \(String(describing: offer.paymentMode?.rawValue))")
                if #available(iOS 18.4, *) {
                    if let period = offer.period {
                        print("     * 优惠周期: \(period)")
                    }
                } else {
                    // Fallback on earlier versions
                }
            }
        } else if #available(iOS 15.0, macOS 12.0, tvOS 15.0, watchOS 8.0, *) {
            // iOS 15.0 - iOS 17.1 使用已废弃的属性
            if let offerType = transaction.offerType {
                print("   - 优惠信息:")
                print("     * 优惠类型: \(offerType)")
                
                if let offerID = transaction.offerID {
                    print("     * 优惠ID: \(offerID)")
                }
                
                if let paymentMode = transaction.offerPaymentModeStringRepresentation {
                    print("     * 支付模式: \(paymentMode)")
                }
                
                if #available(iOS 18.4, macOS 15.4, tvOS 18.4, watchOS 11.4, visionOS 2.4, *) {
                    // iOS 18.4+ 已废弃 offerPeriodStringRepresentation，但为了兼容性仍可检查
                    // 实际上在 iOS 18.4+ 应该使用上面的 offer.period
                } else {
                    // iOS 15.0 - iOS 18.3 使用 offerPeriodStringRepresentation
                    if let period = transaction.offerPeriodStringRepresentation {
                        print("     * 优惠周期: \(period)")
                    }
                }
            }
        } else {
            // iOS 15.0 以下版本不支持优惠信息
            // 不输出任何内容
        }
        
        // 高级商务信息
        if #available(iOS 18.4, *) {
            if let advancedCommerceInfo = transaction.advancedCommerceInfo {
                print("   - 高级商务信息: \(advancedCommerceInfo)") // 高级商务相关信息
            }
        } else {
            // Fallback on earlier versions
        }
        
        // JSON表示（用于服务器验证）
        //if let jsonRepresentation = transaction.jsonRepresentation {
        //    print("   - JSON表示 (前200字符): \(String(jsonRepresentation.prefix(200)))...") // JSON格式的交易数据，可用于服务器验证
        //}
        
        // Debug描述
        print("   - Debug描述: \(transaction.debugDescription)") // 调试用的描述信息
        print("")
        
        
        print("════════════════════════════════════════")
        print("")

        let transactionJSON = TransactionConverter.toDictionary(transaction)
        print("   - JSON表示: \(transactionJSON)")
    }
}