import { createServer, type Server } from 'node:http';
import { readFile, stat } from 'node:fs/promises';
import { extname, join, resolve, sep } from 'node:path';

// Zero-dependency static file server for the mocked-backend CI driver.
//
// It replaces `frontend/scripts/e2e-server.js` (express-based) on purpose:
// that script resolves `express`/`compression` from `frontend/node_modules`,
// which the CI jobs never install (they only run `pnpm install` inside
// `plugins/` and restore the prebuilt bundle), so the driver crashed with
// ERR_MODULE_NOT_FOUND and timed out waiting for localhost:3000. Serving the
// bundle from here keeps the suite runnable with only `plugins/`
// dependencies — the documented local workflow — and identical in CI.
//
// NOTE on provenance: this file is duplicated in
// `plugins/apps/composable-test-suite/ci/static-server.ts`. Keep the two in
// sync (same as the mock harness in `run-ci.ts`).

const MIME_TYPES: Record<string, string> = {
  '.css': 'text/css; charset=utf-8',
  '.gif': 'image/gif',
  '.html': 'text/html; charset=utf-8',
  '.ico': 'image/x-icon',
  '.jpeg': 'image/jpeg',
  '.jpg': 'image/jpeg',
  '.js': 'application/javascript; charset=utf-8',
  '.json': 'application/json; charset=utf-8',
  '.map': 'application/json; charset=utf-8',
  '.mjs': 'application/javascript; charset=utf-8',
  '.otf': 'font/otf',
  '.png': 'image/png',
  '.svg': 'image/svg+xml',
  '.ttf': 'font/ttf',
  '.txt': 'text/plain; charset=utf-8',
  '.wasm': 'application/wasm',
  '.webmanifest': 'application/manifest+json',
  '.webp': 'image/webp',
  '.woff': 'font/woff',
  '.woff2': 'font/woff2',
  '.xml': 'application/xml; charset=utf-8',
};

const INDEX = 'index.html';

export interface StaticServer {
  /** Base URL the server listens on (e.g. `http://localhost:3000`). */
  url: string;
  /** Stop accepting connections; safe to call more than once. */
  close: () => Promise<void>;
}

/**
 * Serve `root` over HTTP on `port` (`0` picks a free port, reported in
 * `url`). Directory requests fall back to `index.html`; the app uses hash
 * routing, so no other fallback is needed.
 */
export function startStaticServer(
  root: string,
  port: number,
): Promise<StaticServer> {
  const docRoot = resolve(root);
  const server: Server = createServer(async (req, res) => {
    try {
      if (req.method !== 'GET' && req.method !== 'HEAD') {
        res.writeHead(405, { 'Content-Type': 'text/plain; charset=utf-8' });
        res.end('Method Not Allowed');
        return;
      }

      const rawPath = (req.url ?? '/').split(/[?#]/, 1)[0] ?? '/';
      let pathname: string;
      try {
        pathname = decodeURIComponent(rawPath);
      } catch {
        res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
        res.end('Bad Request');
        return;
      }

      const resolved = resolve(docRoot, `.${sep}${pathname}`);
      if (resolved !== docRoot && !resolved.startsWith(docRoot + sep)) {
        res.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' });
        res.end('Forbidden');
        return;
      }

      let filePath = resolved;
      const info = await stat(filePath).catch((error: unknown) => {
        if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
        throw error;
      });
      if (info === null) {
        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
        res.end('Not Found');
        return;
      }
      if (info.isDirectory()) {
        filePath = join(filePath, INDEX);
      }

      const body = await readFile(filePath).catch((error: unknown) => {
        if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
        throw error;
      });
      if (body === null) {
        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
        res.end('Not Found');
        return;
      }

      const contentType =
        MIME_TYPES[extname(filePath).toLowerCase()] ??
        'application/octet-stream';
      res.writeHead(200, {
        'Content-Type': contentType,
        'Content-Length': body.length,
      });
      res.end(req.method === 'GET' ? body : undefined);
    } catch {
      if (!res.headersSent) {
        res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
      }
      res.end('Internal Server Error');
    }
  });

  return new Promise((fulfill, reject) => {
    server.once('error', reject);
    server.listen(port, '0.0.0.0', () => {
      server.off('error', reject);
      const address = server.address();
      const actualPort =
        typeof address === 'object' && address !== null ? address.port : port;
      fulfill({
        url: `http://localhost:${actualPort}`,
        close: () =>
          new Promise<void>((done, fail) => {
            if (!server.listening) {
              done();
              return;
            }
            server.close((error) => (error ? fail(error) : done()));
          }),
      });
    });
  });
}