Paywall Generator

import SwiftUI
import StoreKit

/// Full-screen paywall view.
///
/// Usage:
/// ```swift
/// .sheet(isPresented: $showPaywall) {
///     PaywallView()
/// }
/// ```
struct PaywallView: View {

    @Environment(\.dismiss) private var dismiss
    @State private var storeManager = StoreKitManager.shared
    @State private var selectedProduct: Product?
    @State private var isPurchasing = false
    @State private var errorMessage: String?

    var body: some View {
        NavigationStack {
            ScrollView {
                VStack(spacing: 24) {
                    // Header
                    headerSection

                    // Products
                    if storeManager.isLoading {
                        ProgressView()
                            .padding()
                    } else if storeManager.products.isEmpty {
                        Text("Unable to load products")
                            .foregroundStyle(.secondary)
                    } else {
                        productsSection
                    }

                    // Features
                    featuresSection

                    // Purchase button
                    purchaseButton

                    // Restore
                    restoreButton

                    // Terms
                    termsSection
                }
                .padding()
            }
            .navigationTitle("Upgrade to Pro")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .cancellationAction) {
                    Button("Close") {
                        dismiss()
                    }
                }
            }
            .task {
                await storeManager.loadProducts()
                selectedProduct = storeManager.yearlyProduct ?? storeManager.products.first
            }
            .alert("Error", isPresented: .constant(errorMessage != nil)) {
                Button("OK") { errorMessage = nil }
            } message: {
                Text(errorMessage ?? "")
            }
        }
    }

    // MARK: - Sections

    private var headerSection: some View {
        VStack(spacing: 12) {
            Image(systemName: "crown.fill")
                .font(.system(size: 60))
                .foregroundStyle(.yellow)

            Text("Unlock All Features")
                .font(.title.bold())

            Text("Get unlimited access to premium features")
                .font(.subheadline)
                .foregroundStyle(.secondary)
                .multilineTextAlignment(.center)
        }
        .padding(.top)
    }

    private var productsSection: some View {
        VStack(spacing: 12) {
            ForEach(storeManager.products) { product in
                SubscriptionButton(
                    product: product,
                    isSelected: selectedProduct?.id == product.id,
                    isPopular: product.id == Products.yearlySubscription,
                    savingsPercent: product.id == Products.yearlySubscription ? storeManager.yearlySavingsPercent : nil
                ) {
                    selectedProduct = product
                }
            }
        }
    }

    private var featuresSection: some View {
        VStack(alignment: .leading, spacing: 12) {
            Text("What's Included")
                .font(.headline)

            FeatureRow(icon: "checkmark.circle.fill", text: "Unlimited access")
            FeatureRow(icon: "checkmark.circle.fill", text: "Premium features")
            FeatureRow(icon: "checkmark.circle.fill", text: "No ads")
            FeatureRow(icon: "checkmark.circle.fill", text: "Priority support")
        }
        .frame(maxWidth: .infinity, alignment: .leading)
        .padding()
        .background(Color.secondary.opacity(0.1))
        .cornerRadius(12)
    }

    private var purchaseButton: some View {
        Button {
            Task {
                await purchase()
            }
        } label: {
            Group {
                if isPurchasing {
                    ProgressView()
                        .tint(.white)
                } else {
                    Text("Subscribe Now")
                        .font(.headline)
                }
            }
            .frame(maxWidth: .infinity)
            .frame(height: 50)
        }
        .buttonStyle(.borderedProminent)
        .disabled(selectedProduct == nil || isPurchasing)
    }

    private var restoreButton: some View {
        Button("Restore Purchases") {
            Task {
                await restore()
            }
        }
        .font(.footnote)
    }

    private var termsSection: some View {
        VStack(spacing: 4) {
            Text("Subscriptions auto-renew unless cancelled")
                .font(.caption2)
                .foregroundStyle(.secondary)

            HStack(spacing: 8) {
                Link("Terms", destination: URL(string: "https://yourapp.com/terms")!)
                Text("•")
                Link("Privacy", destination: URL(string: "https://yourapp.com/privacy")!)
            }
            .font(.caption2)
        }
    }

    // MARK: - Actions

    private func purchase() async {
        guard let product = selectedProduct else { return }

        isPurchasing = true
        defer { isPurchasing = false }

        do {
            let transaction = try await storeManager.purchase(product)
            if transaction != nil {
                dismiss()
            }
        } catch {
            errorMessage = error.localizedDescription
        }
    }

    private func restore() async {
        isPurchasing = true
        defer { isPurchasing = false }

        do {
            try await storeManager.restorePurchases()
            if storeManager.hasActiveSubscription() {
                dismiss()
            }
        } catch {
            errorMessage = error.localizedDescription
        }
    }
}

// MARK: - Feature Row

private struct FeatureRow: View {
    let icon: String
    let text: String

    var body: some View {
        HStack(spacing: 12) {
            Image(systemName: icon)
                .foregroundStyle(.green)
            Text(text)
                .font(.subheadline)
        }
    }
}

// MARK: - Preview

#Preview {
    PaywallView()
}

import Foundation

/// Product identifiers for in-app purchases.
///
/// Update these to match your App Store Connect configuration.
enum Products {

    // MARK: - Subscription Products

    /// Monthly subscription product ID.
    static let monthlySubscription = "com.yourapp.subscription.monthly"

    /// Yearly subscription product ID.
    static let yearlySubscription = "com.yourapp.subscription.yearly"

    /// Lifetime purchase product ID.
    static let lifetimePurchase = "com.yourapp.lifetime"

    // MARK: - Subscription Group

    /// The subscription group identifier.
    static let subscriptionGroupID = "your_subscription_group_id"

    // MARK: - All Products

    /// All product IDs to load.
    static let allProductIDs: Set<String> = [
        monthlySubscription,
        yearlySubscription,
        lifetimePurchase
    ]

    /// Only subscription product IDs.
    static let subscriptionProductIDs: Set<String> = [
        monthlySubscription,
        yearlySubscription
    ]
}

// MARK: - Product Display Names

extension Products {

    /// Display name for product ID.
    static func displayName(for productID: String) -> String {
        switch productID {
        case monthlySubscription:
            return "Monthly"
        case yearlySubscription:
            return "Yearly"
        case lifetimePurchase:
            return "Lifetime"
        default:
            return "Unknown"
        }
    }
}

import Foundation
import StoreKit

/// Manages StoreKit products and purchases.
///
/// Usage:
/// ```swift
/// let manager = StoreKitManager.shared
///
/// // Load products
/// await manager.loadProducts()
///
/// // Purchase
/// try await manager.purchase(product)
/// ```
@MainActor
@Observable
final class StoreKitManager {

    // MARK: - Singleton

    static let shared = StoreKitManager()

    // MARK: - State

    /// Available products loaded from App Store.
    private(set) var products: [Product] = []

    /// Currently purchased product IDs.
    private(set) var purchasedProductIDs: Set<String> = []

    /// Whether products are loading.
    private(set) var isLoading = false

    /// Any error that occurred.
    private(set) var error: StoreError?

    // MARK: - Transaction Listener

    private var transactionListener: Task<Void, Error>?

    // MARK: - Initialization

    private init() {
        transactionListener = listenForTransactions()
    }

    deinit {
        transactionListener?.cancel()
    }

    // MARK: - Load Products

    /// Load products from the App Store.
    func loadProducts() async {
        isLoading = true
        defer { isLoading = false }

        do {
            products = try await Product.products(for: Products.allProductIDs)
                .sorted { $0.price < $1.price }
            error = nil
        } catch {
            self.error = .productLoadFailed(error)
        }
    }

    // MARK: - Purchase

    /// Purchase a product.
    @discardableResult
    func purchase(_ product: Product) async throws -> Transaction? {
        let result = try await product.purchase()

        switch result {
        case .success(let verification):
            let transaction = try checkVerified(verification)
            await transaction.finish()
            await updatePurchasedProducts()
            return transaction

        case .userCancelled:
            return nil

        case .pending:
            // Ask to Buy - transaction pending approval
            return nil

        @unknown default:
            return nil
        }
    }

    // MARK: - Restore Purchases

    /// Restore previous purchases.
    func restorePurchases() async throws {
        try await AppStore.sync()
        await updatePurchasedProducts()
    }

    // MARK: - Update Purchased Products

    /// Update the set of purchased product IDs.
    func updatePurchasedProducts() async {
        var purchased: Set<String> = []

        for await result in Transaction.currentEntitlements {
            if case .verified(let transaction) = result {
                if transaction.revocationDate == nil {
                    purchased.insert(transaction.productID)
                }
            }
        }

        purchasedProductIDs = purchased
    }

    // MARK: - Check if Purchased

    /// Check if a product is purchased.
    func isPurchased(_ productID: String) -> Bool {
        purchasedProductIDs.contains(productID)
    }

    /// Check if user has any active subscription.
    func hasActiveSubscription() -> Bool {
        !purchasedProductIDs.isEmpty
    }

    // MARK: - Private

    private func listenForTransactions() -> Task<Void, Error> {
        Task.detached {
            for await result in Transaction.updates {
                do {
                    let transaction = try self.checkVerified(result)
                    await self.updatePurchasedProducts()
                    await transaction.finish()
                } catch {
                    // Transaction verification failed
                }
            }
        }
    }

    private func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
        switch result {
        case .verified(let safe):
            return safe
        case .unverified(_, let error):
            throw StoreError.verificationFailed(error)
        }
    }
}

// MARK: - Convenience Properties

extension StoreKitManager {

    /// Monthly subscription product (if available).
    var monthlyProduct: Product? {
        products.first { $0.id == Products.monthlySubscription }
    }

    /// Yearly subscription product (if available).
    var yearlyProduct: Product? {
        products.first { $0.id == Products.yearlySubscription }
    }

    /// Lifetime purchase product (if available).
    var lifetimeProduct: Product? {
        products.first { $0.id == Products.lifetimePurchase }
    }

    /// Calculate savings percentage of yearly vs monthly.
    var yearlySavingsPercent: Int? {
        guard let monthly = monthlyProduct,
              let yearly = yearlyProduct else {
            return nil
        }

        let yearlyIfMonthly = monthly.price * 12
        let savings = yearlyIfMonthly - yearly.price
        let percent = (savings / yearlyIfMonthly) * 100

        return Int(percent.rounded())
    }
}

// MARK: - Errors

enum StoreError: Error, LocalizedError {
    case productLoadFailed(Error)
    case purchaseFailed(Error)
    case verificationFailed(Error)

    var errorDescription: String? {
        switch self {
        case .productLoadFailed(let error):
            return "Failed to load products: \(error.localizedDescription)"
        case .purchaseFailed(let error):
            return "Purchase failed: \(error.localizedDescription)"
        case .verificationFailed(let error):
            return "Verification failed: \(error.localizedDescription)"
        }
    }
}

import SwiftUI
import StoreKit

/// Button for selecting a subscription plan.
///
/// Usage:
/// ```swift
/// SubscriptionButton(
///     product: monthlyProduct,
///     isSelected: selectedID == monthlyProduct.id,
///     isPopular: false
/// ) {
///     selectedID = monthlyProduct.id
/// }
/// ```
struct SubscriptionButton: View {

    let product: Product
    let isSelected: Bool
    let isPopular: Bool
    let savingsPercent: Int?
    let action: () -> Void

    init(
        product: Product,
        isSelected: Bool,
        isPopular: Bool = false,
        savingsPercent: Int? = nil,
        action: @escaping () -> Void
    ) {
        self.product = product
        self.isSelected = isSelected
        self.isPopular = isPopular
        self.savingsPercent = savingsPercent
        self.action = action
    }

    var body: some View {
        Button(action: action) {
            HStack {
                // Selection indicator
                Image(systemName: isSelected ? "checkmark.circle.fill" : "circle")
                    .foregroundStyle(isSelected ? .accentColor : .secondary)
                    .font(.title2)

                // Plan details
                VStack(alignment: .leading, spacing: 4) {
                    HStack {
                        Text(product.displayName)
                            .font(.headline)

                        if isPopular {
                            Text("POPULAR")
                                .font(.caption2.bold())
                                .foregroundStyle(.white)
                                .padding(.horizontal, 6)
                                .padding(.vertical, 2)
                                .background(Color.orange)
                                .cornerRadius(4)
                        }
                    }

                    if let description = product.description, !description.isEmpty {
                        Text(description)
                            .font(.caption)
                            .foregroundStyle(.secondary)
                    }
                }

                Spacer()

                // Price
                VStack(alignment: .trailing, spacing: 2) {
                    Text(product.displayPrice)
                        .font(.headline)

                    if let period = periodText {
                        Text(period)
                            .font(.caption)
                            .foregroundStyle(.secondary)
                    }

                    if let savings = savingsPercent, savings > 0 {
                        Text("Save \(savings)%")
                            .font(.caption.bold())
                            .foregroundStyle(.green)
                    }
                }
            }
            .padding()
            .background(
                RoundedRectangle(cornerRadius: 12)
                    .fill(isSelected ? Color.accentColor.opacity(0.1) : Color.secondary.opacity(0.1))
            )
            .overlay(
                RoundedRectangle(cornerRadius: 12)
                    .stroke(isSelected ? Color.accentColor : Color.clear, lineWidth: 2)
            )
        }
        .buttonStyle(.plain)
    }

    private var periodText: String? {
        guard let subscription = product.subscription else {
            // Lifetime or one-time purchase
            return "one-time"
        }

        let period = subscription.subscriptionPeriod

        switch period.unit {
        case .day:
            return period.value == 1 ? "per day" : "per \(period.value) days"
        case .week:
            return period.value == 1 ? "per week" : "per \(period.value) weeks"
        case .month:
            return period.value == 1 ? "per month" : "per \(period.value) months"
        case .year:
            return period.value == 1 ? "per year" : "per \(period.value) years"
        @unknown default:
            return nil
        }
    }
}

// MARK: - Preview

#Preview {
    VStack(spacing: 12) {
        // Mock products for preview
        Text("Subscription Options")
            .font(.headline)

        // In real usage, use actual Product objects
    }
    .padding()
}

import Foundation
import StoreKit
import SwiftUI

/// Subscription status for the current user.
enum SubscriptionStatus: Sendable {
    case unknown
    case notSubscribed
    case subscribed
    case expired
    case inGracePeriod
    case inBillingRetry

    /// Whether user currently has access to premium features.
    var hasAccess: Bool {
        switch self {
        case .subscribed, .inGracePeriod, .inBillingRetry:
            return true
        case .unknown, .notSubscribed, .expired:
            return false
        }
    }
}

// MARK: - From StoreKit Status

extension SubscriptionStatus {

    /// Create from StoreKit subscription statuses.
    static func from(_ statuses: [Product.SubscriptionInfo.Status]) -> SubscriptionStatus {
        // Check each status in the group
        for status in statuses {
            switch status.state {
            case .subscribed:
                return .subscribed
            case .inGracePeriod:
                return .inGracePeriod
            case .inBillingRetryPeriod:
                return .inBillingRetry
            case .expired:
                continue  // Check other subscriptions
            case .revoked:
                continue
            default:
                continue
            }
        }

        // No active subscription found
        if statuses.contains(where: { $0.state == .expired }) {
            return .expired
        }

        return .notSubscribed
    }
}

// MARK: - Environment Key

private struct SubscriptionStatusKey: EnvironmentKey {
    static let defaultValue: SubscriptionStatus = .unknown
}

extension EnvironmentValues {
    /// Current subscription status.
    var subscriptionStatus: SubscriptionStatus {
        get { self[SubscriptionStatusKey.self] }
        set { self[SubscriptionStatusKey.self] = newValue }
    }
}

// MARK: - SwiftUI Usage Example

/*

 // In App.swift
 @main
 struct MyApp: App {
     @State private var subscriptionStatus: SubscriptionStatus = .unknown

     var body: some Scene {
         WindowGroup {
             ContentView()
                 .environment(\.subscriptionStatus, subscriptionStatus)
                 .subscriptionStatusTask(for: Products.subscriptionGroupID) { statuses in
                     subscriptionStatus = SubscriptionStatus.from(statuses)
                 }
         }
     }
 }

 // In any View
 struct FeatureView: View {
     @Environment(\.subscriptionStatus) var status

     var body: some View {
         if status.hasAccess {
             PremiumContent()
         } else {
             UpgradePrompt()
         }
     }
 }

 */