import { Elysia } from "elysia";
import { logger } from "@chneau/elysia-logger";
import { cors } from "@elysiajs/cors";
import { dlV1Router } from "./sub-router/showtime";
import { FfmpegV2Router } from "./sub-router/probe";
import { IS_GH, NS_runtime } from "@x/types/env.runtime";
import { NS_Misc } from "@x/core/client/misc.ts";
import { NS_error } from "@x/core/client/error.ts";
import { NS_routes_elysia } from "@x/core/server/routes-elysia.ts";
import { start_mongo_db } from "@x/db1/init";
import { ProximaRouter } from "@x/post-process/proxima";
import { CheckRouter } from "./sub-router/check";
import { BucketRouter } from "./sub-router/bucket";
import { StreamRouter } from "./sub-router/stream";
import { NS_server_stats } from "./lib/cpu";
import { proximaRouter } from "./sub-router/proxima";
import { NS_websockets } from "@x/ff-dl/ws";

await NS_runtime.set_env_var_db();

await start_mongo_db();

const APP_ENV = () => NS_runtime.ENV_VAR_DB?.APP_ENV || process?.env?.APP_ENV;

const APP_ORIGIN = () =>
  NS_runtime.ENV_VAR_DB?.APP_ORIGIN || process?.env?.APP_ORIGIN;

const REPO_ORIGIN = () =>
  NS_runtime.ENV_VAR_DB?.REPO_ORIGIN || process.env.REPO_ORIGIN;

const PORT = process.env.PORT || 7860;

const app = new Elysia()

  .use(
    cors({
      origin: "*",
      allowedHeaders: "*",
      methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD"],
      exposeHeaders: "*"
    }) as any
  )

  .derive((ctx: any) => ({
    publicOrigin: NS_routes_elysia.F_public_origin(ctx)
  }))

  .use(logger())

  .onRequest(({ request }) => {
    const url = new URL(request.url);

    url.pathname = url.pathname
      .split("/")
      .map((segment) => segment.replace(/\.$/, ""))
      .join("/");

    const params = new URLSearchParams();

    for (const [key, value] of url.searchParams) {
      params.append(key.replace(/\.$/, ""), value.replace(/\.$/, ""));
    }

    url.search = params.toString();

    if (url.href !== request.url) {
      return new Response(null, {
        status: 308,
        headers: {
          Location: url.href
        }
      });
    }
  })

  .onError(async ({ code, error }) => {
    let e_message = "";
    if (code === "VALIDATION") {
      e_message = error.message;
      try {
        e_message = JSON.parse(e_message).summary;
      } catch (err) {}
    }

    const err_d = NS_error.F_collect_error_status_n_message({
      ERR: error
    });

    NS_Misc.console.error({
      ENV: IS_GH() ? "all" : "dev",
      _browser: false,
      _log: ["\n"]
    });
    NS_Misc.console.error({
      ENV: IS_GH() ? "all" : "dev",
      _browser: false,
      _log: [{ code, e_message, ...err_d }, "\n"]
    });

    return new Response(err_d.message, {
      status: err_d.status,
      headers: {
        "x-error-message": JSON.stringify(err_d.message),
        "x-error-status": err_d.status
      }
    });
  })

  .use(CheckRouter)
  .use(dlV1Router)
  .use(FfmpegV2Router)
  .use(BucketRouter)
  .use(StreamRouter)
  .use(proximaRouter)

  .mount("/", ProximaRouter.fetch)

  .get("/", async ({ request }) => {
    return "🦊 Hello Rafiki 🍿";
  })

  .get("/road", async () => {
    return "11";
  })

  .ws("/ws", {
    open(socket: any) {
      const socket_id = socket.id;
      const remote_address = socket.remoteAddress;

      // Register the socket once.
      NS_websockets.ws_clients.set(socket_id, {
        socket,
        channels: new Set<string>()
      });

      if (!NS_runtime.IS_PROD()) {
        console.log("WS CONNECTED:", remote_address, socket_id);
      }

      NS_websockets.ws_send({
        socket,
        payload: {
          type: "CONNECTED",
          ws_id: socket_id
        }
      });
    },

    close(socket: any) {
      const socket_id = socket.id;
      const remote_address = socket.remoteAddress;

      // Remove the disconnected client.
      const client = NS_websockets.ws_clients.get(socket_id);

      if (client?.socket === socket) {
        NS_websockets.ws_clients.delete(socket_id);
      }

      NS_server_stats.sync();

      if (!NS_runtime.IS_PROD()) {
        console.log("WS CLOSED:", remote_address, socket_id);
      }
    },

    message(socket: any, message: any) {
      const socket_id = socket.id;

      let data: any;

      try {
        data = typeof message === "string" ? JSON.parse(message) : message;
      } catch {
        NS_websockets.ws_error({ socket, socket_id, message: "INVALID_JSON" });
        return;
      }

      if (!data || typeof data !== "object" || Array.isArray(data)) {
        NS_websockets.ws_error({
          socket,
          socket_id,
          message: "INVALID_MESSAGE"
        });
        return;
      }

      const client = NS_websockets.ws_clients.get(socket_id);

      if (!client) {
        NS_websockets.ws_error({
          socket,
          socket_id,
          message: "CLIENT_UNAVAILABLE"
        });
        return;
      }

      // Subscribe to a channel.
      if (typeof data.channel?.connect === "string") {
        const channel = data.channel.connect.trim();

        if (!channel) {
          NS_websockets.ws_error({
            socket,
            socket_id,
            message: "INVALID_CHANNEL"
          });
          return;
        }

        const already_connected = client.channels.has(channel);

        client.channels.add(channel);

        if (channel === "server-stats") {
          NS_server_stats.sync();

          // Send the current snapshot immediately.
          socket.send(
            JSON.stringify({
              type: "SERVER-STATS",
              data: NS_server_stats.get()
            })
          );
        }

        NS_websockets.ws_send({
          socket,
          payload: {
            type: "CHANNEL-CONNECTED",
            ws_id: socket_id,
            channel,
            already_connected,
            channels: [...client.channels]
          }
        });

        return;
      }

      // Unsubscribe from a channel.
      if (typeof data.channel?.disconnect === "string") {
        const channel = data.channel.disconnect.trim();

        if (!channel) {
          NS_websockets.ws_error({
            socket,
            socket_id,
            message: "INVALID_CHANNEL"
          });
          return;
        }

        const disconnected = client.channels.delete(channel);

        if (channel === "server-stats") {
          NS_server_stats.sync();
        }

        NS_websockets.ws_send({
          socket,
          payload: {
            type: "CHANNEL-DISCONNECTED",
            ws_id: socket_id,
            channel,
            disconnected,
            channels: [...client.channels]
          }
        });

        return;
      }

      NS_websockets.ws_error({ socket, socket_id, message: "UNKNOWN_ACTION" });
    }
  })

  .listen({
    port: PORT,
    idleTimeout: 180
  });

console.log(
  `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
);