// client/src/checkout.js
import { loadStripe } from '@stripe/stripe-js';

const stripe = await loadStripe(process.env.REACT_APP_STRIPE_PUBLISHABLE_KEY);

// Create payment method
const { error, paymentMethod } = await stripe.createPaymentMethod({
  type: 'card',
  card: cardElement,
  billing_details: {
    name: customerName,
    email: customerEmail
  }
});

if (error) {
  console.error(error);
} else {
  // Send to backend
  await createSubscription(paymentMethod.id, priceId);
}

// api/subscriptions/create.js
import Stripe from 'stripe';
const stripe = new Stripe(process.env.STRIPE_API_KEY);

export async function createSubscription(customerId, priceId, paymentMethodId) {
  // Attach payment method to customer
  await stripe.paymentMethods.attach(paymentMethodId, {
    customer: customerId
  });

  // Set as default payment method
  await stripe.customers.update(customerId, {
    invoice_settings: {
      default_payment_method: paymentMethodId
    }
  });

  // Create subscription
  const subscription = await stripe.subscriptions.create({
    customer: customerId,
    items: [{ price: priceId }],
    payment_behavior: 'default_incomplete',
    payment_settings: {
      save_default_payment_method: 'on_subscription'
    },
    expand: ['latest_invoice.payment_intent']
  });

  // Save to database
  await saveSubscriptionToDB(subscription);

  return subscription;
}

export async function changeSubscription(subscriptionId, newPriceId) {
  const subscription = await stripe.subscriptions.retrieve(subscriptionId);

  // Update subscription
  const updatedSubscription = await stripe.subscriptions.update(subscriptionId, {
    items: [{
      id: subscription.items.data[0].id,
      price: newPriceId
    }],
    proration_behavior: 'create_prorations'  // Prorate the difference
  });

  // Update database
  await updateSubscriptionInDB(updatedSubscription);

  return updatedSubscription;
}

export async function cancelSubscription(subscriptionId, immediate = false) {
  const options = immediate ? {} : { at_period_end: true };

  const subscription = await stripe.subscriptions.cancel(subscriptionId, options);

  // Update database
  await updateSubscriptionInDB(subscription);

  return subscription;
}

// api/middleware/track-usage.js
export async function trackAPIUsage(userId, subscriptionId) {
  // Get subscription item ID
  const subscription = await getSubscription(subscriptionId);
  const usageItemId = subscription.items.data.find(
    item => item.price.product.name === 'API Calls'
  ).id;

  // Report usage to Stripe
  await stripe.subscriptionItems.createUsageRecord(usageItemId, {
    quantity: 1,  // 1 API call
    timestamp: Math.floor(Date.now() / 1000),
    action: 'increment'
  });

  // Also log in database
  await logUsageInDB(userId, subscriptionId, 'api_calls', 1);
}

// Cron job: Every hour
export async function reportBatchUsage() {
  // Get usage counts from database
  const usageCounts = await getHourlyUsageCounts();

  for (const { subscriptionItemId, quantity } of usageCounts) {
    await stripe.subscriptionItems.createUsageRecord(subscriptionItemId, {
      quantity: quantity,
      timestamp: Math.floor(Date.now() / 1000),
      action: 'increment'
    });
  }
}

export async function getUsageSummary(subscriptionItemId) {
  const usageRecords = await stripe.subscriptionItems.listUsageRecordSummaries(
    subscriptionItemId,
    {
      limit: 10
    }
  );

  return usageRecords.data;
}

// api/payments/create-intent.js
export async function createPaymentIntent(amount, currency, customerId) {
  const paymentIntent = await stripe.paymentIntents.create({
    amount: Math.round(amount * 100),  // cents
    currency: currency,
    customer: customerId,
    payment_method_types: ['card'],
    metadata: {
      product_id: 'product-id',
      user_id: 'user-id'
    }
  });

  return paymentIntent;
}

// client/src/PaymentForm.jsx
import { CardElement, useStripe, useElements } from '@stripe/react-stripe-js';

export function PaymentForm({ amount, onSuccess }) {
  const stripe = useStripe();
  const elements = useElements();

  const handleSubmit = async (event) => {
    event.preventDefault();

    if (!stripe || !elements) return;

    // Create payment intent on backend
    const { clientSecret } = await fetch('/api/payments/create-intent', {
      method: 'POST',
      body: JSON.stringify({ amount: amount })
    }).then(r => r.json());

    // Confirm payment
    const { error, paymentIntent } = await stripe.confirmCardPayment(
      clientSecret,
      {
        payment_method: {
          card: elements.getElement(CardElement)
        }
      }
    );

    if (error) {
      console.error(error);
    } else if (paymentIntent.status === 'succeeded') {
      onSuccess(paymentIntent);
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <CardElement />
      <button type="submit" disabled={!stripe}>
        Pay ${amount}
      </button>
    </form>
  );
}

// api/webhooks/stripe.js
export async function handlePaymentIntentSucceeded(paymentIntent) {
  // Save payment to database
  await savePaymentToDB({
    stripe_payment_intent_id: paymentIntent.id,
    user_id: paymentIntent.metadata.user_id,
    amount: paymentIntent.amount / 100,
    currency: paymentIntent.currency,
    status: 'succeeded'
  });

  // Fulfill order
  await fulfillOrder(paymentIntent.metadata.product_id);

  // Send receipt email
  await sendReceiptEmail(paymentIntent.customer);
}

// api/vendors/create-connect-account.js
export async function createConnectAccount(vendorEmail) {
  // Create Connect account
  const account = await stripe.accounts.create({
    type: 'express',
    email: vendorEmail,
    capabilities: {
      card_payments: { requested: true },
      transfers: { requested: true }
    }
  });

  // Create onboarding link
  const accountLink = await stripe.accountLinks.create({
    account: account.id,
    refresh_url: 'https://yoursite.com/vendor/connect/refresh',
    return_url: 'https://yoursite.com/vendor/connect/complete',
    type: 'account_onboarding'
  });

  return {
    accountId: account.id,
    onboardingUrl: accountLink.url
  };
}

// api/orders/create-with-split.js
export async function createOrderWithSplit(vendorAccountId, amount, platformFee) {
  const vendorAmount = amount - platformFee;

  // Create payment with destination
  const paymentIntent = await stripe.paymentIntents.create({
    amount: Math.round(amount * 100),
    currency: 'usd',
    application_fee_amount: Math.round(platformFee * 100),  // Platform fee
    transfer_data: {
      destination: vendorAccountId  // Vendor receives vendorAmount
    },
    metadata: {
      vendor_account_id: vendorAccountId,
      platform_fee: platformFee
    }
  });

  return paymentIntent;
}

export async function payoutToVendor(vendorAccountId, amount) {
  const payout = await stripe.payouts.create(
    {
      amount: Math.round(amount * 100),
      currency: 'usd'
    },
    {
      stripeAccount: vendorAccountId  // Vendor's Connect account
    }
  );

  return payout;
}

// Attach payment method
await stripe.paymentMethods.attach(paymentMethodId, {
  customer: customerId
});

// Set as default
await stripe.customers.update(customerId, {
  invoice_settings: {
    default_payment_method: paymentMethodId
  }
});

// Implement retry logic
import Stripe from 'stripe';
const stripe = new Stripe(process.env.STRIPE_API_KEY, {
  maxNetworkRetries: 2,
  timeout: 30000
});

// Use batch operations
// Instead of creating 100 customers one by one,
// create them in batches with delays

const { error, paymentIntent } = await stripe.confirmCardPayment(
  clientSecret,
  {
    payment_method: paymentMethodId,
    return_url: 'https://yoursite.com/payment/complete'  // Required for 3DS
  }
);

if (paymentIntent.status === 'requires_action') {
  // Handle 3DS authentication
  const { error: confirmError } = await stripe.handleCardAction(clientSecret);
}