// Stripe modern integration
import { loadStripe } from '@stripe/stripe-js';
import { Elements, CardElement, useStripe, useElements } from '@stripe/react-stripe-js';

const stripePromise = loadStripe(process.env.REACT_APP_STRIPE_PUBLISHABLE_KEY);

const CheckoutForm = () => {
    const stripe = useStripe();
    const elements = useElements();
    const [processing, setProcessing] = useState(false);
    
    const handleSubmit = async (event) => {
        event.preventDefault();
        
        if (!stripe || !elements) return;
        
        setProcessing(true);
        
        try {
            // Create payment method
            const { error, paymentMethod } = await stripe.createPaymentMethod({
                type: 'card',
                card: elements.getElement(CardElement),
                billing_details: {
                    name: 'Customer Name',
                    email: 'customer@example.com'
                }
            });
            
            if (error) {
                console.error('Payment method creation failed:', error);
                return;
            }
            
            // Create payment intent server-side
            const response = await fetch('/api/create-payment-intent', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    payment_method_id: paymentMethod.id,
                    amount: 4999, // €49.99 in cents
                    currency: 'eur'
                })
            });
            
            const { client_secret } = await response.json();
            
            // Confirm payment
            const { error: confirmError } = await stripe.confirmCardPayment(client_secret);
            
            if (confirmError) {
                console.error('Payment confirmation failed:', confirmError);
            } else {
                console.log('Payment succeeded!');
                window.location.href = '/success';
            }
        } catch (error) {
            console.error('Payment processing error:', error);
        } finally {
            setProcessing(false);
        }
    };
    
    return (
        <form onSubmit={handleSubmit} className="stripe-checkout-form">
            <div className="card-element-container">
                <CardElement
                    options={{
                        style: {
                            base: {
                                fontSize: '16px',
                                color: '#424770',
                                '::placeholder': {
                                    color: '#aab7c4',
                                },
                            },
                        },
                    }}
                />
            </div>
            <button 
                type="submit" 
                disabled={!stripe || processing}
                className="stripe-pay-button"
            >
                {processing ? 'Processing...' : 'Pay €49.99'}
            </button>
        </form>
    );
};

const StripeCheckout = () => (
    <Elements stripe={stripePromise}>
        <CheckoutForm />
    </Elements>
);

export default StripeCheckout;

// Stripe server-side integration
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);

class StripePaymentService {
    constructor() {
        this.stripe = stripe;
        this.endpointSecret = process.env.STRIPE_WEBHOOK_SECRET;
    }
    
    async createPaymentIntent(amount, currency, metadata = {}) {
        try {
            const paymentIntent = await this.stripe.paymentIntents.create({
                amount: Math.round(amount * 100), // Convert to cents
                currency: currency.toLowerCase(),
                metadata: metadata,
                automatic_payment_methods: {
                    enabled: true
                }
            });
            
            return {
                client_secret: paymentIntent.client_secret,
                id: paymentIntent.id
            };
        } catch (error) {
            console.error('Payment intent creation failed:', error);
            throw new Error('Payment initialization failed');
        }
    }
    
    async createSubscription(customerId, priceId, metadata = {}) {
        try {
            const subscription = await this.stripe.subscriptions.create({
                customer: customerId,
                items: [{ price: priceId }],
                payment_behavior: 'default_incomplete',
                expand: ['latest_invoice.payment_intent'],
                metadata: metadata
            });
            
            return {
                subscriptionId: subscription.id,
                clientSecret: subscription.latest_invoice.payment_intent.client_secret
            };
        } catch (error) {
            console.error('Subscription creation failed:', error);
            throw new Error('Subscription setup failed');
        }
    }
    
    async createCustomer(email, name, metadata = {}) {
        try {
            const customer = await this.stripe.customers.create({
                email: email,
                name: name,
                metadata: metadata
            });
            
            return customer;
        } catch (error) {
            console.error('Customer creation failed:', error);
            throw new Error('Customer creation failed');
        }
    }
    
    async handleWebhook(rawBody, signature) {
        try {
            const event = this.stripe.webhooks.constructEvent(
                rawBody,
                signature,
                this.endpointSecret
            );
            
            console.log(`Webhook received: ${event.type}`);
            
            switch (event.type) {
                case 'payment_intent.succeeded':
                    await this.handlePaymentSucceeded(event.data.object);
                    break;
                    
                case 'payment_intent.payment_failed':
                    await this.handlePaymentFailed(event.data.object);
                    break;
                    
                case 'customer.subscription.created':
                    await this.handleSubscriptionCreated(event.data.object);
                    break;
                    
                case 'customer.subscription.deleted':
                    await this.handleSubscriptionCancelled(event.data.object);
                    break;
                    
                case 'invoice.payment_succeeded':
                    await this.handleInvoicePaymentSucceeded(event.data.object);
                    break;
                    
                default:
                    console.log(`Unhandled event type: ${event.type}`);
            }
            
            return { received: true };
        } catch (error) {
            console.error('Webhook error:', error);
            throw new Error('Webhook processing failed');
        }
    }
    
    async handlePaymentSucceeded(paymentIntent) {
        console.log('Payment succeeded:', paymentIntent.id);
        
        // Update order status
        // Send confirmation email
        // Grant access to digital products
        // Trigger fulfillment process
    }
    
    async handlePaymentFailed(paymentIntent) {
        console.log('Payment failed:', paymentIntent.id);
        
        // Send payment failure notification
        // Update order status
        // Trigger retry logic if applicable
    }
    
    async handleSubscriptionCreated(subscription) {
        console.log('Subscription created:', subscription.id);
        
        // Activate user account
        // Send welcome email
        // Grant subscription benefits
    }
    
    async handleSubscriptionCancelled(subscription) {
        console.log('Subscription cancelled:', subscription.id);
        
        // Schedule account deactivation
        // Send cancellation confirmation
        // Remove subscription benefits
    }
    
    async refundPayment(paymentIntentId, amount = null) {
        try {
            const refund = await this.stripe.refunds.create({
                payment_intent: paymentIntentId,
                amount: amount ? Math.round(amount * 100) : undefined
            });
            
            return refund;
        } catch (error) {
            console.error('Refund failed:', error);
            throw new Error('Refund processing failed');
        }
    }
}

// Express.js routes
const paymentService = new StripePaymentService();

app.post('/api/create-payment-intent', async (req, res) => {
    try {
        const { amount, currency, metadata } = req.body;
        const result = await paymentService.createPaymentIntent(amount, currency, metadata);
        res.json(result);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

app.post('/api/create-subscription', async (req, res) => {
    try {
        const { customerId, priceId, metadata } = req.body;
        const result = await paymentService.createSubscription(customerId, priceId, metadata);
        res.json(result);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

app.post('/api/stripe-webhook', async (req, res) => {
    try {
        const signature = req.headers['stripe-signature'];
        await paymentService.handleWebhook(req.body, signature);
        res.json({ received: true });
    } catch (error) {
        res.status(400).json({ error: error.message });
    }
});