// Example: Stripe Payment Integration
import Stripe from 'stripe';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY, {
  apiVersion: '2023-10-16',
  timeout: 10000, // 10 seconds
  maxNetworkRetries: 3, // Retry failed requests
});

async function createPaymentIntent(amount: number, currency: string) {
  try {
    const paymentIntent = await stripe.paymentIntents.create({
      amount,
      currency,
      automatic_payment_methods: { enabled: true },
    });
    return paymentIntent;
  } catch (error) {
    if (error.type === 'StripeCardError') {
      // Card was declined
      throw new BadRequestException(error.message);
    }
    // Log and rethrow
    logger.error('Stripe payment failed', error);
    throw new ServiceUnavailableException('Payment service unavailable');
  }
}

// Example: GitHub Webhook Handler
@Post('webhooks/github')
async handleGitHubWebhook(
  @Body() payload: any,
  @Headers('x-hub-signature-256') signature: string,
) {
  // 1. Verify signature
  const isValid = this.verifyGitHubSignature(payload, signature);
  if (!isValid) {
    throw new UnauthorizedException('Invalid signature');
  }

  // 2. Check for duplicate (idempotency)
  const eventId = payload.headers['x-github-delivery'];
  const alreadyProcessed = await this.redis.get(`webhook:${eventId}`);
  if (alreadyProcessed) {
    return { status: 'already_processed' };
  }

  // 3. Queue for async processing
  await this.queue.add('github-webhook', payload);
  await this.redis.setex(`webhook:${eventId}`, 86400, 'true'); // 24h TTL

  // 4. Respond immediately
  return { status: 'received' };
}

private verifyGitHubSignature(payload: any, signature: string): boolean {
  const secret = process.env.GITHUB_WEBHOOK_SECRET;
  const hmac = crypto.createHmac('sha256', secret);
  const expectedSignature = 'sha256=' + hmac.update(JSON.stringify(payload)).digest('hex');
  return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature));
}

// Example: BullMQ (Redis-based queue)
import { Queue, Worker } from 'bullmq';

const emailQueue = new Queue('email', {
  connection: { host: 'localhost', port: 6379 },
});

// Producer: Add jobs to queue
async function sendWelcomeEmail(userId: string) {
  await emailQueue.add('welcome-email', { userId });
}

// Consumer: Process jobs
const worker = new Worker(
  'email',
  async (job) => {
    const { userId } = job.data;
    const user = await getUserById(userId);
    await emailService.send({
      to: user.email,
      subject: 'Welcome!',
      body: renderWelcomeEmail(user),
    });
  },
  { connection: { host: 'localhost', port: 6379 } },
);

// Example: Google OAuth with Passport.js
passport.use(
  new GoogleStrategy(
    {
      clientID: process.env.GOOGLE_CLIENT_ID,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
      callbackURL: '/auth/google/callback',
    },
    async (accessToken, refreshToken, profile, done) => {
      // Find or create user
      let user = await User.findOne({ googleId: profile.id });
      if (!user) {
        user = await User.create({
          googleId: profile.id,
          email: profile.emails[0].value,
          name: profile.displayName,
        });
      }
      return done(null, user);
    }
  )
);