Unity Integration

using StashPopup;

public class MyStore : MonoBehaviour
{
    void PurchaseItem(string checkoutUrl)
    {
        // checkoutUrl is a Stash Pay URL generated on your game backend.
        StashPayCard.Instance.OpenCheckout(
            checkoutUrl,
            dismissCallback: OnCheckoutDismissed,
            successCallback: OnPaymentSuccess,
            failureCallback: OnPaymentFailure
        );
    }
    
    void OnCheckoutDismissed()
    {
        // User closed the dialog, do nothing or handle accordingly.
    }
    
    void OnPaymentSuccess()
    {
        // Payment was completed
        // Trigger purchase validation on the server.
        VerifyAndGrantPurchase();
    }
    
    void OnPaymentFailure()
    {
        // Payment failed - show error to user
        ShowErrorMessage("Payment could not be processed");
    }
}

void OpenInBrowser(string url)
{
    // Enable browser mode
    StashPayCard.Instance.ForceWebBasedCheckout = true;
    
    // Opens in Safari/Chrome instead of card
    // successCallback and failureCallback are not available for the browser mode.
    StashPayCard.Instance.OpenCheckout(url, OnDismiss);
    
    // Restore default mode
    StashPayCard.Instance.ForceWebBasedCheckout = false;
}

public class PurchaseManager : MonoBehaviour
{
    private string currentOrderId;
    
    void PurchaseItem(string checkoutUrl)
    {
        // Store order ID for verification
        currentOrderId = ExtractOrderId(checkoutUrl);
        
        StashPayCard.Instance.OpenCheckout(
            checkoutUrl,
            dismissCallback: OnCheckoutDismissed,
            successCallback: OnPaymentSuccess,
            failureCallback: OnPaymentFailure
        );
        
        // Start a coroutine to verify purchase after timeout
        StartCoroutine(VerifyPurchaseAfterDelay(5.0f));
    }
    
    void OnPaymentSuccess()
    {
        // Callback fired - verify on server
        VerifyPurchaseOnServer(currentOrderId);
    }
    
    IEnumerator VerifyPurchaseAfterDelay(float delay)
    {
        yield return new WaitForSeconds(delay);
        
        // If callback hasn't fired, verify anyway
        // This handles cases where callback fails but purchase succeeded
        VerifyPurchaseOnServer(currentOrderId);
    }
    
    void VerifyPurchaseOnServer(string orderId)
    {
        // Query your server to verify purchase
        // Server should check webhooks or query Stash API
        StartCoroutine(CheckPurchaseStatus(orderId));
    }
}

void OnApplicationPause(bool pauseStatus)
{
    if (pauseStatus)
    {
        // App is being backgrounded
        // Save checkout state if needed
        SaveCheckoutState();
    }
    else
    {
        // App resumed - check for completed purchases
        // This handles cases where purchase completed while app was backgrounded
        CheckForPendingPurchases();
    }
}

void OnEnable()
{
    // Listen for deep link returns
    Application.deepLinkActivated += OnDeepLinkActivated;
}

void OnDeepLinkActivated(string url)
{
    // User returned via deep link after browser checkout
    if (url.Contains("purchase") || url.Contains("checkout"))
    {
        // Verify purchase on server
        VerifyPurchaseOnServer(ExtractOrderIdFromDeepLink(url));
    }
}

void CheckForPendingPurchases()
{
    // Query server for any purchases that completed while app was backgrounded
    // This ensures users get their items even if callbacks were missed
    StartCoroutine(QueryPendingPurchases());
}

void OnDeepLinkActivated(string url)
{
    // Parse deep link URL
    var uri = new Uri(url);
    var queryParams = System.Web.HttpUtility.ParseQueryString(uri.Query);
    
    // Check if this is a purchase return
    if (queryParams["purchase"] != null || queryParams["orderId"] != null)
    {
        var orderId = queryParams["orderId"] ?? queryParams["purchase"];
        
        // Always verify on server - don't trust deep link parameters
        VerifyPurchaseOnServer(orderId);
    }
}