smart_printer/smart_printer/PaywallModels.swift

import Foundation
import StoreKit

struct PaywallPlan: Hashable, Sendable {
    let productID: String

    init(productID: String) {
        self.productID = productID
    }

    static var displayOrder: [PaywallPlan] {
        StoreKitCatalog.orderedPlans
    }

    var kind: PaywallPlanKind? {
        StoreKitCatalog.shared.kind(for: productID)
    }

    var isLifetime: Bool {
        kind == .lifetime
    }

    var isSubscription: Bool {
        kind != .lifetime && kind != nil
    }

    static func fromStoredValue(_ value: String) -> PaywallPlan? {
        StoreKitCatalog.shared.plan(matching: value)
    }

    func planCopy(from config: PaywallConfig, product: Product? = nil) -> PaywallConfig.PlanCopy {
        if let copy = config.planCopy(for: productID) {
            return copy
        }
        if let product {
            return config.synthesizedPlanCopy(for: product)
        }
        return config.placeholderPlanCopy(for: productID)
    }

    func localizedPrice(from product: Product?, config: PaywallConfig) -> String {
        product?.displayPrice ?? config.loadingPrice
    }

    func localizedSubtitle(
        from product: Product?,
        config: PaywallConfig,
        trial: PaywallTrialDisplay? = nil
    ) -> String {
        guard let product else { return config.loadingPrice }
        let copy = planCopy(from: config, product: product)
        let price = product.displayPrice

        if let trial, let trialTemplate = copy.trialSubtitleTemplate {
            return trialTemplate
                .replacingOccurrences(of: "{trial}", with: trial.durationLowercased)
                .replacingOccurrences(of: "{price}", with: price)
        }

        return copy.subtitleTemplate.replacingOccurrences(of: "{price}", with: price)
    }

    func localizedCTATitle(
        from product: Product?,
        config: PaywallConfig,
        trial: PaywallTrialDisplay? = nil
    ) -> String {
        guard let product else { return config.loadingCTA }
        if let trial {
            return trial.ctaText
        }
        let copy = planCopy(from: config, product: product)
        return copy.ctaTemplate.replacingOccurrences(of: "{price}", with: product.displayPrice)
    }

    func localizedRenewalDisclosure(
        from product: Product?,
        config: PaywallConfig,
        trial: PaywallTrialDisplay? = nil
    ) -> String {
        if isLifetime {
            return config.lifetimeDisclosure
        }

        guard let product else { return config.loadingDisclosure }
        let price = product.displayPrice
        let period = product.subscription.map {
            config.subscriptionPeriodDescription(from: $0.subscriptionPeriod)
        } ?? config.messages.periodFallback

        if let trial {
            return config.trialDisclosureTemplate
                .replacingOccurrences(of: "{trial}", with: trial.durationLowercased)
                .replacingOccurrences(of: "{price}", with: price)
                .replacingOccurrences(of: "{period}", with: period)
        }

        return config.subscriptionDisclosureTemplate
            .replacingOccurrences(of: "{price}", with: price)
            .replacingOccurrences(of: "{period}", with: period)
    }
}

struct PaywallTrialDisplay: Equatable, Sendable {
    let badgeText: String
    let durationLowercased: String
    let ctaText: String

    static func from(offer: Product.SubscriptionOffer, config: PaywallConfig) -> PaywallTrialDisplay {
        let durationLowercased = config.trialDurationDescription(from: offer, lowercase: true)
        return PaywallTrialDisplay(
            badgeText: config.trialBadgeText(from: offer),
            durationLowercased: durationLowercased,
            ctaText: config.trialCTATitle(from: offer)
        )
    }

    static func from(fallback: PaywallConfig.TrialFallbackDuration, config: PaywallConfig) -> PaywallTrialDisplay? {
        guard let duration = config.trialDurationDescription(from: fallback),
              let durationLowercased = config.trialDurationDescription(from: fallback, lowercase: true) else {
            return nil
        }
        return PaywallTrialDisplay(
            badgeText: config.trialBadgeText(duration: duration),
            durationLowercased: durationLowercased,
            ctaText: config.trialCTATitle(duration: duration)
        )
    }
}

enum PurchaseError: Equatable {
    case productsLoadTimeout
    case subscriptionUnavailable
    case planUnavailable
    case purchaseNotVerified
    case purchasePending
    case noActiveSubscriptions
    case noActivePurchases
    case restoreSyncTimeout
    case generic
}