#!/usr/bin/env node

import { RingNode } from '../src/ring-node.js';
import { OracleNode } from '../src/oracle-node.js';
import chalk from 'chalk';

/**
 * Example script demonstrating Ring Network usage
 * This creates a simple network and shows basic operations
 */

console.log(chalk.blue.bold('🔗 Ring Network Example\n'));

class NetworkExample {
    constructor() {
        this.nodes = [];
        this.isRunning = false;
    }

    async delay(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    async createNetwork() {
        console.log(chalk.cyan('🏗️  Creating example network...'));
        
        // Create Oracle node (bootstrap)
        const oracle = new OracleNode({
            id: 'oracle-example',
            port: 9000
        });
        this.nodes.push(oracle);
        
        // Create regular nodes
        const node1 = new RingNode({
            id: 'node-1-example',
            port: 9001
        });
        this.nodes.push(node1);
        
        const node2 = new RingNode({
            id: 'node-2-example',
            port: 9002
        });
        this.nodes.push(node2);
        
        console.log(chalk.green('✅ Created 3 nodes: 1 Oracle + 2 Regular'));
        
        // Set up event handlers
        this.setupEventHandlers();
        
        // Allow nodes to initialize
        await this.delay(2000);
        
        return { oracle, node1, node2 };
    }

    setupEventHandlers() {
        this.nodes.forEach((node, index) => {
            const nodeType = node.isOracle ? 'Oracle' : 'Node';
            const nodeColor = node.isOracle ? chalk.yellow : chalk.blue;
            
            node.on('peerConnected', (peerId) => {
                // Peer connected
            });
            
            node.on('peerDisconnected', (peerId) => {
                // Peer disconnected
            });
            
            node.on('ringMessage', ({ from, payload }) => {
                // Message received
            });
        });
    }

    async demonstrateBasicMessaging() {
        console.log(chalk.magenta('\n📨 Demonstrating basic messaging...'));
        
        const [oracle, node1, node2] = this.nodes;
        
        // Simulate ring connections for demonstration
        // In real usage, these would be established via WebRTC
        oracle.rings.inner.right = node1.id;
        node1.rings.inner.right = node2.id;
        node2.rings.inner.right = oracle.id;
        
        // Simulate message sending
        oracle.emit('ringMessage', {
            from: oracle.id,
            payload: { type: 'greeting', message: 'Hello from Oracle!' }
        });
        
        node1.emit('ringMessage', {
            from: node1.id,
            payload: { type: 'response', message: 'Node 1 received the message!' }
        });
        
        await this.delay(1000);
        console.log(chalk.green('✅ Basic messaging demonstration complete'));
    }

    async demonstrateOracleServices() {
        console.log(chalk.yellow('\n🔮 Demonstrating Oracle services...'));
        
        const oracle = this.nodes[0];
        
        // Network Analysis
        console.log(chalk.cyan('\n1. Network Analysis:'));
        const analysis = oracle.analyzeNetwork();
        console.log(`   - Network size: ${analysis.networkSize}`);
        console.log(`   - Network health: ${analysis.networkHealth.overall}%`);
        console.log(`   - Recommendations: ${analysis.recommendations.length}`);
        
        // Data Storage
        console.log(chalk.cyan('\n2. Data Storage:'));
        const storeResult = oracle.handleDataStorage({
            operation: 'set',
            key: 'example-key',
            value: { message: 'Hello World!', timestamp: Date.now() }
        });
        console.log(`   - Data stored: ${storeResult.success}`);
        
        const retrieveResult = oracle.handleDataStorage({
            operation: 'get',
            key: 'example-key'
        });
        console.log(`   - Data retrieved: ${retrieveResult.success}`);
        console.log(`   - Value: ${JSON.stringify(retrieveResult.value)}`);
        
        // Consensus
        console.log(chalk.cyan('\n3. Consensus:'));
        const proposalId = 'example-proposal-' + Date.now();
        const consensusResult = oracle.handleConsensus({
            proposalId,
            proposal: 'Upgrade network protocol to v2.0'
        });
        console.log(`   - Proposal created: ${consensusResult.success}`);
        console.log(`   - Proposal ID: ${proposalId}`);
        
        // Health Check
        console.log(chalk.cyan('\n4. Health Check:'));
        const health = oracle.performHealthCheck();
        console.log(`   - Network healthy: ${health.healthy}`);
        console.log(`   - Connected peers: ${health.checks.webrtc}`);
        console.log(`   - Uptime: ${Math.round(health.checks.uptime / 1000)}s`);
        
        // Metrics
        console.log(chalk.cyan('\n5. Network Metrics:'));
        const metrics = oracle.getNetworkMetrics();
        console.log(`   - Messages processed: ${metrics.messagesProcessed}`);
        console.log(`   - Queries answered: ${metrics.queriesAnswered}`);
        console.log(`   - Data store size: ${metrics.dataStoreSize}`);
        
        console.log(chalk.green('✅ Oracle services demonstration complete'));
    }

    async demonstrateNetworkTopology() {
        console.log(chalk.blue('\n🔗 Demonstrating network topology...'));
        
        const [oracle, node1, node2] = this.nodes;
        
        // Show network information for each node
        this.nodes.forEach((node, index) => {
            const info = node.getNetworkInfo();
            const nodeType = node.isOracle ? 'Oracle' : 'Node';
            
            console.log(chalk.cyan(`\n${nodeType} ${index} (${info.nodeId.substring(0, 8)}):`));
            console.log(`   - Port: ${info.port}`);
            console.log(`   - Known nodes: ${info.knownNodes.length}`);
            console.log(`   - Oracle nodes: ${info.oracleNodes.length}`);
            console.log(`   - Inner ring: L=${info.rings.inner.left?.substring(0, 8) || 'none'} R=${info.rings.inner.right?.substring(0, 8) || 'none'}`);
            console.log(`   - Outer ring: L=${info.rings.outer.left?.substring(0, 8) || 'none'} R=${info.rings.outer.right?.substring(0, 8) || 'none'}`);
        });
        
        console.log(chalk.green('\n✅ Network topology demonstration complete'));
    }

    async demonstrateAdvancedFeatures() {
        console.log(chalk.magenta('\n⚡ Demonstrating advanced features...'));
        
        const oracle = this.nodes[0];
        
        // Routing strategies
        console.log(chalk.cyan('\n1. Routing Strategies:'));
        const routingResult = oracle.handleRouting({
            destination: 'target-node',
            message: { type: 'test', data: 'routing test' },
            strategy: 'ring-flood'
        });
        console.log(`   - Ring flood routing: ${routingResult.success}`);
        
        // Advanced consensus
        console.log(chalk.cyan('\n2. Advanced Consensus:'));
        const advancedProposal = 'proposal-' + Date.now();
        oracle.handleConsensus({
            proposalId: advancedProposal,
            proposal: 'Implement new security protocol'
        });
        
        // Simulate vote
        oracle.handleConsensus({
            proposalId: advancedProposal,
            vote: 'yes'
        });
        
        console.log(`   - Proposal "${advancedProposal}" created and voted on`);
        
        // Network monitoring
        console.log(chalk.cyan('\n3. Network Monitoring:'));
        oracle.monitorNetworkHealth();
        const recentEvents = oracle.networkMetrics.networkEvents.slice(-3);
        console.log(`   - Recent network events: ${recentEvents.length}`);
        recentEvents.forEach(event => {
            console.log(`     * ${event.type} at ${new Date(event.timestamp).toLocaleTimeString()}`);
        });
        
        console.log(chalk.green('✅ Advanced features demonstration complete'));
    }

    async simulateNetworkActivity() {
        console.log(chalk.blue('\n🎭 Simulating network activity...'));
        
        const oracle = this.nodes[0];
        
        // Simulate periodic activity
        for (let i = 0; i < 5; i++) {
            // Random data storage
            oracle.handleDataStorage({
                operation: 'set',
                key: `activity-${i}`,
                value: { activity: `Simulated activity ${i}`, timestamp: Date.now() }
            });
            
            // Simulate message processing
            oracle.networkMetrics.messagesProcessed++;
            oracle.networkMetrics.queriesAnswered++;
            
            await this.delay(500);
            
            if (i % 2 === 0) {
                console.log(chalk.blue(`   - Activity ${i + 1}/5: Data stored and metrics updated`));
            }
        }
        
        console.log(chalk.green('✅ Network activity simulation complete'));
    }

    async cleanup() {
        console.log(chalk.red('\n🧹 Cleaning up example network...'));
        
        for (const node of this.nodes) {
            try {
                await node.destroy();
            } catch (error) {
                console.log(chalk.yellow(`Warning: ${error.message}`));
            }
        }
        
        this.nodes = [];
        console.log(chalk.green('✅ Cleanup complete'));
    }

    async runExample() {
        try {
            this.isRunning = true;
            
            // Create network
            await this.createNetwork();
            
            // Run demonstrations
            await this.demonstrateBasicMessaging();
            await this.demonstrateOracleServices();
            await this.demonstrateNetworkTopology();
            await this.demonstrateAdvancedFeatures();
            await this.simulateNetworkActivity();
            
            console.log(chalk.green.bold('\n🎉 Example completed successfully!'));
            console.log(chalk.blue('\nThis example demonstrated:'));
            console.log('  ✅ Network creation and initialization');
            console.log('  ✅ Basic messaging between nodes');
            console.log('  ✅ Oracle services (analysis, storage, consensus, health)');
            console.log('  ✅ Network topology visualization');
            console.log('  ✅ Advanced features (routing, monitoring)');
            console.log('  ✅ Simulated network activity');
            
            console.log(chalk.cyan('\nTo start a real network:'));
            console.log('  npm run start:oracle -- --port 8080');
            console.log('  npm run start:node -- --port 8081 --bootstrap localhost:8080');
            
        } catch (error) {
            console.error(chalk.red.bold(`\n💥 Example failed: ${error.message}`));
            console.error(error.stack);
        } finally {
            await this.cleanup();
            this.isRunning = false;
        }
    }
}

// Handle graceful shutdown
process.on('SIGINT', async () => {
    console.log(chalk.yellow('\n🛑 Shutting down example...'));
    process.exit(0);
});

// Run example if this file is executed directly
if (import.meta.url === `file://${process.argv[1]}`) {
    const example = new NetworkExample();
    example.runExample()
        .then(() => {
            console.log(chalk.blue('\n👋 Example finished. Goodbye!'));
            process.exit(0);
        })
        .catch(error => {
            console.error(chalk.red.bold(`\n💥 Example crashed: ${error.message}`));
            process.exit(1);
        });
}

export { NetworkExample };