import assert from "node:assert/strict";
import test from "node:test";

import { createControlCoreApp } from "../src/app.mjs";

const managementToken = "test-only-management-token-with-32-bytes";

test("management API forwards a normalized generic Edge registration", async () => {
  let executed;
  const runtime = await startServer({
    managementApiEnabled: true,
    managementToken,
    repository: {
      health: async () => "ready",
      executeManagementCommand: async (input) => {
        executed = input;
        return { replayed: false, result: { created: true } };
      },
    },
  });
  try {
    const response = await fetch(
      `${runtime.baseUrl}/internal/v1/management/edges:ensure`,
      {
        method: "POST",
        headers: managementHeaders(),
        body: JSON.stringify({
          edgeKey: "generic-edge",
          displayName: "Generic Edge",
          deploymentRef: "deployment:device-edge/pilot",
        }),
      },
    );

    assert.equal(response.status, 200);
    assert.equal(executed.commandKind, "edge.ensure");
    assert.deepEqual(executed.command, {
      edgeKey: "generic-edge",
      displayName: "Generic Edge",
      deploymentRef: "deployment:device-edge/pilot",
      lifecycleState: "provisioning",
    });
    assert.equal(executed.actor.hubRole, "owner");
  } finally {
    await runtime.close();
  }
});

test("management API exposes no user-owned session mutation", async () => {
  let executions = 0;
  const runtime = await startServer({
    managementApiEnabled: true,
    managementToken,
    repository: {
      health: async () => "ready",
      executeManagementCommand: async () => {
        executions += 1;
        return { replayed: false, result: {} };
      },
    },
  });
  try {
    const response = await fetch(
      `${runtime.baseUrl}/internal/v1/management/sessions:ensure`,
      {
        method: "POST",
        headers: managementHeaders(),
        body: "{}",
      },
    );

    assert.equal(response.status, 404);
    assert.equal(executions, 0);
  } finally {
    await runtime.close();
  }
});

async function startServer(options) {
  const server = createControlCoreApp(options);
  await new Promise((resolve, reject) => {
    server.once("error", reject);
    server.listen(0, "127.0.0.1", resolve);
  });
  const address = server.address();
  return {
    baseUrl: `http://127.0.0.1:${address.port}`,
    close: () => new Promise((resolve, reject) => {
      server.close((error) => (error ? reject(error) : resolve()));
    }),
  };
}

function managementHeaders() {
  return {
    Authorization: `Bearer ${managementToken}`,
    "Content-Type": "application/json",
    "Idempotency-Key": "phase23-edge-0001",
    "X-NODEDC-User-Ref": "user:platform-owner",
    "X-NODEDC-Hub-Role": "owner",
  };
}