const next = require("next");
const { createServer: createHttpServer } = require("http");
const { createServer: createHttpsServer } = require("https");
const fs = require("fs");
const path = require("path");
const appInsights = require("applicationinsights");

const initAppInsights = (instrumentationKey) => {
    if (!instrumentationKey) {
        console.log("App Insights not configured.");
        return false;
    }

    appInsights
        .setup(instrumentationKey)
        .setAutoCollectConsole(true, true)
        .setSendLiveMetrics(true)
        .start();

    console.log("App Insights enabled.");
    return true;
};

const startServer = async (config) => {
    const serverOptions = {
        dev: config.env === "development",
        dir: ".",
        quiet: false,
    };

    const app = next(serverOptions);
    await app.prepare();

    const handleNextRequests = app.getRequestHandler();

    const httpsOptions = {
        key: fs.readFileSync(
            path.join(__dirname, "certificates", "cert-key.pem")
        ),
        cert: fs.readFileSync(path.join(__dirname, "certificates", "cert.pem")),
    };

    // HTTPS server on port 3000
    const httpsServer = createHttpsServer(httpsOptions, (req, res) => {
        if (config.useAppInsights) {
            appInsights.defaultClient.trackNodeHttpRequest({
                request: req,
                response: res,
            });
        }
        handleNextRequests(req, res);
    });

    // HTTP server on port 3001 for redirect
    const httpServer = createHttpServer((req, res) => {
        const host = req.headers.host?.split(":")[0] || "localhost";
        res.writeHead(301, {
            Location: `https://${host}:3000${req.url}`,
        });
        res.end();
    });

    await new Promise((resolve, reject) => {
        httpsServer.on("error", reject);
        httpsServer.on("listening", () => {
            console.log(`HTTPS server listening on port ${config.port}`);
            resolve();
        });
        httpsServer.listen(config.port, config.hostname);
    });

    await new Promise((resolve, reject) => {
        httpServer.on("error", reject);
        httpServer.on("listening", () => {
            console.log(
                `HTTP server listening on port ${config.httpPort} (redirecting to HTTPS)`
            );
            resolve();
        });
        httpServer.listen(config.httpPort, config.hostname);
    });

    process.on("SIGTERM", () => {
        console.log("Received SIGTERM, shutting down gracefully...");
        httpsServer.close(() => {
            httpServer.close(() => {
                console.log("Servers closed.");
                process.exit(0);
            });
        });
    });

    return app;
};

const startTime = Date.now();
const serverConfig = {
    hostname: "0.0.0.0",
    port: 3000, // HTTPS port
    httpPort: 3001, // HTTP redirect port
    env: process.env.APP_ENV || process.env.NODE_ENV || "production",
    useAppInsights: initAppInsights(
        process.env.NEXT_PUBLIC_APPINSIGHTS_INSTRUMENTATIONKEY
    ),
};

startServer(serverConfig)
    .then(() => {
        console.log(
            `Server ready on https://${serverConfig.hostname}:${serverConfig.port} [${serverConfig.env}]`
        );

        if (serverConfig.useAppInsights) {
            const duration = Date.now() - startTime;
            appInsights.defaultClient.trackMetric({
                name: "Server Startup Time",
                value: duration,
            });
        }
    })
    .catch((err) => {
        console.error("Server failed to start:", err);
        process.exit(1);
    });