import {
  artifactRegistryReadonlyResultFromCommand,
  buildArtifactRegistryReadonlyProbe,
  parseArtifactRegistryOptions,
} from "./src/artifact-registry";
import type { CommandResult } from "./src/command";

type JsonRecord = Record<string, unknown>;

function assertCondition(condition: unknown, message: string, detail: unknown = {}): void {
  if (!condition) throw new Error(`${message}: ${JSON.stringify(detail)}`);
}

function asRecord(value: unknown, label: string): JsonRecord {
  assertCondition(typeof value === "object" && value !== null && !Array.isArray(value), `${label} must be an object`, { value });
  return value as JsonRecord;
}

function asStringArray(value: unknown, label: string): string[] {
  assertCondition(Array.isArray(value), `${label} must be an array`, { value });
  return (value as unknown[]).map(String);
}

function command(overrides: Partial<CommandResult>): CommandResult {
  return {
    command: ["frontend", "/api/dispatch", "D601", "host.ssh", "health"],
    cwd: ".",
    exitCode: 0,
    stdout: "",
    stderr: "",
    signal: null,
    timedOut: false,
    ...overrides,
  };
}

const options = parseArtifactRegistryOptions(["--provider-id", "D601"]);
const probe = buildArtifactRegistryReadonlyProbe("health", options);
assertCondition(Buffer.byteLength(probe.script, "utf8") < 4000, "readonly registry probe script must fit provider-gateway host.ssh command length limit", {
  bytes: Buffer.byteLength(probe.script, "utf8"),
  remoteCommandShape: probe.remoteCommandShape,
});

const missing = asRecord(artifactRegistryReadonlyResultFromCommand(probe, command({
  exitCode: 1,
  stderr: "provider does not declare host.ssh capability: D601\n",
})), "missing provider ssh result");
assertCondition(missing.ok === false, "missing provider ssh command should fail", missing);
assertCondition(missing.failureClassification === "provider-ssh-command-missing", "missing provider ssh command classification mismatch", missing);
assertCondition(asStringArray(missing.failedScopes, "missing.failedScopes").includes("provider-ssh-command"), "missing provider ssh command scope should be reported", missing);
assertCondition(typeof missing.recommendedAction === "string" && missing.recommendedAction.length > 0, "missing provider ssh command should include recommendedAction", missing);
assertCondition(typeof missing.remoteCommandShape === "string" && missing.remoteCommandShape.includes("bash -lc"), "missing provider ssh command should include remoteCommandShape", missing);

const commandShape = asRecord(artifactRegistryReadonlyResultFromCommand(probe, command({
  exitCode: 1,
  stderr: "Error: host SSH command is too long: 4039 bytes\n",
})), "command shape result");
assertCondition(commandShape.ok === false, "oversized host.ssh command should fail", commandShape);
assertCondition(commandShape.failureClassification === "ssh-helper-command-shape-incompatible", "oversized host.ssh command classification mismatch", commandShape);
assertCondition(asStringArray(commandShape.failedScopes, "commandShape.failedScopes").includes("ssh-helper-command-shape"), "oversized host.ssh command scope should be reported", commandShape);

const timeout = asRecord(artifactRegistryReadonlyResultFromCommand(probe, command({
  exitCode: null,
  stderr: "host.ssh task task_contract did not finish within 30000ms\n",
  timedOut: true,
})), "timeout result");
assertCondition(timeout.ok === false, "remote timeout should fail", timeout);
assertCondition(timeout.failureClassification === "remote-command-timeout", "remote timeout classification mismatch", timeout);
assertCondition(asStringArray(timeout.failedScopes, "timeout.failedScopes").includes("remote-command-timeout"), "remote timeout scope should be reported", timeout);
assertCondition(timeout.retryable === true, "remote timeout should be retryable", timeout);

const successStdout = [
  "readonly=true",
  "unit_path=/etc/systemd/system/unidesk-artifact-registry.service",
  "compose_path=/home/ubuntu/.unidesk/artifact-registry/compose.yml",
  "config_path=/home/ubuntu/.unidesk/artifact-registry/config.yml",
  "storage_path=/home/ubuntu/.unidesk/registry-storage",
  "unit_exists=true",
  "compose_exists=true",
  "config_exists=true",
  "storage_exists=true",
  "systemctl_available=true",
  "unit_active=active",
  "unit_enabled=enabled",
  "docker_available=true",
  "container_running=true",
  "container_status=running",
  "container_image=registry:2.8.3",
  "container_restart_policy=unless-stopped",
  "listener_count=1",
  "bad_listener_count=0",
  "loopback_only=true",
  "curl_available=true",
  "v2_http_code=200",
  "config_hash=contract-config",
  "compose_hash=contract-compose",
  "unit_hash=contract-unit",
  "expected_config_hash=contract-config",
  "expected_compose_hash=contract-compose",
  "expected_unit_hash=contract-unit",
  "config_hash_matches=true",
  "compose_hash_matches=true",
  "unit_hash_matches=true",
  "image_matches=true",
  "",
].join("\n");

const success = asRecord(artifactRegistryReadonlyResultFromCommand(probe, command({
  stdout: successStdout,
})), "success result");
assertCondition(success.ok === true, "healthy registry command should pass", success);
assertCondition(success.failureClassification === null, "healthy registry should not have a failure classification", success);
assertCondition(asStringArray(success.failedScopes, "success.failedScopes").length === 0, "healthy registry should not have failed scopes", success);
assertCondition(success.recommendedAction === "none", "healthy registry recommendedAction should be none", success);
assertCondition(success.remoteCommandShape === probe.remoteCommandShape, "healthy registry should echo remote command shape", success);

process.stdout.write(`${JSON.stringify({
  ok: true,
  checks: [
    "provider-ssh-command missing is classified distinctly",
    "oversized host.ssh command shape is classified distinctly",
    "remote host.ssh timeout is classified distinctly",
    "successful registry readonly probe has no failed scopes",
  ],
  classifications: {
    missing: missing.failureClassification,
    commandShape: commandShape.failureClassification,
    timeout: timeout.failureClassification,
    success: success.failureClassification,
  },
}, null, 2)}\n`);