server.js

import express from 'express';
import cors from 'cors';
import { createServer } from 'http';
import { Server } from 'socket.io';
import fs from 'fs';
import path from 'path';
import { exec } from 'child_process';
import { promisify } from 'util';
import { fileURLToPath } from 'url';
import crypto from 'crypto';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const execAsync = promisify(exec);
const app = express();
const server = createServer(app);
const io = new Server(server, { cors: { origin: '*' } });

app.use(cors());
app.use(express.json());
app.use(express.static(path.join(__dirname, 'docs/dashboard')));
app.use(express.static(path.join(__dirname, 'surgery-room')));

// ============================================================
// Configuration
// ============================================================
const ELITE_VERSION = '1.7.0';
const SURGERY_BASE = path.join(__dirname, 'surgery-room');
const REPAIRS_DIR = path.join(SURGERY_BASE, 'repairs');
const SUCCESS_DIR = path.join(SURGERY_BASE, 'successful');
const FAILED_DIR = path.join(SURGERY_BASE, 'failed');
const BLOCKCHAIN_DIR = path.join(__dirname, 'blockchain');

// Create directories
[SURGERY_BASE, REPAIRS_DIR, SUCCESS_DIR, FAILED_DIR, BLOCKCHAIN_DIR].forEach(dir => {
    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
});

// ============================================================
// Data Storage
// ============================================================
let surgeryRecords = [];
let activeSurgeries = new Map();
let blockchainBlocks = [];

// Load records
function loadRecords() {
    const recordsPath = path.join(SURGERY_BASE, 'surgery-records.json');
    if (fs.existsSync(recordsPath)) {
        try {
            surgeryRecords = JSON.parse(fs.readFileSync(recordsPath, 'utf8'));
        } catch(e) { surgeryRecords = []; }
    }
}
loadRecords();

function saveRecords() {
    fs.writeFileSync(path.join(SURGERY_BASE, 'surgery-records.json'), JSON.stringify(surgeryRecords, null, 2));
}

// ============================================================
// Blockchain Functions
// ============================================================
function generateBlockHash(data) {
    return crypto.createHash('sha256')
        .update(JSON.stringify(data) + Date.now())
        .digest('hex');
}

function addToBlockchain(event, data) {
    const block = {
        index: blockchainBlocks.length,
        timestamp: new Date().toISOString(),
        hash: generateBlockHash(data),
        previousHash: blockchainBlocks.length > 0 ? blockchainBlocks[blockchainBlocks.length - 1].hash : '0'.repeat(64),
        data: { event, ...data, timestamp: new Date().toISOString() }
    };
    blockchainBlocks.push(block);
    
    // Persist to disk
    const blockPath = path.join(BLOCKCHAIN_DIR, `block-${block.index}.json`);
    fs.writeFileSync(blockPath, JSON.stringify(block, null, 2));
    return block.hash;
}

// ============================================================
// SurgerySession Class (Elite)
// ============================================================
class SurgerySession {
    constructor(id, repoUrl, branchName, eliteConfig = {}) {
        this.id = id;
        this.repoUrl = repoUrl;
        this.repoName = repoUrl.split('/').pop().replace('.git', '');
        this.branchName = branchName;
        this.surgeryPath = path.join(REPAIRS_DIR, `${this.repoName}_${id}`);
        this.status = 'preparing';
        this.steps = [];
        this.prNumber = null;
        this.startTime = new Date();
        this.hasChanges = false;
        this.language = 'unknown';
        this.eliteConfig = {
            dynamicShifting: true,
            blockchainAudit: true,
            selfHealing: true,
            ...eliteConfig
        };
        this.shiftMetrics = null;
        this.auditHash = null;
        this.blockchainHash = addToBlockchain('session_created', { 
            sessionId: id, 
            repo: this.repoName, 
            branch: branchName 
        });
    }
    
    addStep(stepName, status, detail = '') {
        this.steps.push({ step: stepName, status, detail, timestamp: new Date() });
        io.emit('repair-update', { sessionId: this.id, step: stepName, status, detail });
        saveRecords();
    }
    
    complete(success, prNumber = null, prUrl = null) {
        this.status = success ? 'successful' : 'failed';
        if (prNumber) this.prNumber = prNumber;
        
        addToBlockchain('session_completed', {
            sessionId: this.id,
            success,
            prNumber,
            stepsCount: this.steps.length
        });
        
        saveRecords();
        io.emit('repair-complete', { sessionId: this.id, status: this.status, prNumber, prUrl });
    }
}

// ============================================================
// Helper Functions
// ============================================================
async function execPS(command, cwd) {
    if (!cwd || !fs.existsSync(cwd)) {
        console.error(`Invalid cwd: ${cwd}`);
        return { stdout: '', stderr: 'Invalid working directory' };
    }
    
    const tmpFile = path.join(SURGERY_BASE, `_ps_${Date.now()}.ps1`);
    const scriptContent = `Set-Location "${cwd}"\n${command}\n`;
    fs.writeFileSync(tmpFile, scriptContent, 'utf8');
    
    try {
        const { stdout, stderr } = await execAsync(`powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "${tmpFile}"`, { 
            maxBuffer: 20 * 1024 * 1024, 
            timeout: 120000 
        });
        return { stdout, stderr };
    } catch (error) {
        return { stdout: error.stdout || '', stderr: error.stderr || error.message };
    } finally {
        try { fs.unlinkSync(tmpFile); } catch(e) { /* ignore */ }
    }
}

async function detectLanguage(surgeryPath) {
    try {
        const files = fs.readdirSync(surgeryPath);
        if (files.includes('package.json')) return 'node';
        if (files.includes('requirements.txt') || files.includes('pyproject.toml')) return 'python';
        if (files.includes('Cargo.toml')) return 'rust';
        if (files.includes('go.mod')) return 'golang';
        return 'unknown';
    } catch(e) {
        return 'unknown';
    }
}

async function dynamicTestShifting(surgeryPath, strategy = 'adaptive') {
    console.log(`🔄 Dynamic Test Shifting - Strategy: ${strategy}`);
    
    const testPatterns = ['*.test.js', '*.test.ts', '*.spec.js', '*.spec.ts'];
    let testFiles = [];
    
    for (const pattern of testPatterns) {
        try {
            const { stdout } = await execPS(`Get-ChildItem -Recurse -Filter ${pattern} | Select-Object -ExpandProperty Name`, surgeryPath);
            testFiles.push(...stdout.split('\n').filter(f => f.trim()));
        } catch(e) {}
    }
    
    testFiles = [...new Set(testFiles)];
    
    // Apply strategy
    if (strategy === 'chaos') {
        testFiles.sort(() => Math.random() - 0.5);
    } else if (strategy === 'weighted') {
        testFiles.sort((a, b) => a.length - b.length);
    }
    
    return { count: testFiles.length, strategy, tests: testFiles.slice(0, 5) };
}

// ============================================================
// API Endpoints
// ============================================================
app.get('/health', (req, res) => res.json({ 
    status: 'ELITE_UP', 
    version: ELITE_VERSION,
    blockchainHeight: blockchainBlocks.length,
    timestamp: new Date().toISOString()
}));

app.get('/metrics', (req, res) => res.json({
    totalSurgeries: surgeryRecords.length,
    activeSurgeries: activeSurgeries.size,
    blockchainHeight: blockchainBlocks.length,
    eliteVersion: ELITE_VERSION
}));

app.get('/api/blockchain', (req, res) => res.json(blockchainBlocks));

app.get('/api/surgery/records', (req, res) => res.json(surgeryRecords));

// Start surgery session
app.post('/api/surgery/start', async (req, res) => {
    const { repoUrl, branchName, keepAfterRepair, eliteConfig } = req.body;
    const sessionId = Date.now().toString();
    const session = new SurgerySession(sessionId, repoUrl, branchName, eliteConfig);
    session.keepAfterRepair = keepAfterRepair;
    
    surgeryRecords.unshift({ 
        id: sessionId, 
        repoName: session.repoName, 
        branchName, 
        status: 'running', 
        startTime: session.startTime,
        eliteMode: session.eliteConfig.dynamicShifting
    });
    activeSurgeries.set(sessionId, session);
    saveRecords();
    
    res.json({ success: true, sessionId });
});

// Clone repository
app.post('/api/surgery/clone', async (req, res) => {
    const { sessionId, repoUrl, branchName } = req.body;
    const session = activeSurgeries.get(sessionId);
    if (!session) return res.json({ success: false, error: 'Session not found' });
    
    try {
        if (!fs.existsSync(session.surgeryPath)) {
            fs.mkdirSync(session.surgeryPath, { recursive: true });
        }
        
        await execAsync(`git clone ${repoUrl} "${session.surgeryPath}"`);
        await execAsync(`cd "${session.surgeryPath}" && git checkout -b ${branchName} 2>/dev/null || git checkout ${branchName}`);
        
        session.addStep('📡 Clone', 'completed', `Cloned to ${session.surgeryPath}`);
        res.json({ success: true });
    } catch (error) {
        session.addStep('📡 Clone', 'failed', error.message);
        res.json({ success: false, error: error.message });
    }
});

// Run generic step
app.post('/api/surgery/step', async (req, res) => {
    const { sessionId, step, command } = req.body;
    const session = activeSurgeries.get(sessionId);
    if (!session) return res.json({ success: false, error: 'Session not found' });
    
    try {
        const { stdout } = await execPS(command, session.surgeryPath);
        session.addStep(step, 'completed', stdout.substring(0, 200));
        res.json({ success: true, output: stdout });
    } catch (error) {
        session.addStep(step, 'failed', error.message);
        res.json({ success: false, error: error.message });
    }
});

// Elite auto-repair (NEW)
app.post('/api/surgery/elite-repair', async (req, res) => {
    const { sessionId, shiftStrategy } = req.body;
    const session = activeSurgeries.get(sessionId);
    if (!session) return res.json({ success: false, error: 'Session not found' });
    
    const fixes = [];
    
    try {
        // Dynamic test shifting
        if (session.eliteConfig.dynamicShifting) {
            const shiftResult = await dynamicTestShifting(session.surgeryPath, shiftStrategy || 'adaptive');
            session.shiftMetrics = shiftResult;
            session.addStep('🔄 Dynamic Shift', 'completed', `${shiftResult.count} tests redistributed (${shiftResult.strategy})`);
            fixes.push(`Dynamic test shifting: ${shiftResult.count} tests`);
        }
        
        // Detect language
        const language = await detectLanguage(session.surgeryPath);
        session.language = language;
        session.addStep('🔍 Detection', 'completed', `Detected: ${language}`);
        fixes.push(`Detected language: ${language}`);
        
        // Create package.json if missing (Node.js)
        const pkgPath = path.join(session.surgeryPath, 'package.json');
        if (!fs.existsSync(pkgPath) && language === 'node') {
            const defaultPkg = {
                name: session.repoName,
                version: '1.0.0',
                scripts: {
                    build: 'tsc || echo "Build configured"',
                    test: 'node --test || echo "Tests configured"'
                },
                devDependencies: {
                    typescript: '^5.4.0',
                    '@types/node': '^20.0.0'
                }
            };
            fs.writeFileSync(pkgPath, JSON.stringify(defaultPkg, null, 2));
            fixes.push('✅ Created package.json');
        }
        
        // Create .gitignore if missing
        const gitignorePath = path.join(session.surgeryPath, '.gitignore');
        if (!fs.existsSync(gitignorePath)) {
            const gitignoreContent = `node_modules/\ndist/\n.env\n*.log\ncoverage/\n.DS_Store\noracle-memory.json\nblockchain/\n`;
            fs.writeFileSync(gitignorePath, gitignoreContent);
            fixes.push('✅ Created .gitignore');
        }
        
        // Install dependencies
        if (language === 'node') {
            await execPS('npm install', session.surgeryPath);
            fixes.push('✅ npm install completed');
            await execPS('npm run build', session.surgeryPath).catch(() => {});
            fixes.push('✅ Build attempted');
        }
        
        // Blockchain audit
        if (session.eliteConfig.blockchainAudit) {
            const auditHash = addToBlockchain('repair_completed', {
                sessionId: session.id,
                repo: session.repoName,
                fixes: fixes.length,
                shiftMetrics: session.shiftMetrics
            });
            session.auditHash = auditHash;
            session.addStep('⛓️ Blockchain', 'completed', `Hash: ${auditHash.substring(0, 16)}...`);
            fixes.push(`Blockchain recorded: ${auditHash.substring(0, 16)}...`);
        }
        
        session.hasChanges = fixes.length > 2;
        session.addStep('🔧 Elite Repair', 'completed', `${fixes.length} actions performed`);
        res.json({ success: true, fixes, shiftMetrics: session.shiftMetrics, auditHash: session.auditHash, hasChanges: session.hasChanges });
        
    } catch (error) {
        session.addStep('🔧 Elite Repair', 'failed', error.message);
        res.json({ success: false, error: error.message, fixes });
    }
});

// Commit changes
app.post('/api/surgery/commit', async (req, res) => {
    const { sessionId, commitMessage } = req.body;
    const session = activeSurgeries.get(sessionId);
    if (!session) return res.json({ success: false, error: 'Session not found' });
    
    try {
        const { stdout: statusOutput } = await execPS('git status --porcelain', session.surgeryPath);
        
        if (!statusOutput.trim()) {
            return res.json({ success: false, noChanges: true, error: 'No changes to commit' });
        }
        
        await execPS('git add .', session.surgeryPath);
        await execPS(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, session.surgeryPath);
        await execPS(`git push origin ${session.branchName} -f`, session.surgeryPath);
        
        session.addStep('💾 Commit', 'completed', `Pushed changes`);
        res.json({ success: true });
    } catch (error) {
        session.addStep('💾 Commit', 'failed', error.message);
        res.json({ success: false, error: error.message });
    }
});

// Create PR
app.post('/api/surgery/create-pr', async (req, res) => {
    const { sessionId, prTitle, prBody, baseBranch } = req.body;
    const session = activeSurgeries.get(sessionId);
    if (!session) return res.json({ success: false, error: 'Session not found' });
    
    try {
        const blockchainNote = session.auditHash ? `\n\n⛓️ **Blockchain Audit Hash:** \`${session.auditHash}\`` : '';
        const fullBody = prBody + blockchainNote;
        
        const { stdout } = await execPS(`gh pr create --title "${prTitle.replace(/"/g, '\\"')}" --body "${fullBody.replace(/"/g, '\\"')}" --base ${baseBranch || 'main'} --head ${session.branchName} 2>&1`, session.surgeryPath);
        
        const prMatch = stdout.match(/\/pull\/(\d+)/);
        const prNumber = prMatch ? prMatch[1] : 'unknown';
        
        session.addStep('📝 PR', 'completed', `PR #${prNumber} created`);
        session.complete(true, prNumber, stdout);
        
        if (!session.keepAfterRepair && fs.existsSync(session.surgeryPath)) {
            try { fs.rmSync(session.surgeryPath, { recursive: true, force: true }); } catch(e) {}
        }
        
        res.json({ success: true, prNumber, prUrl: stdout });
    } catch (error) {
        session.addStep('📝 PR', 'failed', error.message);
        session.complete(false);
        res.json({ success: false, error: error.message });
    } finally {
        activeSurgeries.delete(sessionId);
    }
});

// Legacy autofix (for backward compatibility)
app.post('/api/surgery/autofix', async (req, res) => {
    const { sessionId } = req.body;
    const session = activeSurgeries.get(sessionId);
    if (!session) return res.json({ success: false, error: 'Session not found' });
    
    // Redirect to elite-repair
    const result = await fetch(`http://localhost:${PORT}/api/surgery/elite-repair`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ sessionId, shiftStrategy: 'adaptive' })
    });
    const data = await result.json();
    res.json(data);
});

// ============================================================
// WebSocket
// ============================================================
io.on('connection', (socket) => { 
    console.log('🔌 Elite client connected'); 
    socket.emit('connected', { status: 'elite', version: ELITE_VERSION });
});

// ============================================================
// Start Server
// ============================================================
const PORT = process.env.PORT || 3001;
server.listen(PORT, () => {
    console.log(`\n╔══════════════════════════════════════════════════════════════╗`);
    console.log(`║  🏥 ATOMIC SWARM GODS ELITE v${ELITE_VERSION} - SURGERY ROOM       ║`);
    console.log(`╚══════════════════════════════════════════════════════════════╝`);
    console.log(`\n🌐 Server: http://localhost:${PORT}`);
    console.log(`📊 Dashboard: http://localhost:${PORT}/dashboard.html`);
    console.log(`📁 Surgery Base: ${SURGERY_BASE}`);
    console.log(`⛓️ Blockchain: ${BLOCKCHAIN_DIR} (${blockchainBlocks.length} blocks)`);
    console.log(`\n✨ Elite Features: Dynamic Shifting | Blockchain Audit | Self-Healing\n`);
});