const os = require('os');
const fs = require('fs');
const path = require('path');
const ip = require('ip');
const { logger, logRequestInfo, ErrorLogger } = require('../config/logs');
const packageJson = require('../package.json');
const si = require('systeminformation');
const fetch = require('node-fetch');

class SystemReport {
    static async generate() {
        const date = new Date();
        date.setDate(date.getDate() - 1);
        const previousDate = date.toISOString().split('T')[0];

        const logFile = path.join(__dirname, '..', 'logs', `log-${previousDate}.log`);
        const logs = fs.readFileSync(logFile, 'utf-8');

        const internalErrors = logs.split('\n').filter(line => /\[38;5;9mInternal-Error/.test(line));

        if (internalErrors.length === 0) {
            logger.info('No internal errors in yesterday\'s logs. No report will be generated.');
            return null;
        }

        function formatUptime(uptime) {
            const days = Math.floor(uptime / (24 * 60 * 60));
            uptime %= (24 * 60 * 60);
            const hours = Math.floor(uptime / (60 * 60));
            uptime %= (60 * 60);
            const minutes = Math.floor(uptime / 60);
            return `${days}d ${hours}h ${minutes}m`;
        }

        const osInfo = {
            type: os.type(),
            platform: os.platform(),
            arch: os.arch(),
            release: os.release(),
            uptime: formatUptime(os.uptime()),
            loadavg: os.loadavg().map(load => (load / os.cpus().length) * 100)
        };

        const networkInterfaces = os.networkInterfaces(); 
        const serverUptime = os.uptime();
        const systemLoad = os.loadavg(); 

        const diskUsage = await si.fsSize(); 
        const cpuTemperature = await si.cpuTemperature();

        const userInfo = os.userInfo();

        const systemInfo = {
            memoryInfo: ((os.totalmem() - os.freemem()) / os.totalmem() * 100).toFixed(2),
            cpuInfo: (os.cpus().length / os.cpus().length * 100).toFixed(2),
            diskInfo: ((os.totalmem() - os.freemem()) / os.totalmem() * 100).toFixed(2),
            ipAddress: ip.address(),
            cdnVersion: packageJson.version,
            osInfo: osInfo,
            userInfo: userInfo, 
            errors: internalErrors,
            networkInterfaces: networkInterfaces,
            serverUptime: serverUptime,
            systemLoad: systemLoad,
            diskUsage: diskUsage,
            cpuTemperature: cpuTemperature,
        };

        const filename = path.join(__dirname, '..', 'report', `report_${previousDate}_${ip.address()}.json`);
        fs.writeFileSync(filename, JSON.stringify(systemInfo, null, 2));

        logger.info("Preparing to send report...");
        logger.info("Report:", JSON.stringify(systemInfo, null, 2));
        

        try {
            const response = await fetch('https://cdn-apollon-p198-61m1.dinawo.fr/api/report/receive', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(systemInfo)
            });

            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            } else {
                const data = await response.json();
                logger.info('Report sent successfully. Response data:', data);
            }
        } catch (error) {
            console.error(error);
            logger.error('Failed to send report. Error:', error);
        }

        return systemInfo;
    }
}

module.exports = SystemReport;