X-API-Token: pk_your_api_token_here
Content-Type: application/json

X-API-Token: pk_your_api_token_here
X-Signature: sha256_signature_here
Content-Type: application/json

// PHP Example
$string_to_sign = $api_token . '|' . json_encode($request_data) . '|' . time();
$signature = hash_hmac('sha256', $string_to_sign, $api_secret);

// JavaScript/Node.js Example
const response = await fetch('https://yourdomain.com/api/payment.php', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'X-API-Token': 'pk_your_api_token_here'
    },
    body: JSON.stringify({
        action: 'create_order',
        amount: 100.00,
        order_id: 'ORDER_12345',
        customer_name: 'John Doe',
        customer_email: 'john@example.com',
        customer_phone: '+91 9876543210',
        product_name: 'Premium Subscription',
        redirect_url: 'https://yoursite.com/success',
        webhook_url: 'https://yoursite.com/webhook'
    })
});

const data = await response.json();

// PHP Example
$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => 'https://yourdomain.com/api/payment.php',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Content-Type: application/json',
        'X-API-Token: pk_your_api_token_here'
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'action' => 'create_order',
        'amount' => 100.00,
        'order_id' => 'ORDER_12345',
        'customer_name' => 'John Doe',
        'customer_email' => 'john@example.com',
        'customer_phone' => '+91 9876543210',
        'product_name' => 'Premium Subscription',
        'redirect_url' => 'https://yoursite.com/success',
        'webhook_url' => 'https://yoursite.com/webhook'
    ])
]);

$response = curl_exec($curl);
$data = json_decode($response, true);

// Java Example (using HttpClient - Java 11+)
import java.net.http.*;
import java.net.URI;
import org.json.JSONObject;

HttpClient client = HttpClient.newHttpClient();

JSONObject requestData = new JSONObject();
requestData.put("action", "create_order");
requestData.put("amount", 100.00);
requestData.put("order_id", "ORDER_12345");
requestData.put("customer_name", "John Doe");
requestData.put("customer_email", "john@example.com");
requestData.put("customer_phone", "+91 9876543210");
requestData.put("product_name", "Premium Subscription");
requestData.put("redirect_url", "https://yoursite.com/success");
requestData.put("webhook_url", "https://yoursite.com/webhook");

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://yourdomain.com/api/payment.php"))
    .header("Content-Type", "application/json")
    .header("X-API-Token", "pk_your_api_token_here")
    .POST(HttpRequest.BodyPublishers.ofString(requestData.toString()))
    .build();

HttpResponse<String> response = client.send(request, 
    HttpResponse.BodyHandlers.ofString());

JSONObject responseData = new JSONObject(response.body());

// Java Spring Boot Example (using RestTemplate)
import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;
import java.util.HashMap;
import java.util.Map;

@Service
public class RabbitPayService {
    
    private final RestTemplate restTemplate = new RestTemplate();
    private final String API_URL = "https://yourdomain.com/api/payment.php";
    private final String API_TOKEN = "pk_your_api_token_here";
    
    public ResponseEntity<Map> createPaymentOrder(
        double amount, 
        String orderId,
        String customerName,
        String customerEmail,
        String customerPhone,
        String productName,
        String redirectUrl,
        String webhookUrl
    ) {
        // Prepare headers
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("X-API-Token", API_TOKEN);
        
        // Prepare request body
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("action", "create_order");
        requestBody.put("amount", amount);
        requestBody.put("order_id", orderId);
        requestBody.put("customer_name", customerName);
        requestBody.put("customer_email", customerEmail);
        requestBody.put("customer_phone", customerPhone);
        requestBody.put("product_name", productName);
        requestBody.put("redirect_url", redirectUrl);
        requestBody.put("webhook_url", webhookUrl);
        
        // Create request entity
        HttpEntity<Map<String, Object>> entity = 
            new HttpEntity<>(requestBody, headers);
        
        // Make API call
        return restTemplate.exchange(
            API_URL,
            HttpMethod.POST,
            entity,
            Map.class
        );
    }
}

// Usage in Controller
@RestController
@RequestMapping("/api/payments")
public class PaymentController {
    
    @Autowired
    private RabbitPayService rabbitPayService;
    
    @PostMapping("/create")
    public ResponseEntity<?> createPayment(@RequestBody PaymentRequest request) {
        ResponseEntity<Map> response = rabbitPayService.createPaymentOrder(
            request.getAmount(),
            request.getOrderId(),
            request.getCustomerName(),
            request.getCustomerEmail(),
            request.getCustomerPhone(),
            request.getProductName(),
            "https://yoursite.com/success",
            "https://yoursite.com/webhook"
        );
        return ResponseEntity.ok(response.getBody());
    }
}

const response = await fetch('https://yourdomain.com/api/payment.php', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'X-API-Token': 'pk_your_api_token_here'
    },
    body: JSON.stringify({
        action: 'verify_payment',
        transaction_id: 'TXN_1728655234_5678'
    })
});

const data = await response.json();

// Java Example
import java.net.http.*;
import org.json.JSONObject;

HttpClient client = HttpClient.newHttpClient();

JSONObject requestData = new JSONObject();
requestData.put("action", "verify_payment");
requestData.put("transaction_id", "TXN_1728655234_5678");

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://yourdomain.com/api/payment.php"))
    .header("Content-Type", "application/json")
    .header("X-API-Token", "pk_your_api_token_here")
    .POST(HttpRequest.BodyPublishers.ofString(requestData.toString()))
    .build();

HttpResponse<String> response = client.send(request, 
    HttpResponse.BodyHandlers.ofString());
JSONObject data = new JSONObject(response.body());

// Java Spring Boot Example
@Service
public class RabbitPayService {
    
    private final RestTemplate restTemplate = new RestTemplate();
    private final String API_URL = "https://yourdomain.com/api/payment.php";
    private final String API_TOKEN = "pk_your_api_token_here";
    
    public ResponseEntity<Map> verifyPayment(String transactionId) {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("X-API-Token", API_TOKEN);
        
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("action", "verify_payment");
        requestBody.put("transaction_id", transactionId);
        
        HttpEntity<Map<String, Object>> entity = 
            new HttpEntity<>(requestBody, headers);
        
        return restTemplate.exchange(
            API_URL,
            HttpMethod.POST,
            entity,
            Map.class
        );
    }
}

// Usage in Controller
@GetMapping("/verify/{transactionId}")
public ResponseEntity<?> verifyPayment(@PathVariable String transactionId) {
    ResponseEntity<Map> response = rabbitPayService.verifyPayment(transactionId);
    return ResponseEntity.ok(response.getBody());
}

GET https://yourdomain.com/api/check-order-status.php?order_id=ORDER_12345
X-API-Token: pk_your_api_token_here

// PHP Webhook Verification
$payload = file_get_contents('php://input');
$signature = $_SERVER['HTTP_X_SIGNATURE'] ?? '';

$calculated_signature = hash_hmac('sha256', $payload, $your_api_secret);

if (hash_equals($calculated_signature, $signature)) {
    // Webhook is authentic
    $data = json_decode($payload, true);
    // Process the webhook data
} else {
    // Invalid webhook
    http_response_code(400);
    echo 'Invalid signature';
}

// Node.js Webhook Handler
const crypto = require('crypto');
const express = require('express');
const app = express();

app.use(express.json());

app.post('/webhook', (req, res) => {
    const payload = JSON.stringify(req.body);
    const signature = req.headers['x-signature'];
    const apiSecret = 'sk_your_api_secret_here';
    
    const calculatedSignature = crypto
        .createHmac('sha256', apiSecret)
        .update(payload)
        .digest('hex');
    
    if (signature === calculatedSignature) {
        // Webhook is authentic
        const data = req.body;
        
        // Process webhook based on event type
        switch(data.event) {
            case 'payment.completed':
                // Handle successful payment
                console.log('Payment completed:', data.data);
                break;
            case 'payment.failed':
                // Handle failed payment
                console.log('Payment failed:', data.data);
                break;
        }
        
        res.status(200).json({ success: true });
    } else {
        res.status(400).json({ error: 'Invalid signature' });
    }
});

// Java Webhook Handler (using Servlet)
import javax.servlet.http.*;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.BufferedReader;
import java.util.Base64;
import org.json.JSONObject;

public class WebhookServlet extends HttpServlet {
    
    private static final String API_SECRET = "sk_your_api_secret_here";
    
    @Override
    protected void doPost(HttpServletRequest request, 
                         HttpServletResponse response) 
                         throws IOException {
        
        // Read the payload
        StringBuilder payload = new StringBuilder();
        BufferedReader reader = request.getReader();
        String line;
        while ((line = reader.readLine()) != null) {
            payload.append(line);
        }
        
        String payloadStr = payload.toString();
        String receivedSignature = request.getHeader("X-Signature");
        
        // Calculate signature
        String calculatedSignature = calculateHMAC(payloadStr, API_SECRET);
        
        // Verify signature
        if (calculatedSignature.equals(receivedSignature)) {
            // Webhook is authentic
            JSONObject data = new JSONObject(payloadStr);
            String event = data.getString("event");
            JSONObject eventData = data.getJSONObject("data");
            
            // Process webhook based on event type
            switch (event) {
                case "payment.completed":
                    handlePaymentCompleted(eventData);
                    break;
                case "payment.failed":
                    handlePaymentFailed(eventData);
                    break;
                case "payment.cancelled":
                    handlePaymentCancelled(eventData);
                    break;
            }
            
            response.setStatus(HttpServletResponse.SC_OK);
            response.getWriter().write("{\"success\": true}");
        } else {
            response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
            response.getWriter().write("{\"error\": \"Invalid signature\"}");
        }
    }
    
    private String calculateHMAC(String data, String secret) {
        try {
            Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
            SecretKeySpec secret_key = new SecretKeySpec(
                secret.getBytes("UTF-8"), "HmacSHA256");
            sha256_HMAC.init(secret_key);
            
            byte[] hash = sha256_HMAC.doFinal(data.getBytes("UTF-8"));
            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) hexString.append('0');
                hexString.append(hex);
            }
            return hexString.toString();
        } catch (Exception e) {
            throw new RuntimeException("Error calculating HMAC", e);
        }
    }
    
    private void handlePaymentCompleted(JSONObject data) {
        String transactionId = data.getString("transaction_id");
        String orderId = data.getString("order_id");
        double amount = data.getDouble("amount");
        
        // Update your database
        // Send confirmation email
        // Fulfill the order
        System.out.println("Payment completed for order: " + orderId);
    }
    
    private void handlePaymentFailed(JSONObject data) {
        String transactionId = data.getString("transaction_id");
        String orderId = data.getString("order_id");
        
        // Update order status
        // Notify customer
        System.out.println("Payment failed for order: " + orderId);
    }
    
    private void handlePaymentCancelled(JSONObject data) {
        String transactionId = data.getString("transaction_id");
        String orderId = data.getString("order_id");
        
        // Handle cancellation
        System.out.println("Payment cancelled for order: " + orderId);
    }
}

// Java Spring Boot Webhook Handler
import org.springframework.web.bind.annotation.*;
import org.springframework.http.*;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.util.Map;

@RestController
@RequestMapping("/webhook")
public class WebhookController {
    
    private static final String API_SECRET = "sk_your_api_secret_here";
    
    @PostMapping("/rabbitpay")
    public ResponseEntity<Map<String, Object>> handleWebhook(
        @RequestBody Map<String, Object> payload,
        @RequestHeader("X-Signature") String signature
    ) {
        try {
            // Convert payload to JSON string for verification
            String payloadStr = new ObjectMapper().writeValueAsString(payload);
            
            // Calculate and verify signature
            String calculatedSignature = calculateHMAC(payloadStr, API_SECRET);
            
            if (!calculatedSignature.equals(signature)) {
                return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                    .body(Map.of("error", "Invalid signature"));
            }
            
            // Signature is valid, process webhook
            String event = (String) payload.get("event");
            Map<String, Object> data = 
                (Map<String, Object>) payload.get("data");
            
            switch (event) {
                case "payment.completed":
                    handlePaymentCompleted(data);
                    break;
                case "payment.failed":
                    handlePaymentFailed(data);
                    break;
                case "payment.cancelled":
                    handlePaymentCancelled(data);
                    break;
                default:
                    System.out.println("Unknown event: " + event);
            }
            
            return ResponseEntity.ok(Map.of("success", true));
            
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(Map.of("error", "Internal server error"));
        }
    }
    
    private String calculateHMAC(String data, String secret) {
        try {
            Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
            SecretKeySpec secret_key = new SecretKeySpec(
                secret.getBytes("UTF-8"), "HmacSHA256");
            sha256_HMAC.init(secret_key);
            
            byte[] hash = sha256_HMAC.doFinal(data.getBytes("UTF-8"));
            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) hexString.append('0');
                hexString.append(hex);
            }
            return hexString.toString();
        } catch (Exception e) {
            throw new RuntimeException("Error calculating HMAC", e);
        }
    }
    
    private void handlePaymentCompleted(Map<String, Object> data) {
        String transactionId = (String) data.get("transaction_id");
        String orderId = (String) data.get("order_id");
        Double amount = (Double) data.get("amount");
        
        // Process successful payment
        // 1. Update order status in database
        // 2. Send confirmation email to customer
        // 3. Trigger order fulfillment
        // 4. Update inventory
        
        System.out.println("Payment completed for order: " + orderId 
            + ", Amount: " + amount);
    }
    
    private void handlePaymentFailed(Map<String, Object> data) {
        String transactionId = (String) data.get("transaction_id");
        String orderId = (String) data.get("order_id");
        
        // Handle failed payment
        // 1. Update order status to failed
        // 2. Notify customer about failure
        // 3. Log the failure reason
        
        System.out.println("Payment failed for order: " + orderId);
    }
    
    private void handlePaymentCancelled(Map<String, Object> data) {
        String transactionId = (String) data.get("transaction_id");
        String orderId = (String) data.get("order_id");
        
        // Handle cancelled payment
        // 1. Update order status to cancelled
        // 2. Release reserved inventory
        // 3. Notify relevant parties
        
        System.out.println("Payment cancelled for order: " + orderId);
    }
}

// Optional: Create a Service layer for better organization
@Service
public class PaymentWebhookService {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private EmailService emailService;
    
    @Transactional
    public void processPaymentCompleted(Map<String, Object> data) {
        String orderId = (String) data.get("order_id");
        Double amount = (Double) data.get("amount");
        
        // Update order in database
        Order order = orderRepository.findByOrderId(orderId);
        if (order != null) {
            order.setStatus("COMPLETED");
            order.setPaymentStatus("PAID");
            order.setPaidAmount(amount);
            order.setCompletedAt(LocalDateTime.now());
            orderRepository.save(order);
            
            // Send confirmation email
            emailService.sendOrderConfirmation(order);
            
            // Additional business logic
        }
    }
}

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Boot Starter Data JPA (for database) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <!-- JSON Processing -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
    
    <!-- For Java 8 HTTP Client Alternative -->
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.13</version>
    </dependency>
    
    <!-- Lombok (Optional - for cleaner code) -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

// RabbitPayConfig.java
package com.yourcompany.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import lombok.Data;

@Configuration
@ConfigurationProperties(prefix = "rabbitpay")
@Data
public class RabbitPayConfig {
    private String apiUrl;
    private String apiToken;
    private String apiSecret;
    private String webhookUrl;
    private String redirectUrl;
}

// application.properties or application.yml
rabbitpay.api-url=https://yourdomain.com/api/payment.php
rabbitpay.api-token=pk_your_api_token_here
rabbitpay.api-secret=sk_your_api_secret_here
rabbitpay.webhook-url=https://yoursite.com/webhook/rabbitpay
rabbitpay.redirect-url=https://yoursite.com/payment/success

// PaymentRequest.java
package com.yourcompany.dto;

import lombok.Data;
import lombok.Builder;
import com.fasterxml.jackson.annotation.JsonProperty;

@Data
@Builder
public class PaymentRequest {
    private String action;
    private Double amount;
    
    @JsonProperty("order_id")
    private String orderId;
    
    @JsonProperty("customer_name")
    private String customerName;
    
    @JsonProperty("customer_email")
    private String customerEmail;
    
    @JsonProperty("customer_phone")
    private String customerPhone;
    
    @JsonProperty("product_name")
    private String productName;
    
    @JsonProperty("redirect_url")
    private String redirectUrl;
    
    @JsonProperty("webhook_url")
    private String webhookUrl;
}

// PaymentResponse.java
package com.yourcompany.dto;

import lombok.Data;
import com.fasterxml.jackson.annotation.JsonProperty;

@Data
public class PaymentResponse {
    private Boolean success;
    private String message;
    private PaymentData data;
    
    @JsonProperty("error_code")
    private String errorCode;
}

@Data
class PaymentData {
    @JsonProperty("transaction_id")
    private String transactionId;
    
    @JsonProperty("order_id")
    private String orderId;
    
    private Double amount;
    private String currency;
    
    @JsonProperty("payment_url")
    private String paymentUrl;
    
    @JsonProperty("razorpay_order_id")
    private String razorpayOrderId;
    
    private String status;
    
    @JsonProperty("created_at")
    private String createdAt;
}

// WebhookPayload.java
package com.yourcompany.dto;

import lombok.Data;
import java.util.Map;

@Data
public class WebhookPayload {
    private String event;
    private Map<String, Object> data;
    private String signature;
    private String timestamp;
}

// RabbitPayService.java
package com.yourcompany.service;

import com.yourcompany.config.RabbitPayConfig;
import com.yourcompany.dto.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.client.HttpClientErrorException;
import lombok.extern.slf4j.Slf4j;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;

@Service
@Slf4j
public class RabbitPayService {
    
    @Autowired
    private RabbitPayConfig config;
    
    @Autowired
    private RestTemplate restTemplate;
    
    /**
     * Create a payment order
     */
    public PaymentResponse createPaymentOrder(
        Double amount,
        String orderId,
        String customerName,
        String customerEmail,
        String customerPhone,
        String productName
    ) {
        try {
            // Prepare headers
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            headers.set("X-API-Token", config.getApiToken());
            
            // Build request
            PaymentRequest request = PaymentRequest.builder()
                .action("create_order")
                .amount(amount)
                .orderId(orderId)
                .customerName(customerName)
                .customerEmail(customerEmail)
                .customerPhone(customerPhone)
                .productName(productName)
                .redirectUrl(config.getRedirectUrl())
                .webhookUrl(config.getWebhookUrl())
                .build();
            
            HttpEntity<PaymentRequest> entity = 
                new HttpEntity<>(request, headers);
            
            // Make API call
            ResponseEntity<PaymentResponse> response = restTemplate.exchange(
                config.getApiUrl(),
                HttpMethod.POST,
                entity,
                PaymentResponse.class
            );
            
            log.info("Payment order created successfully: {}", 
                response.getBody().getData().getTransactionId());
            
            return response.getBody();
            
        } catch (HttpClientErrorException e) {
            log.error("Error creating payment order: {}", e.getMessage());
            throw new RuntimeException("Payment creation failed: " 
                + e.getResponseBodyAsString());
        } catch (Exception e) {
            log.error("Unexpected error: {}", e.getMessage());
            throw new RuntimeException("Payment creation failed", e);
        }
    }
    
    /**
     * Verify payment status
     */
    public PaymentResponse verifyPayment(String transactionId) {
        try {
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            headers.set("X-API-Token", config.getApiToken());
            
            PaymentRequest request = PaymentRequest.builder()
                .action("verify_payment")
                .build();
            
            // Add transaction_id to the request
            Map<String, Object> requestMap = new HashMap<>();
            requestMap.put("action", "verify_payment");
            requestMap.put("transaction_id", transactionId);
            
            HttpEntity<Map<String, Object>> entity = 
                new HttpEntity<>(requestMap, headers);
            
            ResponseEntity<PaymentResponse> response = restTemplate.exchange(
                config.getApiUrl(),
                HttpMethod.POST,
                entity,
                PaymentResponse.class
            );
            
            log.info("Payment verification result: {}", 
                response.getBody().getData().getStatus());
            
            return response.getBody();
            
        } catch (Exception e) {
            log.error("Error verifying payment: {}", e.getMessage());
            throw new RuntimeException("Payment verification failed", e);
        }
    }
    
    /**
     * Calculate HMAC signature for webhook verification
     */
    public String calculateHMAC(String data, String secret) {
        try {
            Mac sha256HMAC = Mac.getInstance("HmacSHA256");
            SecretKeySpec secretKey = new SecretKeySpec(
                secret.getBytes(StandardCharsets.UTF_8), 
                "HmacSHA256"
            );
            sha256HMAC.init(secretKey);
            
            byte[] hash = sha256HMAC.doFinal(
                data.getBytes(StandardCharsets.UTF_8)
            );
            
            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) {
                    hexString.append('0');
                }
                hexString.append(hex);
            }
            
            return hexString.toString();
            
        } catch (Exception e) {
            throw new RuntimeException("Error calculating HMAC", e);
        }
    }
    
    /**
     * Verify webhook signature
     */
    public boolean verifyWebhookSignature(String payload, String signature) {
        String calculatedSignature = calculateHMAC(
            payload, 
            config.getApiSecret()
        );
        return calculatedSignature.equals(signature);
    }
}

// RestTemplate Configuration
@Configuration
public class RestTemplateConfig {
    
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

// PaymentController.java
package com.yourcompany.controller;

import com.yourcompany.dto.*;
import com.yourcompany.service.RabbitPayService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.web.bind.annotation.*;
import lombok.extern.slf4j.Slf4j;

@RestController
@RequestMapping("/api/payments")
@Slf4j
public class PaymentController {
    
    @Autowired
    private RabbitPayService rabbitPayService;
    
    /**
     * Create a new payment order
     */
    @PostMapping("/create")
    public ResponseEntity<?> createPayment(
        @RequestBody CreatePaymentRequest request
    ) {
        try {
            PaymentResponse response = rabbitPayService.createPaymentOrder(
                request.getAmount(),
                request.getOrderId(),
                request.getCustomerName(),
                request.getCustomerEmail(),
                request.getCustomerPhone(),
                request.getProductName()
            );
            
            if (response.getSuccess()) {
                return ResponseEntity.ok(response);
            } else {
                return ResponseEntity.badRequest().body(response);
            }
            
        } catch (Exception e) {
            log.error("Error creating payment", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(Map.of("error", e.getMessage()));
        }
    }
    
    /**
     * Verify payment status
     */
    @GetMapping("/verify/{transactionId}")
    public ResponseEntity<?> verifyPayment(
        @PathVariable String transactionId
    ) {
        try {
            PaymentResponse response = 
                rabbitPayService.verifyPayment(transactionId);
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("Error verifying payment", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(Map.of("error", e.getMessage()));
        }
    }
    
    /**
     * Payment success callback page
     */
    @GetMapping("/success")
    public ResponseEntity<String> paymentSuccess(
        @RequestParam(required = false) String transaction_id,
        @RequestParam(required = false) String order_id
    ) {
        log.info("Payment success callback - Transaction: {}, Order: {}", 
            transaction_id, order_id);
        
        // Redirect to frontend success page or return success view
        return ResponseEntity.ok("Payment successful!");
    }
}

// CreatePaymentRequest.java
@Data
public class CreatePaymentRequest {
    private Double amount;
    private String orderId;
    private String customerName;
    private String customerEmail;
    private String customerPhone;
    private String productName;
}

// WebhookController.java
package com.yourcompany.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.yourcompany.dto.WebhookPayload;
import com.yourcompany.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.web.bind.annotation.*;
import lombok.extern.slf4j.Slf4j;

import java.util.Map;

@RestController
@RequestMapping("/webhook")
@Slf4j
public class WebhookController {
    
    @Autowired
    private RabbitPayService rabbitPayService;
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private EmailService emailService;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    /**
     * Handle Rabbit Pay webhook notifications
     */
    @PostMapping("/rabbitpay")
    public ResponseEntity<Map<String, Object>> handleRabbitPayWebhook(
        @RequestBody String payload,
        @RequestHeader(value = "X-Signature", required = false) String signature
    ) {
        log.info("Received webhook payload");
        
        try {
            // Verify signature
            if (signature == null || signature.isEmpty()) {
                log.error("Missing webhook signature");
                return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                    .body(Map.of("error", "Missing signature"));
            }
            
            if (!rabbitPayService.verifyWebhookSignature(payload, signature)) {
                log.error("Invalid webhook signature");
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
                    .body(Map.of("error", "Invalid signature"));
            }
            
            // Parse payload
            WebhookPayload webhookData = 
                objectMapper.readValue(payload, WebhookPayload.class);
            
            String event = webhookData.getEvent();
            Map<String, Object> data = webhookData.getData();
            
            log.info("Processing webhook event: {}", event);
            
            // Process webhook based on event type
            switch (event) {
                case "payment.created":
                    handlePaymentCreated(data);
                    break;
                    
                case "payment.completed":
                    handlePaymentCompleted(data);
                    break;
                    
                case "payment.failed":
                    handlePaymentFailed(data);
                    break;
                    
                case "payment.cancelled":
                    handlePaymentCancelled(data);
                    break;
                    
                default:
                    log.warn("Unknown webhook event: {}", event);
            }
            
            // Return success response
            return ResponseEntity.ok(Map.of(
                "success", true,
                "message", "Webhook processed successfully"
            ));
            
        } catch (Exception e) {
            log.error("Error processing webhook", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(Map.of("error", "Internal server error"));
        }
    }
    
    private void handlePaymentCreated(Map<String, Object> data) {
        String orderId = (String) data.get("order_id");
        String transactionId = (String) data.get("transaction_id");
        
        log.info("Payment created - Order: {}, Transaction: {}", 
            orderId, transactionId);
        
        // Update order status to 'payment_initiated'
        orderService.updateOrderStatus(orderId, "PAYMENT_INITIATED");
    }
    
    private void handlePaymentCompleted(Map<String, Object> data) {
        String orderId = (String) data.get("order_id");
        String transactionId = (String) data.get("transaction_id");
        Double amount = ((Number) data.get("amount")).doubleValue();
        String paymentMethod = (String) data.get("payment_method");
        
        log.info("Payment completed - Order: {}, Amount: {}", 
            orderId, amount);
        
        // Update order in database
        orderService.markOrderAsPaid(
            orderId, 
            transactionId, 
            amount, 
            paymentMethod
        );
        
        // Send confirmation email
        emailService.sendPaymentConfirmation(orderId);
        
        // Trigger order fulfillment
        orderService.initiateOrderFulfillment(orderId);
        
        // Update inventory
        orderService.updateInventory(orderId);
    }
    
    private void handlePaymentFailed(Map<String, Object> data) {
        String orderId = (String) data.get("order_id");
        String transactionId = (String) data.get("transaction_id");
        
        log.warn("Payment failed - Order: {}", orderId);
        
        // Update order status
        orderService.updateOrderStatus(orderId, "PAYMENT_FAILED");
        
        // Notify customer
        emailService.sendPaymentFailureNotification(orderId);
        
        // Release any reserved inventory
        orderService.releaseReservedInventory(orderId);
    }
    
    private void handlePaymentCancelled(Map<String, Object> data) {
        String orderId = (String) data.get("order_id");
        String transactionId = (String) data.get("transaction_id");
        
        log.info("Payment cancelled - Order: {}", orderId);
        
        // Update order status
        orderService.updateOrderStatus(orderId, "PAYMENT_CANCELLED");
        
        // Release inventory
        orderService.releaseReservedInventory(orderId);
    }
}

// Example: E-commerce Checkout Flow
@Service
public class CheckoutService {
    
    @Autowired
    private RabbitPayService rabbitPayService;
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Transactional
    public PaymentResponse initiateCheckout(CheckoutRequest request) {
        // 1. Create order in your database
        Order order = new Order();
        order.setOrderId(generateOrderId());
        order.setCustomerName(request.getCustomerName());
        order.setCustomerEmail(request.getCustomerEmail());
        order.setCustomerPhone(request.getCustomerPhone());
        order.setAmount(request.getAmount());
        order.setStatus("PENDING");
        order.setCreatedAt(LocalDateTime.now());
        orderRepository.save(order);
        
        // 2. Create payment with Rabbit Pay
        PaymentResponse paymentResponse = rabbitPayService.createPaymentOrder(
            order.getAmount(),
            order.getOrderId(),
            order.getCustomerName(),
            order.getCustomerEmail(),
            order.getCustomerPhone(),
            request.getProductName()
        );
        
        // 3. Store transaction ID
        if (paymentResponse.getSuccess()) {
            order.setTransactionId(
                paymentResponse.getData().getTransactionId()
            );
            order.setPaymentUrl(
                paymentResponse.getData().getPaymentUrl()
            );
            orderRepository.save(order);
        }
        
        return paymentResponse;
    }
    
    private String generateOrderId() {
        return "ORD_" + System.currentTimeMillis() + 
               "_" + (int)(Math.random() * 10000);
    }
}

// Usage in your checkout API
@PostMapping("/checkout")
public ResponseEntity<?> checkout(@RequestBody CheckoutRequest request) {
    PaymentResponse response = checkoutService.initiateCheckout(request);
    
    if (response.getSuccess()) {
        // Redirect user to payment URL
        return ResponseEntity.ok(Map.of(
            "payment_url", response.getData().getPaymentUrl(),
            "transaction_id", response.getData().getTransactionId()
        ));
    } else {
        return ResponseEntity.badRequest().body(response);
    }
}

// Unit Test Example
@SpringBootTest
class RabbitPayServiceTest {
    
    @Autowired
    private RabbitPayService rabbitPayService;
    
    @Test
    void testCreatePaymentOrder() {
        PaymentResponse response = rabbitPayService.createPaymentOrder(
            100.00,
            "TEST_ORDER_123",
            "Test Customer",
            "test@example.com",
            "+91 9876543210",
            "Test Product"
        );
        
        assertNotNull(response);
        assertTrue(response.getSuccess());
        assertNotNull(response.getData().getTransactionId());
        assertNotNull(response.getData().getPaymentUrl());
    }
    
    @Test
    void testWebhookSignatureVerification() {
        String payload = "{\"event\":\"payment.completed\"}";
        String signature = rabbitPayService.calculateHMAC(
            payload, 
            "sk_test_secret"
        );
        
        boolean isValid = rabbitPayService.verifyWebhookSignature(
            payload, 
            signature
        );
        
        assertTrue(isValid);
    }
}