Complete Implementation Guide

const axios = require('axios');

class BigCityRewardsWorkflow {
    constructor(companySecret) {
        this.baseUrl = 'https://api.bigcity.in/v1';
        this.companySecret = companySecret;
        this.companyToken = null;
        
        // Configure axios defaults
        this.client = axios.create({
            timeout: 30000,
            headers: {
                'Content-Type': 'application/json'
            }
        });
    }
    
    async authenticateCompany() {
        console.log('🏢 Authenticating company...');
        
        try {
            const response = await this.client.post(`${this.baseUrl}/company/auth`, 
                { secret: this.companySecret },
                {
                    headers: { 'Authorization': 'Required' }
                }
            );
            
            this.companyToken = response.data.auth_token;
            console.log(`✅ Company authenticated. Vendor: ${response.data.vendor_name}`);
            return this.companyToken;
            
        } catch (error) {
            console.error('❌ Company authentication failed:', error.response?.data || error.message);
            throw error;
        }
    }
    
    async getRewards() {
        if (!this.companyToken) {
            throw new Error('Company not authenticated');
        }
        
        console.log('🎁 Fetching available rewards...');
        
        try {
            const response = await this.client.get(`${this.baseUrl}/bigcity/rewards`, {
                headers: { 'Authorization': `Bearer ${this.companyToken}` }
            });
            
            const activeRewards = response.data.filter(r => r.status === 1);
            console.log(`✅ Found ${activeRewards.length} active rewards`);
            return response.data;
            
        } catch (error) {
            console.error('❌ Failed to get rewards:', error.response?.data || error.message);
            throw error;
        }
    }
    
    async authenticateCustomer(customerData) {
        if (!this.companyToken) {
            throw new Error('Company not authenticated');
        }
        
        console.log(`👤 Authenticating customer: ${customerData.customer_name}`);
        
        try {
            const response = await this.client.post(`${this.baseUrl}/customer/auth`,
                customerData,
                {
                    headers: { 'Authorization': `Bearer ${this.companyToken}` }
                }
            );
            
            console.log(`✅ Customer authenticated. ID: ${response.data.customer_id}`);
            return response.data.customer_token;
            
        } catch (error) {
            console.error('❌ Customer authentication failed:', error.response?.data || error.message);
            throw error;
        }
    }
    
    async createRedemptionOrder(customerToken, orderData) {
        console.log(`📦 Creating redemption order: ${orderData.line_items[0].order_id}`);
        
        try {
            const response = await this.client.post(`${this.baseUrl}/bigcity/redeemptiononskus`,
                orderData,
                {
                    headers: { 'Authorization': `Bearer ${customerToken}` }
                }
            );
            
            const result = response.data;
            console.log(`✅ Order created. State: ${result.state}, Vouchers: ${result.vouchers?.length || 0}`);
            return result;
            
        } catch (error) {
            console.error('❌ Order creation failed:', error.response?.data || error.message);
            throw error;
        }
    }
    
    generateOrderId() {
        const timestamp = new Date().toISOString().slice(0, 10).replace(/-/g, '');
        const random = Math.random().toString(36).substr(2, 8).toUpperCase();
        return `ORD-${timestamp}-${random}`;
    }
    
    async processCompleteWorkflow(customerData, cartItems) {
        try {
            // Step 1: Company Authentication
            await this.authenticateCompany();
            
            // Step 2: Get Rewards (optional, for validation)
            const rewards = await this.getRewards();
            
            // Step 3: Customer Authentication
            const customerToken = await this.authenticateCustomer(customerData);
            
            // Step 4: Prepare Order Data
            const orderId = this.generateOrderId();
            const orderTotal = cartItems.reduce((total, item) => 
                total + (item.price * item.quantity), 0
            );
            
            const orderData = {
                order_timestamp: new Date().toISOString(),
                order_total: orderTotal,
                order_items: cartItems.length,
                line_items: cartItems.map(item => ({
                    order_id: orderId,
                    SKU: item.sku,
                    qty: item.quantity
                }))
            };
            
            // Step 5: Create Redemption Order
            const redemptionResult = await this.createRedemptionOrder(customerToken, orderData);
            
            return {
                success: true,
                orderId,
                customer: customerData,
                orderSummary: {
                    totalAmount: orderTotal,
                    itemsCount: cartItems.length,
                    vouchersGenerated: redemptionResult.vouchers?.length || 0
                },
                vouchers: redemptionResult.vouchers,
                redemptionUrl: redemptionResult.redemption_url,
                howToAvail: redemptionResult.how_to_avail,
                terms: redemptionResult.terms
            };
            
        } catch (error) {
            return {
                success: false,
                error: error.message,
                timestamp: new Date().toISOString()
            };
        }
    }
}

// Usage Example
async function runExample() {
    const api = new BigCityRewardsWorkflow('your_company_secret_here');
    
    const customerData = {
        customer_name: "Bob Wilson",
        customer_mobile: "5551234567",
        customer_email: "bob@example.com"
    };
    
    const cartItems = [
        { sku: 'NUTRI-SEEDS-1200', quantity: 1, price: 25.00 },
        { sku: 'NUTRI-OATS-MULTI', quantity: 2, price: 15.00 }
    ];
    
    const result = await api.processCompleteWorkflow(customerData, cartItems);
    
    if (result.success) {
        console.log('\n🎉 Workflow completed successfully!');
        console.log(`Order ID: ${result.orderId}`);
        console.log(`Customer: ${result.customer.customer_name}`);
        console.log(`Total: $${result.orderSummary.totalAmount}`);
        console.log(`Vouchers: ${result.orderSummary.vouchersGenerated}`);
        
        if (result.vouchers && result.vouchers.length > 0) {
            console.log('\n🎫 Voucher Details:');
            result.vouchers.forEach((voucher, index) => {
                console.log(`  ${index + 1}. Code: ${voucher.voucher_code}`);
                console.log(`     PIN: ${voucher.pin || 'N/A'}`);
                console.log(`     Valid until: ${voucher.validity}`);
            });
        }
        
        console.log(`\n🌐 Redeem at: ${result.redemptionUrl}`);
    } else {
        console.error('\n❌ Workflow failed:', result.error);
    }
}

// Run the example
runExample().catch(console.error);

companySecret = $companySecret;
    }
    
    public function authenticateCompany() {
        echo "🏢 Authenticating company...\n";
        
        $curl = curl_init();
        curl_setopt_array($curl, [
            CURLOPT_URL => $this->baseUrl . '/company/auth',
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_POST => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: Required',
                'Content-Type: application/json'
            ],
            CURLOPT_POSTFIELDS => json_encode(['secret' => $this->companySecret]),
            CURLOPT_TIMEOUT => 30
        ]);
        
        $response = curl_exec($curl);
        $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
        curl_close($curl);
        
        if ($httpCode === 200) {
            $authData = json_decode($response, true);
            $this->companyToken = $authData['auth_token'];
            echo "✅ Company authenticated. Vendor: {$authData['vendor_name']}\n";
            return $this->companyToken;
        } else {
            throw new Exception("Company authentication failed: $response");
        }
    }
    
    public function processCompleteWorkflow($customerData, $cartItems) {
        try {
            // Step 1: Company Authentication
            $companyToken = $this->authenticateCompany();
            
            // Step 2: Get Rewards
            $rewards = $this->getRewards();
            
            // Step 3: Customer Authentication
            $customerToken = $this->authenticateCustomer($customerData);
            
            // Step 4: Prepare Order Data
            $orderTotal = array_sum(array_map(fn($item) => $item['price'] * $item['quantity'], $cartItems));
            $orderId = 'ORD-' . date('Ymd') . '-' . strtoupper(substr(uniqid(), -8));
            
            $orderData = [
                'order_timestamp' => date('c'), // ISO 8601
                'order_total' => $orderTotal,
                'order_items' => count($cartItems),
                'line_items' => array_map(fn($item) => [
                    'order_id' => $orderId,
                    'SKU' => $item['sku'],
                    'qty' => $item['quantity']
                ], $cartItems)
            ];
            
            // Step 5: Create Redemption Order
            $result = $this->createRedemptionOrder($customerToken, $orderData);
            
            return [
                'success' => true,
                'order_id' => $orderId,
                'redemption_result' => $result,
                'customer_data' => $customerData,
                'order_summary' => [
                    'total_amount' => $orderTotal,
                    'items_count' => count($cartItems),
                    'vouchers_generated' => count($result['vouchers'] ?? [])
                ]
            ];
            
        } catch (Exception $e) {
            echo "❌ Workflow failed: " . $e->getMessage() . "\n";
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }
}