Code faster.
Store smarter.
Get more done.

// Process a refund via Stripe API
export async function processRefund(
  paymentIntentId: string,
  amount?: number
): Promise<{ success: boolean; data?: any; error?: string }> {
  try {
    const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
    
    const refundParams: any = {
      payment_intent: paymentIntentId,
    };
    
    // If amount is specified, add it to refund params
    if (amount) {
      refundParams.amount = amount; // Amount in cents
    }
    
    const refund = await stripe.refunds.create(refundParams);
    
    return { 
      success: true, 
      data: refund 
    };
  } catch (error: any) {
    console.error('Refund processing error:', error.message);
    return { 
      success: false, 
      error: error.message 
    };
  }
}

// Create a new subscription with Stripe
export async function createSubscription(
  customerId: string,
  priceId: string,
  trialDays = 0
): Promise<{ success: boolean; data?: any; error?: string }> {
  try {
    const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
    
    // Subscription parameters
    const subscriptionParams: any = {
      customer: customerId,
      items: [{ price: priceId }],
      payment_behavior: 'default_incomplete',
      payment_settings: { save_default_payment_method: 'on_subscription' },
      expand: ['latest_invoice.payment_intent'],
    };
    
    // Add trial period if specified
    if (trialDays > 0) {
      subscriptionParams.trial_period_days = trialDays;
    }
    
    const subscription = await stripe.subscriptions.create(subscriptionParams);
    
    return {
      success: true,
      data: {
        subscriptionId: subscription.id,
        clientSecret: subscription.latest_invoice.payment_intent.client_secret,
      },
    };
  } catch (error: any) {
    console.error('Subscription creation error:', error.message);
    return {
      success: false,
      error: error.message,
    };
  }
}

// Stripe webhook handler for subscription events
import { NextApiRequest, NextApiResponse } from 'next';
import { buffer } from 'micro';
import Stripe from 'stripe';
import { updateUserSubscription } from '@/lib/db';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY as string, {
  apiVersion: '2022-11-15',
});

export const config = {
  api: {
    bodyParser: false,
  },
};

export default async function handler(
  req: NextApiRequest,
  res: NextApiResponse
) {
  if (req.method !== 'POST') {
    return res.status(405).json({ error: 'Method not allowed' });
  }

  const buf = await buffer(req);
  const sig = req.headers['stripe-signature'] as string;
  const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET as string;

  try {
    const event = stripe.webhooks.constructEvent(
      buf.toString(),
      sig,
      webhookSecret
    );

    // Handle subscription events
    switch (event.type) {
      case 'customer.subscription.created':
      case 'customer.subscription.updated':
        const subscription = event.data.object as Stripe.Subscription;
        await updateUserSubscription(subscription);
        break;
      
      case 'customer.subscription.deleted':
        const cancelledSubscription = event.data.object as Stripe.Subscription;
        await updateUserSubscription(cancelledSubscription, true);
        break;
        
      default:
        console.log(`Unhandled event type: ${event.type}`);
    }

    res.status(200).json({ received: true });
  } catch (err: any) {
    console.error(`Webhook error: ${err.message}`);
    res.status(400).json({ error: `Webhook error: ${err.message}` });
  }
}