import { describe, expect, it } from "vitest";
import {
  nativeAcpRunnerCommandFromEnvironment,
  parseDeploymentConfig,
  serializeNativeAcpInjection,
  type DeploymentConfig,
} from "../../apps/control-plane/src/deployment-config.js";

describe("control-plane deployment configuration", () => {
  it("defaults to a configuration that serializes no injection", () => {
    const config = parseDeploymentConfig({}, { nativeAcpEnabled: false });
    expect(config).toEqual({ mode: "default" });
    expect(serializeNativeAcpInjection(config)).toEqual({});
  });

  it("allows production while always serializing no injection", () => {
    const config = parseDeploymentConfig(
      { AWP_DEPLOYMENT_MODE: "production" },
      { nativeAcpEnabled: true },
    );
    expect(config).toEqual({ mode: "production" });
    expect(serializeNativeAcpInjection(config)).toEqual({});
  });

  it("accepts only the fixed dogfood native ACP injection", () => {
    const config = parseDeploymentConfig(
      {
        AWP_DEPLOYMENT_MODE: "dogfood",
        AWP_DOGFOOD_NATIVE_ACP_FAIL_AFTER_PROMPT_ON_INITIAL: "1",
      },
      { nativeAcpEnabled: true },
    );
    expect(config).toEqual({
      mode: "dogfood",
      nativeAcpInjection: "fail-after-prompt-on-initial",
    });
    expect(serializeNativeAcpInjection(config)).toEqual({
      AWP_DOGFOOD_NATIVE_ACP_FAIL_AFTER_PROMPT_ON_INITIAL: "1",
    });
  });

  it("propagates the validated injection into the native workspace launch", () => {
    const env = {
      AWP_NATIVE_ACP_ENABLED: "1",
      AWP_WORKSPACE_IMAGE: `registry.example/runner@sha256:${"a".repeat(64)}`,
      AWP_DEPLOYMENT_MODE: "dogfood",
      AWP_DOGFOOD_NATIVE_ACP_FAIL_AFTER_PROMPT_ON_INITIAL: "1",
    };
    expect(nativeAcpRunnerCommandFromEnvironment(env, { nativeAcpEnabled: true })).toEqual([
      "env",
      "AWP_DOGFOOD_NATIVE_ACP_FAIL_AFTER_PROMPT_ON_INITIAL=1",
      "node",
      "/opt/awp-agent-runner/runner.mjs",
    ]);
  });

  it.each(["default", "production"] as const)(
    "does not alter the native launch command in %s mode",
    (mode) => {
      const env = {
        AWP_NATIVE_ACP_ENABLED: "1",
        AWP_WORKSPACE_IMAGE: `registry.example/runner@sha256:${"b".repeat(64)}`,
        AWP_DEPLOYMENT_MODE: mode,
      };
      expect(
        nativeAcpRunnerCommandFromEnvironment(env, { nativeAcpEnabled: true }),
      ).toBeUndefined();
    },
  );

  it.each(["", "DOGFOOD", "staging", " dogfood", "dogfood "])(
    "rejects malformed deployment mode %j",
    (mode) => {
      expect(() =>
        parseDeploymentConfig({ AWP_DEPLOYMENT_MODE: mode }, { nativeAcpEnabled: true }),
      ).toThrow(/AWP_DEPLOYMENT_MODE/);
    },
  );

  it.each(["", "0", "true", "echo fail", "1; rm -rf /", " 1"])(
    "rejects arbitrary injection value %j",
    (value) => {
      expect(() =>
        parseDeploymentConfig(
          {
            AWP_DEPLOYMENT_MODE: "dogfood",
            AWP_DOGFOOD_NATIVE_ACP_FAIL_AFTER_PROMPT_ON_INITIAL: value,
          },
          { nativeAcpEnabled: true },
        ),
      ).toThrow(/must be exactly 1/);
    },
  );

  it("rejects injection outside dogfood", () => {
    expect(() =>
      parseDeploymentConfig(
        { AWP_DOGFOOD_NATIVE_ACP_FAIL_AFTER_PROMPT_ON_INITIAL: "1" },
        { nativeAcpEnabled: true },
      ),
    ).toThrow(/permitted only/);
  });

  it("rejects injection without the native ACP path", () => {
    expect(() =>
      parseDeploymentConfig(
        {
          AWP_DEPLOYMENT_MODE: "dogfood",
          AWP_DOGFOOD_NATIVE_ACP_FAIL_AFTER_PROMPT_ON_INITIAL: "1",
        },
        { nativeAcpEnabled: false },
      ),
    ).toThrow(/requires AWP_NATIVE_ACP_ENABLED=1/);
  });

  it("fails closed if an untyped caller supplies an unknown injection", () => {
    const malformed = {
      mode: "dogfood",
      nativeAcpInjection: "run-arbitrary-command",
    } as unknown as DeploymentConfig;
    expect(() => serializeNativeAcpInjection(malformed)).toThrow(/Unsupported/);
  });
});