const express = require("express");
const cors = require("cors");
const multer = require("multer");
const fs = require("fs");
const path = require("path");
const os = require("os");
const { execSync } = require("child_process");


const FILE_DIR = path.join(__dirname, "files");
const EXPIRATION_TIME = 24 * 60 * 60 * 1000; // 24 jam dalam milidetik
const META_FILE = path.join(__dirname, "files.json");

// Load metadata file (kalau ada)
let fileData = {};
if (fs.existsSync(META_FILE)) {
    fileData = JSON.parse(fs.readFileSync(META_FILE));
}

function formatRemainingTime(expiresAt) {
    const remainingMs = expiresAt - Date.now();
    if (remainingMs <= 0) return "Expired";

    const hours = Math.floor(remainingMs / (1000 * 60 * 60));
    const minutes = Math.floor((remainingMs % (1000 * 60 * 60)) / (1000 * 60));
    const seconds = Math.floor((remainingMs % (1000 * 60)) / 1000);

    return `${hours}h ${minutes}m ${seconds}s`;
}

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

const uploadDir = path.join(__dirname, "files");
if (!fs.existsSync(uploadDir)) {
    fs.mkdirSync(uploadDir, { recursive: true });
}

app.use(cors());
app.use("/files", express.static(uploadDir));

const storage = multer.diskStorage({
    destination: (req, file, cb) => {
        cb(null, FILE_DIR);
    },
    filename: (req, file, cb) => {
        const uniqueName = `${Date.now()}-${file.originalname}`;
        cb(null, uniqueName);
    }
});

const upload = multer({ storage });

app.post("/upload", upload.single("file"), (req, res) => {
    if (!req.file) {
        return res.status(400).json({ success: false, message: "No file uploaded" });
    }

    const filePath = req.file.filename;
    const expiresAt = Date.now() + EXPIRATION_TIME;
    fileData[filePath] = expiresAt;
    fs.writeFileSync(META_FILE, JSON.stringify(fileData));

    res.json({
        success: true,
        file_url: `http://yourdomain.com/files/${filePath}`,
        expires_in: formatRemainingTime(expiresAt) // Format sesuai sisa waktu
    });
});

app.get("/files", (req, res) => {
    fs.readdir(uploadDir, (err, files) => {
        if (err) return res.status(500).json({ success: false, message: "Error reading files" });

        const fileList = files.map(filename => ({
            filename,
            file_url: `${req.protocol}://${req.get("host")}/files/${filename}`,
            expires_in: formatRemainingTime(fileData[filename])
        }));

        res.json({ success: true, files: fileList });
    });
});

app.delete("/files/:filename", (req, res) => {
    const filePath = path.join(uploadDir, req.params.filename);
    
    fs.unlink(filePath, err => {
        if (err) return res.status(404).json({ success: false, message: "File not found" });

        res.json({ success: true, message: "File deleted successfully!" });
    });
});

app.get("/", (req, res) => {
    res.json({
        success: true,
        message: "Welcome to Temporary Cloud File API 🚀",
        usage: {
            upload_file: {
                method: "POST",
                endpoint: "/upload",
                description: "Upload a file",
                body: "FormData (key: file)",
                response: {
                    success: true,
                    file_url: "http://yourdomain.com/files/filename.ext",
                    expires_in: "24h"
                }
            },
            list_files: {
                method: "GET",
                endpoint: "/files",
                description: "Get all uploaded files",
                response: {
                    success: true,
                    files: [
                        {
                            filename: "example.txt",
                            file_url: "http://yourdomain.com/files/example.txt"
                        }
                    ]
                }
            },
            delete_file: {
                method: "DELETE",
                endpoint: "/files/:filename",
                description: "Delete a file",
                response: {
                    success: true,
                    message: "File deleted successfully!"
                }
            },
            check_server: {
                method: "GET",
                endpoint: "/status",
                description: "Check server status (RAM, CPU, uptime, etc.)"
            }
        },
        author: "rizxyu",
        github: "https://github.com/rizxyu"
    });
});


app.get("/status", (req, res) => {
    const uptime = process.uptime(); 
    const memoryUsage = process.memoryUsage(); 
    const cpuLoad = os.loadavg(); 
    
    let diskUsage = "Not available";
    try {
        diskUsage = execSync("df -h / | tail -1 | awk '{print $3 \" used / \" $2 \" total (\" $5 \" used)\"}'").toString().trim();
    } catch (err) {
        diskUsage = "Error fetching disk usage";
    }

    res.json({
        success: true,
        server_time: new Date().toISOString(),
        uptime: `${Math.floor(uptime / 3600)}h ${Math.floor((uptime % 3600) / 60)}m ${Math.floor(uptime % 60)}s`,
        memory: {
            total: `${(os.totalmem() / 1024 / 1024).toFixed(2)} MB`,
            used: `${(memoryUsage.rss / 1024 / 1024).toFixed(2)} MB`
        },
        cpu: {
            cores: os.cpus().length,
            load_avg: cpuLoad.map(load => load.toFixed(2))
        },
        disk: diskUsage,
        node_version: process.version
    });
});


setInterval(() => {
    const now = Date.now();
    let updatedFileData = {};

    Object.keys(fileData).forEach(filename => {
        if (fileData[filename] <= now) {
            const filePath = path.join(FILE_DIR, filename);
            if (fs.existsSync(filePath)) {
                fs.unlinkSync(filePath);
                console.log(`🗑️ File expired dihapus: ${filename}`);
            }
        } else {
            updatedFileData[filename] = fileData[filename];
        }
    });

    // Update metadata file
    fileData = updatedFileData;
    fs.writeFileSync(META_FILE, JSON.stringify(fileData));
}, 60 * 60 * 1000); // Cek tiap 1 jam


app.listen(port, () => {
    console.log("Listening on http://localhost:" + port);
});