/**
 * Test Confidential Swap API - End-to-End Flow
 *
 * Tests the privacy swap API endpoints without requiring blockchain credentials.
 * Verifies proof generation, order creation, and order taking flows.
 */

const API_URL = process.env.API_URL || 'http://localhost:8090';

interface ElGamalCiphertext {
    c1_x: string;
    c1_y: string;
    c2_x: string;
    c2_y: string;
}

interface ProofBundle {
    rangeProof: {
        commitment: { x: string; y: string };
        challenge: string;
        response: string;
    };
    rateProof: {
        rateCommitment: { x: string; y: string };
        challenge: string;
        responseGive: string;
        responseRate: string;
        responseBlinding: string;
    };
    balanceProof: {
        balanceCommitment: { x: string; y: string };
        challenge: string;
        response: string;
    };
}

function log(msg: string, type: 'info' | 'success' | 'error' | 'header' = 'info') {
    const colors = {
        info: '\x1b[36m',
        success: '\x1b[32m',
        error: '\x1b[31m',
        header: '\x1b[35m',
    };
    console.log(`${colors[type]}${msg}\x1b[0m`);
}

async function testHealthEndpoint(): Promise<boolean> {
    try {
        const response = await fetch(`${API_URL}/api/v1/privacy/health`);
        const data = await response.json();
        log(`  Status: ${data.status}`, data.status === 'healthy' ? 'success' : 'error');
        log(`  GPU Available: ${data.gpu_available}`, 'info');
        log(`  Version: ${data.version}`, 'info');
        return data.status === 'healthy';
    } catch (e) {
        log(`  Health check failed: ${(e as Error).message}`, 'error');
        return false;
    }
}

async function testListOrders(): Promise<any[]> {
    try {
        const response = await fetch(`${API_URL}/api/v1/privacy/orders`);
        const data = await response.json();
        log(`  Total orders: ${data.orders?.length || 0}`, 'success');
        return data.orders || [];
    } catch (e) {
        log(`  List orders failed: ${(e as Error).message}`, 'error');
        return [];
    }
}

async function testGenerateProof(giveAmount: string, wantAmount: string): Promise<ProofBundle | null> {
    try {
        const response = await fetch(`${API_URL}/api/v1/privacy/generate-swap-proof`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                giveAsset: 0, // SAGE
                wantAsset: 1, // USDC
                giveAmount,
                wantAmount,
                rate: (BigInt(wantAmount) * BigInt('1000000000000000000') / BigInt(giveAmount)).toString(),
                blindingFactor: '0x' + Math.random().toString(16).slice(2).padStart(64, '0'),
            }),
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}`);
        }

        const data = await response.json();
        log(`  Range proof: generated`, 'success');
        log(`  Rate proof: generated`, 'success');
        log(`  Balance proof: generated`, 'success');
        return data;
    } catch (e) {
        log(`  Proof generation failed: ${(e as Error).message}`, 'error');
        return null;
    }
}

async function testCreateOrder(proofs: ProofBundle): Promise<string | null> {
    try {
        // Generate mock encrypted amounts
        const randomHex = () => '0x' + Math.random().toString(16).slice(2).padStart(64, '0');

        const encryptedGive: ElGamalCiphertext = {
            c1_x: randomHex(),
            c1_y: randomHex(),
            c2_x: randomHex(),
            c2_y: randomHex(),
        };

        const encryptedWant: ElGamalCiphertext = {
            c1_x: randomHex(),
            c1_y: randomHex(),
            c2_x: randomHex(),
            c2_y: randomHex(),
        };

        const response = await fetch(`${API_URL}/api/v1/privacy/orders`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                giveAsset: 0,
                wantAsset: 1,
                encryptedGive,
                encryptedWant,
                rateCommitment: randomHex(),
                minFillPct: 0,
                expiresIn: 604800,
                proofs,
            }),
        });

        if (!response.ok) {
            const text = await response.text();
            log(`  Create order returned ${response.status}: ${text.slice(0, 100)}`, 'info');
            // May not be fully implemented - that's OK for API test
            return null;
        }

        const data = await response.json();
        log(`  Order created: ${data.orderId}`, 'success');
        return data.orderId;
    } catch (e) {
        log(`  Create order not implemented (expected): ${(e as Error).message}`, 'info');
        return null;
    }
}

async function testTakeOrder(orderId: string = '1'): Promise<boolean> {
    try {
        const randomHex = () => '0x' + Math.random().toString(16).slice(2).padStart(64, '0');

        // Generate 64 bit commitments and responses for range proof
        const bitCommitments = Array.from({ length: 64 }, () => ({
            x: randomHex(),
            y: randomHex(),
        }));
        const responses = Array.from({ length: 64 }, () => randomHex());

        const response = await fetch(`${API_URL}/api/v1/privacy/orders/${orderId}/take`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                // Match the Rust API schema: TakeOrderRequest
                takerGive: {
                    c1: { x: randomHex(), y: randomHex() },
                    c2: { x: randomHex(), y: randomHex() },
                },
                takerWant: {
                    c1: { x: randomHex(), y: randomHex() },
                    c2: { x: randomHex(), y: randomHex() },
                },
                proofs: {
                    rangeProof: {
                        bitCommitments,
                        challenge: randomHex(),
                        responses,
                        numBits: 64,
                    },
                    rateProof: {
                        rateCommitment: { x: randomHex(), y: randomHex() },
                        challenge: randomHex(),
                        responseGive: randomHex(),
                        responseRate: randomHex(),
                        responseBlinding: randomHex(),
                    },
                    balanceProof: {
                        balanceCommitment: { x: randomHex(), y: randomHex() },
                        challenge: randomHex(),
                        response: randomHex(),
                    },
                },
            }),
        });

        const data = await response.json();
        if (data.matchId) {
            log(`  Order taken! Match ID: ${data.matchId.slice(0, 20)}...`, 'success');
            log(`  Status: ${data.status}`, 'success');
            return true;
        } else if (data.error) {
            log(`  Take order error: ${data.error}`, 'error');
            return false;
        }
        return false;
    } catch (e) {
        log(`  Take order failed: ${(e as Error).message}`, 'error');
        return false;
    }
}

async function testGetBalance(): Promise<boolean> {
    try {
        const testAddress = '0x0759a4374389b0e3cfcc59d49310b6bc75bb12bbf8ce550eb5c2f026918bb344';
        // Asset ID: 0=SAGE, 1=USDC, 2=STRK, 3=ETH
        const assetId = 0; // SAGE
        const response = await fetch(`${API_URL}/api/v1/privacy/balance/${testAddress}/${assetId}`);
        const data = await response.json();
        log(`  Encrypted balance retrieved`, 'success');
        log(`  Has ciphertext: ${!!data.c1?.x}`, 'info');
        return true;
    } catch (e) {
        log(`  Get balance failed: ${(e as Error).message}`, 'error');
        return false;
    }
}

async function testSwapHistory(): Promise<boolean> {
    try {
        const testAddress = '0x0759a4374389b0e3cfcc59d49310b6bc75bb12bbf8ce550eb5c2f026918bb344';
        const response = await fetch(`${API_URL}/api/v1/privacy/swaps/history/${testAddress}`);
        const data = await response.json();
        log(`  Swap history entries: ${data.swaps?.length || 0}`, 'success');
        return true;
    } catch (e) {
        log(`  Get swap history failed: ${(e as Error).message}`, 'error');
        return false;
    }
}

async function main() {
    log('\n╔══════════════════════════════════════════════════════════════════════╗', 'header');
    log('║    CONFIDENTIAL SWAP API - End-to-End Test                           ║', 'header');
    log('╚══════════════════════════════════════════════════════════════════════╝', 'header');
    log(`\n  API URL: ${API_URL}\n`, 'info');

    const results: { test: string; passed: boolean }[] = [];

    // Test 1: Health Check
    log('\n=== Test 1: Health Check ===', 'header');
    const healthOk = await testHealthEndpoint();
    results.push({ test: 'Health Check', passed: healthOk });

    if (!healthOk) {
        log('\n  Server not running or unhealthy. Aborting tests.', 'error');
        process.exit(1);
    }

    // Test 2: List Orders
    log('\n=== Test 2: List Orders ===', 'header');
    const orders = await testListOrders();
    results.push({ test: 'List Orders', passed: true });

    // Test 3: Generate Proof
    log('\n=== Test 3: Generate STWO Proof ===', 'header');
    log('  Generating proof for: 100 SAGE -> 10 USDC', 'info');
    const proofs = await testGenerateProof('100000000000000000000', '10000000');
    results.push({ test: 'Generate Proof', passed: !!proofs });

    // Test 4: Take Order (simulated)
    log('\n=== Test 4: Take Order (Simulated) ===', 'header');
    const takeOk = await testTakeOrder('1');
    results.push({ test: 'Take Order', passed: takeOk });

    // Test 5: Get Encrypted Balance
    log('\n=== Test 5: Get Encrypted Balance ===', 'header');
    const balanceOk = await testGetBalance();
    results.push({ test: 'Get Balance', passed: balanceOk });

    // Test 6: Get Swap History
    log('\n=== Test 6: Get Swap History ===', 'header');
    const historyOk = await testSwapHistory();
    results.push({ test: 'Swap History', passed: historyOk });

    // Summary
    log('\n╔══════════════════════════════════════════════════════════════════════╗', 'header');
    log('║                        TEST SUMMARY                                  ║', 'header');
    log('╚══════════════════════════════════════════════════════════════════════╝', 'header');

    const passed = results.filter(r => r.passed).length;
    const total = results.length;

    for (const r of results) {
        log(`  ${r.passed ? '✓' : '✗'} ${r.test}`, r.passed ? 'success' : 'error');
    }

    log(`\n  Result: ${passed}/${total} tests passed`, passed === total ? 'success' : 'error');

    if (passed === total) {
        log('\n  Confidential Swap API is fully operational!', 'success');
        log('  Ready for SDK integration and frontend testing.\n', 'success');
    }
}

main().catch(e => {
    log(`\nFatal error: ${e.message}`, 'error');
    console.error(e);
    process.exit(1);
});