// App.kt
import android.app.Application
import com.revenuecat.purchases.LogLevel
import com.revenuecat.purchases.Purchases
import com.revenuecat.purchases.PurchasesConfiguration

class App : Application() {
    override fun onCreate() {
        super.onCreate()
        Purchases.logLevel = LogLevel.DEBUG
        Purchases.configure(
            PurchasesConfiguration.Builder(this, "goog_YOUR_PUBLIC_SDK_KEY").build()
        )
    }
}

// main.dart
import 'dart:io' show Platform;
import 'package:purchases_flutter/purchases_flutter.dart';

Future<void> configureRevenueCat() async {
  await Purchases.setLogLevel(LogLevel.debug);
  final config = Platform.isIOS
      ? PurchasesConfiguration("appl_YOUR_PUBLIC_SDK_KEY")
      : PurchasesConfiguration("goog_YOUR_PUBLIC_SDK_KEY");
  await Purchases.configure(config);
}

// revenuecat.ts
import { Platform } from 'react-native';
import Purchases, { LOG_LEVEL } from 'react-native-purchases';

export function configureRevenueCat() {
  Purchases.setLogLevel(LOG_LEVEL.DEBUG);
  Purchases.configure({
    apiKey: Platform.OS === 'ios' ? 'appl_YOUR_PUBLIC_SDK_KEY' : 'goog_YOUR_PUBLIC_SDK_KEY',
  });
}

// commonMain
import com.revenuecat.purchases.kmp.LogLevel
import com.revenuecat.purchases.kmp.Purchases

// Each target supplies the key (appl_ on iOS, goog_ on Android).
expect val revenueCatApiKey: String

fun configureRevenueCat() {
    Purchases.logLevel = LogLevel.DEBUG
    Purchases.configure(apiKey = revenueCatApiKey)
}

import com.revenuecat.purchases.Purchases
import com.revenuecat.purchases.awaitLogIn

// Use this SAME id on your backend when you spend gems (see step 8).
// LogInResult is a Poko class (no destructuring); read the property.
val result = Purchases.sharedInstance.awaitLogIn("your-stable-user-id")
val created = result.created

import 'package:purchases_flutter/purchases_flutter.dart';

// Use this SAME id on your backend when you spend gems (see step 8).
final LogInResult result = await Purchases.logIn("your-stable-user-id");
final bool created = result.created;

import Purchases from 'react-native-purchases';

// Use this SAME id on your backend when you spend gems (see step 8).
const { created } = await Purchases.logIn('your-stable-user-id');

import com.revenuecat.purchases.kmp.Purchases
import com.revenuecat.purchases.kmp.ktx.awaitLogIn

// Use this SAME id on your backend when you spend gems (see step 8).
val login = Purchases.sharedInstance.awaitLogIn("your-stable-user-id")
val created = login.created

// GemStoreViewModel.kt
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.revenuecat.purchases.Package
import com.revenuecat.purchases.Purchases
import com.revenuecat.purchases.awaitOfferings
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch

class GemStoreViewModel : ViewModel() {
    data class UiState(
        val packages: List<Package> = emptyList(),
        val gemBalance: Int = 0,
        val error: String? = null,
    )
    private val _state = MutableStateFlow(UiState())
    val state = _state.asStateFlow()

    init {
        viewModelScope.launch {
            val offerings = Purchases.sharedInstance.awaitOfferings()
            val offering = offerings.all["gems"] ?: offerings.current
            _state.update { it.copy(packages = offering?.availablePackages ?: emptyList()) }
            refreshBalance()
        }
    }
    // buy(...) and refreshBalance() are added in the next steps.
}

// GemStoreScreen.kt
import android.app.Activity
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

@Composable
fun GemStoreScreen(vm: GemStoreViewModel, activity: Activity) {
    val ui by vm.state.collectAsState()
    LazyColumn(Modifier.fillMaxSize().padding(16.dp)) {
        item {
            Text("${ui.gemBalance} gems", style = MaterialTheme.typography.headlineSmall)
            Spacer(Modifier.height(16.dp))
        }
        items(ui.packages, key = { it.identifier }) { pkg ->
            ListItem(
                headlineContent = { Text(pkg.product.title) },
                trailingContent = { Text(pkg.product.price.formatted) },
                modifier = Modifier.clickable { vm.buy(pkg, activity) }
            )
        }
    }
}

// gem_store_page.dart
import 'package:flutter/material.dart';
import 'package:purchases_flutter/purchases_flutter.dart';

class GemStorePage extends StatefulWidget {
  const GemStorePage({super.key});
  @override
  State<GemStorePage> createState() => _GemStorePageState();
}

class _GemStorePageState extends State<GemStorePage> {
  List<Package> _packages = [];
  int _gemBalance = 0;

  @override
  void initState() {
    super.initState();
    _init();
  }

  Future<void> _init() async {
    final offerings = await Purchases.getOfferings();
    final offering = offerings.all["gems"] ?? offerings.current;
    if (mounted) setState(() => _packages = offering?.availablePackages ?? []);
    await refreshBalance();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Gem Store')),
      body: ListView(
        children: [
          ListTile(
            title: Text('$_gemBalance gems',
                style: Theme.of(context).textTheme.headlineSmall),
          ),
          const Divider(),
          for (final pkg in _packages)
            ListTile(
              title: Text(pkg.storeProduct.title),
              trailing: Text(pkg.storeProduct.priceString),
              onTap: () => buy(pkg),
            ),
        ],
      ),
    );
  }
  // buy() and refreshBalance() are added in the next steps.
}

// GemStoreScreen.tsx
import React, { useEffect, useState } from 'react';
import { FlatList, Text, TouchableOpacity, View } from 'react-native';
import Purchases, { PurchasesPackage } from 'react-native-purchases';

export function GemStoreScreen() {
  const [packages, setPackages] = useState<PurchasesPackage[]>([]);
  const [gemBalance, setGemBalance] = useState(0);

  useEffect(() => {
    (async () => {
      const offerings = await Purchases.getOfferings();
      const offering = offerings.all['gems'] ?? offerings.current;
      setPackages(offering?.availablePackages ?? []);
      await refreshBalance(setGemBalance);
    })();
  }, []);

  return (
    <View style={{ flex: 1, padding: 16 }}>
      <Text style={{ fontSize: 22, fontWeight: '600' }}>{gemBalance} gems</Text>
      <FlatList
        data={packages}
        keyExtractor={(p) => p.identifier}
        renderItem={({ item: pkg }) => (
          <TouchableOpacity
            onPress={() => buy(pkg, gemBalance, setGemBalance)}
            style={{ flexDirection: 'row', justifyContent: 'space-between', paddingVertical: 12 }}
          >
            <Text>{pkg.product.title}</Text>
            <Text style={{ color: '#888' }}>{pkg.product.priceString}</Text>
          </TouchableOpacity>
        )}
      />
    </View>
  );
}

// GemStoreScreen.kt (commonMain, Compose Multiplatform)
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import com.revenuecat.purchases.kmp.Purchases
import com.revenuecat.purchases.kmp.ktx.awaitOfferings
import com.revenuecat.purchases.kmp.models.Package
import kotlinx.coroutines.launch

@Composable
fun GemStoreScreen() {
    val scope = rememberCoroutineScope()
    var packages by remember { mutableStateOf<List<Package>>(emptyList()) }
    var gemBalance by remember { mutableStateOf(0) }

    LaunchedEffect(Unit) {
        val offerings = Purchases.sharedInstance.awaitOfferings()
        val offering = offerings.all["gems"] ?: offerings.current
        packages = offering?.availablePackages ?: emptyList()
        gemBalance = refreshBalance()
    }

    LazyColumn(Modifier.fillMaxSize().padding(16.dp)) {
        item {
            Text("$gemBalance gems", style = MaterialTheme.typography.headlineSmall)
            Spacer(Modifier.height(16.dp))
        }
        items(packages, key = { it.identifier }) { pkg ->
            ListItem(
                headlineContent = { Text(pkg.storeProduct.title) },
                trailingContent = { Text(pkg.storeProduct.price.formatted) },
                modifier = Modifier.clickable { scope.launch { gemBalance = buy(pkg, gemBalance) } }
            )
        }
    }
}

// Add to GemStoreViewModel
import android.app.Activity
import com.revenuecat.purchases.PurchaseParams
import com.revenuecat.purchases.PurchasesErrorCode
import com.revenuecat.purchases.PurchasesException
import com.revenuecat.purchases.awaitPurchase
import kotlinx.coroutines.delay

fun buy(pkg: Package, activity: Activity) = viewModelScope.launch {
    try {
        Purchases.sharedInstance.awaitPurchase(
            PurchaseParams.Builder(activity, pkg).build()
        )
        // Poll briefly until the credited balance lands.
        val before = state.value.gemBalance
        repeat(5) {
            refreshBalance()
            if (state.value.gemBalance > before) return@launch
            delay(500)
        }
    } catch (e: PurchasesException) {
        if (e.code == PurchasesErrorCode.PurchaseCancelledError) return@launch
        _state.update { it.copy(error = "Purchase failed: ${e.message}") }
    }
}

// Add to _GemStorePageState
import 'package:flutter/services.dart' show PlatformException;

Future<void> buy(Package package) async {
  try {
    await Purchases.purchasePackage(package);
    // Poll briefly until the credited balance lands.
    final before = _gemBalance;
    for (var i = 0; i < 5; i++) {
      await refreshBalance();
      if (_gemBalance > before) break;
      await Future.delayed(const Duration(milliseconds: 500));
    }
  } on PlatformException catch (e) {
    final code = PurchasesErrorHelper.getErrorCode(e);
    if (code == PurchasesErrorCode.purchaseCancelledError) return; // closed the sheet
    // surface "Purchase failed" as you prefer
  }
}

import Purchases, { PurchasesPackage, PURCHASES_ERROR_CODE } from 'react-native-purchases';

const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

export async function buy(
  pkg: PurchasesPackage,
  before: number,
  setGemBalance: (n: number) => void,
) {
  try {
    await Purchases.purchasePackage(pkg);
    // Poll briefly until the credited balance lands.
    for (let i = 0; i < 5; i++) {
      const balance = await refreshBalance(setGemBalance);
      if (balance > before) break;
      await sleep(500);
    }
  } catch (e: any) {
    if (e.code === PURCHASES_ERROR_CODE.PURCHASE_CANCELLED_ERROR) return; // closed the sheet
    // surface "Purchase failed" as you prefer
  }
}

// commonMain
import com.revenuecat.purchases.kmp.Purchases
import com.revenuecat.purchases.kmp.PurchasesException
import com.revenuecat.purchases.kmp.ktx.awaitPurchase
import com.revenuecat.purchases.kmp.models.Package
import com.revenuecat.purchases.kmp.models.PurchasesErrorCode
import kotlinx.coroutines.delay

suspend fun buy(pkg: Package, before: Int): Int {
    return try {
        Purchases.sharedInstance.awaitPurchase(packageToPurchase = pkg)
        // Poll briefly until the credited balance lands.
        var balance = before
        repeat(5) {
            balance = refreshBalance()
            if (balance > before) return balance
            delay(500)
        }
        balance
    } catch (e: PurchasesException) {
        if (e.error.code == PurchasesErrorCode.PurchaseCancelledError) before // closed the sheet
        else before // surface "Purchase failed" as you prefer
    }
}

// Add to GemStoreViewModel
import com.revenuecat.purchases.awaitGetVirtualCurrencies

suspend fun refreshBalance() {
    try {
        Purchases.sharedInstance.invalidateVirtualCurrenciesCache()
        val currencies = Purchases.sharedInstance.awaitGetVirtualCurrencies()
        _state.update { it.copy(gemBalance = currencies.all["GEM"]?.balance ?: 0) }
    } catch (e: Exception) {
        _state.update { it.copy(error = "Could not load your balance: ${e.message}") }
    }
}

// Add to _GemStorePageState
Future<void> refreshBalance() async {
  try {
    await Purchases.invalidateVirtualCurrenciesCache();
    final currencies = await Purchases.getVirtualCurrencies();
    if (mounted) setState(() => _gemBalance = currencies.all["GEM"]?.balance ?? 0);
  } catch (e) {
    // surface error as you prefer
  }
}

import Purchases from 'react-native-purchases';

export async function refreshBalance(
  setGemBalance: (n: number) => void,
): Promise<number> {
  await Purchases.invalidateVirtualCurrenciesCache();
  const currencies = await Purchases.getVirtualCurrencies();
  const balance = currencies.all['GEM']?.balance ?? 0;
  setGemBalance(balance);
  return balance;
}

// commonMain
import com.revenuecat.purchases.kmp.Purchases
import com.revenuecat.purchases.kmp.ktx.awaitVirtualCurrencies

suspend fun refreshBalance(): Int {
    Purchases.sharedInstance.invalidateVirtualCurrenciesCache()
    val currencies = Purchases.sharedInstance.awaitVirtualCurrencies()
    return currencies.all["GEM"]?.balance ?: 0
}

// Android also exposes a synchronous cached property (null before the first fetch):
val cached = Purchases.sharedInstance.cachedVirtualCurrencies?.all["GEM"]?.balance

// Flutter's cached accessor is an async method (not a property):
final cached = (await Purchases.getCachedVirtualCurrencies())?.all["GEM"]?.balance;

// React Native's cached accessor is an async method (not a property):
const cached = (await Purchases.getCachedVirtualCurrencies())?.all['GEM']?.balance;

// KMP's cached accessor is a method (not a property):
val cached = Purchases.sharedInstance.getCachedVirtualCurrencies()?.all["GEM"]?.balance

// Add to GemStoreViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject

private val http = OkHttpClient()

// Create idempotencyKey once per spend intent and reuse it on every retry.
fun spend(item: String, idempotencyKey: String) = viewModelScope.launch {
    try {
        val ok = withContext(Dispatchers.IO) {
            val body = JSONObject()
                .put("item", item) // server looks up the price; client never sends a cost
                .put("idempotencyKey", idempotencyKey)
                .toString()
                .toRequestBody("application/json".toMediaType())
            val req = Request.Builder()
                .url("https://your-api.example.com/spend")
                .header("Authorization", "Bearer $yourSessionToken") // app token, NOT the RC key
                .post(body)
                .build()
            http.newCall(req).execute().use { res ->
                if (res.code == 402) return@withContext false
                if (!res.isSuccessful) throw IllegalStateException("Spend failed")
                true
            }
        }
        if (!ok) {
            _state.update { it.copy(error = "You need more gems for that.") }
            return@launch
        }
        refreshBalance()
    } catch (e: Exception) {
        _state.update { it.copy(error = "Could not complete that purchase.") }
    }
}

// Add to _GemStorePageState
import 'dart:convert';
import 'package:http/http.dart' as http;

// Create idempotencyKey once per spend intent and reuse it on every retry.
Future<void> spend(String item, String idempotencyKey) async {
  try {
    final res = await http.post(
      Uri.parse('https://your-api.example.com/spend'),
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer $yourSessionToken', // app token, NOT the RC key
      },
      body: jsonEncode({'item': item, 'idempotencyKey': idempotencyKey}),
    );
    if (res.statusCode == 402) {
      // show "You need more gems for that."
      return;
    }
    if (res.statusCode ~/ 100 != 2) throw Exception('Spend failed');
    await refreshBalance();
  } catch (e) {
    // show "Could not complete that purchase."
  }
}

// Create idempotencyKey once per spend intent and reuse it on every retry.
export async function spend(
  item: string,
  idempotencyKey: string,
  yourSessionToken: string,
  setGemBalance: (n: number) => void,
) {
  try {
    const res = await fetch('https://your-api.example.com/spend', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${yourSessionToken}`, // app token, NOT the RC key
      },
      body: JSON.stringify({ item, idempotencyKey }),
    });
    if (res.status === 402) {
      // show "You need more gems for that."
      return;
    }
    if (!res.ok) throw new Error('Spend failed');
    await refreshBalance(setGemBalance);
  } catch {
    // show "Could not complete that purchase."
  }
}

// commonMain (Ktor client)
import io.ktor.client.HttpClient
import io.ktor.client.request.header
import io.ktor.client.request.post
import io.ktor.client.request.setBody
import io.ktor.client.statement.HttpResponse
import io.ktor.http.ContentType
import io.ktor.http.HttpHeaders
import io.ktor.http.contentType
import io.ktor.http.isSuccess
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json

@Serializable
data class SpendRequest(val item: String, val idempotencyKey: String)

// Create idempotencyKey once per spend intent and reuse it on every retry.
suspend fun spend(
    client: HttpClient,
    item: String,
    idempotencyKey: String,
    yourSessionToken: String,
): Boolean {
    val res: HttpResponse = client.post("https://your-api.example.com/spend") {
        header(HttpHeaders.Authorization, "Bearer $yourSessionToken") // app token, NOT the RC key
        contentType(ContentType.Application.Json)
        setBody(Json.encodeToString(SpendRequest(item, idempotencyKey)))
    }
    return when {
        res.status.value == 402 -> false
        res.status.isSuccess() -> { refreshBalance(); true }
        else -> throw IllegalStateException("Spend failed")
    }
}