function isDockerAvailable(): boolean

import { spawnSync } from "child_process";

function isDockerAvailable(): boolean {
  try {
    const result = spawnSync("docker", ["info"], {
      stdio: "pipe",
      timeout: 5000,
    });
    return result.status === 0;
  } catch {
    return false;
  }
}

function generateDocsWithSandbox(sourcePath: string) {
  if (!isDockerAvailable()) {
    console.error(
      "Docker is not available. Sandboxed code execution requires Docker to be installed and running.\n" +
      "Install Docker at https://docs.docker.com/get-docker/ and ensure the daemon is started."
    );
    process.exit(1);
  }

  console.log("Docker detected — proceeding with sandboxed example generation.");
  // Container-dependent logic would follow here
  console.log(`Generating docs for: ${sourcePath}`);
}

generateDocsWithSandbox("./src");

// Output when Docker is running:
// Docker detected — proceeding with sandboxed example generation.
// Generating docs for: ./src

// Output when Docker is not running:
// Docker is not available. Sandboxed code execution requires Docker to be installed and running.
// Install Docker at https://docs.docker.com/get-docker/ and ensure the daemon is started.

function parseEnvironments(envString: string): DockerEnvironment[]

type DockerEnvironment = {
  name: string
  image: string
  port: number
}

const DOCKER_ENVIRONMENTS: DockerEnvironment[] = [
  { name: "development", image: "node:20-alpine", port: 3000 },
  { name: "staging",     image: "node:20-slim",   port: 8080 },
  { name: "production",  image: "node:20-slim",   port: 443  },
]

function parseEnvironments(envString: string): DockerEnvironment[] {
  const names = envString.split(",").map((s) => s.trim()).filter(Boolean)
  const envs: DockerEnvironment[] = []

  for (const name of names) {
    const env = DOCKER_ENVIRONMENTS.find((e) => e.name === name)
    if (env) envs.push(env)
  }

  return envs
}

// Simulates a value coming from a CLI flag: --envs "staging, production"
const cliInput = "staging, production"

const resolved = parseEnvironments(cliInput)

console.log(`Resolved ${resolved.length} environment(s):`)
for (const env of resolved) {
  console.log(`  ${env.name} → ${env.image} on port ${env.port}`)
}

// Expected output:
// Resolved 2 environment(s):
//   staging → node:20-slim on port 8080
//   production → node:20-slim on port 443

function getCompatibleEnvironments(language: string, environments: DockerEnvironment[]): DockerEnvironment[]

interface DockerEnvironment {
  id: string;
  image: string;
  languages: string[];
  description: string;
}

function getCompatibleEnvironments(
  language: string,
  environments: DockerEnvironment[]
): DockerEnvironment[] {
  return environments.filter((env) => env.languages.includes(language));
}

const allEnvironments: DockerEnvironment[] = [
  {
    id: "node-20",
    image: "skrypt/runner-node:20",
    languages: ["typescript", "javascript"],
    description: "Node.js 20 LTS runtime",
  },
  {
    id: "python-311",
    image: "skrypt/runner-python:3.11",
    languages: ["python"],
    description: "Python 3.11 runtime",
  },
  {
    id: "go-121",
    image: "skrypt/runner-go:1.21",
    languages: ["go"],
    description: "Go 1.21 runtime",
  },
  {
    id: "polyglot",
    image: "skrypt/runner-polyglot:latest",
    languages: ["typescript", "python", "go"],
    description: "Multi-language runtime for mixed projects",
  },
];

const compatible = getCompatibleEnvironments("typescript", allEnvironments);

console.log(`Found ${compatible.length} compatible environment(s) for TypeScript:`);
compatible.forEach((env) => {
  console.log(`  - ${env.id} (${env.image})`);
});

// Expected output:
// Found 2 compatible environment(s) for TypeScript:
//   - node-20 (skrypt/runner-node:20)
//   - polyglot (skrypt/runner-polyglot:latest)

async function runInDocker(snippet: ExtractedSnippet, environment: DockerEnvironment, config: RunnerConfig): Promise<TestResult>

type ExtractedSnippet = {
  id: string;
  language: "typescript" | "python";
  code: string;
  sourceFile: string;
};

type DockerEnvironment = {
  image: string;
  workdir: string;
};

type RunnerConfig = {
  timeoutMs: number;
  memoryLimitMb: number;
  failOnNonZeroExit: boolean;
};

type TestResult = {
  passed: boolean;
  exitCode: number;
  stdout: string;
  stderr: string;
  durationMs: number;
};

// Mock implementation — replace with actual runInDocker import in your project
async function runInDocker(
  snippet: ExtractedSnippet,
  environment: DockerEnvironment,
  config: RunnerConfig
): Promise<TestResult> {
  const start = Date.now();
  // Simulates a successful run of the snippet
  await new Promise((res) => setTimeout(res, 120));
  return {
    passed: true,
    exitCode: 0,
    stdout: "User created: usr_4f8a2b1c9d\n",
    stderr: "",
    durationMs: Date.now() - start,
  };
}

const snippet: ExtractedSnippet = {
  id: "snip_7e3d91a0b2",
  language: "typescript",
  sourceFile: "src/users/createUser.ts",
  code: `
    const user = { id: "usr_4f8a2b1c9d", email: "ada@example.com" };
    console.log("User created:", user.id);
  `,
};

const environment: DockerEnvironment = {
  image: "node:20-alpine",
  workdir: "/app",
};

const config: RunnerConfig = {
  timeoutMs: 10000,
  memoryLimitMb: 128,
  failOnNonZeroExit: true,
};

async function main() {
  try {
    const result = await runInDocker(snippet, environment, config);

    if (!result.passed) {
      console.error(`Snippet ${snippet.id} failed (exit ${result.exitCode}):`);
      console.error(result.stderr);
      process.exit(1);
    }

    console.log(`✓ Snippet ${snippet.id} passed in ${result.durationMs}ms`);
    console.log("Output:", result.stdout.trim());
    // Expected output:
    // ✓ Snippet snip_7e3d91a0b2 passed in 120ms
    // Output: User created: usr_4f8a2b1c9d
  } catch (err) {
    console.error("Docker runner error — is the Docker daemon running?", err);
    process.exit(1);
  }
}

main();