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

import { getEnv, getOptionalEnv, parseEnvInt, parseEnvIntInRange, parseEnvPort } from "../main/config/runtime-config";

function withEnv(name: string, value: string | undefined, run: () => void): void {
  const previousValue = process.env[name];

  if (value === undefined) {
    delete process.env[name];
  } else {
    process.env[name] = value;
  }

  try {
    run();
  } finally {
    if (previousValue === undefined) {
      delete process.env[name];
      return;
    }

    process.env[name] = previousValue;
  }
}

test("getOptionalEnv returns undefined for missing variable", () => {
  withEnv("TEST_OPTIONAL_ENV", undefined, () => {
    assert.equal(getOptionalEnv("TEST_OPTIONAL_ENV"), undefined);
  });
});

test("getOptionalEnv trims spaces and returns value", () => {
  withEnv("TEST_OPTIONAL_ENV", "  scoreko  ", () => {
    assert.equal(getOptionalEnv("TEST_OPTIONAL_ENV"), "scoreko");
  });
});

test("getEnv returns fallback for empty value", () => {
  withEnv("TEST_ENV", "   ", () => {
    assert.equal(getEnv("TEST_ENV", "fallback"), "fallback");
  });
});

test("getEnv returns the value when present", () => {
  withEnv("TEST_ENV", "value", () => {
    assert.equal(getEnv("TEST_ENV", "fallback"), "value");
  });
});

test("parseEnvInt returns fallback for invalid values", () => {
  withEnv("TEST_ENV_INT", "abc", () => {
    assert.equal(parseEnvInt("TEST_ENV_INT", 100), 100);
  });
});

test("parseEnvInt parses valid integers", () => {
  withEnv("TEST_ENV_INT", "4500", () => {
    assert.equal(parseEnvInt("TEST_ENV_INT", 100), 4500);
  });
});

test("parseEnvIntInRange hard-fails for out-of-range values", () => {
  withEnv("TEST_ENV_INT_RANGE", "999", () => {
    assert.throws(() => parseEnvIntInRange("TEST_ENV_INT_RANGE", 100, 0, 100), /must be an integer/);
  });
});

test("parseEnvIntInRange accepts valid value", () => {
  withEnv("TEST_ENV_INT_RANGE", "42", () => {
    assert.equal(parseEnvIntInRange("TEST_ENV_INT_RANGE", 100, 0, 100), 42);
  });
});

test("parseEnvPort validates TCP range", () => {
  withEnv("TEST_ENV_PORT", "70000", () => {
    assert.throws(() => parseEnvPort("TEST_ENV_PORT", "9090"), /valid TCP port/);
  });
});

test("parseEnvPort normalizes valid port", () => {
  withEnv("TEST_ENV_PORT", "009090", () => {
    assert.equal(parseEnvPort("TEST_ENV_PORT", "9090"), "9090");
  });
});