app_for_indeed/App for Indeed/Subscription/SubscriptionStore.swift

//
//  SubscriptionStore.swift
//  App for Indeed
//

import Foundation
import StoreKit

extension Notification.Name {
    static let subscriptionStatusDidChange = Notification.Name("subscriptionStatusDidChange")
}

@MainActor
final class SubscriptionStore {
    static let shared = SubscriptionStore()

    private(set) var productsByID: [String: Product] = [:]
    /// Mirrors StoreKit entitlements; safe to read on the main thread after `refreshEntitlements()` or a `.subscriptionStatusDidChange` notification.
    private(set) var isProActive: Bool = false
    private var transactionListenerTask: Task<Void, Never>?

    private init() {
        transactionListenerTask = Task { await listenForTransactions() }
    }

    deinit {
        transactionListenerTask?.cancel()
    }

    /// Syncs `isProActive` with `Transaction.currentEntitlements`. Call on launch and after StoreKit events.
    func refreshEntitlements() async {
        isProActive = await computeProEntitlementFromStore()
    }

    /// Loads subscription products from the App Store (or StoreKit Testing in Xcode).
    func loadProducts() async {
        do {
            let products = try await Product.products(for: SubscriptionProductIDs.all)
            var map: [String: Product] = [:]
            for product in products {
                map[product.id] = product
            }
            productsByID = map
        } catch {
            productsByID = [:]
        }
    }

    func product(forPlanKey planKey: String) -> Product? {
        guard let id = SubscriptionProductIDs.productID(planKey: planKey) else { return nil }
        return productsByID[id]
    }

    func purchase(planKey: String) async throws -> Bool {
        guard let product = product(forPlanKey: planKey) else {
            throw SubscriptionStoreError.productUnavailable
        }
        let result = try await product.purchase()
        switch result {
        case .success(let verification):
            let transaction = try checkVerified(verification)
            await transaction.finish()
            await refreshEntitlements()
            NotificationCenter.default.post(name: .subscriptionStatusDidChange, object: nil)
            return true
        case .userCancelled:
            return false
        case .pending:
            return false
        @unknown default:
            return false
        }
    }

    /// Restores purchases by syncing with the App Store (required on macOS instead of `restoreCompletedTransactions`).
    func restorePurchases() async throws {
        try await AppStore.sync()
        await refreshEntitlements()
        NotificationCenter.default.post(name: .subscriptionStatusDidChange, object: nil)
    }

    /// Whether the user has an active subscription for one of this app’s Pro product IDs.
    func hasActiveSubscription() async -> Bool {
        await refreshEntitlements()
        return isProActive
    }

    private func computeProEntitlementFromStore() async -> Bool {
        for await result in Transaction.currentEntitlements {
            guard case .verified(let transaction) = result else { continue }
            if transaction.revocationDate != nil { continue }
            guard transaction.productType == .autoRenewable else { continue }
            if SubscriptionProductIDs.all.contains(transaction.productID) {
                return true
            }
        }
        return false
    }

    private func listenForTransactions() async {
        for await result in Transaction.updates {
            guard case .verified(let transaction) = result else { continue }
            await transaction.finish()
            await refreshEntitlements()
            NotificationCenter.default.post(name: .subscriptionStatusDidChange, object: nil)
        }
    }

    private nonisolated func checkVerified(_ result: VerificationResult<Transaction>) throws -> Transaction {
        switch result {
        case .unverified(_, let error):
            throw error
        case .verified(let transaction):
            return transaction
        }
    }
}

enum SubscriptionStoreError: LocalizedError {
    /// No `Product` was returned for this ID (wrong IDs, products not approved in ASC, or StoreKit Configuration not selected in the scheme).
    case productUnavailable

    var errorDescription: String? {
        switch self {
        case .productUnavailable:
            return "That subscription isn’t available from the App Store right now."
        }
    }

    var recoverySuggestion: String? {
        switch self {
        case .productUnavailable:
            return """
            For local testing in Xcode: Product → Scheme → Edit Scheme → Run → Options → StoreKit Configuration → choose ProSubscriptions.storekit.

            For TestFlight / App Store: In App Store Connect, create auto-renewable subscriptions whose Product IDs exactly match SubscriptionProductIDs.swift (same spelling as com.mqldev.appforindeed.pro.*), then submit them with the app version.
            """
        }
    }
}