const crypto = require('crypto');
const express = require('express');

const EnvironmentMode = {
    SANDBOX: 'sandbox',
    PRODUCTION: 'production'
};

// {{ __('Webhook handler') }}
app.post('/api/webhooks/{{ strtolower(setting("site_title")) }}', async (req, res) => {
    const environment = req.headers['x-environment'] || 'production';
    const signature = req.headers['x-signature'];
    
    # {{ __('Get appropriate secret based on environment') }}
    const secret = getSecretForEnvironment(environment);
    
    # {{ __('Verify signature') }}
    if (!verifySignature(JSON.stringify(req.body), signature, secret)) {
        console.warn('{{ __(setting("site_title")." webhook signature verification failed") }}', {
            environment: environment
        });
        
        return res.status(401).json({ error: '{{ __('Invalid signature') }}' });
    }
    
    const payload = req.body;
    
    try {
        # {{ __('Handle based on environment') }}
        if (environment === EnvironmentMode.SANDBOX) {
            await handleSandboxWebhook(payload);
        } else {
            await handleProductionWebhook(payload);
        }
        
        res.json({ status: '{{ __('processed') }}' });
    } catch (error) {
        console.error('{{ __('Webhook processing error') }}:', error);
        res.status(500).json({ error: '{{ __('Processing failed') }}' });
    }
});

function getSecretForEnvironment(environment) {
    # {{ __('Return test secret for sandbox, live secret for production') }}
    return environment === 'sandbox' 
        ? process.env.{{ strtoupper(setting("site_title")) }}_TEST_WEBHOOK_SECRET
        : process.env.{{ strtoupper(setting("site_title")) }}_WEBHOOK_SECRET;
}

function verifySignature(payload, signature, secret) {
    if (!signature) {
        return false;
    }
    
    const expectedSignature = crypto
        .createHmac('sha256', secret)
        .update(payload)
        .digest('hex');
    const providedSignature = signature.startsWith('sha256=') ? signature.slice(7) : signature;
    
    return crypto.timingSafeEqual(
        Buffer.from(expectedSignature),
        Buffer.from(providedSignature)
    );
}

async function handleSandboxWebhook(payload) {
    console.log('{{ __('Processing sandbox webhook') }}:', payload);
    
    # {{ __('Your sandbox-specific logic here') }}
    # {{ __('Don\'t fulfill orders, don\'t send emails to real customers, etc.') }}
}

async function handleProductionWebhook(payload) {
    console.log('{{ __('Processing production webhook') }}:', payload);
    
    # {{ __('Your production logic here') }}
    # {{ __('Fulfill orders, send confirmation emails, etc.') }}
}

import hmac
import hashlib
import json
import logging
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_http_methods

logger = logging.getLogger(__name__)

ENVIRONMENT_MODE = {
    'SANDBOX': 'sandbox',
    'PRODUCTION': 'production'
}

@csrf_exempt
@require_http_methods(["POST"])
def {{ strtolower(setting("site_title")) }}_webhook(request):
    environment = request.headers.get('X-Environment', 'production')
    signature = request.headers.get('X-Signature', '')
    
    # {{ __('Get appropriate secret based on environment') }}
    secret = get_secret_for_environment(environment)
    
    # {{ __('Verify signature') }}
    if not verify_signature(request.body, signature, secret):
        logger.warning('{{ __(setting("site_title")." webhook signature verification failed") }}', extra={
            'environment': environment
        })
        
        return JsonResponse({'error': '{{ __('Invalid signature') }}'}, status=401)
    
    try:
        payload = json.loads(request.body)
        
        # {{ __('Handle based on environment') }}
        if environment == ENVIRONMENT_MODE['SANDBOX']:
            handle_sandbox_webhook(payload)
        else:
            handle_production_webhook(payload)
        
        return JsonResponse({'status': '{{ __('processed') }}'})
    
    except Exception as e:
        logger.error(f'{{ __('Webhook processing error') }}:{str(e)}')
        return JsonResponse({'error': '{{ __('Processing failed') }}'}, status=500)

def get_secret_for_environment(environment):
    from django.conf import settings
    
    # {{ __('Return test secret for sandbox, live secret for production') }}
    return (settings.{{ strtoupper(setting("site_title")) }}_TEST_WEBHOOK_SECRET 
            if environment == 'sandbox' 
            else settings.{{ strtoupper(setting("site_title")) }}_WEBHOOK_SECRET)

def verify_signature(payload, signature, secret):
    if not signature:
        return False
    
    expected_signature = hmac.new(
        secret.encode('utf-8'),
        payload,
        hashlib.sha256
    ).hexdigest()
    provided_signature = signature[7:] if signature.startswith('sha256=') else signature
    
    return hmac.compare_digest(expected_signature, provided_signature)

def handle_sandbox_webhook(payload):
    logger.info('{{ __('Processing sandbox webhook') }}', extra=payload)
    
    # {{ __('Your sandbox-specific logic here') }}
    # {{ __('Don\'t fulfill orders, don\'t send emails to real customers, etc.') }}

def handle_production_webhook(payload):
    logger.info('{{ __('Processing production webhook') }}', extra=payload)
    
    # {{ __('Your production logic here') }}
    # {{ __('Fulfill orders, send confirmation emails, etc.') }}