Projektarbeit-MYP/frontend/debug-server/src/app.js

const express = require('express');
const fs = require('fs');
const path = require('path');
const axios = require('axios');
const os = require('os');
const { execSync } = require('child_process');

const app = express();
const PORT = process.env.PORT || 8081;

// Konfigurationsdatei
const CONFIG_FILE = path.join(__dirname, '../../../.env.local');
const DEFAULT_BACKEND_URL = 'https://raspberrypi';

// Middleware
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(express.static(path.join(__dirname, '../public')));
app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, '../public/views'));

// Hilfsfunktionen
function getBackendUrl() {
    try {
        if (fs.existsSync(CONFIG_FILE)) {
            const content = fs.readFileSync(CONFIG_FILE, 'utf8');
            const match = content.match(/NEXT_PUBLIC_API_URL=(.+)/);
            if (match && match[1]) {
                return match[1].trim();
            }
        }
    } catch (error) {
        console.error('Fehler beim Lesen der Backend-URL:', error);
    }
    return DEFAULT_BACKEND_URL;
}

function setBackendUrl(url) {
    try {
        let content = '';
        
        if (fs.existsSync(CONFIG_FILE)) {
            content = fs.readFileSync(CONFIG_FILE, 'utf8');
            // Ersetze die URL, wenn sie bereits existiert
            if (content.match(/NEXT_PUBLIC_API_URL=.+/)) {
                content = content.replace(/NEXT_PUBLIC_API_URL=.+/, `NEXT_PUBLIC_API_URL=${url}`);
            } else {
                // Füge die URL hinzu, wenn sie nicht existiert
                content += `\nNEXT_PUBLIC_API_URL=${url}`;
            }
        } else {
            // Erstelle eine neue Datei mit der URL
            content = `NEXT_PUBLIC_API_URL=${url}`;
        }
        
        fs.writeFileSync(CONFIG_FILE, content, 'utf8');
        return true;
    } catch (error) {
        console.error('Fehler beim Speichern der Backend-URL:', error);
        return false;
    }
}

function getNetworkInterfaces() {
    const interfaces = [];
    const networkInterfaces = os.networkInterfaces();
    
    for (const [name, netInterface] of Object.entries(networkInterfaces)) {
        if (name.startsWith('lo') || name.startsWith('docker') || name.startsWith('br-')) {
            continue;
        }
        
        for (const iface of netInterface) {
            if (iface.family === 'IPv4' || iface.family === 4) {
                interfaces.push({
                    name: name,
                    address: iface.address
                });
                break;
            }
        }
    }
    
    return interfaces;
}

function pingHost(host) {
    try {
        const platform = process.platform;
        const cmd = platform === 'win32' ? 
            `ping -n 1 -w 1000 ${host}` :
            `ping -c 1 -W 1 ${host}`;
            
        execSync(cmd, { stdio: 'ignore' });
        return true;
    } catch (error) {
        return false;
    }
}

async function testBackendConnection(url) {
    try {
        const response = await axios.get(`${url}/api/test`, { timeout: 3000 });
        return response.status === 200;
    } catch (error) {
        return false;
    }
}

// Routen
app.get('/', async (req, res) => {
    const backendUrl = getBackendUrl();
    const interfaces = getNetworkInterfaces();
    
    // Analysiere die URL, um Host und Port zu extrahieren
    let backendHost = '';
    let backendPort = '';
    
    try {
        const url = new URL(backendUrl);
        backendHost = url.hostname;
        backendPort = url.port || (url.protocol === 'https:' ? '443' : '80');
    } catch (error) {
        console.error('Ungültige Backend-URL:', error);
    }
    
    // Prüfe Backend-Verbindung
    let backendStatus = 'Unbekannt';
    let pingStatus = false;
    
    if (backendHost) {
        pingStatus = pingHost(backendHost);
        
        if (pingStatus) {
            try {
                const connectionStatus = await testBackendConnection(backendUrl);
                backendStatus = connectionStatus ? 'Verbunden' : 'Keine API-Verbindung';
            } catch (error) {
                backendStatus = 'Verbindungsfehler';
            }
        } else {
            backendStatus = 'Nicht erreichbar';
        }
    }
    
    res.render('index', {
        title: 'MYP Frontend Debug',
        backendUrl,
        backendHost,
        backendPort,
        backendStatus,
        pingStatus,
        interfaces,
        lastCheck: new Date().toLocaleString('de-DE')
    });
});

app.post('/update-backend', async (req, res) => {
    const { backendUrl } = req.body;
    
    if (!backendUrl) {
        return res.json({ success: false, message: 'Keine Backend-URL angegeben' });
    }
    
    // Validiere URL
    try {
        new URL(backendUrl);
    } catch (error) {
        return res.json({ success: false, message: 'Ungültige URL' });
    }
    
    // Speichere die URL
    const saved = setBackendUrl(backendUrl);
    
    if (!saved) {
        return res.json({ success: false, message: 'Fehler beim Speichern der URL' });
    }
    
    // Teste die Verbindung zum Backend
    let connectionStatus = false;
    
    try {
        connectionStatus = await testBackendConnection(backendUrl);
    } catch (error) {
        // Ignoriere Fehler
    }
    
    return res.json({ 
        success: true, 
        message: 'Backend-URL erfolgreich aktualisiert',
        connection: connectionStatus
    });
});

app.post('/test-backend', async (req, res) => {
    const { backendUrl } = req.body;
    
    if (!backendUrl) {
        return res.json({ success: false, message: 'Keine Backend-URL angegeben' });
    }
    
    // Validiere URL
    let hostname = '';
    try {
        const url = new URL(backendUrl);
        hostname = url.hostname;
    } catch (error) {
        return res.json({ success: false, message: 'Ungültige URL' });
    }
    
    // Teste Ping
    const pingStatus = pingHost(hostname);
    
    // Teste API-Verbindung
    let connectionStatus = false;
    
    if (pingStatus) {
        try {
            connectionStatus = await testBackendConnection(backendUrl);
        } catch (error) {
            // Ignoriere Fehler
        }
    }
    
    return res.json({
        success: true,
        ping: pingStatus,
        connection: connectionStatus
    });
});

// Server starten
app.listen(PORT, () => {
    console.log(`MYP Frontend Debug Server läuft auf Port ${PORT}`);
});