Paywall cards

import { AppState, Platform } from 'react-native';
import Purchases, {
  PRODUCT_TYPE,
  type CustomerInfo,
  type PurchasesOffering,
} from 'react-native-purchases';
import RevenueCatUI from 'react-native-purchases-ui';
import { Reception, type ReceptionPaywallProduct } from 'react-native-reception';

function subscriptionMetadata(info: CustomerInfo): Record<string, string> {
  const latest = Object.values(info.entitlements.active).sort((a, b) =>
    (b.expirationDate ?? '9999').localeCompare(a.expirationDate ?? '9999'),
  )[0];
  if (!latest) return { subscription_status: 'none' };
  const metadata: Record<string, string> = {
    subscription_status: 'active',
    plan: latest.productIdentifier,
  };
  if (latest.isSandbox) metadata.environment = 'sandbox';
  if (latest.expirationDate)
    metadata[latest.willRenew ? 'renews_on' : 'expires_on'] =
      latest.expirationDate.slice(0, 10);
  return metadata;
}

function title(offering: PurchasesOffering): string {
  let result = '';
  for (const character of offering.serverDescription.trim() ||
    offering.identifier) {
    if (result.length + character.length > 60) break;
    result += character;
  }
  return result;
}

/** What the offering sells, shown to your team in Reception. Periods are already ISO 8601, like "P1M". */
function products(offering: PurchasesOffering): ReceptionPaywallProduct[] {
  return offering.availablePackages.map(({ product }) => ({
    id: product.identifier,
    price: product.priceString,
    period: product.subscriptionPeriod ?? undefined,
    trial:
      product.introPrice && product.introPrice.price === 0
        ? product.introPrice.period
        : undefined,
  }));
}

function start({ syncsSubscriptionMetadata = true } = {}) {
  let active = true;
  let revision = 0;
  let offeringRevision = 0;
  let offerings: Record<string, PurchasesOffering> = {};
  const failed = () =>
    console.warn('Reception paywalls could not refresh or present.');
  const update = (info: CustomerInfo) => {
    if (!active) return;
    // Invalidate an older foreground request before accepting this snapshot.
    revision += 1;
    if (syncsSubscriptionMetadata)
      void Reception.setMetadata(subscriptionMetadata(info)).catch(failed);
    void Reception.refreshPaywalls({ invalidate: true }).catch(failed);
  };
  const reload = async () => {
    const request = ++offeringRevision;
    const metadataRevision = revision;
    const [all, info] = await Promise.all([
      Purchases.getOfferings(),
      Purchases.getCustomerInfo(),
    ]);
    if (!active || request !== offeringRevision) return;
    const entries = Object.values(all.all)
      .filter((offering) => /^[A-Za-z0-9_.-]{1,64}$/.test(offering.identifier))
      .sort((a, b) => a.identifier.localeCompare(b.identifier))
      .slice(0, 20);
    // RN does not expose Swift's hasPaywall. Mark published offerings in dashboard metadata;
    // the others are listed for the team but never sent as cards.
    offerings = Object.fromEntries(
      entries
        .filter((offering) => offering.metadata.reception === true)
        .map((offering) => [offering.identifier, offering]),
    );
    Reception.paywalls = entries.map((offering) => ({
      id: offering.identifier,
      title: title(offering),
      source: 'revenuecat',
      products: products(offering),
      presentable: offering.metadata.reception === true,
    }));
    if (metadataRevision === revision) update(info);
    else void Reception.refreshPaywalls({ invalidate: true }).catch(failed);
  };
  Reception.paywallAvailability = async (id) => {
    const offering = offerings[id];
    if (!offering) return false;
    const info = await Purchases.getCustomerInfo();
    const owned = new Set([
      ...info.activeSubscriptions,
      ...info.nonSubscriptionTransactions.map((item) => item.productIdentifier),
    ]);
    return (
      active &&
      offering.availablePackages.some(
        ({ product }) =>
          product.productType === PRODUCT_TYPE.CONSUMABLE ||
          !owned.has(product.identifier),
      )
    );
  };
  Reception.onPaywall = (id) => {
    const offering = offerings[id];
    if (!active || !offering) return;
    // On Android the chat sheet is its own activity; close it so the paywall shows above.
    void (Platform.OS === 'android' ? Reception.closeChat() : Promise.resolve())
      .then(() => RevenueCatUI.presentPaywall({ offering, displayCloseButton: true }))
      .then(() => {
        if (active) return reload();
      })
      .catch(failed);
  };
  Purchases.addCustomerInfoUpdateListener(update);
  const foreground = AppState.addEventListener('change', (state) => {
    if (state === 'active') void reload().catch(failed);
  });
  void reload().catch(failed);
  return () => {
    active = false;
    Purchases.removeCustomerInfoUpdateListener(update);
    foreground.remove();
    Reception.onPaywall = null;
    Reception.paywallAvailability = null;
    Reception.paywalls = [];
  };
}

export const ReceptionRevenueCatPaywalls = { start, subscriptionMetadata };

import { useEffect, useRef } from 'react';
import { AppState, Platform } from 'react-native';
import {
  useSuperwall,
  useSuperwallEvents,
  type CustomerInfo,
  type SubscriptionStatus,
} from 'expo-superwall';
import { Reception, type ReceptionPaywall } from 'react-native-reception';

// Resolves once the chat has closed, or after two seconds if it stays open.
function chatClosed() {
  return new Promise<void>((resolve) => {
    if (!Reception.isChatOpen) return resolve();
    const done = () => {
      clearTimeout(timer);
      subscription.remove();
      resolve();
    };
    const timer = setTimeout(done, 2000);
    const subscription = Reception.addChatOpenListener((open) => {
      if (!open) done();
    });
  });
}

export function subscriptionMetadata(
  info: CustomerInfo,
  status: SubscriptionStatus,
): Record<string, string> {
  const latest = info.subscriptions
    .filter((item) => item.isActive && !item.isRevoked)
    .sort((a, b) =>
      (b.expirationDate ?? '9999').localeCompare(a.expirationDate ?? '9999'),
    )[0];
  if (!latest)
    return {
      subscription_status: status.status === 'ACTIVE' ? 'active' : 'none',
    };
  const metadata: Record<string, string> = {
    subscription_status: 'active',
    plan: latest.productId,
  };
  if (latest.expirationDate)
    metadata[latest.willRenew ? 'renews_on' : 'expires_on'] =
      latest.expirationDate.slice(0, 10);
  return metadata;
}

// Mount once below your existing SuperwallProvider, after Reception is configured.
export function useReceptionSuperwallPaywalls(
  placements: readonly ReceptionPaywall[],
  { syncsSubscriptionMetadata = true } = {},
) {
  const {
    isConfigured,
    subscriptionStatus,
    customerInfo,
    getCustomerInfo,
    getPresentationResult,
    registerPlacement,
    dismiss,
  } = useSuperwall();
  // Superwall shows one paywall at a time, so the hook remembers whether one is open.
  const presented = useRef(false);
  useSuperwallEvents({
    onPaywallPresent: () => {
      presented.current = true;
    },
    onPaywallDismiss: () => {
      presented.current = false;
    },
  });
  useEffect(() => {
    if (
      (Platform.OS !== 'ios' && Platform.OS !== 'android') ||
      !isConfigured ||
      subscriptionStatus.status === 'UNKNOWN'
    )
      return;
    let active = true;
    const failed = () =>
      console.warn('Reception paywalls could not refresh or present.');
    Reception.paywallAvailability = async (id) => {
      const result = await getPresentationResult(id);
      // The native bridge returns a serialized result, not a JavaScript class instance.
      return active && 'type' in result && result.type === 'Paywall';
    };
    Reception.onPaywall = (id) => {
      void (async () => {
        // Like Superwall's own follow-up paywalls: one still open, as after a cancelled purchase, makes way. The
        // chat on top of it closes first, since closing the paywall would otherwise close only the chat. On Android
        // the chat sheet is its own activity, so it always closes first to let the paywall show above.
        const reopen = presented.current;
        if (reopen || Platform.OS === 'android') {
          await Reception.closeChat();
          await chatClosed();
        }
        if (reopen) await dismiss();
        await registerPlacement(id);
      })().catch(failed);
    };
    Reception.paywalls = placements.map((placement) => ({
      ...placement,
      source: 'superwall',
    }));
    if (syncsSubscriptionMetadata && customerInfo) {
      void Reception.setMetadata(
        subscriptionMetadata(customerInfo, subscriptionStatus),
      ).catch(failed);
    }
    void Reception.refreshPaywalls({ invalidate: true }).catch(failed);
    return () => {
      active = false;
      Reception.onPaywall = null;
      Reception.paywallAvailability = null;
      Reception.paywalls = [];
    };
  }, [
    isConfigured,
    subscriptionStatus,
    customerInfo,
    getPresentationResult,
    registerPlacement,
    dismiss,
    placements,
    syncsSubscriptionMetadata,
  ]);
  useEffect(() => {
    if ((Platform.OS !== 'ios' && Platform.OS !== 'android') || !isConfigured)
      return;
    const refresh = () => {
      void getCustomerInfo().catch(() =>
        console.warn('Reception subscription refresh failed.'),
      );
    };
    refresh();
    const foreground = AppState.addEventListener('change', (state) => {
      if (state === 'active') refresh();
    });
    return () => foreground.remove();
  }, [isConfigured, getCustomerInfo]);
}

import { AppState, Platform } from 'react-native';
import Purchases, { type CustomerInfo } from 'react-native-purchases';
import { Reception } from 'react-native-reception';

function subscriptionMetadata(info: CustomerInfo): Record<string, string> {
  const latest = Object.values(info.entitlements.active).sort((a, b) =>
    (b.expirationDate ?? '9999').localeCompare(a.expirationDate ?? '9999'),
  )[0];
  if (!latest) return { subscription_status: 'none' };
  const metadata: Record<string, string> = {
    subscription_status: 'active',
    plan: latest.productIdentifier,
  };
  if (latest.isSandbox) metadata.environment = 'sandbox';
  if (latest.expirationDate)
    metadata[latest.willRenew ? 'renews_on' : 'expires_on'] =
      latest.expirationDate.slice(0, 10);
  return metadata;
}

// Replace with the products sold by your existing screen. Consumables never count as owned.
const products = [
  { id: 'pro_monthly', consumable: false },
  { id: 'pro_yearly', consumable: false },
];

function start(
  present: () => Promise<void>,
  { syncsSubscriptionMetadata = true } = {},
) {
  let active = true;
  let revision = 0;
  const failed = () =>
    console.warn('Reception paywall could not refresh or present.');
  const update = (info: CustomerInfo) => {
    if (!active) return;
    revision += 1;
    if (syncsSubscriptionMetadata)
      void Reception.setMetadata(subscriptionMetadata(info)).catch(failed);
    void Reception.refreshPaywalls({ invalidate: true }).catch(failed);
  };
  const reload = async () => {
    const request = ++revision;
    const info = await Purchases.getCustomerInfo();
    if (active && request === revision) update(info);
  };
  Reception.paywallAvailability = async (id) => {
    if (id !== 'plans') return false;
    const info = await Purchases.getCustomerInfo();
    const owned = new Set([
      ...info.activeSubscriptions,
      ...info.nonSubscriptionTransactions.map((item) => item.productIdentifier),
    ]);
    return (
      active &&
      products.some((product) => product.consumable || !owned.has(product.id))
    );
  };
  Reception.onPaywall = (id) => {
    if (active && id === 'plans')
      // On Android the chat sheet is its own activity; close it so the paywall shows above.
      void (Platform.OS === 'android' ? Reception.closeChat() : Promise.resolve())
        .then(present)
        .then(() => {
          if (active) return reload();
        })
        .catch(failed);
  };
  Reception.paywalls = [
    {
      id: 'plans',
      title: 'Plans',
      source: 'app',
      products: products.map(({ id }) => ({ id })),
    },
  ];
  Purchases.addCustomerInfoUpdateListener(update);
  const foreground = AppState.addEventListener('change', (state) => {
    if (state === 'active') void reload().catch(failed);
  });
  void reload().catch(failed);
  return () => {
    active = false;
    Purchases.removeCustomerInfoUpdateListener(update);
    foreground.remove();
    Reception.onPaywall = null;
    Reception.paywallAvailability = null;
    Reception.paywalls = [];
  };
}

export const ReceptionStorePaywall = { start, subscriptionMetadata };

import 'dart:async';

import 'package:flutter/foundation.dart';
import 'package:flutter/widgets.dart';
import 'package:purchases_flutter/purchases_flutter.dart';
import 'package:purchases_ui_flutter/purchases_ui_flutter.dart';
import 'package:reception_flutter/reception_flutter.dart';

/// Offers RevenueCat offerings as Reception paywall cards.
///
/// Start once in `main()` after `Reception.configure` and
/// `Purchases.configure`, and keep the returned helper:
///
///     var paywalls = ReceptionRevenueCatPaywalls.start();
///
/// Every offering is listed for your team; those with offering metadata
/// `reception: true` become cards. Call [stop] before changing accounts, then
/// start again for the new account.
final class ReceptionRevenueCatPaywalls {
  ReceptionRevenueCatPaywalls._(this._syncsMetadata, this._consumables);

  final bool _syncsMetadata;
  final Set<String> _consumables;
  AppLifecycleListener? _lifecycle;
  var _active = false;
  var _revision = 0;
  var _offeringRevision = 0;
  var _offerings = <String, Offering>{};

  static final _validId = RegExp(r'^[A-Za-z0-9_.-]{1,64}$');

  /// Starts on iOS and Android; on web and desktop Reception shows no cards,
  /// so this does nothing there. RevenueCat's Flutter products don't say which ones are
  /// consumable, so list those in [consumableProductIds]; they never count as
  /// owned.
  static ReceptionRevenueCatPaywalls start({
    bool syncsSubscriptionMetadata = true,
    Set<String> consumableProductIds = const {},
  }) {
    final helper = ReceptionRevenueCatPaywalls._(
      syncsSubscriptionMetadata,
      consumableProductIds,
    );
    if (!_supported) return helper;
    helper._active = true;
    Reception.paywallAvailability = helper._isAvailable;
    Reception.onPaywall = helper._present;
    Purchases.addCustomerInfoUpdateListener(helper._update);
    helper._lifecycle = AppLifecycleListener(onResume: helper._refresh);
    helper._refresh();
    return helper;
  }

  /// The customer's plan for the support dashboard.
  static Map<String, String> subscriptionMetadata(CustomerInfo info) {
    final active = info.entitlements.active.values.toList()
      ..sort(
        (a, b) =>
            (b.expirationDate ?? '9999').compareTo(a.expirationDate ?? '9999'),
      );
    if (active.isEmpty) return {'subscription_status': 'none'};
    final latest = active.first;
    return {
      'subscription_status': 'active',
      'plan': latest.productIdentifier,
      if (latest.isSandbox) 'environment': 'sandbox',
      if (latest.expirationDate case final date?)
        latest.willRenew ? 'renews_on' : 'expires_on': date.split('T').first,
    };
  }

  /// Removes the listeners, and the cards while this helper still owns them.
  void stop() {
    if (!_active) return;
    _active = false;
    Purchases.removeCustomerInfoUpdateListener(_update);
    _lifecycle?.dispose();
    if (Reception.paywallAvailability == _isAvailable) {
      Reception.paywallAvailability = null;
    }
    if (Reception.onPaywall == _present) {
      Reception.onPaywall = null;
      Reception.paywalls = const [];
    }
  }

  void _update(CustomerInfo info) {
    if (!_active) return;
    // Invalidates an older foreground request before accepting this snapshot.
    _revision += 1;
    if (_syncsMetadata) {
      unawaited(
        Reception.setMetadata(subscriptionMetadata(info)).catchError(_failed),
      );
    }
    unawaited(Reception.refreshPaywalls(invalidate: true).catchError(_failed));
  }

  void _refresh() => unawaited(_reload().catchError(_failed));

  Future<void> _reload() async {
    final request = ++_offeringRevision;
    final metadataRevision = _revision;
    final (all, info) = await (
      Purchases.getOfferings(),
      Purchases.getCustomerInfo(),
    ).wait;
    if (!_active || request != _offeringRevision) return;
    final entries =
        all.all.values
            .where((offering) => _validId.hasMatch(offering.identifier))
            .toList()
          ..sort((a, b) => a.identifier.compareTo(b.identifier));
    final listed = entries.take(20).toList();
    // Flutter's Offering has no hasPaywall. Offerings marked in RevenueCat
    // become cards; the others are listed for the team but never sent.
    _offerings = {
      for (final offering in listed)
        if (_marked(offering)) offering.identifier: offering,
    };
    Reception.paywalls = [
      for (final offering in listed)
        ReceptionPaywall(
          id: offering.identifier,
          title: _title(offering),
          source: 'revenuecat',
          products: _products(offering),
          presentable: _marked(offering),
        ),
    ];
    if (metadataRevision == _revision) {
      _update(info);
    } else {
      await Reception.refreshPaywalls(invalidate: true);
    }
  }

  static bool _marked(Offering offering) =>
      offering.metadata['reception'] == true;

  /// Reception accepts titles of up to 60 characters.
  static String _title(Offering offering) {
    final description = offering.serverDescription.trim();
    final title = StringBuffer();
    for (final rune
        in (description.isEmpty ? offering.identifier : description).runes) {
      final character = String.fromCharCode(rune);
      if (title.length + character.length > 60) break;
      title.write(character);
    }
    return title.toString();
  }

  /// What the offering sells, shown to your team in Reception. Periods are
  /// already ISO 8601, like "P1M".
  static List<ReceptionPaywallProduct> _products(Offering offering) => [
    for (final package in offering.availablePackages)
      ReceptionPaywallProduct(
        id: package.storeProduct.identifier,
        price: package.storeProduct.priceString,
        period: package.storeProduct.subscriptionPeriod,
        trial: switch (package.storeProduct.introductoryPrice) {
          final intro? when intro.price == 0 => intro.period,
          _ => null,
        },
      ),
  ];

  Future<bool> _isAvailable(String id) async {
    final offering = _offerings[id];
    if (offering == null) return false;
    final info = await Purchases.getCustomerInfo();
    final owned = {
      ...info.activeSubscriptions,
      for (final transaction in info.nonSubscriptionTransactions)
        transaction.productIdentifier,
    };
    return _active &&
        offering.availablePackages.any((package) {
          final product = package.storeProduct.identifier;
          return _consumables.contains(product) || !owned.contains(product);
        });
  }

  /// RevenueCatUI presents natively and returns after dismissal: above the
  /// chat on iOS, and after the chat closes on Android, where the chat sheet
  /// is its own activity.
  void _present(String id) {
    final offering = _offerings[id];
    if (!_active || offering == null) return;
    unawaited(_presentPaywall(offering).catchError(_failed));
  }

  Future<void> _presentPaywall(Offering offering) async {
    if (defaultTargetPlatform == TargetPlatform.android) {
      await Reception.closeChat();
      if (!_active) return;
    }
    await RevenueCatUI.presentPaywall(
      offering: offering,
      displayCloseButton: true,
    );
    if (_active) await _reload();
  }

  /// Reception runs on iOS and Android, not on web or desktop.
  static bool get _supported =>
      !kIsWeb &&
      (defaultTargetPlatform == TargetPlatform.iOS ||
          defaultTargetPlatform == TargetPlatform.android);

  static void _failed(Object error) =>
      debugPrint('Reception paywalls could not refresh or present: $error');
}

import 'dart:async';

import 'package:flutter/foundation.dart';
import 'package:flutter/widgets.dart';
import 'package:reception_flutter/reception_flutter.dart';
import 'package:superwallkit_flutter/superwallkit_flutter.dart';

/// Offers your Superwall placements as Reception paywall cards.
///
/// Start once in `main()` after `Reception.configure` and
/// `Superwall.configure`, with every placement your app registers, and keep the
/// returned helper:
///
///     var paywalls = ReceptionSuperwallPaywalls.start(placements: [
///       ReceptionPaywall(id: 'upgrade_pro', title: 'Upgrade to Pro'),
///     ]);
///
/// A card is available when Superwall would show a paywall for its placement to
/// this customer. A tap registers the placement, so Superwall presents the
/// paywall above the chat. Call [stop] before changing accounts, then start
/// again for the new account.
final class ReceptionSuperwallPaywalls {
  ReceptionSuperwallPaywalls._(this._syncsMetadata);

  final bool _syncsMetadata;
  final _subscriptions = <StreamSubscription<Object?>>[];
  AppLifecycleListener? _lifecycle;
  var _active = false;
  var _revision = 0;

  /// Starts on iOS and Android; on web and desktop Reception shows no cards,
  /// so this does nothing there.
  static ReceptionSuperwallPaywalls start({
    required List<ReceptionPaywall> placements,
    bool syncsSubscriptionMetadata = true,
  }) {
    final helper = ReceptionSuperwallPaywalls._(syncsSubscriptionMetadata);
    if (!_supported) return helper;
    helper._active = true;
    Reception.paywalls = [
      for (final placement in placements)
        ReceptionPaywall(
          id: placement.id,
          title: placement.title,
          source: 'superwall',
          products: placement.products,
        ),
    ];
    Reception.paywallAvailability = helper._isAvailable;
    Reception.onPaywall = helper._present;
    // Recheck after purchases or plan changes.
    helper._subscriptions
      ..add(
        Superwall.shared.subscriptionStatus.listen(
          (_) => helper._changed(),
          onError: _failed,
        ),
      )
      ..add(
        Superwall.shared.customerInfoStream.listen(
          (_) => helper._changed(),
          onError: _failed,
        ),
      );
    // Cancelling in the App Store changes no purchase, so the plan is also
    // rechecked when the app returns to the foreground.
    helper._lifecycle = AppLifecycleListener(
      onResume: helper._syncMetadataLater,
    );
    unawaited(helper._whenConfigured().catchError(_failed));
    return helper;
  }

  /// The customer's plan for the support dashboard. Don't send it while
  /// [status] is still unknown.
  static Map<String, String> subscriptionMetadata(
    CustomerInfo info,
    SubscriptionStatus status,
  ) {
    final never = DateTime.utc(9999);
    final active =
        info.subscriptions
            .where((item) => item.isActive && !item.isRevoked)
            .toList()
          ..sort(
            (a, b) => (b.expirationDate ?? never).compareTo(
              a.expirationDate ?? never,
            ),
          );
    if (active.isEmpty) {
      return {'subscription_status': status.isActive ? 'active' : 'none'};
    }
    final latest = active.first;
    return {
      'subscription_status': 'active',
      'plan': latest.productId,
      if (latest.expirationDate case final date?)
        latest.willRenew ? 'renews_on' : 'expires_on': date
            .toUtc()
            .toIso8601String()
            .substring(0, 10),
    };
  }

  /// Removes the listeners, and the cards while this helper still owns them.
  void stop() {
    if (!_active) return;
    _active = false;
    for (final subscription in _subscriptions) {
      unawaited(subscription.cancel());
    }
    _lifecycle?.dispose();
    if (Reception.paywallAvailability == _isAvailable) {
      Reception.paywallAvailability = null;
    }
    if (Reception.onPaywall == _present) {
      Reception.onPaywall = null;
      Reception.paywalls = const [];
    }
  }

  /// Superwall's Flutter SDK has no configuration stream, so the helper checks
  /// until it has loaded, then rechecks the cards and the plan.
  Future<void> _whenConfigured() async {
    for (var attempt = 0; attempt < 120 && _active; attempt++) {
      if (await Superwall.shared.getConfigurationStatus() ==
          ConfigurationStatus.configured) {
        _changed();
        return;
      }
      await Future<void>.delayed(const Duration(milliseconds: 500));
    }
  }

  void _changed() {
    if (!_active) return;
    unawaited(Reception.refreshPaywalls(invalidate: true).catchError(_failed));
    _syncMetadataLater();
  }

  void _syncMetadataLater() => unawaited(_syncMetadata().catchError(_failed));

  Future<void> _syncMetadata() async {
    if (!_syncsMetadata) return;
    final request = ++_revision;
    final (status, info) = await (
      Superwall.shared.getSubscriptionStatus(),
      Superwall.shared.getCustomerInfo(),
    ).wait;
    // Before Superwall has loaded, "none" could be wrong.
    if (!_active ||
        request != _revision ||
        status is SubscriptionStatusUnknown) {
      return;
    }
    await Reception.setMetadata(subscriptionMetadata(info, status));
  }

  Future<bool> _isAvailable(String placement) async {
    final (configuration, status) = await (
      Superwall.shared.getConfigurationStatus(),
      Superwall.shared.getSubscriptionStatus(),
    ).wait;
    if (configuration != ConfigurationStatus.configured ||
        status is SubscriptionStatusUnknown) {
      return false;
    }
    final result = await Superwall.shared.getPresentationResult(placement);
    return _active && result is PaywallPresentationResult;
  }

  void _present(String placement) {
    if (_active) unawaited(_register(placement).catchError(_failed));
  }

  Future<void> _register(String placement) async {
    // Like Superwall's own follow-up paywalls: one still open, as after a
    // cancelled purchase, makes way. The chat on top of it closes first, since
    // closing the paywall would otherwise close only the chat. On Android the
    // chat sheet is its own activity, so it always closes first to let the
    // paywall show above.
    final presented = await Superwall.shared.getIsPaywallPresented();
    if (presented || defaultTargetPlatform == TargetPlatform.android) {
      if (!_active) return;
      await Reception.closeChat();
      await _chatClosed();
    }
    if (presented) {
      if (!_active) return;
      await Superwall.shared.dismiss();
      // dismiss() returns before the paywall has closed.
      for (var attempt = 0; attempt < 40; attempt++) {
        if (!await Superwall.shared.getIsPaywallPresented()) break;
        await Future<void>.delayed(const Duration(milliseconds: 50));
      }
    }
    if (!_active) return;
    // StoreKit entitlements can settle after Superwall publishes its purchase
    // state, so the plan is rechecked when the paywall closes.
    final handler = PaywallPresentationHandler()
      ..onDismiss((info, result) => _syncMetadataLater());
    await Superwall.shared.registerPlacement(placement, handler: handler);
  }

  /// Completes once the chat has closed, or after two seconds if it stays open.
  static Future<void> _chatClosed() {
    final open = Reception.isChatOpen;
    if (!open.value) return Future.value();
    final closed = Completer<void>();
    void listener() {
      if (!open.value && !closed.isCompleted) closed.complete();
    }

    open.addListener(listener);
    return closed.future
        .timeout(const Duration(seconds: 2), onTimeout: () {})
        .whenComplete(() => open.removeListener(listener));
  }

  /// Reception runs on iOS and Android, not on web or desktop.
  static bool get _supported =>
      !kIsWeb &&
      (defaultTargetPlatform == TargetPlatform.iOS ||
          defaultTargetPlatform == TargetPlatform.android);

  static void _failed(Object error) =>
      debugPrint('Reception paywalls could not refresh or present: $error');
}

import 'dart:async';

import 'package:flutter/foundation.dart';
import 'package:flutter/widgets.dart';
import 'package:reception_flutter/reception_flutter.dart';

/// Offers a paywall screen built in your Flutter code as a Reception paywall
/// card. It works with any store library: you supply the owned product IDs.
///
/// Start once in `main()` after `Reception.configure` and your store
/// library's setup, passing your function that shows the screen and completes
/// when it closes, and keep the returned helper:
///
///     var paywall = ReceptionStorePaywall.start(
///       presentYourPaywall,
///       ownedProductIds: yourOwnedProductIds,
///     );
///
/// The card stays available until the customer owns every product in
/// `_products`. Call [stop] before changing accounts, then start again for the
/// new account.
final class ReceptionStorePaywall {
  ReceptionStorePaywall._(
    this._present,
    this._ownedProductIds,
    this._subscriptionMetadata,
    this._closesChat,
  );

  // Replace with the products sold by your existing screen. Consumables never
  // count as owned.
  static const _products = [
    (id: 'pro_monthly', consumable: false),
    (id: 'pro_yearly', consumable: false),
  ];

  final Future<void> Function() _present;
  final Future<Set<String>> Function() _ownedProductIds;
  final FutureOr<Map<String, String>> Function()? _subscriptionMetadata;
  final bool _closesChat;
  StreamSubscription<void>? _purchases;
  AppLifecycleListener? _lifecycle;
  var _active = false;
  var _revision = 0;

  /// Starts on iOS and Android; on web and desktop Reception shows no cards,
  /// so this does nothing there.
  ///
  /// [ownedProductIds] returns the product IDs the customer currently owns.
  /// [purchasesChanged] emits after purchases, restores and expiries.
  /// [subscriptionMetadata] returns the plan fields for the support dashboard;
  /// leave it out when your app sends its own metadata. Pass
  /// `closesChatSheet: false` when the chat is a `ReceptionChatView` inside
  /// your own route.
  static ReceptionStorePaywall start(
    Future<void> Function() present, {
    required Future<Set<String>> Function() ownedProductIds,
    Stream<void>? purchasesChanged,
    FutureOr<Map<String, String>> Function()? subscriptionMetadata,
    bool closesChatSheet = true,
  }) {
    final helper = ReceptionStorePaywall._(
      present,
      ownedProductIds,
      subscriptionMetadata,
      closesChatSheet,
    );
    if (!_supported) return helper;
    helper._active = true;
    Reception.paywallAvailability = helper._isAvailable;
    Reception.onPaywall = helper._open;
    Reception.paywalls = [
      ReceptionPaywall(
        id: 'plans',
        title: 'Plans',
        source: 'app',
        products: [
          for (final product in _products)
            ReceptionPaywallProduct(id: product.id),
        ],
      ),
    ];
    helper._purchases = purchasesChanged?.listen((_) => helper._changed());
    helper._lifecycle = AppLifecycleListener(onResume: helper._changed);
    helper._changed();
    return helper;
  }

  /// Removes the listeners, and the card while this helper still owns it.
  void stop() {
    if (!_active) return;
    _active = false;
    unawaited(_purchases?.cancel());
    _lifecycle?.dispose();
    if (Reception.paywallAvailability == _isAvailable) {
      Reception.paywallAvailability = null;
    }
    if (Reception.onPaywall == _open) {
      Reception.onPaywall = null;
      Reception.paywalls = const [];
    }
  }

  void _changed() {
    if (!_active) return;
    unawaited(Reception.refreshPaywalls(invalidate: true).catchError(_failed));
    unawaited(_syncMetadata().catchError(_failed));
  }

  Future<void> _syncMetadata() async {
    final metadata = _subscriptionMetadata;
    if (metadata == null) return;
    final request = ++_revision;
    final fields = await metadata();
    if (_active && request == _revision) await Reception.setMetadata(fields);
  }

  Future<bool> _isAvailable(String id) async {
    if (id != 'plans') return false;
    final owned = await _ownedProductIds();
    return _active &&
        _products.any(
          (product) => product.consumable || !owned.contains(product.id),
        );
  }

  void _open(String id) {
    if (!_active || id != 'plans') return;
    unawaited(_presentPaywall().catchError(_failed));
  }

  /// Your screen renders in Flutter, below Reception's native chat sheet, so
  /// the sheet closes first and opens again when your screen closes.
  Future<void> _presentPaywall() async {
    final reopen = _closesChat && Reception.isChatOpen.value;
    if (reopen) {
      await Reception.closeChat();
      await _chatClosed();
      if (!_active) return;
    }
    await _present();
    if (!_active) return;
    if (reopen) await Reception.openChat();
    _changed();
  }

  /// Completes once the chat has closed, or after two seconds if it stays open.
  static Future<void> _chatClosed() {
    final open = Reception.isChatOpen;
    if (!open.value) return Future.value();
    final closed = Completer<void>();
    void listener() {
      if (!open.value && !closed.isCompleted) closed.complete();
    }

    open.addListener(listener);
    return closed.future
        .timeout(const Duration(seconds: 2), onTimeout: () {})
        .whenComplete(() => open.removeListener(listener));
  }

  /// Reception runs on iOS and Android, not on web or desktop.
  static bool get _supported =>
      !kIsWeb &&
      (defaultTargetPlatform == TargetPlatform.iOS ||
          defaultTargetPlatform == TargetPlatform.android);

  static void _failed(Object error) =>
      debugPrint('Reception paywall could not refresh or present: $error');
}