import StoreKit
 
@MainActor
final class SubscriptionManager: ObservableObject {
    @Published private(set) var products: [Product] = []
    @Published private(set) var purchasedProductIDs: Set<String> = []
 
    private let productIDs = ["pro.monthly", "pro.yearly"]
    private var updatesTask: Task<Void, Never>?
 
    init() {
        updatesTask = observeTransactionUpdates()
        Task {
            await loadProducts()
            await refreshEntitlements()
        }
    }
 
    deinit {
        updatesTask?.cancel()
    }
 
    func loadProducts() async {
        do {
            products = try await Product.products(for: productIDs)
        } catch {
            print("Failed to load products: \(error)")
        }
    }
 
    func purchase(_ product: Product) async throws {
        let result = try await product.purchase()
 
        switch result {
        case .success(let verification):
            let transaction = try checkVerified(verification)
            await transaction.finish()
            await refreshEntitlements()
        case .userCancelled, .pending:
            break
        @unknown default:
            break
        }
    }
 
    func refreshEntitlements() async {
        var active: Set<String> = []
        for await result in Transaction.currentEntitlements {
            guard let transaction = try? checkVerified(result) else { continue }
            if transaction.revocationDate == nil {
                active.insert(transaction.productID)
            }
        }
        purchasedProductIDs = active
    }
 
    private func observeTransactionUpdates() -> Task<Void, Never> {
        Task(priority: .background) { [weak self] in
            for await result in Transaction.updates {
                guard let transaction = try? self?.checkVerified(result) else { continue }
                await transaction.finish()
                await self?.refreshEntitlements()
            }
        }
    }
 
    private func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
        switch result {
        case .unverified:
            throw StoreError.failedVerification
        case .verified(let safe):
            return safe
        }
    }
}
 
enum StoreError: Error {
    case failedVerification
}

extension SubscriptionManager {
    /// Returns true if the user should keep Pro access,
    /// including grace period and billing retry — not just `.subscribed`.
    func hasActiveProAccess(for group: Product.SubscriptionInfo?) async -> Bool {
        guard let statuses = try? await group?.status else { return false }
 
        for status in statuses {
            switch status.state {
            case .subscribed, .inGracePeriod:
                return true
            case .inBillingRetryPeriod:
                // Apple is still retrying the charge — don't cut access yet.
                return true
            case .expired, .revoked:
                continue
            default:
                continue
            }
        }
        return false
    }
}

struct PaywallView: View {
    let groupID: String
 
    var body: some View {
        SubscriptionStoreView(groupID: groupID) {
            VStack(spacing: 12) {
                Image(systemName: "chart.line.uptrend.xyaxis")
                    .font(.largeTitle)
                Text("Unlock Pro Forecasts")
                    .font(.title2.bold())
                Text("Advanced analytics and extended forecasts for $2.99/mo")
                    .font(.subheadline)
                    .foregroundStyle(.secondary)
            }
            .padding()
        }
        .storeButton(.visible, for: .restorePurchases)
        .subscriptionStoreControlStyle(.prominentPicker)
        .onInAppPurchaseCompletion { product, result in
            if case .success(.success) = result {
                // refresh entitlements, dismiss paywall, etc.
            }
        }
    }
}

extension SubscriptionManager {
    func availableWinBackOffer(for product: Product) async -> Product.SubscriptionOffer? {
        guard let status = try? await product.subscription?.status.first,
              case .expired = status.state else { return nil }
 
        let eligible = await product.subscription?.eligibleWinBackOffers ?? []
        return eligible.first
    }
 
    func redeem(_ offer: Product.SubscriptionOffer, for product: Product) async throws {
        let result = try await product.purchase(options: [.winBackOffer(offer)])
        if case .success(let verification) = result {
            let transaction = try checkVerified(verification)
            await transaction.finish()
            await refreshEntitlements()
        }
    }
}