SubKitViews.swift

import StoreKit
import SubKit
import SwiftUI
import Observation

@available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, visionOS 1.0, *)
private enum ProductLoadState<Value> {
    case loading
    case loaded(Value)
    case empty
    case failed(String)
}

@available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, visionOS 1.0, *)
public struct SubKitProductView: View {
    private let productID: Product.ID
    private let appAccountToken: UUID?
    private let prefersPromotionalIcon: Bool
    private let icon: (() -> AnyView)?
    private let placeholderIcon: (() -> AnyView)?

    @State private var loadState = ProductLoadState<Product>.loading

    public init(
        id productID: Product.ID,
        appAccountToken: UUID? = nil,
        prefersPromotionalIcon: Bool = false
    ) {
        self.productID = productID
        self.appAccountToken = appAccountToken
        self.prefersPromotionalIcon = prefersPromotionalIcon
        self.icon = nil
        self.placeholderIcon = nil
    }

    public init<Icon: View>(
        id productID: Product.ID,
        appAccountToken: UUID? = nil,
        prefersPromotionalIcon: Bool = false,
        @ViewBuilder icon: @escaping () -> Icon
    ) {
        self.productID = productID
        self.appAccountToken = appAccountToken
        self.prefersPromotionalIcon = prefersPromotionalIcon
        self.icon = { AnyView(icon()) }
        self.placeholderIcon = nil
    }

    public init<Icon: View, Placeholder: View>(
        id productID: Product.ID,
        appAccountToken: UUID? = nil,
        prefersPromotionalIcon: Bool = false,
        @ViewBuilder icon: @escaping () -> Icon,
        @ViewBuilder placeholderIcon: @escaping () -> Placeholder
    ) {
        self.productID = productID
        self.appAccountToken = appAccountToken
        self.prefersPromotionalIcon = prefersPromotionalIcon
        self.icon = { AnyView(icon()) }
        self.placeholderIcon = { AnyView(placeholderIcon()) }
    }

    public var body: some View {
        Group {
            switch self.loadState {
            case .loading:
                ProgressView()
            case let .loaded(product):
                self.productView(product)
            case .empty:
                ContentUnavailableView(
                    "Product Unavailable",
                    systemImage: "shippingbox",
                    description: Text("This product is unavailable in the current storefront.")
                )
            case let .failed(message):
                ContentUnavailableView(
                    "Product Unavailable",
                    systemImage: "exclamationmark.triangle",
                    description: Text(message)
                )
            }
        }
        .task(id: self.productID) {
            await self.loadTask()
        }
        .inAppPurchaseOptions { _ in
            self.purchaseOptions()
        }
    }

    @ViewBuilder
    private func productView(_ product: Product) -> some View {
        if let icon = self.icon, let placeholderIcon = self.placeholderIcon {
            ProductView(
                id: product.id,
                prefersPromotionalIcon: self.prefersPromotionalIcon,
                icon: { icon() },
                placeholderIcon: { placeholderIcon() }
            )
        } else if let icon = self.icon {
            ProductView(
                product,
                prefersPromotionalIcon: self.prefersPromotionalIcon,
                icon: { icon() }
            )
        } else {
            ProductView(product, prefersPromotionalIcon: self.prefersPromotionalIcon)
        }
    }

    private func loadTask() async {
        self.loadState = .loading

        do {
            let products = try await Product.products(for: [self.productID])
            guard let product = products.first else {
                self.loadState = .empty
                return
            }
            self.loadState = .loaded(product)
        } catch {
            self.loadState = .failed(self.errorDescription(error))
        }
    }

    private func errorDescription(_ error: some Error) -> String {
        if let error = error as? LocalizedError, let description = error.errorDescription {
            return description
        }
        return String(describing: error)
    }

    private func purchaseOptions() -> Set<Product.PurchaseOption> {
        guard let appAccountToken = self.appAccountToken else {
            return []
        }
        return [.appAccountToken(appAccountToken)]
    }
}

@available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, visionOS 1.0, *)
public struct SubKitStoreView: View {
    private let productIDs: [Product.ID]
    private let appAccountToken: UUID?
    private let prefersPromotionalIcon: Bool
    private let icon: ((Product) -> AnyView)?

    @State private var loadState = ProductLoadState<[Product]>.loading

    public init(
        ids productIDs: some Collection<Product.ID>,
        appAccountToken: UUID? = nil,
        prefersPromotionalIcon: Bool = false
    ) {
        self.productIDs = Array(productIDs)
        self.appAccountToken = appAccountToken
        self.prefersPromotionalIcon = prefersPromotionalIcon
        self.icon = nil
    }

    public init<Icon: View>(
        ids productIDs: some Collection<Product.ID>,
        appAccountToken: UUID? = nil,
        prefersPromotionalIcon: Bool = false,
        @ViewBuilder icon: @escaping (Product) -> Icon
    ) {
        self.productIDs = Array(productIDs)
        self.appAccountToken = appAccountToken
        self.prefersPromotionalIcon = prefersPromotionalIcon
        self.icon = { AnyView(icon($0)) }
    }

    public var body: some View {
        Group {
            switch self.loadState {
            case .loading:
                ProgressView()
            case let .loaded(products):
                self.storeView(products)
            case .empty:
                ContentUnavailableView(
                    "Store Unavailable",
                    systemImage: "basket",
                    description: Text("No products are available in the current storefront.")
                )
            case let .failed(message):
                ContentUnavailableView(
                    "Store Unavailable",
                    systemImage: "exclamationmark.triangle",
                    description: Text(message)
                )
            }
        }
        .task(id: self.productIDs) {
            await self.loadTask()
        }
        .inAppPurchaseOptions { _ in
            self.purchaseOptions()
        }
    }

    @ViewBuilder
    private func storeView(_ products: [Product]) -> some View {
        if let icon = self.icon {
            StoreView(
                products: products,
                prefersPromotionalIcon: self.prefersPromotionalIcon,
                icon: { product in
                    icon(product)
                }
            )
        } else {
            StoreView(products: products, prefersPromotionalIcon: self.prefersPromotionalIcon)
        }
    }

    private func loadTask() async {
        guard !self.productIDs.isEmpty else {
            self.loadState = .empty
            return
        }

        self.loadState = .loading

        do {
            let products = try await Product.products(for: self.productIDs)
            self.loadState = products.isEmpty ? .empty : .loaded(products.sorted(by: self.sortProducts))
        } catch {
            self.loadState = .failed(self.errorDescription(error))
        }
    }

    private func sortProducts(_ lhs: Product, _ rhs: Product) -> Bool {
        if lhs.price == rhs.price {
            return lhs.id < rhs.id
        }
        return lhs.price < rhs.price
    }

    private func errorDescription(_ error: some Error) -> String {
        if let error = error as? LocalizedError, let description = error.errorDescription {
            return description
        }
        return String(describing: error)
    }

    private func purchaseOptions() -> Set<Product.PurchaseOption> {
        guard let appAccountToken = self.appAccountToken else {
            return []
        }
        return [.appAccountToken(appAccountToken)]
    }
}

@available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, visionOS 1.0, *)
public struct SubKitSubscriptionStoreView: View {
    private enum Source {
        case groupID(String)
        case productIDs([Product.ID])
    }

    private let source: Source
    private let appAccountToken: UUID?
    private let visibleRelationships: Product.SubscriptionRelationship
    private let marketingContent: (() -> AnyView)?

    @State private var loadState = ProductLoadState<[Product]>.loading

    public init(
        groupID: String,
        appAccountToken: UUID? = nil,
        visibleRelationships: Product.SubscriptionRelationship = .all
    ) {
        self.source = .groupID(groupID)
        self.appAccountToken = appAccountToken
        self.visibleRelationships = visibleRelationships
        self.marketingContent = nil
    }

    public init<Content: View>(
        groupID: String,
        appAccountToken: UUID? = nil,
        visibleRelationships: Product.SubscriptionRelationship = .all,
        @ViewBuilder marketingContent: @escaping () -> Content
    ) {
        self.source = .groupID(groupID)
        self.appAccountToken = appAccountToken
        self.visibleRelationships = visibleRelationships
        self.marketingContent = { AnyView(marketingContent()) }
    }

    public init(productIDs: some Collection<Product.ID>, appAccountToken: UUID? = nil) {
        self.source = .productIDs(Array(productIDs))
        self.appAccountToken = appAccountToken
        self.visibleRelationships = .all
        self.marketingContent = nil
    }

    public init<Content: View>(
        productIDs: some Collection<Product.ID>,
        appAccountToken: UUID? = nil,
        @ViewBuilder marketingContent: @escaping () -> Content
    ) {
        self.source = .productIDs(Array(productIDs))
        self.appAccountToken = appAccountToken
        self.visibleRelationships = .all
        self.marketingContent = { AnyView(marketingContent()) }
    }

    public var body: some View {
        Group {
            switch self.source {
            case .groupID:
                self.groupBackedView
            case .productIDs:
                self.productBackedView
            }
        }
        .inAppPurchaseOptions { _ in
            self.purchaseOptions()
        }
    }

    @ViewBuilder
    private var groupBackedView: some View {
        if case let .groupID(groupID) = self.source {
            if let marketingContent = self.marketingContent {
                SubscriptionStoreView(
                    groupID: groupID,
                    visibleRelationships: self.visibleRelationships
                ) {
                    marketingContent()
                }
            } else {
                SubscriptionStoreView(
                    groupID: groupID,
                    visibleRelationships: self.visibleRelationships
                )
            }
        }
    }

    @ViewBuilder
    private var productBackedView: some View {
        switch self.loadState {
        case .loading:
            ProgressView()
                .task {
                    await self.productTask()
                }
        case let .loaded(products):
            self.subscriptionStoreView(products)
        case .empty:
            ContentUnavailableView(
                "Subscription Unavailable",
                systemImage: "creditcard",
                description: Text("The subscription is unavailable in the current storefront.")
            )
        case let .failed(message):
            ContentUnavailableView(
                "Subscription Unavailable",
                systemImage: "exclamationmark.triangle",
                description: Text(message)
            )
        }
    }

    @ViewBuilder
    private func subscriptionStoreView(_ products: [Product]) -> some View {
        if let marketingContent = self.marketingContent {
            SubscriptionStoreView(subscriptions: products) {
                marketingContent()
            }
        } else {
            SubscriptionStoreView(subscriptions: products)
        }
    }

    private func productTask() async {
        guard case let .productIDs(productIDs) = self.source else {
            return
        }
        guard !productIDs.isEmpty else {
            self.loadState = .empty
            return
        }

        self.loadState = .loading

        do {
            let products = try await Product.products(for: productIDs)
                .filter { $0.type == .autoRenewable }
            self.loadState = products.isEmpty ? .empty : .loaded(products.sorted(by: self.sortProducts))
        } catch {
            self.loadState = .failed(self.errorDescription(error))
        }
    }

    private func sortProducts(_ lhs: Product, _ rhs: Product) -> Bool {
        if lhs.price == rhs.price {
            return lhs.id < rhs.id
        }
        return lhs.price < rhs.price
    }

    private func errorDescription(_ error: some Error) -> String {
        if let error = error as? LocalizedError, let description = error.errorDescription {
            return description
        }
        return String(describing: error)
    }

    private func purchaseOptions() -> Set<Product.PurchaseOption> {
        guard let appAccountToken = self.appAccountToken else {
            return []
        }
        return [.appAccountToken(appAccountToken)]
    }
}

@available(iOS 15.0, visionOS 1.0, *)
@available(macOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
@MainActor
@Observable
public final class SubKitManageSubscriptionsModel {
    public var isPresented = false
    public let subscriptionGroupID: String?

    public init(subscriptionGroupID: String? = nil) {
        self.subscriptionGroupID = subscriptionGroupID
    }

    public func present() {
        self.isPresented = true
    }

    public func dismiss() {
        self.isPresented = false
    }
}

@available(iOS 15.0, visionOS 1.0, *)
@available(macOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
public struct SubKitManageSubscriptionsPresenter: View {
    public let model: SubKitManageSubscriptionsModel

    public init(model: SubKitManageSubscriptionsModel) {
        self.model = model
    }

    public var body: some View {
        @Bindable var model = self.model

        Color.clear
            .ignoresSafeArea()
            .allowsHitTesting(false)
            .modifier(ManageSubscriptionsSheetModifier(
                isPresented: $model.isPresented,
                subscriptionGroupID: model.subscriptionGroupID
            ))
    }
}

@available(iOS 15.0, visionOS 1.0, *)
@available(macOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
public struct SubKitManageSubscriptionsButton<Label: View>: View {
    private enum Source {
        case external(SubKitManageSubscriptionsModel)
        case owned(String?)
    }

    private let source: Source
    private let label: () -> Label

    public init(
        model: SubKitManageSubscriptionsModel,
        @ViewBuilder label: @escaping () -> Label
    ) {
        self.source = .external(model)
        self.label = label
    }

    public init(
        subscriptionGroupID: String? = nil,
        @ViewBuilder label: @escaping () -> Label
    ) {
        self.source = .owned(subscriptionGroupID)
        self.label = label
    }

    @ViewBuilder
    public var body: some View {
        switch self.source {
        case let .external(model):
            ExternalManageSubscriptionsButton(model: model, label: self.label)
        case let .owned(subscriptionGroupID):
            OwnedManageSubscriptionsButton(
                subscriptionGroupID: subscriptionGroupID,
                label: self.label
            )
        }
    }
}

@available(iOS 15.0, visionOS 1.0, *)
@available(macOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
private struct ExternalManageSubscriptionsButton<Label: View>: View {
    let model: SubKitManageSubscriptionsModel
    private let label: () -> Label

    init(
        model: SubKitManageSubscriptionsModel,
        @ViewBuilder label: @escaping () -> Label
    ) {
        self.model = model
        self.label = label
    }

    var body: some View {
        Button(action: self.manageSubscriptionButtonTapped) {
            self.label()
        }
        .background {
            SubKitManageSubscriptionsPresenter(model: self.model)
        }
    }

    private func manageSubscriptionButtonTapped() {
        self.model.present()
    }
}

@available(iOS 15.0, visionOS 1.0, *)
@available(macOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
private struct OwnedManageSubscriptionsButton<Label: View>: View {
    @State private var model: SubKitManageSubscriptionsModel
    private let label: () -> Label

    init(
        subscriptionGroupID: String?,
        @ViewBuilder label: @escaping () -> Label
    ) {
        self._model = State(
            initialValue: SubKitManageSubscriptionsModel(
                subscriptionGroupID: subscriptionGroupID
            )
        )
        self.label = label
    }

    var body: some View {
        Button(action: self.manageSubscriptionButtonTapped) {
            self.label()
        }
        .background {
            SubKitManageSubscriptionsPresenter(model: self.model)
        }
    }

    private func manageSubscriptionButtonTapped() {
        self.model.present()
    }
}

@available(iOS 15.0, visionOS 1.0, *)
@available(macOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
extension SubKitManageSubscriptionsButton where Label == Text {
    public init(
        _ title: LocalizedStringKey = "Manage Subscription",
        model: SubKitManageSubscriptionsModel
    ) {
        self.init(model: model) {
            Text(title)
        }
    }

    public init(
        _ title: LocalizedStringKey = "Manage Subscription",
        subscriptionGroupID: String? = nil
    ) {
        self.init(subscriptionGroupID: subscriptionGroupID) {
            Text(title)
        }
    }
}

@available(iOS 15.0, visionOS 1.0, *)
@available(macOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
private struct ManageSubscriptionsSheetModifier: ViewModifier {
    @Binding var isPresented: Bool
    let subscriptionGroupID: String?

    func body(content: Content) -> some View {
        if let subscriptionGroupID {
            if #available(iOS 17.0, *) {
                content.manageSubscriptionsSheet(
                    isPresented: self.$isPresented,
                    subscriptionGroupID: subscriptionGroupID
                )
            } else {
                content.manageSubscriptionsSheet(isPresented: self.$isPresented)
            }
        } else {
            content.manageSubscriptionsSheet(isPresented: self.$isPresented)
        }
    }
}

#Preview("SubKit Product") {
    if #available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, visionOS 1.0, *) {
        SubKitProductView(id: "com.example.subkit.lifetime")
            .padding()
    }
}

#Preview("SubKit Store") {
    if #available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, visionOS 1.0, *) {
        NavigationStack {
            SubKitStoreView(
                ids: [
                    "com.example.subkit.lifetime",
                    "com.example.subkit.monthly",
                    "com.example.subkit.yearly",
                ]
            )
            .navigationTitle("SubKit")
        }
    }
}

#Preview("SubKit Subscription") {
    if #available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, visionOS 1.0, *) {
        SubKitSubscriptionStoreView(
            productIDs: [
                "com.example.subkit.monthly",
                "com.example.subkit.yearly",
            ]
        )
    }
}