const { data } = trpc.stripe.getProducts.useQuery();

// Returns
{
  products: [
    {
      id: "prod_xxx",
      name: "Pro Yearly",
      description: "Annual subscription",
      prices: [
        { id: "price_xxx", unit_amount: 9999, recurring: { interval: "year" } },
      ],
    },
  ];
}

const mutation = trpc.stripe.createPaymentIntent.useMutation();

const { clientSecret } = await mutation.mutateAsync({
  amount: 999, // Amount in cents
  currency: "usd",
  description: "Pro Lifetime Access",
});

const mutation = trpc.stripe.createCheckoutSession.useMutation();

const { url } = await mutation.mutateAsync({
  priceId: "price_xxx",
  mode: "subscription",
  successUrl: "myapp://success",
  cancelUrl: "myapp://cancel",
});

const { data } = trpc.stripe.getSubscriptionStatus.useQuery();

// Returns
{
  hasSubscription: true,
  subscription: { id: "sub_xxx", status: "active", cancel_at_period_end: false },
  localSubscription: {
    id: "sub_xxx",
    status: "active",
    cancelAtPeriodEnd: false,
    currentPeriodEnd: "2026-01-23T12:34:56.000Z",
  },
}

const mutation = trpc.stripe.cancelSubscription.useMutation();
await mutation.mutateAsync();

const mutation = trpc.stripe.resumeSubscription.useMutation();
await mutation.mutateAsync();

const mutation = trpc.stripe.changeSubscriptionPlan.useMutation();
await mutation.mutateAsync({
  priceId: "price_new",
});

export const stripeRouter = router({
  getProducts: publicProcedure.query(async () => {
    // Fetch products from Stripe
  }),

  createPaymentIntent: protectedProcedure
    .input(
      z.object({
        amount: z.number(),
        currency: z.string(),
        description: z.string().optional(),
      })
    )
    .mutation(async ({ input, ctx }) => {
      // Create payment intent
    }),

  createCheckoutSession: protectedProcedure
    .input(
      z.object({
        priceId: z.string(),
        mode: z.enum(["subscription", "payment"]),
        successUrl: z.string(),
        cancelUrl: z.string(),
      })
    )
    .mutation(async ({ input, ctx }) => {
      // Create checkout session
    }),

  getSubscriptionStatus: protectedProcedure.query(async ({ ctx }) => {
    // Return Stripe subscription and local subscription record
  }),

  cancelSubscription: protectedProcedure.mutation(async ({ ctx }) => {
    // Set cancel_at_period_end to true
  }),

  resumeSubscription: protectedProcedure.mutation(async ({ ctx }) => {
    // Set cancel_at_period_end to false
  }),

  changeSubscriptionPlan: protectedProcedure
    .input(z.object({ priceId: z.string() }))
    .mutation(async ({ input, ctx }) => {
      // Swap subscription price with proration rules
    }),
});

// Automatic customer creation
const customer = await stripe.customers.create({
  email: user.email,
  name: user.name,
  metadata: { userId: user.id },
});

try {
  await mutation.mutateAsync({ ... });
} catch (error) {
  // error.message contains Stripe error details
  Alert.alert("Payment Failed", error.message);
}