#!/usr/bin/env node

process.on('unhandledRejection', error => {
    // this makes sure that stacktrace of failed promise is printed out
    console.log(error);

    // but also try to log it into file
    require('./services/log').info(error);
});

process.on('SIGINT', function() {
	console.log("Caught interrupt signal. Exiting.");
	process.exit();
});

const { app, sessionParser } = require('./app');
const debug = require('debug')('node:server');
const fs = require('fs');
const http = require('http');
const https = require('https');
const config = require('./services/config');
const log = require('./services/log');
const appInfo = require('./services/app_info');
const ws = require('./services/ws.js');
const utils = require('./services/utils');
const sqlInit = require('./services/sql_init');
const port = require('./services/port');
const host = require('./services/host');
const semver = require('semver');

if (!semver.satisfies(process.version, ">=10.5.0")) {
    console.error("Trilium only supports node.js 10.5 and later");
    process.exit(1);
}

let httpServer;

async function startTrilium() {
    const usedPort = await port;
    const usedHost = await host;

    app.set('port', usedPort);
    app.set('host', usedHost);

    if (config['Network']['https']) {
        if (!config['Network']['keyPath'] || !config['Network']['keyPath'].trim().length) {
            throw new Error("keyPath in config.ini is required when https=true, but it's empty");
        }

        if (!config['Network']['certPath'] || !config['Network']['certPath'].trim().length) {
            throw new Error("certPath in config.ini is required when https=true, but it's empty");
        }

        const options = {
            key: fs.readFileSync(config['Network']['keyPath']),
            cert: fs.readFileSync(config['Network']['certPath'])
        };

        httpServer = https.createServer(options, app);

        log.info("App HTTPS server starting up at port " + usedPort);
    }
    else {
        httpServer = http.createServer(app);

        log.info("App HTTP server starting up at port " + usedPort);
    }

    log.info(JSON.stringify(appInfo, null, 2));

    /**
     * Listen on provided port, on all network interfaces.
     */

    httpServer.keepAliveTimeout = 120000 * 5;
    httpServer.listen(usedPort, usedHost);
    httpServer.on('error', onError);
    httpServer.on('listening', () => debug('Listening on port' + httpServer.address().port));

    sqlInit.dbReady.then(() => ws.init(httpServer, sessionParser));

    if (utils.isElectron()) {
        const electronRouting = require('./routes/electron');
        electronRouting(app);
    }
}

startTrilium();

/**
 * Event listener for HTTP server "error" event.
 */

function onError(error) {
    if (error.syscall !== 'listen') {
        throw error;
    }

    // handle specific listen errors with friendly messages
    switch (error.code) {
        case 'EACCES':
            console.error('Port requires elevated privileges');
            process.exit(1);
        break;

        case 'EADDRINUSE':
            console.error('Port is already in use');
            process.exit(1);
        break;

        default:
            throw error;
    }
}