/**
 * @file Tests the DASHBOARD_CLIENT_DIST override in server/index.js. A plugin
 * install runs the server from a read-only plugin cache directory, so the
 * client bundle is served from the writable runtime dir instead of the
 * checkout's client/dist, with a hashed asset's pre-compressed `.br`/`.gz`
 * sibling sent to a browser that accepts it. Also asserts the API still answers when the
 * configured bundle directory does not exist yet (the normal state before
 * /agenthub-open builds it).
 * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
 */

const { describe, it, before, after } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("fs");
const os = require("os");
const path = require("path");
const http = require("http");

const TMP = fs.mkdtempSync(path.join(os.tmpdir(), "agenthub-clientdist-"));
const DIST = path.join(TMP, "client-dist");
fs.mkdirSync(DIST);
fs.writeFileSync(path.join(DIST, "index.html"), "<!doctype html><title>from-runtime</title>");
// A hashed bundle with the pre-compressed siblings the client build writes.
fs.mkdirSync(path.join(DIST, "assets"));
const BUNDLE = "console.log('plain bundle');".repeat(50);
fs.writeFileSync(path.join(DIST, "assets", "app-abc123.js"), BUNDLE);
fs.writeFileSync(
  path.join(DIST, "assets", "app-abc123.js.br"),
  require("zlib").brotliCompressSync(BUNDLE)
);
fs.writeFileSync(path.join(DIST, "assets", "app-abc123.js.gz"), require("zlib").gzipSync(BUNDLE));
fs.writeFileSync(path.join(DIST, "assets", "only-plain.css"), "body{}");

// Must be set BEFORE requiring the server: the data dir, discovery file and
// the static mount are all resolved at startup. NODE_ENV=production is the
// gate server/index.js uses to decide whether to serve the client bundle at
// all - this suite exercises exactly that code path, so it cannot rely on
// whatever NODE_ENV the ambient shell happens to have.
const PREV_NODE_ENV = process.env.NODE_ENV;
process.env.NODE_ENV = "production";
process.env.CLAUDE_HOME = TMP;
process.env.DASHBOARD_DB_PATH = path.join(TMP, "test.db");
process.env.DASHBOARD_LIVENESS_PROBE = "0";
process.env.DASHBOARD_CLIENT_DIST = DIST;

const { createApp, startServer } = require("../index");
const { db } = require("../db");

let server;
let BASE;

function get(urlPath, headers = {}) {
  return new Promise((resolve, reject) => {
    const req = http.get(new URL(urlPath, BASE), { headers }, (res) => {
      const chunks = [];
      res.on("data", (c) => chunks.push(c));
      res.on("end", () => {
        const raw = Buffer.concat(chunks);
        resolve({ status: res.statusCode, body: raw.toString(), raw, headers: res.headers });
      });
    });
    req.on("error", reject);
  });
}

describe("DASHBOARD_CLIENT_DIST override", () => {
  before(async () => {
    server = await startServer(createApp(), 0);
    BASE = `http://127.0.0.1:${server.address().port}`;
  });

  after(() => {
    if (server) server.close();
    if (db) db.close();
    fs.rmSync(TMP, { recursive: true, force: true });
    delete process.env.DASHBOARD_CLIENT_DIST;
  });

  it("serves index.html from the configured directory", async () => {
    const res = await get("/");
    assert.equal(res.status, 200);
    assert.match(res.body, /from-runtime/);
  });

  it("serves a hashed asset's pre-compressed sibling to a browser that takes it", async () => {
    const zlib = require("zlib");
    const br = await get("/assets/app-abc123.js", { "accept-encoding": "gzip, deflate, br" });
    assert.equal(br.status, 200);
    assert.equal(br.headers["content-encoding"], "br");
    assert.match(br.headers["content-type"], /javascript/);
    assert.match(br.headers.vary, /Accept-Encoding/i);
    assert.match(br.headers["cache-control"], /immutable/);
    assert.equal(zlib.brotliDecompressSync(br.raw).toString(), BUNDLE);

    const gz = await get("/assets/app-abc123.js", { "accept-encoding": "gzip" });
    assert.equal(gz.headers["content-encoding"], "gzip");
    assert.equal(zlib.gunzipSync(gz.raw).toString(), BUNDLE);

    const plain = await get("/assets/app-abc123.js", { "accept-encoding": "identity" });
    assert.equal(plain.headers["content-encoding"], undefined);
    assert.equal(plain.body, BUNDLE);

    // No sibling on disk: the plain file, as before.
    const css = await get("/assets/only-plain.css", { "accept-encoding": "br" });
    assert.equal(css.headers["content-encoding"], undefined);
    assert.equal(css.body, "body{}");
    // A name that is not a flat file name never reaches the disk lookup.
    const walk = await get("/assets/..%2findex.html", { "accept-encoding": "br" });
    assert.equal(walk.headers["content-encoding"], undefined);
  });

  it("keeps the API working alongside the override", async () => {
    const res = await get("/api/health");
    assert.equal(res.status, 200);
  });
});

describe("DASHBOARD_CLIENT_DIST pointing at a missing directory", () => {
  let srv;
  let base;

  before(async () => {
    process.env.DASHBOARD_CLIENT_DIST = path.join(TMP, "not-built-yet");
    srv = await startServer(createApp(), 0);
    base = `http://127.0.0.1:${srv.address().port}`;
  });

  after(() => {
    if (srv) srv.close();
    process.env.NODE_ENV = PREV_NODE_ENV;
  });

  it("answers the API and only 404s the UI route", async () => {
    const prevBase = BASE;
    BASE = base;
    try {
      const health = await get("/api/health");
      assert.equal(health.status, 200);
      const ui = await get("/");
      assert.equal(ui.status, 404);
    } finally {
      BASE = prevBase;
    }
  });
});