/**
 * Clynk PC Client (Node.js)
 * A simple clipboard synchronization client for Clynk Android app.
 */

const net = require('net');
const crypto = require('crypto');
const readline = require('readline');
const clipboardy = require('clipboardy');

const PORT = 8765;
const HOST = '0.0.0.0';

function generateKey(pin) {
    return crypto.createHash('sha256').update(pin).digest();
}

function decrypt(ciphertext, key) {
    const data = Buffer.from(ciphertext, 'base64');
    const iv = data.slice(0, 16);
    const encrypted = data.slice(16);
    const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
    let decrypted = decipher.update(encrypted);
    decrypted = Buffer.concat([decrypted, decipher.final()]);
    return decrypted.toString('utf-8');
}

function encrypt(plaintext, key) {
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
    let encrypted = cipher.update(plaintext, 'utf-8');
    encrypted = Buffer.concat([encrypted, cipher.final()]);
    const combined = Buffer.concat([iv, encrypted]);
    return combined.toString('base64');
}

async function main() {
    console.log('='.repeat(50));
    console.log('  Clynk PC Client v1.0.0');
    console.log('  Secure Clipboard Synchronization');
    console.log('='.repeat(50));
    
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
    });
    
    const useEncryption = await new Promise(resolve => {
        rl.question('\n🔐 Enable encryption? (y/n): ', answer => {
            resolve(answer.toLowerCase() === 'y');
        });
    });
    
    let key = null;
    if (useEncryption) {
        const pin = await new Promise(resolve => {
            rl.question('🔑 Enter 6-digit PIN from Android app: ', answer => {
                resolve(answer);
            });
        });
        key = generateKey(pin);
        console.log('✅ Encryption enabled with AES-256');
    } else {
        console.log('⚠️  Running without encryption (not recommended)');
    }
    
    rl.close();
    
    console.log(`\n🌐 Listening on ${HOST}:${PORT}`);
    console.log('⏳ Waiting for Android device to connect...\n');
    
    const server = net.createServer(socket => {
        console.log(`✅ Connected to ${socket.remoteAddress}:${socket.remotePort}`);
        console.log('📋 Clipboard sync is now active!\n');
        
        let lastClipboard = '';
        let buffer = '';
        
        const clipboardInterval = setInterval(async () => {
            try {
                const current = await clipboardy.read();
                if (current !== lastClipboard && current) {
                    lastClipboard = current;
                    const msg = {
                        type: 'CLIPBOARD_UPDATE',
                        content: key ? encrypt(current, key) : current,
                        deviceName: 'PC',
                        timestamp: Date.now(),
                        encrypted: key !== null
                    };
                    socket.write(JSON.stringify(msg) + '\n');
                    const preview = current.length > 50 ? current.substring(0, 50) + '...' : current;
                    console.log(`📤 Sent: ${preview}`);
                }
            } catch (err) {
                // Ignore clipboard errors
            }
        }, 1000);
        
        socket.on('data', data => {
            buffer += data.toString();
            
            while (buffer.includes('\n')) {
                const idx = buffer.indexOf('\n');
                const line = buffer.substring(0, idx);
                buffer = buffer.substring(idx + 1);
                
                try {
                    const msg = JSON.parse(line);
                    
                    if (msg.type === 'CLIPBOARD_UPDATE') {
                        let content = msg.content;
                        if (msg.encrypted && key) {
                            content = decrypt(content, key);
                        }
                        
                        clipboardy.writeSync(content);
                        lastClipboard = content;
                        const preview = content.length > 50 ? content.substring(0, 50) + '...' : content;
                        console.log(`📥 Received: ${preview}`);
                    }
                } catch (err) {
                    console.error('❌ Parse error:', err.message);
                }
            }
        });
        
        socket.on('close', () => {
            clearInterval(clipboardInterval);
            console.log('\n⚠️  Connection closed. Waiting for reconnection...\n');
        });
        
        socket.on('error', err => {
            console.error('❌ Socket error:', err.message);
        });
    });
    
    server.listen(PORT, HOST);
}

main().catch(err => {
    console.error('💥 Fatal error:', err);
    process.exit(1);
});