/**
 * JavaScript Table Sender Test
 * Tests the smartsend function with table (Arrow IPC) payloads
 */

const NATSBridge = require('../src/natbridge.js');

const TEST_SUBJECT = '/test/table';
const TEST_BROKER_URL = process.env.NATS_URL || 'nats://localhost:4222';
const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://localhost:8080';

async function runTest() {
    console.log('=== JavaScript Table Sender Test ===\n');
    
    const correlationId = NATSBridge.uuidv4();
    console.log(`Correlation ID: ${correlationId}`);
    console.log(`Subject: ${TEST_SUBJECT}`);
    console.log(`Broker URL: ${TEST_BROKER_URL}\n`);
    
    // Test data - table data as array of objects
    const tableData = [
        { id: 1, name: 'Alice', age: 30, active: true },
        { id: 2, name: 'Bob', age: 25, active: false },
        { id: 3, name: 'Charlie', age: 35, active: true },
        { id: 4, name: 'Diana', age: 28, active: true },
        { id: 5, name: 'Eve', age: 32, active: false }
    ];
    
    const testData = [
        ['users_table', tableData, 'table']
    ];
    
    try {
        // Send the message
        console.log('Sending table payload...');
        const [env, envJsonStr] = await NATSBridge.smartsend(
            TEST_SUBJECT,
            testData,
            {
                broker_url: TEST_BROKER_URL,
                fileserver_url: TEST_FILESERVER_URL,
                correlation_id: correlationId,
                msg_purpose: 'test',
                sender_name: 'js-table-test',
                is_publish: false
            }
        );
        
        console.log('\n=== Envelope Created ===');
        console.log(`Correlation ID: ${env.correlation_id}`);
        console.log(`Message ID: ${env.msg_id}`);
        console.log(`Timestamp: ${env.timestamp}`);
        console.log(`Subject: ${env.send_to}`);
        console.log(`Purpose: ${env.msg_purpose}`);
        console.log(`Sender: ${env.sender_name}`);
        console.log(`Payloads: ${env.payloads.length}\n`);
        
        // Validate envelope structure
        console.log('=== Validation ===');
        let passed = true;
        
        if (env.payloads.length !== 1) {
            console.log(`❌ Expected 1 payload, got ${env.payloads.length}`);
            passed = false;
        } else {
            console.log('✅ Correct number of payloads');
        }
        
        const payload = env.payloads[0];
        if (payload.dataname !== 'users_table') {
            console.log(`❌ Expected dataname 'users_table', got '${payload.dataname}'`);
            passed = false;
        } else {
            console.log('✅ Correct dataname');
        }
        
        if (payload.payload_type !== 'table') {
            console.log(`❌ Expected payload_type 'table', got '${payload.payload_type}'`);
            passed = false;
        } else {
            console.log('✅ Correct payload_type');
        }
        
        if (payload.transport !== 'direct') {
            console.log(`❌ Expected transport 'direct', got '${payload.transport}'`);
            passed = false;
        } else {
            console.log('✅ Correct transport');
        }
        
        if (payload.encoding !== 'base64') {
            console.log(`❌ Expected encoding 'base64', got '${payload.encoding}'`);
            passed = false;
        } else {
            console.log('✅ Correct encoding');
        }
        
        // Verify Arrow IPC data can be decoded
        console.log('\n=== Arrow IPC Verification ===');
        const decodedData = Buffer.from(payload.data, 'base64');
        console.log(`Arrow IPC buffer size: ${decodedData.length} bytes`);
        
        if (decodedData.length > 0) {
            console.log('✅ Arrow IPC data present');
        } else {
            console.log('❌ Arrow IPC data is empty');
            passed = false;
        }
        
        // Test with larger table
        console.log('\n=== Larger Table Test ===');
        const largeTableData = [];
        for (let i = 1; i <= 100; i++) {
            largeTableData.push({
                id: i,
                name: `User${i}`,
                age: Math.floor(Math.random() * 100),
                active: Math.random() > 0.5,
                score: Math.random() * 100
            });
        }
        
        const largeTestData = [
            ['large_table', largeTableData, 'table']
        ];
        
        const [largeEnv, _] = await NATSBridge.smartsend(
            TEST_SUBJECT,
            largeTestData,
            {
                broker_url: TEST_BROKER_URL,
                fileserver_url: TEST_FILESERVER_URL,
                correlation_id: 'large-' + correlationId,
                is_publish: false
            }
        );
        
        if (largeEnv.payloads.length === 1) {
            console.log('✅ Large table handled correctly');
            console.log(`   Size: ${largeEnv.payloads[0].size} bytes`);
        } else {
            console.log('❌ Large table handling failed');
            passed = false;
        }
        
        // Test JSON string output
        console.log('\n=== JSON String Output Test ===');
        try {
            const parsed = JSON.parse(envJsonStr);
            if (parsed.correlation_id === env.correlation_id && 
                parsed.payloads.length === env.payloads.length) {
                console.log('✅ JSON string is valid and matches envelope');
            } else {
                console.log('❌ JSON string does not match envelope');
                passed = false;
            }
        } catch (e) {
            console.log('❌ JSON string is invalid:', e.message);
            passed = false;
        }
        
        // Final result
        console.log('\n=== Test Result ===');
        if (passed) {
            console.log('✅ ALL TESTS PASSED');
            process.exit(0);
        } else {
            console.log('❌ SOME TESTS FAILED');
            process.exit(1);
        }
        
    } catch (error) {
        console.error('❌ Test failed with error:', error.message);
        console.error(error.stack);
        process.exit(1);
    }
}

runTest();