import fs from "node:fs";
import path from "node:path";
import { describe, expect, it } from "vitest";
import type { OpenClawConfig } from "../config/types.openclaw.js";
import { withTempDirSync } from "../test-helpers/temp-dir.js";
import { withEnv } from "../test-utils/env.js";
import { shouldIncludeHook } from "./config.js";
import { buildWorkspaceHookStatus } from "./hooks-status.js";
import type { HookEntry } from "./types.js";

const ENV_NAME = "OPENCLAW_TEST_HOOK_REQUIRED_ENV";
const HOOK_NAME = "required-env-hook";

const entry: HookEntry = {
  hook: {
    name: HOOK_NAME,
    description: "Requires an environment variable",
    source: "openclaw-bundled",
    filePath: "/tmp/HOOK.md",
    baseDir: "/tmp",
    handlerPath: "/tmp/handler.js",
  },
  frontmatter: {},
  metadata: {
    events: ["command:new"],
    requires: { env: [ENV_NAME] },
  },
};

function configWithEnv(value: string): OpenClawConfig {
  return {
    hooks: {
      internal: {
        entries: {
          [HOOK_NAME]: { env: { [ENV_NAME]: value } },
        },
      },
    },
  };
}

function evaluate(config?: OpenClawConfig) {
  const runtimeIncluded = shouldIncludeHook({ entry, config });
  const status = buildWorkspaceHookStatus("/tmp", { entries: [entry], config }).hooks[0];
  return { runtimeIncluded, status };
}

it("includes a hook after an accepted binary is installed on unchanged PATH", () => {
  withTempDirSync({ prefix: "openclaw-hook-binary-" }, (binDir) => {
    const binaryEntry: HookEntry = {
      ...entry,
      metadata: { events: ["command:new"], requires: { anyBins: ["fixture-hook-tool"] } },
    };
    withEnv({ PATH: binDir }, () => {
      const included = () => shouldIncludeHook({ entry: binaryEntry });
      expect(included()).toBe(false);
      const executable = path.join(binDir, "fixture-hook-tool");
      fs.writeFileSync(executable, "#!/bin/sh\nexit 0\n");
      fs.chmodSync(executable, 0o755);
      expect(process.env.PATH).toBe(binDir);
      expect(included()).toBe(true);
    });
  });
});

describe("hook environment requirements", () => {
  it.each([
    { name: "missing values", hostEnv: undefined, configEnv: undefined, satisfied: false },
    { name: "blank host env", hostEnv: " \t ", configEnv: undefined, satisfied: false },
    { name: "blank config env", hostEnv: undefined, configEnv: " \n ", satisfied: false },
    { name: "valid host env", hostEnv: " host-token ", configEnv: undefined, satisfied: true },
    { name: "valid config env", hostEnv: undefined, configEnv: " config-token ", satisfied: true },
    {
      name: "valid config env after blank host env",
      hostEnv: "   ",
      configEnv: " config-token ",
      satisfied: true,
    },
  ])("keeps runtime and status aligned for $name", ({ hostEnv, configEnv, satisfied }) => {
    const { runtimeIncluded, status } = withEnv({ [ENV_NAME]: hostEnv }, () =>
      evaluate(configEnv === undefined ? undefined : configWithEnv(configEnv)),
    );

    expect(runtimeIncluded).toBe(satisfied);
    expect(status?.requirementsSatisfied).toBe(satisfied);
    expect(status?.loadable).toBe(satisfied);
    expect(status?.missing.env).toEqual(satisfied ? [] : [ENV_NAME]);
  });
});