Module 7 - Monétisation et stratégies business

# Configuration du module de paiement
payment:
  stripe:
    enabled: true
    publishableKey: "pk_live_..."
    secretKey: "sk_live_..."
    webhookSecret: "whsec_..."
    
    # Plans d'abonnement
    plans:
      premium:
        priceId: "price_premium_monthly"
        name: "Premium Monthly"
        price: 29
        currency: "eur"
        interval: "month"
        features:
          - "unlimited_content"
          - "premium_support"
          - "certificates"
          
      enterprise:
        priceId: "price_enterprise_monthly" 
        name: "Enterprise Monthly"
        price: 99
        currency: "eur"
        interval: "month"
        features:
          - "all_premium_features"
          - "custom_sso"
          - "dedicated_support"
    
    # Configuration des webhooks
    webhooks:
      - "invoice.payment_succeeded"
      - "invoice.payment_failed"
      - "customer.subscription.updated"
      - "customer.subscription.deleted"
    
    # Essais gratuits
    trialDays: 14
    
    # Gestion des échecs de paiement
    dunningSettings:
      maxRetries: 3
      retryInterval: 7 # jours

// Middleware pour vérifier l'abonnement actif
class SubscriptionMiddleware {
  constructor(stripeService, userService) {
    this.stripe = stripeService;
    this.userService = userService;
  }

  requireActiveSubscription(plans = []) {
    return async (req, res, next) => {
      try {
        const user = req.user;
        if (!user) {
          return res.status(401).json({ error: 'Authentication required' });
        }

        // Vérifier l'abonnement actif
        const subscription = await this.getUserSubscription(user.id);
        
        if (!subscription || subscription.status !== 'active') {
          return res.status(402).json({ 
            error: 'Active subscription required',
            redirect: '/pricing'
          });
        }

        // Vérifier le plan si spécifié
        if (plans.length > 0 && !plans.includes(subscription.plan)) {
          return res.status(403).json({
            error: 'Upgrade required',
            currentPlan: subscription.plan,
            requiredPlans: plans
          });
        }

        req.subscription = subscription;
        next();
      } catch (error) {
        console.error('Subscription check failed:', error);
        res.status(500).json({ error: 'Subscription verification failed' });
      }
    };
  }

  async getUserSubscription(userId) {
    const user = await this.userService.findById(userId);
    if (!user.stripeCustomerId) {
      return null;
    }

    const subscriptions = await this.stripe.subscriptions.list({
      customer: user.stripeCustomerId,
      status: 'active'
    });

    return subscriptions.data.length > 0 ? {
      id: subscriptions.data[0].id,
      status: subscriptions.data[0].status,
      plan: subscriptions.data[0].items.data[0].price.lookup_key,
      currentPeriodEnd: new Date(subscriptions.data[0].current_period_end * 1000)
    } : null;
  }

  // Webhook pour traiter les événements Stripe
  async handleWebhook(req, res) {
    const signature = req.headers['stripe-signature'];
    
    try {
      const event = this.stripe.webhooks.constructEvent(
        req.body,
        signature,
        process.env.STRIPE_WEBHOOK_SECRET
      );

      switch (event.type) {
        case 'invoice.payment_succeeded':
          await this.handlePaymentSucceeded(event.data.object);
          break;
          
        case 'invoice.payment_failed':
          await this.handlePaymentFailed(event.data.object);
          break;
          
        case 'customer.subscription.updated':
          await this.handleSubscriptionUpdated(event.data.object);
          break;
          
        case 'customer.subscription.deleted':
          await this.handleSubscriptionCanceled(event.data.object);
          break;
      }

      res.json({ received: true });
    } catch (error) {
      console.error('Webhook error:', error);
      res.status(400).send(`Webhook Error: ${error.message}`);
    }
  }

  async handlePaymentSucceeded(invoice) {
    const subscription = await this.stripe.subscriptions.retrieve(
      invoice.subscription
    );
    
    const customer = await this.stripe.customers.retrieve(invoice.customer);
    const user = await this.userService.findByEmail(customer.email);
    
    if (user) {
      await this.userService.updateSubscriptionStatus(user.id, {
        status: 'active',
        plan: subscription.items.data[0].price.lookup_key,
        stripeSubscriptionId: subscription.id,
        currentPeriodEnd: new Date(subscription.current_period_end * 1000)
      });
    }
  }
}