import Fastify from 'fastify';
import { createServer } from 'node:http';
import wisp from 'wisp-server-node';
import createRammerhead from "../lib/rammerhead/src/server/index.js";
import { epoxyPath } from "@mercuryworkshop/epoxy-transport";
import { libcurlPath } from "@mercuryworkshop/libcurl-transport";
import { bareModulePath } from "@mercuryworkshop/bare-as-module3";
import { baremuxPath } from "@mercuryworkshop/bare-mux/node";
import { uvPath } from "@titaniumnetwork-dev/ultraviolet";
import fastifyHelmet from '@fastify/helmet';
import fastifyStatic from '@fastify/static';
import pageRoutes from "./routes.mjs";
import { readFile } from 'node:fs/promises';
import path from 'node:path';
import { paintSource, preloaded404, tryReadFile } from './randomization.mjs';
import loadTemplates from './templates.mjs';
import { fileURLToPath } from 'node:url';
import { existsSync, unlinkSync } from 'node:fs';
import ecosystem from '../ecosystem.config.js';

const config = Object.freeze(
    JSON.parse(await readFile(new URL("./config.json", import.meta.url)))
  ),
  ecosystemConfig = Object.freeze(
    ecosystem.apps.find(app => app.name === "HolyUB") || ecosystem.apps[0]
  ),
  { pages, externalPages } = pageRoutes,
  __dirname = path.resolve();

//  Record the server's location as a URL object, including its host and port.
//  The host can be modified at /src/config.json, whereas the ports can be modified
//  at /ecosystem.config.js.
const serverUrl = (base => {
  try {
    base = new URL(config.host);
  } catch (e) {
    base = new URL("http://a");
    base.host = config.host;
  }
  base.port = ecosystemConfig[ config.production ? "env_production" : "env" ].PORT;
  return Object.freeze(base);
})();
console.log(serverUrl);

//  The server will check for the existence of this file when a shutdown is requested.
//  The shutdown script in run-command.js will temporarily produce this file.
const shutdown = fileURLToPath(new URL("./.shutdown", import.meta.url));

const rh = createRammerhead();
const rammerheadScopes = [
  "/rammerhead.js",
  "/hammerhead.js",
  "/transport-worker.js",
  "/task.js",
  "/iframe-task.js",
  "/worker-hammerhead.js",
  "/messaging",
  "/sessionexists",
  "/deletesession",
  "/newsession",
  "/editsession",
  "/needpassword",
  "/syncLocalStorage",
  "/api/shuffleDict",
  "/mainport",
];

const rammerheadSession = /^\/[a-z0-9]{32}/,
  shouldRouteRh = req => {
    try {
      const url = new URL(req.url, serverUrl);
      return (
        rammerheadScopes.includes(url.pathname) ||
        rammerheadSession.test(url.pathname)
      );
    } catch (e) {return false}
  },
  routeRhRequest = (req, res) => {
    rh.emit("request", req, res);
  },
  routeRhUpgrade = (req, socket, head) => {
    rh.emit("upgrade", req, socket, head);
  };

//  Create a server factory for RH, and wisp (and bare if you please).
const serverFactory = (handler) => {
  return createServer()
    .on('request', (req, res) => {
      if (shouldRouteRh(req))
        routeRhRequest(req, res);
      else handler(req, res);
    })
    .on('upgrade', (req, socket, head) => {
      if (shouldRouteRh(req))
        routeRhUpgrade(req, socket, head);
      else if (req.url.endsWith('/wisp/'))
        wisp.routeRequest(req, socket, head);
    });
};

//  Set logger to true for logs
const app = Fastify({
  ignoreDuplicateSlashes: true,
  ignoreTrailingSlash: true,
  logger: false,
  serverFactory: serverFactory
});

//  Apply Helmet middleware for security
app.register(fastifyHelmet, {
  contentSecurityPolicy: false, // Disable CSP
  xPoweredBy: false
});

//  Assign server file paths to different paths, for serving content on the website.
app.register(fastifyStatic, {
  root: fileURLToPath(new URL("../views/pages", import.meta.url)),
  decorateReply: false
});

app.register(fastifyStatic, {
  root: fileURLToPath(new URL("../views/assets", import.meta.url)),
  prefix: "/assets/",
  decorateReply: false
});

app.register(fastifyStatic, {
  root: fileURLToPath(new URL("../views/archive", import.meta.url)),
  prefix: "/arcade/",
  decorateReply: false
});

app.register(fastifyStatic, {
  root: fileURLToPath(new URL(
//  Use the pre-compiled, minified scripts instead, if enabled in config.
    config.minifyScripts ? "../views/dist/assets/js" : "../views/assets/js",
    import.meta.url
  )),
  prefix: "/assets/js/",
  decorateReply: false
});

app.register(fastifyStatic, {
  root: fileURLToPath(new URL(
//  Use the pre-compiled, minified stylesheets instead, if enabled in config.
    config.minifyScripts ? "../views/dist/assets/css" : "../views/assets/css",
    import.meta.url
  )),
  prefix: "/assets/css/",
  decorateReply: false
});

//  This combines scripts from the official UV repository with local UV scripts into
//  one directory path. Local versions of files override the official versions.
app.register(fastifyStatic, {
  root: [
    fileURLToPath(new URL(
//    Use the pre-compiled, minified scripts instead, if enabled in config.
      config.minifyScripts ? "../views/dist/uv" : "../views/uv",
      import.meta.url
    )),
    uvPath
  ],
  prefix: "/uv/",
  decorateReply: false
});

//  Register proxy paths to the website.
app.register(fastifyStatic, {
  root: epoxyPath,
  prefix: "/epoxy/",
  decorateReply: false
});

app.register(fastifyStatic, {
  root: libcurlPath,
  prefix: "/libcurl/",
  decorateReply: false
});

app.register(fastifyStatic, {
  root: bareModulePath,
  prefix: "/bareasmodule/",
  decorateReply: false
});

app.register(fastifyStatic, {
  root: baremuxPath,
  prefix: "/baremux/",
  decorateReply: false
});


//  All website files are stored in the /views directory.
//  This takes one of those files and displays it for a site visitor.
//  Paths like /browsing are converted into paths like /views/pages/surf.html
//  back here. Which path converts to what is defined in routes.mjs.
app.get("/:path", (req, reply) => {

//  Testing for future features that need cookies to deliver alternate source files.
  if (req.raw.rawHeaders.includes("Cookie"))
    console.log(req.raw.rawHeaders[ req.raw.rawHeaders.indexOf("Cookie") + 1 ]);

  const reqPath = req.params.path;

  if (reqPath in externalPages) {
    let externalRoute = externalPages[reqPath];
    if (typeof externalRoute !== "string") externalRoute = externalRoute.default;
    return reply.redirect(externalRoute);
  }

//  If a GET request is sent to /test-shutdown and a script-generated shutdown file
//  is present, gracefully shut the server down.
    if (reqPath === "test-shutdown" && existsSync(shutdown)) {
        console.log("Holy Unblocker is shutting down.");
        app.close();
        unlinkSync(shutdown);
        process.exitCode = 0;
    }

//  Return the error page if the query is not found in routes.mjs.
    if (reqPath && !(reqPath in pages))
      return reply.code(404).type("text/html").send(preloaded404);

    reply.type("text/html").send(
      paintSource(
        loadTemplates(
          tryReadFile(
            path.join(
              __dirname,
              "views",
//            Set the index the as the default page.
              reqPath ? pages[reqPath] : pages.index
            )
          )
        )
      )
    );
});

app.get("/github/:redirect", (req, reply) => {
  if (req.params.redirect in externalPages.github)
    reply.redirect(externalPages.github[req.params.redirect]);
  else reply.code(404).type("text/html").send(preloaded404);
});

/*
Testing for future restructuring of this config file.

app.get("/assets/js/uv/uv.config.js", (req, reply) => {
  console.log(req.url);
  reply.type("text/javascript");
  reply.send(tryReadFile(path.join(__dirname, "views/assets/js/uv/uv.config.js")));
});
*/

//  Set an error page for invalid paths outside the query string system.
app.setNotFoundHandler((req, reply) => {
  reply.code(404).type("text/html").send(preloaded404);
});

app.listen({ port: serverUrl.port, host: serverUrl.hostname });
console.log(`Holy Unblocker is listening on port ${serverUrl.port}.`);