app_for_reddit/App AI for Reddit/Models/PaywallConfig.swift

import Foundation
import StoreKit

struct PaywallConfig: Codable, Sendable {
    struct PlanCopy: Codable, Sendable {
        let title: String
        let badge: String?
        let subtitleTemplate: String
        let trialSubtitleTemplate: String?
        let ctaTemplate: String
        let fallbackPrice: String
        let priceSuffix: String?
        let fallbackBillingDescription: String
        let features: [String]

        init(
            title: String,
            badge: String? = nil,
            subtitleTemplate: String,
            trialSubtitleTemplate: String? = nil,
            ctaTemplate: String,
            fallbackPrice: String,
            priceSuffix: String? = nil,
            fallbackBillingDescription: String,
            features: [String]
        ) {
            self.title = title
            self.badge = badge
            self.subtitleTemplate = subtitleTemplate
            self.trialSubtitleTemplate = trialSubtitleTemplate
            self.ctaTemplate = ctaTemplate
            self.fallbackPrice = fallbackPrice
            self.priceSuffix = priceSuffix
            self.fallbackBillingDescription = fallbackBillingDescription
            self.features = features
        }
    }

    struct TrustItem: Codable, Sendable {
        let icon: String
        let title: String
        let subtitle: String
    }

    struct Footer: Codable, Sendable {
        let continueFree: String
        let manageSubscription: String
        let restorePurchase: String
        let privacyPolicy: String
        let termsOfService: String
        let support: String
    }

    struct URLs: Codable, Sendable {
        let privacy: String
        let terms: String
        let support: String
        let manageSubscriptions: String
    }

    struct Plans: Codable, Sendable {
        private let byKey: [String: PlanCopy]

        init(byKey: [String: PlanCopy]) {
            self.byKey = byKey
        }

        init(from decoder: Decoder) throws {
            byKey = try decoder.singleValueContainer().decode([String: PlanCopy].self)
        }

        func encode(to encoder: Encoder) throws {
            var container = encoder.singleValueContainer()
            try container.encode(byKey)
        }

        func planCopy(for key: String) -> PlanCopy? {
            byKey[key]
        }
    }

    struct DurationUnit: Codable, Sendable {
        let one: String
        let other: String
        let lowerOne: String
        let lowerOther: String
    }

    struct Duration: Codable, Sendable {
        let units: DurationUnits
        let countUnitTemplate: String
        let unknownFallback: String
    }

    struct DurationUnits: Codable, Sendable {
        let day: DurationUnit
        let week: DurationUnit
        let month: DurationUnit
        let year: DurationUnit
    }

    struct TrialFallbackDuration: Codable, Sendable {
        let count: Int
        let unit: String
    }

    struct Trial: Codable, Sendable {
        let eligiblePlan: String
        let badgeTemplate: String
        let ctaTemplate: String
        let fallbackDuration: TrialFallbackDuration?
    }

    struct Messages: Codable, Sendable {
        let productNotFound: String
        let failedVerification: String
        let noPlansAvailable: String
        let plansLoadFailed: String
        let purchaseFailedTitle: String
        let restoreNotFoundTitle: String
        let restoreNotFoundMessage: String
        let pendingPurchaseTitle: String
        let pendingPurchaseMessage: String
        let alertOK: String
        let retry: String
        let retrying: String
        let periodFallback: String
        let productsLoadTimeout: String
        let subscriptionUnavailable: String
        let planUnavailable: String
        let noActiveSubscriptions: String
        let restoreSyncTimeout: String
        let purchaseGeneric: String
    }

    struct Sidebar: Codable, Sendable {
        let unlockTitle: String
        let proTitle: String
        let unlockDescription: String
        let proDescription: String
        let upgradeAction: String
        let manageSubscriptionAction: String
        let lifetimeAction: String
    }

    let productIDs: [String]?
    let leftPanelTitle: String
    let rightTitle: String
    let rightSubtitle: String
    let features: [String]
    let trustItems: [TrustItem]
    let lifetimeTrustItem: TrustItem
    let plans: Plans
    let footer: Footer
    let urls: URLs
    let trial: Trial
    let duration: Duration
    let messages: Messages
    let sidebar: Sidebar
    let loadingPrice: String
    let loadingCTA: String
    let subscriptionDisclosureTemplate: String
    let trialDisclosureTemplate: String
    let lifetimeDisclosure: String
    let loadingDisclosure: String
    let securePaymentNote: String
    let closeButtonHelp: String
}

extension PaywallConfig {
    func mergingMarketing(from remote: PaywallConfig) -> PaywallConfig {
        PaywallConfig(
            productIDs: productIDs ?? remote.productIDs,
            leftPanelTitle: remote.leftPanelTitle,
            rightTitle: remote.rightTitle,
            rightSubtitle: remote.rightSubtitle,
            features: remote.features,
            trustItems: remote.trustItems,
            lifetimeTrustItem: remote.lifetimeTrustItem,
            plans: remote.plans,
            footer: footer,
            urls: urls,
            trial: trial,
            duration: duration,
            messages: messages,
            sidebar: remote.sidebar,
            loadingPrice: loadingPrice,
            loadingCTA: loadingCTA,
            subscriptionDisclosureTemplate: subscriptionDisclosureTemplate,
            trialDisclosureTemplate: trialDisclosureTemplate,
            lifetimeDisclosure: lifetimeDisclosure,
            loadingDisclosure: loadingDisclosure,
            securePaymentNote: securePaymentNote,
            closeButtonHelp: closeButtonHelp
        )
    }

    func message(for error: PurchaseError) -> String {
        switch error {
        case .productsLoadTimeout:
            messages.productsLoadTimeout
        case .subscriptionUnavailable:
            messages.subscriptionUnavailable
        case .planUnavailable:
            messages.planUnavailable
        case .purchaseNotVerified:
            messages.failedVerification
        case .purchasePending:
            messages.pendingPurchaseMessage
        case .noActiveSubscriptions:
            messages.noActiveSubscriptions
        case .noActivePurchases:
            messages.restoreNotFoundMessage
        case .restoreSyncTimeout:
            messages.restoreSyncTimeout
        case .generic:
            messages.purchaseGeneric
        }
    }

    static func loadBundled() -> PaywallConfig {
        guard let url = Bundle.main.url(forResource: "paywall", withExtension: "json"),
              let data = try? Data(contentsOf: url),
              let config = try? JSONDecoder().decode(PaywallConfig.self, from: data) else {
            fatalError("Missing or invalid paywall.json in app bundle.")
        }
        return config
    }

    func formatDuration(count: Int, unit: Product.SubscriptionPeriod.Unit, lowercase: Bool) -> String {
        guard count > 0 else {
            return duration.unknownFallback.replacingOccurrences(of: "{count}", with: "0")
        }

        let durationUnit: DurationUnit
        switch unit {
        case .day: durationUnit = duration.units.day
        case .week: durationUnit = duration.units.week
        case .month: durationUnit = duration.units.month
        case .year: durationUnit = duration.units.year
        @unknown default:
            return duration.unknownFallback.replacingOccurrences(of: "{count}", with: "\(count)")
        }

        let unitWord: String
        if count == 1 {
            unitWord = lowercase ? durationUnit.lowerOne : durationUnit.one
        } else {
            unitWord = lowercase ? durationUnit.lowerOther : durationUnit.other
        }

        if count == 1, lowercase {
            return unitWord
        }

        return duration.countUnitTemplate
            .replacingOccurrences(of: "{count}", with: "\(count)")
            .replacingOccurrences(of: "{unit}", with: unitWord)
    }

    func trialDurationDescription(from offer: Product.SubscriptionOffer, lowercase: Bool = false) -> String {
        let count = offer.period.value * offer.periodCount
        return formatDuration(count: count, unit: offer.period.unit, lowercase: lowercase)
    }

    func subscriptionPeriodDescription(from period: Product.SubscriptionPeriod) -> String {
        formatDuration(count: period.value, unit: period.unit, lowercase: true)
    }

    func trialBadgeText(from offer: Product.SubscriptionOffer) -> String {
        let duration = trialDurationDescription(from: offer)
        return trial.badgeTemplate.replacingOccurrences(of: "{duration}", with: duration)
    }

    func trialCTATitle(from offer: Product.SubscriptionOffer) -> String {
        let duration = trialDurationDescription(from: offer)
        return trial.ctaTemplate.replacingOccurrences(of: "{duration}", with: duration)
    }

    func trialBadgeText(duration: String) -> String {
        trial.badgeTemplate.replacingOccurrences(of: "{duration}", with: duration)
    }

    func trialCTATitle(duration: String) -> String {
        trial.ctaTemplate.replacingOccurrences(of: "{duration}", with: duration)
    }

    func trialDurationDescription(from fallback: TrialFallbackDuration, lowercase: Bool = false) -> String? {
        guard let unit = subscriptionPeriodUnit(from: fallback.unit) else { return nil }
        return formatDuration(count: fallback.count, unit: unit, lowercase: lowercase)
    }

    var trialEligiblePlan: PaywallPlan? {
        PaywallPlan.from(rawValue: trial.eligiblePlan)
    }

    var fallbackPlanCopy: PlanCopy {
        PlanCopy(
            title: "Premium",
            subtitleTemplate: "{price}",
            ctaTemplate: "Get Premium for {price}",
            fallbackPrice: loadingPrice,
            fallbackBillingDescription: "Billed at {price}",
            features: Array(features.prefix(3))
        )
    }

    func generatedPlanCopy(for product: Product) -> PlanCopy {
        let title = product.displayName
        let cardFeatures = Array(features.prefix(3))

        if product.type == .nonConsumable {
            return PlanCopy(
                title: title,
                badge: plans.planCopy(for: "lifetime")?.badge,
                subtitleTemplate: "{price} once, lifetime access",
                ctaTemplate: "Unlock Lifetime for {price}",
                fallbackPrice: product.displayPrice,
                fallbackBillingDescription: "One-time payment of {price}",
                features: cardFeatures
            )
        }

        if let period = product.subscription?.subscriptionPeriod {
            let periodLabel = subscriptionPeriodDescription(from: period)
            let suffix = shortPeriodSuffix(from: period)
            return PlanCopy(
                title: title,
                subtitleTemplate: "{price} / \(periodLabel), cancel anytime",
                ctaTemplate: "Get Premium for {price}",
                fallbackPrice: product.displayPrice,
                priceSuffix: suffix,
                fallbackBillingDescription: "Billed at {price} every \(periodLabel)",
                features: cardFeatures
            )
        }

        return PlanCopy(
            title: title,
            subtitleTemplate: "{price}",
            ctaTemplate: "Get Premium for {price}",
            fallbackPrice: product.displayPrice,
            fallbackBillingDescription: "Billed at {price}",
            features: cardFeatures
        )
    }

    private func shortPeriodSuffix(from period: Product.SubscriptionPeriod) -> String {
        switch period.unit {
        case .day: "/day"
        case .week: "/wk"
        case .month: "/mo"
        case .year: "/yr"
        @unknown default: ""
        }
    }

    private func subscriptionPeriodUnit(from value: String) -> Product.SubscriptionPeriod.Unit? {
        switch value {
        case "day": .day
        case "week": .week
        case "month": .month
        case "year": .year
        default: nil
        }
    }
}

extension PaywallConfig: Equatable {
    static func == (lhs: PaywallConfig, rhs: PaywallConfig) -> Bool {
        guard let lhsData = try? JSONEncoder().encode(lhs),
              let rhsData = try? JSONEncoder().encode(rhs) else {
            return false
        }
        return lhsData == rhsData
    }
}

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