import path from "path";
import cors from "cors";
import express, { Express } from "express";
import dotenv from "dotenv";
import { createServer } from "http";
import { Server } from "socket.io";
import { DokkuClient } from "./DokkuClient";
import { SecureGitClient, FileData } from "./SecureGitClient";
import fs, { readFile } from "fs";

import { z } from "zod";
import {
  TFile,
  TFileData,
  TFolder,
  User
} from "./types";
import {
  createFile,
  deleteFile,
  getFolder,
  getProjectSize,
  getSandboxFiles,
  renameFile,
  saveFile,
} from "./fileoperations";
import { LockManager } from "./utils";

import { Sandbox, Filesystem, FilesystemEvent, EntryInfo, WatchHandle } from "e2b";

import { Terminal } from "./Terminal"

import {
  MAX_BODY_SIZE,
  createFileRL,
  createFolderRL,
  deleteFileRL,
  renameFileRL,
  saveFileRL,
} from "./ratelimit";

process.on('uncaughtException', (error) => {
  console.error('Uncaught Exception:', error);
  // Do not exit the process
  // You can add additional logging or recovery logic here
});

process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
  // Do not exit the process
  // You can also handle the rejected promise here if needed
});

// The amount of time in ms that a container will stay alive without a hearbeat.
const CONTAINER_TIMEOUT = 60_000;

dotenv.config();

const app: Express = express();
const port = process.env.PORT || 4000;
app.use(cors());
const httpServer = createServer(app);
const io = new Server(httpServer, {
  cors: {
    origin: "*",
  },
});

let inactivityTimeout: NodeJS.Timeout | null = null;
let isOwnerConnected = false;

const containers: Record<string, Sandbox> = {};
const connections: Record<string, number> = {};
const terminals: Record<string, Terminal> = {};

const dirName = "/home/user";

const moveFile = async (filesystem: Filesystem, filePath: string, newFilePath: string) => {
  try {
    const fileContents = await filesystem.read(filePath);
    await filesystem.write(newFilePath, fileContents);
    await filesystem.remove(filePath);
  } catch (e) {
    console.error(`Error moving file from ${filePath} to ${newFilePath}:`, e);
  }
};

io.use(async (socket, next) => {
  const handshakeSchema = z.object({
    userId: z.string(),
    sandboxId: z.string(),
    EIO: z.string(),
    transport: z.string(),
  });

  const q = socket.handshake.query;
  const parseQuery = handshakeSchema.safeParse(q);

  if (!parseQuery.success) {
    next(new Error("Invalid request."));
    return;
  }

  const { sandboxId, userId } = parseQuery.data;
  const dbUser = await fetch(
    `${process.env.DATABASE_WORKER_URL}/api/user?id=${userId}`,
    {
      headers: {
        Authorization: `${process.env.WORKERS_KEY}`,
      },
    }
  );
  const dbUserJSON = (await dbUser.json()) as User;

  if (!dbUserJSON) {
    next(new Error("DB error."));
    return;
  }

  const sandbox = dbUserJSON.sandbox.find((s) => s.id === sandboxId);
  const sharedSandboxes = dbUserJSON.usersToSandboxes.find(
    (uts) => uts.sandboxId === sandboxId
  );

  if (!sandbox && !sharedSandboxes) {
    next(new Error("Invalid credentials."));
    return;
  }

  socket.data = {
    userId,
    sandboxId: sandboxId,
    isOwner: sandbox !== undefined,
  };

  next();
});

const lockManager = new LockManager();

if (!process.env.DOKKU_HOST) console.error('Environment variable DOKKU_HOST is not defined');
if (!process.env.DOKKU_USERNAME) console.error('Environment variable DOKKU_USERNAME is not defined');
if (!process.env.DOKKU_KEY) console.error('Environment variable DOKKU_KEY is not defined');

const client =
  process.env.DOKKU_HOST && process.env.DOKKU_KEY && process.env.DOKKU_USERNAME
    ? new DokkuClient({
        host: process.env.DOKKU_HOST,
        username: process.env.DOKKU_USERNAME,
        privateKey: fs.readFileSync(process.env.DOKKU_KEY),
      })
    : null;
client?.connect();

const git = process.env.DOKKU_HOST && process.env.DOKKU_KEY ? new SecureGitClient(
  `dokku@${process.env.DOKKU_HOST}`,
  process.env.DOKKU_KEY
) : null;

io.on("connection", async (socket) => {
  try {
    if (inactivityTimeout) clearTimeout(inactivityTimeout);

    const data = socket.data as {
      userId: string;
      sandboxId: string;
      isOwner: boolean;
    };

    if (data.isOwner) {
      isOwnerConnected = true;
      connections[data.sandboxId] = (connections[data.sandboxId] ?? 0) + 1;
    } else {
      if (!isOwnerConnected) {
        socket.emit("disableAccess", "The sandbox owner is not connected.");
        return;
      }
    }

    const createdContainer = await lockManager.acquireLock(data.sandboxId, async () => {
      try {
        // Start a new container if the container doesn't exist or it timed out.
        if (!containers[data.sandboxId] || !(await containers[data.sandboxId].isRunning())) {
          containers[data.sandboxId] = await Sandbox.create({ timeoutMs: CONTAINER_TIMEOUT });
          console.log("Created container ", data.sandboxId);
          return true;
        }
      } catch (e: any) {
        console.error(`Error creating container ${data.sandboxId}:`, e);
        io.emit("error", `Error: container creation. ${e.message ?? e}`);
      }
    });

    const sandboxFiles = await getSandboxFiles(data.sandboxId);
    const projectDirectory = path.posix.join(dirName, "projects", data.sandboxId);
    const containerFiles = containers[data.sandboxId].files;
    const fileWatchers: WatchHandle[] = [];

    // Change the owner of the project directory to user
    const fixPermissions = async (projectDirectory: string) => {
      try {
        await containers[data.sandboxId].commands.run(
          `sudo chown -R user "${projectDirectory}"`
        );
      } catch (e: any) {
        console.log("Failed to fix permissions: " + e);
      }
    };

    // Check if the given path is a directory
    const isDirectory = async (projectDirectory: string): Promise<boolean> => {
      try {
        const result = await containers[data.sandboxId].commands.run(
          `[ -d "${projectDirectory}" ] && echo "true" || echo "false"`
        );
        return result.stdout.trim() === "true";
      } catch (e: any) {
        console.log("Failed to check if directory: " + e);
        return false;
      }
    };

    // Only continue to container setup if a new container was created
    if (createdContainer) {

      // Copy all files from the project to the container
      const promises = sandboxFiles.fileData.map(async (file) => {
        try {
          const filePath = path.posix.join(dirName, file.id);
          const parentDirectory = path.dirname(filePath);
          if (!containerFiles.exists(parentDirectory)) {
            await containerFiles.makeDir(parentDirectory);
          }
          await containerFiles.write(filePath, file.data);
        } catch (e: any) {
          console.log("Failed to create file: " + e);
        }
      });
      await Promise.all(promises);

      // Make the logged in user the owner of all project files
      fixPermissions(projectDirectory);

    }

    // Start filesystem watcher for the project directory
    const watchDirectory = async (directory: string): Promise<WatchHandle | undefined> => {
      try {
        return await containerFiles.watch(directory, async (event: FilesystemEvent) => {
          try {

            function removeDirName(path : string, dirName : string) {
                return path.startsWith(dirName) ? path.slice(dirName.length) : path;
            }

            // This is the absolute file path in the container
            const containerFilePath = path.posix.join(directory, event.name);
            // This is the file path relative to the home directory
            const sandboxFilePath = removeDirName(containerFilePath, dirName + "/");
            // This is the directory being watched relative to the home directory
            const sandboxDirectory = removeDirName(directory, dirName + "/");

            // Helper function to find a folder by id
            function findFolderById(files: (TFolder | TFile)[], folderId : string) {
              return files.find((file : TFolder | TFile) => file.type === "folder" && file.id === folderId);
            }

            // A new file or directory was created.
            if (event.type === "create") {
              const folder = findFolderById(sandboxFiles.files, sandboxDirectory) as TFolder;
              const isDir = await isDirectory(containerFilePath);

              const newItem = isDir
                ? { id: sandboxFilePath, name: event.name, type: "folder", children: [] } as TFolder
                : { id: sandboxFilePath, name: event.name, type: "file" } as TFile;

              if (folder) {
                // If the folder exists, add the new item (file/folder) as a child
                folder.children.push(newItem);
              } else {
                // If folder doesn't exist, add the new item to the root
                sandboxFiles.files.push(newItem);
              }

              if (!isDir) {
                const fileData = await containers[data.sandboxId].files.read(containerFilePath);
                const fileContents = typeof fileData === "string" ? fileData : "";
                sandboxFiles.fileData.push({ id: sandboxFilePath, data: fileContents });
              }

              console.log(`Create ${sandboxFilePath}`);
            }

            // A file or directory was removed or renamed.
            else if (event.type === "remove" || event.type == "rename") {
              const folder = findFolderById(sandboxFiles.files, sandboxDirectory) as TFolder;
              const isDir = await isDirectory(containerFilePath);

              const isFileMatch = (file: TFolder | TFile | TFileData) => file.id === sandboxFilePath || file.id.startsWith(containerFilePath + '/');

              if (folder) {
                // Remove item from its parent folder
                folder.children = folder.children.filter((file: TFolder | TFile) => !isFileMatch(file));
              } else {
                // Remove from the root if it's not inside a folder
                sandboxFiles.files = sandboxFiles.files.filter((file: TFolder | TFile) => !isFileMatch(file));
              }

              // Also remove any corresponding file data
              sandboxFiles.fileData = sandboxFiles.fileData.filter((file: TFileData) => !isFileMatch(file));

              console.log(`Removed: ${sandboxFilePath}`);
            }

            // The contents of a file were changed.
            else if (event.type === "write") {
              const folder = findFolderById(sandboxFiles.files, sandboxDirectory) as TFolder;
              const fileToWrite = sandboxFiles.fileData.find(file => file.id === sandboxFilePath);

              if (fileToWrite) {
                fileToWrite.data = await containers[data.sandboxId].files.read(containerFilePath);
                console.log(`Write to ${sandboxFilePath}`);
              } else {
                // If the file is part of a folder structure, locate it and update its data
                const fileInFolder = folder?.children.find(file => file.id === sandboxFilePath);
                if (fileInFolder) {
                  const fileData = await containers[data.sandboxId].files.read(containerFilePath);
                  const fileContents = typeof fileData === "string" ? fileData : "";
                  sandboxFiles.fileData.push({ id: sandboxFilePath, data: fileContents });
                  console.log(`Write to ${sandboxFilePath}`);
                }
              }
            }

            // Tell the client to reload the file list
            socket.emit("loaded", sandboxFiles.files);

          } catch (error) {
            console.error(`Error handling ${event.type} event for ${event.name}:`, error);
          }
        }, { "timeout": 0 } )
      } catch (error) {
        console.error(`Error watching filesystem:`, error);
      }
    };

    // Watch the project directory
    const handle = await watchDirectory(projectDirectory);
    // Keep track of watch handlers to close later
    if (handle) fileWatchers.push(handle);

    // Watch all subdirectories of the project directory, but not deeper
    // This also means directories created after the container is created won't be watched
    const dirContent = await containerFiles.list(projectDirectory);
    await Promise.all(dirContent.map(async (item : EntryInfo) => {
      if (item.type === "dir") {
        console.log("Watching " + item.path);
        // Keep track of watch handlers to close later
        const handle = await watchDirectory(item.path);
        if (handle) fileWatchers.push(handle);
      }
    }))
  
    socket.emit("loaded", sandboxFiles.files);

    socket.on("heartbeat", async () => {
      try {
        // This keeps the container alive for another CONTAINER_TIMEOUT seconds.
        // The E2B docs are unclear, but the timeout is relative to the time of this method call. 
        await containers[data.sandboxId].setTimeout(CONTAINER_TIMEOUT);
      } catch (e: any) {
        console.error("Error setting timeout:", e);
        io.emit("error", `Error: set timeout. ${e.message ?? e}`);
      }
    });

    socket.on("getFile", (fileId: string, callback) => {
      console.log(fileId);
      try {
        const file = sandboxFiles.fileData.find((f) => f.id === fileId);
        if (!file) return;

        callback(file.data);
      } catch (e: any) {
        console.error("Error getting file:", e);
        io.emit("error", `Error: get file. ${e.message ?? e}`);
      }
    });

    socket.on("getFolder", async (folderId: string, callback) => {
      try {
        const files = await getFolder(folderId);
        callback(files);
      } catch (e: any) {
        console.error("Error getting folder:", e);
        io.emit("error", `Error: get folder. ${e.message ?? e}`);
      }
    });

    // todo: send diffs + debounce for efficiency
    socket.on("saveFile", async (fileId: string, body: string) => {
      if (!fileId) return; // handles saving when no file is open

      try {
        if (Buffer.byteLength(body, "utf-8") > MAX_BODY_SIZE) {
          socket.emit(
            "error",
            "Error: file size too large. Please reduce the file size."
          );
          return;
        }
        try {
          await saveFileRL.consume(data.userId, 1);
          await saveFile(fileId, body);
        } catch (e) {
          io.emit("error", "Rate limited: file saving. Please slow down.");
          return;
        }

        const file = sandboxFiles.fileData.find((f) => f.id === fileId);
        if (!file) return;
        file.data = body;

        await containers[data.sandboxId].files.write(
          path.posix.join(dirName, file.id),
          body
        );
        fixPermissions(projectDirectory);
      } catch (e: any) {
        console.error("Error saving file:", e);
        io.emit("error", `Error: file saving. ${e.message ?? e}`);
      }
    });

    socket.on(
      "moveFile",
      async (fileId: string, folderId: string, callback) => {
        try {
          const file = sandboxFiles.fileData.find((f) => f.id === fileId);
          if (!file) return;

          const parts = fileId.split("/");
          const newFileId = folderId + "/" + parts.pop();

          await moveFile(
            containers[data.sandboxId].files,
            path.posix.join(dirName, fileId),
            path.posix.join(dirName, newFileId)
          );
          fixPermissions(projectDirectory);

          file.id = newFileId;

          await renameFile(fileId, newFileId, file.data);
          const newFiles = await getSandboxFiles(data.sandboxId);
          callback(newFiles.files);
        } catch (e: any) {
          console.error("Error moving file:", e);
          io.emit("error", `Error: file moving. ${e.message ?? e}`);
        }
      }
    );

    interface CallbackResponse {
      success: boolean;
      apps?: string[];
      message?: string;
    }

    socket.on(
      "list",
      async (callback: (response: CallbackResponse) => void) => {
        console.log("Retrieving apps list...");
        try {
          if (!client) throw Error("Failed to retrieve apps list: No Dokku client")
          callback({
            success: true,
            apps: await client.listApps()
          });
        } catch (error) {
          callback({
            success: false,
            message: "Failed to retrieve apps list",
          });
        }
      }
    );

    socket.on(
      "deploy",
      async (callback: (response: CallbackResponse) => void) => {
        try {
          // Push the project files to the Dokku server
          console.log("Deploying project ${data.sandboxId}...");
          if (!git) throw Error("Failed to retrieve apps list: No git client")
          // Remove the /project/[id]/ component of each file path:
          const fixedFilePaths = sandboxFiles.fileData.map((file) => {
            return {
              ...file,
              id: file.id.split("/").slice(2).join("/"),
            };
          });
          // Push all files to Dokku.
          await git.pushFiles(fixedFilePaths, data.sandboxId);
          callback({
            success: true,
          });
        } catch (error) {
          callback({
            success: false,
            message: "Failed to deploy project: " + error,
          });
        }
      }
    );

    socket.on("createFile", async (name: string, callback) => {
      try {
        const size: number = await getProjectSize(data.sandboxId);
        // limit is 200mb
        if (size > 200 * 1024 * 1024) {
          io.emit(
            "error",
            "Rate limited: project size exceeded. Please delete some files."
          );
          callback({ success: false });
          return;
        }

        try {
          await createFileRL.consume(data.userId, 1);
        } catch (e) {
          io.emit("error", "Rate limited: file creation. Please slow down.");
          return;
        }

        const id = `projects/${data.sandboxId}/${name}`;

        await containers[data.sandboxId].files.write(
          path.posix.join(dirName, id),
          ""
        );
        fixPermissions(projectDirectory);

        sandboxFiles.files.push({
          id,
          name,
          type: "file",
        });

        sandboxFiles.fileData.push({
          id,
          data: "",
        });

        await createFile(id);

        callback({ success: true });
      } catch (e: any) {
        console.error("Error creating file:", e);
        io.emit("error", `Error: file creation. ${e.message ?? e}`);
      }
    });

    socket.on("createFolder", async (name: string, callback) => {
      try {
        try {
          await createFolderRL.consume(data.userId, 1);
        } catch (e) {
          io.emit("error", "Rate limited: folder creation. Please slow down.");
          return;
        }

        const id = `projects/${data.sandboxId}/${name}`;

        await containers[data.sandboxId].files.makeDir(
          path.posix.join(dirName, id)
        );

        callback();
      } catch (e: any) {
        console.error("Error creating folder:", e);
        io.emit("error", `Error: folder creation. ${e.message ?? e}`);
      }
    });

    socket.on("renameFile", async (fileId: string, newName: string) => {
      try {
        try {
          await renameFileRL.consume(data.userId, 1);
        } catch (e) {
          io.emit("error", "Rate limited: file renaming. Please slow down.");
          return;
        }

        const file = sandboxFiles.fileData.find((f) => f.id === fileId);
        if (!file) return;
        file.id = newName;

        const parts = fileId.split("/");
        const newFileId =
          parts.slice(0, parts.length - 1).join("/") + "/" + newName;

        await moveFile(
          containers[data.sandboxId].files,
          path.posix.join(dirName, fileId),
          path.posix.join(dirName, newFileId)
        );
        fixPermissions(projectDirectory);
        await renameFile(fileId, newFileId, file.data);
      } catch (e: any) {
        console.error("Error renaming folder:", e);
        io.emit("error", `Error: folder renaming. ${e.message ?? e}`);
      }
    });

    socket.on("deleteFile", async (fileId: string, callback) => {
      try {
        try {
          await deleteFileRL.consume(data.userId, 1);
        } catch (e) {
          io.emit("error", "Rate limited: file deletion. Please slow down.");
        }

        const file = sandboxFiles.fileData.find((f) => f.id === fileId);
        if (!file) return;

        await containers[data.sandboxId].files.remove(
          path.posix.join(dirName, fileId)
        );
        sandboxFiles.fileData = sandboxFiles.fileData.filter(
          (f) => f.id !== fileId
        );

        await deleteFile(fileId);

        const newFiles = await getSandboxFiles(data.sandboxId);
        callback(newFiles.files);
      } catch (e: any) {
        console.error("Error deleting file:", e);
        io.emit("error", `Error: file deletion. ${e.message ?? e}`);
      }
    });

    // todo
    // socket.on("renameFolder", async (folderId: string, newName: string) => {
    // });

    socket.on("deleteFolder", async (folderId: string, callback) => {
      try {
        const files = await getFolder(folderId);

        await Promise.all(
          files.map(async (file) => {
            await containers[data.sandboxId].files.remove(
              path.posix.join(dirName, file)
            );

            sandboxFiles.fileData = sandboxFiles.fileData.filter(
              (f) => f.id !== file
            );

            await deleteFile(file);
          })
        );

        const newFiles = await getSandboxFiles(data.sandboxId);

        callback(newFiles.files);
      } catch (e: any) {
        console.error("Error deleting folder:", e);
        io.emit("error", `Error: folder deletion. ${e.message ?? e}`);
      }
    });

    socket.on("createTerminal", async (id: string, callback) => {
      try {
        // Note: The number of terminals per window is limited on the frontend, but not backend
        if (terminals[id]) {
          return;
        }

        await lockManager.acquireLock(data.sandboxId, async () => {
          try {
            terminals[id] = new Terminal(containers[data.sandboxId])
            await terminals[id].init({
              onData: (responseString: string) => {
                io.emit("terminalResponse", { id, data: responseString });

                function extractPortNumber(inputString: string) {
                  // Remove ANSI escape codes
                  const cleanedString = inputString.replace(/\x1B\[[0-9;]*m/g, '');

                  // Regular expression to match port number
                  const regex = /http:\/\/localhost:(\d+)/;
                  // If a match is found, return the port number
                  const match = cleanedString.match(regex);
                  return match ? match[1] : null;
                }
                const port = parseInt(extractPortNumber(responseString) ?? "");
                if (port) {
                  io.emit(
                    "previewURL",
                    "https://" + containers[data.sandboxId].getHost(port)
                  );
                }
              },
              cols: 80,
              rows: 20,
              //onExit: () => console.log("Terminal exited", id),
            });

            const defaultDirectory = path.posix.join(dirName, "projects", data.sandboxId);
            const defaultCommands = [
              `cd "${defaultDirectory}"`,
              "export PS1='user> '",
              "clear"
            ]
            for (const command of defaultCommands) await terminals[id].sendData(command + "\r");

            console.log("Created terminal", id);
          } catch (e: any) {
            console.error(`Error creating terminal ${id}:`, e);
            io.emit("error", `Error: terminal creation. ${e.message ?? e}`);
          }
        });

        callback();
      } catch (e: any) {
        console.error(`Error creating terminal ${id}:`, e);
        io.emit("error", `Error: terminal creation. ${e.message ?? e}`);
      }
    });

    socket.on(
      "resizeTerminal",
      (dimensions: { cols: number; rows: number }) => {
        try {
          Object.values(terminals).forEach((t) => {
            t.resize(dimensions);
          });
        } catch (e: any) {
          console.error("Error resizing terminal:", e);
          io.emit("error", `Error: terminal resizing. ${e.message ?? e}`);
        }
      }
    );

    socket.on("terminalData", async (id: string, data: string) => {
      try {
        if (!terminals[id]) {
          return;
        }

        await terminals[id].sendData(data);
      } catch (e: any) {
        console.error("Error writing to terminal:", e);
        io.emit("error", `Error: writing to terminal. ${e.message ?? e}`);
      }
    });

    socket.on("closeTerminal", async (id: string, callback) => {
      try {
        if (!terminals[id]) {
          return;
        }

        await terminals[id].close();
        delete terminals[id];

        callback();
      } catch (e: any) {
        console.error("Error closing terminal:", e);
        io.emit("error", `Error: closing terminal. ${e.message ?? e}`);
      }
    });

    socket.on(
      "generateCode",
      async (
        fileName: string,
        code: string,
        line: number,
        instructions: string,
        callback
      ) => {
        try {
          const fetchPromise = fetch(
            `${process.env.DATABASE_WORKER_URL}/api/sandbox/generate`,
            {
              method: "POST",
              headers: {
                "Content-Type": "application/json",
                Authorization: `${process.env.WORKERS_KEY}`,
              },
              body: JSON.stringify({
                userId: data.userId,
              }),
            }
          );

          // Generate code from cloudflare workers AI
          const generateCodePromise = fetch(
            `${process.env.AI_WORKER_URL}/api?fileName=${encodeURIComponent(fileName)}&code=${encodeURIComponent(code)}&line=${encodeURIComponent(line)}&instructions=${encodeURIComponent(instructions)}`,
            {
              headers: {
                "Content-Type": "application/json",
                Authorization: `${process.env.CF_AI_KEY}`,
              },
            }
          );

          const [fetchResponse, generateCodeResponse] = await Promise.all([
            fetchPromise,
            generateCodePromise,
          ]);

          const json = await generateCodeResponse.json();

          callback({ response: json.response, success: true });
        } catch (e: any) {
          console.error("Error generating code:", e);
          io.emit("error", `Error: code generation. ${e.message ?? e}`);
        }
      }
    );

    socket.on("disconnect", async () => {
      try {
        if (data.isOwner) {
          connections[data.sandboxId]--;
        }

        // Stop watching file changes in the container
        Promise.all(fileWatchers.map(async (handle : WatchHandle) => {
          await handle.close();
        }));

        if (data.isOwner && connections[data.sandboxId] <= 0) {
          socket.broadcast.emit(
            "disableAccess",
            "The sandbox owner has disconnected."
          );
        }

        // const sockets = await io.fetchSockets();
        // if (inactivityTimeout) {
        //   clearTimeout(inactivityTimeout);
        // }
        // if (sockets.length === 0) {
        //   console.log("STARTING TIMER");
        //   inactivityTimeout = setTimeout(() => {
        //     io.fetchSockets().then(async (sockets) => {
        //       if (sockets.length === 0) {
        //         console.log("Server stopped", res);
        //       }
        //     });
        //   }, 20000);
        // } else {
        //   console.log("number of sockets", sockets.length);
        // }
      } catch (e: any) {
        console.log("Error disconnecting:", e);
        io.emit("error", `Error: disconnecting. ${e.message ?? e}`);
      }
    });
  } catch (e: any) {
    console.error("Error connecting:", e);
    io.emit("error", `Error: connection. ${e.message ?? e}`);
  }
});

httpServer.listen(port, () => {
  console.log(`Server running on port ${port}`);
});