const express = require("express");
const app = express();
const bodyParser = require("body-parser");
const cors = require("cors");
const reqValidate = require("./src/module/reqValidate");

const port = 7860;
const authToken = null;
global.browserLimit = 20;
global.timeOut = 60000;

global.browserLength = 0;
// Add a new global variable to hold the browser instance directly
global.browser = null;

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(cors());

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

if (server) {
  try {
    server.timeout = global.timeOut;
    server.keepAliveTimeout = global.timeOut + 5000;
    server.headersTimeout = global.timeOut + 6000;
  } catch (e) {
    console.error("Failed to set server timeouts:", e);
  }
}

// Require createBrowser, but don't immediately call it here.
// We'll manage its lifecycle from within the browser creation module itself.
require("./src/module/createBrowser");

const getSource = require("./src/endpoints/getSource");
const solveTurnstileMin = require("./src/endpoints/solveTurnstile.min");
const solveTurnstileMax = require("./src/endpoints/solveTurnstile.max");
const wafSession = require("./src/endpoints/wafSession");

async function handleRequest(fn, data) {
  try {
    return { ...(await fn(data)), code: 200 };
  } catch (err) {
    return { code: 500, message: String(err) };
  }
}

app.post("/cf-clearance-scraper", async (req, res) => {
  try {
    const data = req.body;
    const check = reqValidate(data);

    if (check !== true) {
      return res.status(400).json({ code: 400, message: "Bad Request", schema: check });
    }

    if (authToken && data.authToken !== authToken) {
      return res.status(401).json({ code: 401, message: "Unauthorized" });
    }

    if (global.browserLength >= global.browserLimit) {
      return res.status(429).json({ code: 429, message: "Too Many Requests" });
    }

    // Use global.browser instead of global.browser
    if (!global.browser) {
      return res.status(500).json({
        code: 500,
        message: "The scanner is not ready yet. Please try again a little later.",
      });
    }

    global.browserLength++;

    let result = { code: 500 };
    try {
      // Pass the active browser instance to the handler functions
      const requestData = { ...data, browser: global.browser };
      switch (data.mode) {
        case "source":
          result = await handleRequest(getSource, requestData);
          break;
        case "turnstile-min":
          result = await handleRequest(solveTurnstileMin, requestData);
          break;
        case "turnstile-max":
          result = await handleRequest(solveTurnstileMax, requestData);
          break;
        case "waf-session":
          result = await handleRequest(wafSession, requestData);
          break;
        default:
          result = { code: 400, message: "Invalid mode" };
      }
    } finally {
      global.browserLength--;
    }

    res.status(result.code ?? 500).json(result);
  } catch (e) {
    console.error("Error in /cf-clearance-scraper:", e);
    res.status(500).json({ code: 500, message: "Internal Server Error" });
  }
});

app.use((req, res) => {
  res.status(404).json({ code: 404, message: "Not Found" });
});