// @ts-ignore
import DHT from "@hyperswarm/dht";
// @ts-ignore
import {relay} from "@hyperswarm/dht-relay";
// @ts-ignore
import Stream from "@hyperswarm/dht-relay/ws";
import express, {Express} from "express";
import path from "path";
import {fileURLToPath} from "url";
import config from "./config.js";
import * as http from "http";
import * as https from "https";
import * as tls from "tls";
import * as acme from "acme-client";
import {Buffer} from "buffer";
import {intervalToDuration} from "date-fns";
import cron from "node-cron";
import {get as getDHT} from "./dht.js";
import WS from "ws";
// @ts-ignore
import DHT from "@hyperswarm/dht";
import {pack} from "msgpackr";
import {overwriteRegistryEntry} from "libskynetnode";
import {hashDataKey} from "./util.js";

let sslCtx: tls.SecureContext = tls.createSecureContext();
const sslParams: tls.SecureContextOptions = {};

const sslPrivateKey = await acme.forge.createPrivateKey();
const acmeClient = new acme.Client({
    accountKey: sslPrivateKey,
    directoryUrl: acme.directory.letsencrypt.production,
});

let app: Express;
let router = express.Router();

export async function start() {
    const relayPort = config.str("relay-port");
    app = express();
    app.use(function (req, res, next) {
        router(req, res, next);
    });

    let httpsServer = https.createServer({
        SNICallback(servername, cb) {
            cb(null, sslCtx);
        },
    });

    let httpServer = http.createServer(app);

    cron.schedule("0 * * * *", createOrRenewSSl);

    await new Promise((resolve) => {
        httpServer.listen(80, "0.0.0.0", function () {
            console.info("HTTP Listening on ", httpServer.address());
            resolve(null);
        });
    });
    const dht = await getDHT();

    let wsServer = new WS.Server({server: httpsServer});

    wsServer.on("connection", (socket: any) => {
        relay(dht, new Stream(false, socket));
    });

    await new Promise((resolve) => {
        httpsServer.listen(relayPort, "0.0.0.0", function () {
            console.info("Relay started on ", httpsServer.address());
            resolve(null);
        });
    });

    await createOrRenewSSl();
}

async function createOrRenewSSl() {
    if (sslParams.cert) {
        const expires = (
            await acme.forge.readCertificateInfo(sslParams.cert as Buffer)
        ).notAfter;

        let duration = intervalToDuration({start: new Date(), end: expires});

        let daysLeft = (duration.months as number) * 30 + (duration.days as number);

        if (daysLeft > 30) {
            return;
        }
    }

    const [certificateKey, certificateRequest] = await acme.forge.createCsr({
        commonName: config.str("relay-domain"),
    });

    sslParams.cert = await acmeClient.auto({
        csr: certificateRequest,
        termsOfServiceAgreed: true,
        challengeCreateFn: async (authz, challenge, keyAuthorization) => {
            router.get(
                `/.well-known/acme-challenge/${challenge.token}`,
                (req, res) => {
                    res.send(keyAuthorization);
                }
            );
        },
        challengeRemoveFn: async () => {
            router = express.Router();
        },
        challengePriority: ["http-01"],
    });
    sslParams.key = certificateKey;
    sslCtx = tls.createSecureContext(sslParams);

    console.log("SSL Certificate Updated");
}