telegram_server_monitoring/server_monitor_bot.js

const TelegramBot = require('node-telegram-bot-api');
const ping = require('ping');
const os = require('os');
const fs = require('fs');
const yaml = require('js-yaml');
require('dotenv').config();
const serverNotificationState = {};
const logDirectory = 'logs/';
let usersAddingServer = {};
let isShowingDetails = false;
const botStartTime = new Date();


const developerChatIds = process.env.DEVELOPER_CHAT_IDS.split(',');
const token = process.env.TELEGRAM_BOT_TOKEN;
const tgId = process.env.TG_ID;
const bot = new TelegramBot(token, { polling: true });


if (!tgId) {
    const errorMessage = 'Fehler: TG_ID-Umgebungsvariable nicht festgelegt. Der Bot wird nicht gestartet.';
    console.error(errorMessage);
    sendErrorNotification(developerChatIds[0], errorMessage);
    process.exit(1);
}


if (tgId !== '5507179337') {
    const errorMessage = 'Fehler: Der Bot wird nicht gestartet.';
    console.error(errorMessage);
    sendErrorNotification(developerChatIds[0], errorMessage);
    process.exit(1);
}


function isDeveloperChat(chatId) {
    return developerChatIds.includes(chatId.toString());
}

const activeUserIds = new Set();

const monitoredServers = [];

// Lese die Konfigurationsdatei
try {
    const configContent = fs.readFileSync('configurations.yml', 'utf8');
    const config = yaml.load(configContent);

    // Überprüfe, ob es eine Server-Konfiguration gibt
    if (config) {
        // Füge die überwachten Server zur Liste hinzu
        Object.values(config).forEach(serverList => {
            monitoredServers.push(...serverList);
        });
    }
} catch (error) {
    console.error('Fehler beim Lesen der Konfigurationsdatei:', error.message);
}

// Event-Handler für den Befehl /stats
bot.onText(/\/stats/, (msg) => {
    const chatId = msg.chat.id;

    if (isDeveloperChat(chatId)) {
        if (!activeUserIds.has(chatId)) {
            activeUserIds.add(chatId);
        }

        try {
            // Gesamtanzahl der überwachten Server
            const serverCount = getServerCount(); // Funktion, die die Anzahl der überwachten Server zurückgibt

            // Anzahl der Fehler im error.log
            const errorCount = getErrorCount(); // Funktion, die die Anzahl der Fehler im error.log zurückgibt

            // Bot Uptime in Stunden
            const uptime = getBotUptime(); // Funktion, die die Bot-Uptime in Stunden zurückgibt

            // Anzahl der Benutzer, die diesen Bot nutzen
            const totalUserCount = getTotalUserCount();

            // Version des Telegram Bot API-Pakets
            const telegramBotApiVersion = getTelegramBotApiVersion();

             // Nachricht mit den Statistiken senden
            bot.sendMessage(chatId, `
            *Statistik*
Gesamtanzahl der überwachten Server: ${serverCount}
Anzahl der Fehler im error.log: ${errorCount}
Bot Uptime: ${uptime.days} Tage, ${uptime.hours} Stunden und ${uptime.minutes} Minuten
Anzahl der Benutzer: ${totalUserCount}
Telegram Bot API-Version: ${telegramBotApiVersion}
            `);
        } catch (error) {
            console.error('Fehler beim Abrufen der Statistiken:', error.message);
            bot.sendMessage(chatId, 'Fehler beim Abrufen der Statistiken. Bitte versuche es später erneut.');
        }
    } else {
        bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler');
    }
});

// Funktion, um die Anzahl der überwachten Server zu erhalten
function getServerCount() {
    return monitoredServers.length;
}

// Funktion, um die Anzahl der Fehler im error.log zu erhalten
function getErrorCount() {
    try {
        const errorLogContent = fs.readFileSync('error.log', 'utf8');
        const errorLines = errorLogContent.split('\n');
        return errorLines.length;
    } catch (error) {
        console.error('Fehler beim Lesen der error.log-Datei:', error.message);
        return 'Fehler beim Lesen der Log-Datei';
    }
}

// Funktion, um die Bot-Uptime in Tagen, Stunden und Minuten zu erhalten
function getBotUptime() {
    const uptimeMilliseconds = new Date() - botStartTime; // botStartTime sollte irgendwo definiert und beim Bot-Start festgelegt sein

    // Berechne Tage, Stunden und Minuten
    const days = Math.floor(uptimeMilliseconds / (1000 * 60 * 60 * 24));
    const hours = Math.floor((uptimeMilliseconds % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
    const minutes = Math.floor((uptimeMilliseconds % (1000 * 60 * 60)) / (1000 * 60));

    return { days, hours, minutes };
}


// Pfad zur user_information.yml
const userInformationPath = 'user_information.yml';

// Funktion, um die Gesamtanzahl der Benutzer-IDs in der user_information.yml zu erhalten
function getTotalUserCount() {
    try {
        // Lese den Inhalt der Datei
        const userInformationContent = fs.readFileSync(userInformationPath, 'utf8');

        // Parsen des YAML-Inhalts
        const userInformation = yaml.load(userInformationContent);

        // Prüfe, ob die Benutzerinformation ein Objekt ist
        if (typeof userInformation === 'object' && userInformation !== null) {
            // Zähle die Gesamtanzahl der Benutzer-IDs
            const totalUserCount = Object.keys(userInformation).length;
            return `${totalUserCount}`;
        } else {
            console.error('Ungültiges Format der Benutzerinformation.');
            return 'Fehler bei der Verarbeitung der Benutzerinformation';
        }
    } catch (error) {
        console.error('Fehler beim Lesen der Benutzerinformation:', error.message);
        return 'Fehler beim Lesen der Benutzerinformation';
    }
}

// Beispielaufruf
console.log(getTotalUserCount());

            // Funktion, um die Version des Telegram Bot API-Pakets zu erhalten
function getTelegramBotApiVersion() {
    try {
        // Lese den Inhalt der package.json-Datei
        const packageJsonContent = fs.readFileSync('package.json', 'utf8');

        // Parsen des JSON-Inhalts
        const packageJson = JSON.parse(packageJsonContent);

        // Gib die Version des Telegram Bot API-Pakets zurück
        return packageJson.dependencies['node-telegram-bot-api'];
    } catch (error) {
        console.error('Fehler beim Lesen der package.json-Datei:', error.message);
        return 'Fehler beim Lesen der package.json-Datei';
    }
}

// Funktion zum Speichern von Benutzerinformationen
function saveUserInformation(userId, username) {
    try {
        let userInformation = {};

        if (fs.existsSync(userInformationPath)) {
            const data = fs.readFileSync(userInformationPath, 'utf8');
            userInformation = yaml.load(data) || {};
        }

        userInformation[`user${userId}`] = {
            id: userId,
            name: username
        };

        const yamlString = yaml.dump(userInformation);
        fs.writeFileSync(userInformationPath, yamlString, 'utf8');
    } catch (error) {
        console.error('Fehler beim Speichern von Benutzerinformationen:', error.message);
    }
}

// Funktion zum Initialisieren beim Start des Bots
function initialize() {
    // Stelle sicher, dass die Datei existiert oder erstelle sie
    const userInformationPath = 'user_information.yml';

    if (!fs.existsSync(userInformationPath)) {
        fs.writeFileSync(userInformationPath, '', 'utf8');
    }
}

// Rufe die Initialisierungsfunktion auf
initialize();

bot.onText(/\/user_id/, (msg) => {
    const chatId = msg.chat.id;

    // Überprüfen, ob der Benutzer Entwickler ist
    if (!isDeveloperChat(chatId)) {
        bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler.');
        return;
    }

    try {
        // Lade Benutzerinformationen aus der user_information.yml-Datei
        const userInformation = loadUserInformation();

        // Überprüfen, ob Benutzerinformationen vorhanden sind
        if (Object.keys(userInformation).length === 0) {
            bot.sendMessage(chatId, 'Keine Benutzerinformationen gefunden.');
            return;
        }

        // Konvertiere Benutzerinformationen in eine Liste von Benutzernamen und IDs
        const userList = Object.keys(userInformation).map(key => {
            const user = userInformation[key];
            return `${user.name} - ${user.id}`;
        });

        // Sende die Liste der Benutzerinformationen
        bot.sendMessage(chatId, 'Benutzerinformationen:\n' + userList.join('\n'));
    } catch (error) {
        console.error('Fehler beim Abrufen von Benutzerinformationen:', error.message);
        bot.sendMessage(chatId, 'Fehler beim Abrufen von Benutzerinformationen.');
    }
});

function loadUserInformation() {
    try {
        const userInformationPath = './user_information.yml';
        const data = fs.readFileSync(userInformationPath, 'utf8');
        return yaml.load(data) || {};
    } catch (error) {
        console.error('Fehler beim Laden der Benutzerinformationen:', error.message);
        return {};
    }
}

// Event-Handler für das Hinzufügen und Entfernen von Benutzern
bot.on('message', (msg) => {
    const chatId = msg.chat.id;
    const userId = msg.from.id;

    // Überprüfe, ob die Benutzer-ID bereits gespeichert wurde
    if (!activeUserIds.has(chatId)) {
        activeUserIds.add(chatId);

        // Speichere Benutzerinformationen
        saveUserInformation(userId.toString(), `@${msg.from.username}`);
    }

    if (!activeUserIds.has(chatId)) {
        activeUserIds.add(chatId);
    }
});

bot.on('polling_error', (error) => {
    console.error(`Polling error: ${error.message}`);
});

function escapeMarkdown(text) {
    
    return text.replace(/[_*[\]()~`>#+-=|{}.!]/g, '\\$&');
}

function getBotInfo() {
    const botInfo = {
        name: 'Server Monitoring',
        version: '1.0.0',
        author: 'M_Viper',
        license: 'MIT',
    };
    

    const infoMessage = `
Bot Information:
- *Name:* ${escapeMarkdown(botInfo.name)}
- *Version:* ${escapeMarkdown(botInfo.version)}
- *Author:* ${escapeMarkdown(botInfo.author)}
- *License:* ${escapeMarkdown(botInfo.license)}
Bot wurde am 22.01.2024 erstellt.
    `;

    console.log(infoMessage);

    return infoMessage;
}

bot.onText(/\/user_id (.+)/, (msg, match) => {
    const chatId = msg.chat.id;

    // Überprüfen, ob der Benutzer Entwickler ist
    if (!isDeveloperChat(chatId)) {
        bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler.');
        return;
    }

    const targetUsername = match[1];

    // Überprüfen, ob der Benutzer existiert
    bot.getChat(targetUsername)
        .then(user => {
            const userId = user.id;
            bot.sendMessage(chatId, `Die ID des Benutzers @${targetUsername} ist: ${userId}`);
        })
        .catch(error => {
            bot.sendMessage(chatId, `Der Benutzer @${targetUsername} existiert nicht.`);
        });
});

bot.onText(/\/user_delete (.+)/, (msg, match) => {
    const chatId = msg.chat.id;

    // Überprüfen, ob der Benutzer Entwickler ist
    if (!isDeveloperChat(chatId)) {
        bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler.');
        return;
    }

    const targetUserId = match[1];

    // Überprüfen, ob der Benutzer existiert und Server hinzugefügt hat
    if (!targetUserId || !userServerConfigurations[targetUserId]) {
        bot.sendMessage(chatId, `Der Benutzer mit ID ${targetUserId} existiert nicht oder hat keine Server hinzugefügt.`);
        return;
    }

    // Lösche alle Server des Zielbenutzers
    delete userServerConfigurations[targetUserId];
    saveConfigurations(userServerConfigurations);

    bot.sendMessage(chatId, `Alle Server des Benutzers mit ID ${targetUserId} wurden gelöscht.`);
});

bot.onText(/\/info/, (msg) => {
    const chatId = msg.chat.id;
    const infoMessage = getBotInfo();

    const options = {
        parse_mode: 'Markdown',
    };

    bot.sendMessage(chatId, infoMessage, options);
});

// Füge diese Funktion hinzu, um Fehlerbenachrichtigungen und das Protokoll zu handhaben
bot.on('polling_error', (error) => {
    console.error(`Polling error: ${error.message}`);
    sendErrorNotification(developerChatId, `Polling error: ${error.message}`);
});

process.on('unhandledRejection', (reason, promise) => {
    console.error('Unhandled rejection:', reason);
    sendErrorNotification(developerChatId, `Unhandled rejection: ${reason}`);
});

process.on('uncaughtException', (error) => {
    console.error('Uncaught exception:', error);
    sendErrorNotification(developerChatId, `Uncaught exception: ${error}`);
});

// Füge diese Funktion hinzu, um Fehlerbenachrichtigungen und das Protokoll zu handhaben
bot.on('polling_error', (error) => {
    console.error(`Polling error: ${error.message}`);
    sendErrorNotification(developerChatId, `Polling error: ${error.message}`);
});

process.on('unhandledRejection', (reason, promise) => {
    console.error('Unhandled rejection:', reason);
    sendErrorNotification(developerChatId, `Unhandled rejection: ${reason}`);
});

process.on('uncaughtException', (error) => {
    console.error('Uncaught exception:', error);
    sendErrorNotification(developerChatId, `Uncaught exception: ${error}`);
});

// Funktion zum Senden von Fehlerbenachrichtigungen und Erstellen des Fehlerprotokolls
function sendErrorNotification(chatId, errorMessage) {
    const errorNotification = `❗️ *Fehler im Bot:*\n\n\`\`\`${errorMessage}\`\`\``;

    bot.sendMessage(chatId, errorNotification, { parse_mode: 'Markdown' });

    // Fehlerprotokoll erstellen
    const logFilePath = 'error.log';
    const formattedDate = new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '');
    const logEntry = `[${formattedDate}] ${errorMessage}\n`;

    fs.appendFile(logFilePath, logEntry, (err) => {
        if (err) {
            console.error(`Fehler beim Schreiben in das Fehlerprotokoll: ${err.message}`);
        }
    });
}

const errorLogPath = 'error.log';
fs.openSync(errorLogPath, 'a');

bot.onText(/\/error/, (msg) => {
    const chatId = msg.chat.id;

    // Überprüfen, ob die Chat-ID des Benutzers in den Developer-Chat-IDs enthalten ist
    if (!isDeveloperChat(chatId)) {
        bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler');
        return;
    }

    try {
        const logFileName = 'error.log';
        const logFilePath = logDirectory + logFileName;

        if (fs.existsSync(logFilePath)) {
            const logContent = fs.readFileSync(logFilePath, 'utf8');
            const logEntries = logContent.split('\n').filter(entry => entry.trim() !== '').slice(-8);

            if (logEntries.length > 0) {
                const logMessage = `Die letzten 8 Fehlerprotokolle:\n\n${logEntries.join('\n')}`;
                bot.sendMessage(chatId, logMessage);
            } else {
                bot.sendMessage(chatId, 'Keine Fehlerprotokolle vorhanden.');
            }
        } else {
            bot.sendMessage(chatId, 'Kein Fehlerprotokoll vorhanden. Es wurden noch keine Fehler protokolliert.');
        }
    } catch (error) {
        console.error(`Fehler beim Lesen des Fehlerprotokolls: ${error.message}`);
        bot.sendMessage(chatId, 'Fehler beim Lesen des Fehlerprotokolls.');
    }
});


function createLogEntry(action, serverName, serverAddress) {
    const currentDate = new Date();
    const formattedDate = currentDate.toISOString().replace(/T/, ' ').replace(/\..+/, '');

    const logEntry = `[${formattedDate}] Action: ${action}, Server Name: ${serverName}, Server Address: ${serverAddress}\n`;

    return logEntry;
}

function writeToLog(userId, logEntry) {
    const logFileName = `user_${userId}_log.txt`;
    const logFilePath = logDirectory + logFileName;

    try {
        if (!fs.existsSync(logDirectory)) {
            fs.mkdirSync(logDirectory);
        }

        // Lese vorhandene Logeinträge
        let existingLogEntries = [];
        if (fs.existsSync(logFilePath)) {
            const existingLogContent = fs.readFileSync(logFilePath, 'utf8');
            existingLogEntries = existingLogContent.split('\n').filter(entry => entry.trim() !== '');
        }

        // Füge neuen Eintrag hinzu
        existingLogEntries.push(logEntry);

        // Entferne Einträge älter als 7 Tage
        const currentTime = Date.now();
        const sevenDaysAgo = currentTime - 7 * 24 * 60 * 60 * 1000;
        existingLogEntries = existingLogEntries.filter(entry => {
            const entryTimestamp = new Date(entry.split(']')[0].replace('[', '')).getTime();
            return entryTimestamp >= sevenDaysAgo;
        });

        // Schreibe die neuen Logeinträge
        fs.writeFileSync(logFilePath, existingLogEntries.join('\n'), 'utf8');
    } catch (error) {
        console.error(`Fehler beim Schreiben des Logs: ${error.message}`);
    }
}

let userServerConfigurations = loadConfigurations();
const chatIds = new Set();

function loadConfigurations() {
    try {
        if (fs.existsSync('configurations.yml')) {
            const data = fs.readFileSync('configurations.yml', 'utf8');
            return yaml.load(data) || {};
        } else {
            saveConfigurations({});
            return {};
        }
    } catch (error) {
        console.error('Fehler beim Laden der Konfigurationen:', error.message);
        return {};
    }
}

function saveConfigurations(configurations) {
    try {
        const yamlString = yaml.dump(configurations);
        fs.writeFileSync('configurations.yml', yamlString, 'utf8');
    } catch (error) {
        console.error('Fehler beim Speichern der Konfigurationen:', error.message);
    }
}

function getCpuUsage() {
    return Math.floor(Math.random() * 101);
}

function getRamUsage() {
    return Math.floor(Math.random() * 101);
}

function getNetworkTraffic() {
    return Math.floor(Math.random() * 101);
}

async function getUptime() {
    const uptimeInSeconds = os.uptime();
    const days = Math.floor(uptimeInSeconds / (24 * 3600));
    const hours = Math.floor((uptimeInSeconds % (24 * 3600)) / 3600);
    const minutes = Math.floor((uptimeInSeconds % 3600) / 60);
    return `${days} Tage, ${hours} Stunden, ${minutes} Minuten`;
}

async function checkServerStatus(serverAddress) {
    try {
        const result = await ping.promise.probe(serverAddress);
        return result.alive ? 'Online' : 'Offline';
    } catch (error) {
        console.error(`Fehler beim Überprüfen des Servers ${serverAddress}: ${error.message}`);
        return 'Fehler';
    }
}

const onlineIcon = '✅';
const offlineIcon = '❌';
const errorIcon = '⚠️';
const bannerEmoji = '🚀';





function sendStatusMessage(chatId, serverName, serverStatus) {
    const statusIcon = serverStatus === 'Online' ? onlineIcon : offlineStatus === 'Offline' ? offlineIcon : errorIcon;

    const statusMessage = `Server ${bannerEmoji}${serverName}${bannerEmoji} ist ${statusIcon} ${serverStatus}.`;

    bot.sendMessage(chatId, statusMessage);
}

bot.onText(/\/uptime/, async (msg) => {
    const chatId = msg.chat.id;
    const uptime = await getUptime();
    bot.sendMessage(chatId, `Bot Uptime: ${uptime}`);
});

bot.onText(/\/start/, (msg) => {
    const chatId = msg.chat.id;

    // Überprüfen, ob der Befehl /start_notifications verwendet wurde
    if (!msg.text.includes('/start_notifications')) {
        // Senden Sie die Nachricht nur, wenn der Befehl /start_notifications nicht verwendet wurde
        bot.sendMessage(chatId, 'Bot gestartet. Benutze /add_server, /delete_server, /status und /help für die Serververwaltung.');
    }

    chatIds.add(chatId);
});

bot.onText(/\/start_notifications/, (msg) => {
    const chatId = msg.chat.id;
    startNotifications(chatId);
});

function startNotifications(chatId) {
    const userServers = userServerConfigurations[chatId] || [];

    if (userServers.length === 0) {
        bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
        return;
    }

    userServers.forEach(serverConfig => {
        const serverAddress = serverConfig.address;
        serverNotificationState[serverAddress] = true;
    });

    bot.sendMessage(chatId, 'Benachrichtigungen für alle Server wurden aktiviert.');
}

bot.onText(/\/stop_notifications/, (msg) => {
    const chatId = msg.chat.id;
    stopNotifications(chatId);
});

function stopNotifications(chatId) {
    const userServers = userServerConfigurations[chatId] || [];

    if (userServers.length === 0) {
        bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
        return;
    }

    userServers.forEach(serverConfig => {
        const serverAddress = serverConfig.address;
        serverNotificationState[serverAddress] = false;
    });

    bot.sendMessage(chatId, 'Benachrichtigungen für alle Server wurden deaktiviert.');
}

bot.onText(/\/status/, async (msg) => {
    const chatId = msg.chat.id;
    const userServers = userServerConfigurations[chatId] || [];

    if (userServers.length === 0) {
        bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
        return;
    }

    let statusMessage = 'Server Status:\n';

    for (const serverConfig of userServers) {
        const serverName = serverConfig.name;
        const serverAddress = serverConfig.address;

        try {
            const serverStatus = await checkServerStatus(serverAddress);

            const statusIcon = serverStatus === 'Online' ? '✅' : serverStatus === 'Offline' ? '❌' : '⚠️';
            const notificationEnabled = serverNotificationState[serverAddress];

            statusMessage += `
*Server:* ${bannerEmoji}${serverName}${bannerEmoji} ${statusIcon} ${serverStatus}
*Benachrichtigungen:* ${notificationEnabled ? 'Aktiviert' : 'Deaktiviert'}
\n`;
        } catch (error) {
            console.error(`Fehler beim Überprüfen des Servers ${serverName}: ${error.message}`);
            statusMessage += `Fehler beim Überprüfen des Servers ${bannerEmoji}${serverName}${bannerEmoji}. ${errorIcon}\n`;
        }
    }

    // Füge hier den Benachrichtigungsstatus direkt unterhalb der Serverliste hinzu
    const notificationStatusMessage = 'Benachrichtigungen für alle Server sind ' +
        (Object.values(serverNotificationState).every((status) => status) ? 'aktiviert.' : 'deaktiviert.');

    statusMessage += `\n${notificationStatusMessage}`;

    const options = {
        parse_mode: 'Markdown',
        reply_markup: {
            inline_keyboard: [
                [{
                    text: 'Details',
                    callback_data: 'details'
                }]
            ]
        }
    };

    bot.sendMessage(chatId, statusMessage, options);
});

bot.onText(/\/add_server/, (msg) => {
    const chatId = msg.chat.id;

    bot.sendMessage(chatId, 'Füge einen neuen Server hinzu. Sende mir zuerst den Namen des Servers:');

    // Verwendung der Variable usersAddingServer
    usersAddingServer[chatId] = { name: null, address: null };

    bot.once('text', (serverNameMsg) => {
        usersAddingServer[chatId].name = serverNameMsg.text;

        bot.sendMessage(chatId, `Servername ${bannerEmoji}${serverNameMsg.text}${bannerEmoji} wurde hinzugefügt. Jetzt sende mir die IP-Adresse des Servers:`);

        bot.once('text', (serverAddressMsg) => {
            usersAddingServer[chatId].address = serverAddressMsg.text;

            userServerConfigurations[chatId] = userServerConfigurations[chatId] || [];
            userServerConfigurations[chatId].push(usersAddingServer[chatId]);

            saveConfigurations(userServerConfigurations);

            const logEntry = createLogEntry('Add Server', usersAddingServer[chatId].name, usersAddingServer[chatId].address);
            writeToLog(chatId, logEntry);

            bot.sendMessage(chatId, `Server ${bannerEmoji}${usersAddingServer[chatId].name}${bannerEmoji} mit Adresse "${usersAddingServer[chatId].address}" wurde hinzugefügt.`);
        });
    });
});

bot.onText(/\/delete_server/, (msg) => {
    const chatId = msg.chat.id;
    const userServers = userServerConfigurations[chatId] || [];

    if (userServers.length === 0) {
        bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
        return;
    }

    const keyboard = {
        reply_markup: {
            inline_keyboard: userServers.map(server => [{
                text: `${server.name} - ${server.address}`,
                callback_data: `delete:${server.name}:${server.address}`
            }])
        }
    };

    bot.sendMessage(chatId, 'Wähle einen Server zum Löschen aus:', keyboard);
});

bot.on('callback_query', (query) => {
    const chatId = query.message.chat.id;
    const [action, serverName, serverAddress] = query.data.split(':');

    if (action === 'delete') {
        userServerConfigurations[chatId] = (userServerConfigurations[chatId] || []).filter(server => !(server.name === serverName && server.address === serverAddress));

        saveConfigurations(userServerConfigurations);

        const logEntry = createLogEntry('Delete Server', serverName, serverAddress);
        writeToLog(chatId, logEntry);

        bot.answerCallbackQuery({ callback_query_id: query.id, text: `Server ${bannerEmoji}${serverName}${bannerEmoji} mit Adresse "${serverAddress}" wurde gelöscht.` });
    } else if (action === 'stop_notifications') {
        if (serverAddress) {
            serverNotificationState[serverAddress] = false;

            const logEntry = createLogEntry('Stop Notifications', '', serverAddress);
            writeToLog(chatId, logEntry);

            bot.answerCallbackQuery({ callback_query_id: query.id, text: `Benachrichtigungen für Server mit Adresse "${serverAddress}" gestoppt.` });
        } else {
            console.error('Ungültige Anfrage: serverAddress ist undefined.');
            bot.answerCallbackQuery({ callback_query_id: query.id, text: 'Fehler: Server-Adresse ist undefiniert.' });
        }
    } else if (action === 'details_server') {
        showServerDetails(chatId, serverName, serverAddress);
    }
});

bot.onText(/\/log/, (msg) => {
    const chatId = msg.chat.id;

    try {
        const logFileName = `user_${chatId}_log.txt`;
        const logFilePath = logDirectory + logFileName;

        if (fs.existsSync(logFilePath)) {
            const logContent = fs.readFileSync(logFilePath, 'utf8');
            const logEntries = logContent.split('\n').filter(entry => entry.trim() !== '').slice(-8);

            if (logEntries.length > 0) {
                const logMessage = `Die letzten 8 Logeinträge:\n\n${logEntries.join('\n')}`;
                bot.sendMessage(chatId, logMessage);
            } else {
                bot.sendMessage(chatId, 'Keine Logeinträge vorhanden.');
            }
        } else {
            bot.sendMessage(chatId, 'Keine Logdatei vorhanden. Führen Sie zuerst Aktionen durch, um Logeinträge zu generieren.');
        }
    } catch (error) {
        console.error(`Fehler beim Lesen des Logs: ${error.message}`);
        bot.sendMessage(chatId, 'Fehler beim Lesen des Logs.');
    }
});

bot.onText(/\/save_log/, (msg) => {
    console.log('In /save_log');
    const chatId = msg.chat.id;

    try {
        const logFileName = `user_${chatId}_log.txt`;
        const logFilePath = logDirectory + logFileName;

        if (fs.existsSync(logFilePath)) {
            // Hier direkt den Dateipfad zur Logdatei verwenden
            bot.sendDocument(chatId, logFilePath, { caption: 'Hier ist Ihre Logdatei.' });
        } else {
            bot.sendMessage(chatId, 'Keine Logdatei vorhanden. Führen Sie zuerst Aktionen durch, um Logeinträge zu generieren.');
        }
    } catch (error) {
        console.error(`Fehler beim Lesen des Logs: ${error.message}`);
        bot.sendMessage(chatId, 'Fehler beim Lesen des Logs.');
    }
});

function sendStatusNotification(chatId, serverName, serverStatus, serverAddress) {
    const statusIcon = serverStatus === 'Online' ? onlineIcon : serverStatus === 'Offline' ? offlineIcon : errorIcon;

    const inlineKeyboard = [[
        {
            text: 'Details anzeigen',
            callback_data: `details_server:${serverName}:${serverAddress}`
        },
        
    ]];

    const options = {
        parse_mode: 'Markdown',
        reply_markup: {
            inline_keyboard: inlineKeyboard
        }
    };

    const notificationMessage = `Server ${bannerEmoji}${serverName}${bannerEmoji} ist ${statusIcon} ${serverStatus}. Benachrichtigungen aktiviert.`;

    bot.sendMessage(chatId, notificationMessage, options);
}

function stopNotifications(chatId) {
    const userServers = userServerConfigurations[chatId] || [];

    if (userServers.length === 0) {
        bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
        return;
    }

    userServers.forEach(serverConfig => {
        const serverAddress = serverConfig.address;
        serverNotificationState[serverAddress] = false;
    });

    bot.sendMessage(chatId, 'Benachrichtigungen für alle Server wurden deaktiviert.');
}

async function showServerDetails(chatId, serverName, serverAddress) {
    console.log(`showServerDetails called for ${serverName}`);

    if (isShowingDetails) {
        console.log('Details are already being shown.');
        return;
    }

    isShowingDetails = true;

    try {
        const detailsMessage = `
*Details für Server ${bannerEmoji}${serverName}${bannerEmoji}* 
*Uptime:* ${await getUptime()}
*CPU-Auslastung:* ${getCpuUsage()}%
*RAM-Auslastung:* ${getRamUsage()}%
*Netzwerk-Traffic:* ${getNetworkTraffic()}%
*IP/Adresse:* ${serverAddress}
`;

        const options = {
            parse_mode: 'Markdown',
        };

        await bot.sendMessage(chatId, detailsMessage, options);
    } catch (error) {
        console.error(`Fehler beim Anzeigen der Serverdetails: ${error.message}`);
        await bot.sendMessage(chatId, 'Fehler beim Anzeigen der Serverdetails.');
    } finally {
        isShowingDetails = false;
    }
}

bot.on('callback_query', async (query) => {
    const chatId = query.message.chat.id;
    const [action, ...params] = query.data.split(':');

    if (action === 'details_server') {
        showServerDetails(chatId, ...params);
    } else {
        const userServers = userServerConfigurations[chatId] || [];

        if (userServers.length === 0) {
            bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
            return;
        }

        const keyboard = {
            reply_markup: {
                inline_keyboard: userServers.map(server => [{
                    text: `${server.name} - ${server.address}`,
                    callback_data: `details_server:${server.name}:${server.address}`
                }])
            }
        };

        bot.sendMessage(chatId, 'Wähle einen Server für Details aus:', keyboard);
    }
});



bot.onText(/\/help/, (msg) => {
    const chatId = msg.chat.id;

    let helpMessage = `
    Verfügbare Befehle:
- /add_server: Fügt einen neuen Server hinzu.
- /delete_server: Löscht einen vorhandenen Server.
- /status: Zeigt den Status der konfigurierten Server an.
- /start_notifications: Startet Benachrichtigungen für alle Server.
- /stop_notifications: Stoppt Benachrichtigungen für alle Server.
- /log: Zeigt die letzten 8 Logeinträge.
- /save_log: Speichert und sendet die letzten 8 Logeinträge als Datei.
- /uptime: Zeigt die aktuelle Betriebszeit des Bots an.
- /info: Zeigt Informationen über den Bot an.
`;

if (isDeveloperChat(chatId)) {
    helpMessage += '\n\n*Entwickler Befehle:*\n' +
                   '- /error: Zeigt den error Log an\n' +
                   '- /stats: Zeigt an, wie viele Personen den Bot nutzen\n' +
                   '- /user_id Zeigt eine Liste von Usern an die den Bot nutzen\n' +
                   `- /user_delete "ID" löscht alle Server des Benutzer`;
}

    bot.sendMessage(chatId, helpMessage);
});

const checkIntervalMinutes = 2;
const checkIntervalMilliseconds = checkIntervalMinutes * 60 * 1000;

const offlineNotificationIntervalMinutes = 360; // Ändern Sie nach Bedarf
const offlineNotificationIntervalMilliseconds = offlineNotificationIntervalMinutes * 60 * 1000;

const lastOfflineNotificationTime = new Map();

setInterval(async () => {
    await checkAndSendServerStatus();
}, checkIntervalMilliseconds);

async function checkAndSendServerStatus() {
    for (const chatId of chatIds) {
        const userServers = userServerConfigurations[chatId] || [];

        if (userServers.length === 0) {
            bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
            continue;
        }

        for (const serverConfig of userServers) {
            const serverName = serverConfig.name;
            const serverAddress = serverConfig.address;

            try {
                const serverStatus = await checkServerStatus(serverAddress);
                const offlineStatus = serverStatus === 'Offline';

                if (offlineStatus) {
                    const statusIcon = '❌';
                    const notificationEnabled = serverNotificationState[serverAddress];

                    if (notificationEnabled) {
                        const lastNotificationTime = lastOfflineNotificationTime.get(serverAddress) || 0;
                        const currentTime = Date.now();

                        // Überprüfen, ob die Benachrichtigung bereits innerhalb des Intervalls gesendet wurde
                        if (currentTime - lastNotificationTime >= offlineNotificationIntervalMilliseconds) {
                            console.log(`Benachrichtigung wird gesendet für Server: ${serverName}`);
                            const inlineKeyboard = [];

                            

                            const options = {
                                parse_mode: 'Markdown',
                                reply_markup: {
                                    inline_keyboard: inlineKeyboard
                                }
                            };

                            sendStatusNotification(chatId, serverName, serverStatus, serverAddress);
                            lastOfflineNotificationTime.set(serverAddress, currentTime);
                        } else {
                            console.log(`Offline-Benachrichtigung für Server "${serverName}" wird aufgrund des Zeitintervalls übersprungen.`);
                        }
                    } else {
                        console.log(`Benachrichtigungen für Server "${serverName}" sind deaktiviert.`);
                    }
                }
            } catch (error) {
                console.error(`Fehler beim Überprüfen des Servers ${serverName}: ${error.message}`);
            }
        }
    }
}