#!/usr/bin/env bash
#
# virtualisation-check.sh — discover virtualization tools and inspect their instances.
# Full documentation: see virtualisation-check.md in this same folder.

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
# shellcheck source=lib/common.sh
source "${SCRIPT_DIR}/../lib/common.sh"

SCRIPT_HELP=$(cat <<'HELP'
Usage: ./Virtualisation/virtualisation-check.sh [OPTIONS]

Detects installed virtual-machine and container solutions, then reports their
configured/running instances without starting or changing any of them. Reports
can be displayed or saved as TXT, JSON, or HTML.

Options:
  -o, --output PATH   Save directly to PATH; otherwise ask interactively
  -f, --format FORMAT Report format: txt, json, or html
      --force         Overwrite an existing output file without prompting
  -h, --help          Show this help message and exit

Examples:
  ./Virtualisation/virtualisation-check.sh
  ./Virtualisation/virtualisation-check.sh --output "$HOME/virtualisation.json" --format json
  ./Virtualisation/virtualisation-check.sh --output /tmp/virtualisation.html --force
HELP
)

common::show_help_if_requested "$@"

OUTPUT_PATH=""
OUTPUT_FORMAT=""
FORCE=0
while [[ $# -gt 0 ]]; do
    case "$1" in
        -o|--output)
            [[ $# -ge 2 && -n "$2" ]] || common::die "$1 requires a path"
            OUTPUT_PATH="$2"
            shift 2
            ;;
        -f|--format)
            [[ $# -ge 2 ]] || common::die "$1 requires txt, json, or html"
            OUTPUT_FORMAT="${2,,}"
            case "$OUTPUT_FORMAT" in
                txt|json|html) ;;
                *) common::die "unsupported report format: $2 (use txt, json, or html)" ;;
            esac
            shift 2
            ;;
        --force)
            FORCE=1
            shift
            ;;
        *)
            common::die "unknown argument: $1"
            ;;
    esac
done

common::require_cmd python3
common::require_cmd cat

python3 -c "$(cat <<'PYCODE'
import datetime
import html
import json
import os
import pathlib
import re
import shutil
import subprocess
import sys
import tempfile


def execute(executable, arguments, timeout=20):
    path = shutil.which(executable)
    if path is None:
        return None, f"{executable} is not installed"
    try:
        result = subprocess.run(
            [path, *arguments],
            check=False,
            capture_output=True,
            text=True,
            errors="replace",
            timeout=timeout,
        )
    except subprocess.TimeoutExpired:
        return None, f"{executable} timed out after {timeout} seconds"
    except OSError as error:
        return None, str(error)
    if result.returncode != 0:
        detail = result.stderr.strip() or result.stdout.strip() or f"exit status {result.returncode}"
        return None, detail
    return result.stdout.strip(), None


def parse_json_lines(output):
    values = []
    for line in (output or "").splitlines():
        try:
            values.append(json.loads(line))
        except json.JSONDecodeError:
            continue
    return values


def solution_record(name, category, executable, collector, note=None):
    path = shutil.which(executable)
    record = {
        "name": name,
        "category": category,
        "executable": executable,
        "installed": path is not None,
        "path": path,
        "status": "Not installed" if path is None else "Installed",
        "note": note,
        "instances": [],
        "images": [],
    }
    if path is None:
        return record
    try:
        instances, images = collector(executable)
        record["instances"] = instances
        record["images"] = images or []
        record["status"] = "Available"
    except RuntimeError as error:
        record["status"] = "Installed; query failed"
        record["note"] = str(error)
    return record


def collect_virsh(executable):
    output, error = execute(executable, ["list", "--all", "--name"])
    if error:
        raise RuntimeError(error)
    instances = []
    for name in (line.strip() for line in output.splitlines()):
        if not name:
            continue
        state, state_error = execute(executable, ["domstate", name])
        instances.append({
            "name": name,
            "state": state or "Unknown",
            "running": bool(state and state.strip().lower() == "running"),
            "details": state_error,
        })
    return instances, []


def collect_virtualbox(executable):
    output, error = execute(executable, ["list", "vms"])
    if error:
        raise RuntimeError(error)
    running_output, running_error = execute(executable, ["list", "runningvms"])
    running_ids = set()
    if running_output:
        running_ids = set(re.findall(r"\{([0-9a-fA-F-]+)\}", running_output))
    instances = []
    for line in output.splitlines():
        match = re.match(r'^"(.*)"\s+\{([0-9a-fA-F-]+)\}', line)
        if match:
            instances.append({
                "name": match.group(1),
                "id": match.group(2),
                "state": "Running" if match.group(2) in running_ids else "Powered off",
                "running": match.group(2) in running_ids,
            })
    if running_error:
        raise RuntimeError(running_error)
    return instances, []


def collect_vmrun(executable):
    output, error = execute(executable, ["list"])
    if error:
        raise RuntimeError(error)
    instances = []
    for path in output.splitlines()[1:]:
        path = path.strip()
        if path:
            instances.append({
                "name": pathlib.Path(path).parent.name or pathlib.Path(path).stem,
                "state": "Running",
                "running": True,
                "details": path,
            })
    return instances, []


def collect_multipass(executable):
    output, error = execute(executable, ["list", "--format", "json"])
    if error:
        raise RuntimeError(error)
    try:
        items = json.loads(output or "{}").get("list", [])
    except json.JSONDecodeError as error:
        raise RuntimeError(f"invalid JSON from multipass: {error}") from error
    instances = []
    for item in items:
        state = item.get("state") or "Unknown"
        instances.append({
            "name": item.get("name") or "Unknown",
            "state": state,
            "running": state.lower() == "running",
            "details": ", ".join(item.get("ipv4") or []),
        })
    return instances, []


def collect_podman_machines(executable):
    output, error = execute(executable, ["machine", "list", "--format", "json"])
    if error:
        raise RuntimeError(error)
    try:
        items = json.loads(output or "[]")
    except json.JSONDecodeError as error:
        raise RuntimeError(f"invalid JSON from podman machine: {error}") from error
    instances = []
    for item in items:
        state = str(item.get("Running", item.get("State", "Unknown")))
        running = state.lower() in ("true", "running")
        instances.append({
            "name": item.get("Name") or item.get("name") or "Unknown",
            "state": "Running" if running else ("Stopped" if state.lower() in ("false", "stopped") else state),
            "running": running,
            "details": item.get("VMType") or item.get("vmtype"),
        })
    return instances, []


def collect_proxmox(executable):
    output, error = execute(executable, ["list"])
    if error:
        raise RuntimeError(error)
    instances = []
    for line in output.splitlines():
        match = re.match(r"^\s*(\d+)\s+(.+?)\s+(running|stopped)\s+", line, re.IGNORECASE)
        if match:
            state = match.group(3).lower()
            instances.append({"id": match.group(1), "name": match.group(2), "state": state, "running": state == "running"})
    return instances, []


def collect_qemu_processes():
    executables = sorted(set(
        [pathlib.Path(path).name for pattern in ("/usr/bin/qemu-system-*", "/usr/local/bin/qemu-system-*") for path in pathlib.Path("/").glob(pattern.lstrip("/"))]
        + [name for name in ("qemu-system-x86_64", "qemu-system-aarch64", "qemu-kvm") if shutil.which(name)]
    ))
    processes = []
    proc = pathlib.Path("/proc")
    for entry in proc.iterdir():
        if not entry.name.isdigit():
            continue
        try:
            arguments = (entry / "cmdline").read_bytes().decode(errors="replace").split("\0")
        except OSError:
            continue
        command = pathlib.Path(arguments[0]).name if arguments and arguments[0] else ""
        if not command.startswith(("qemu-system-", "qemu-kvm")):
            continue
        name = command
        if "-name" in arguments:
            position = arguments.index("-name") + 1
            if position < len(arguments):
                name = arguments[position].split(",", 1)[0].removeprefix("guest=") or command
        processes.append({"name": name, "id": entry.name, "state": "Running", "running": True, "executable": command})
    return executables, processes


def collect_container_cli(executable):
    output, error = execute(executable, ["ps", "--all", "--format", "{{json .}}"])
    if error:
        raise RuntimeError(error)
    instances = []
    for item in parse_json_lines(output):
        state = str(item.get("State") or item.get("Status") or "Unknown")
        instances.append({
            "id": item.get("ID") or item.get("Id"),
            "name": item.get("Names") or item.get("Name") or "Unknown",
            "image": item.get("Image") or "Unknown",
            "state": state,
            "running": state.lower().startswith("running"),
            "details": item.get("Status"),
        })
    image_output, _ = execute(executable, ["image", "ls", "--format", "{{json .}}"])
    images = []
    for item in parse_json_lines(image_output):
        images.append({
            "name": item.get("Repository", "<none>"),
            "tag": item.get("Tag", "<none>"),
            "id": item.get("ID"),
            "size": item.get("Size"),
        })
    return instances, images


def collect_lxc_classic(executable):
    output, error = execute(executable, ["--fancy"])
    if error:
        output, error = execute(executable, [])
    if error:
        raise RuntimeError(error)
    lines = output.splitlines()
    instances = []
    header = lines[0].split() if lines and "NAME" in lines[0].upper() else []
    if header:
        for line in lines[1:]:
            fields = line.split()
            if not fields:
                continue
            values = dict(zip(header, fields))
            name = values.get("NAME") or fields[0]
            state = values.get("STATE") or "Unknown"
            instances.append({"name": name, "state": state, "running": state.lower() == "running"})
    else:
        instances = [{"name": name, "state": "Unknown", "running": False} for name in output.split()]
    return instances, []


def collect_lxd_style(executable):
    output, error = execute(executable, ["list", "--format=json"])
    if error:
        raise RuntimeError(error)
    try:
        items = json.loads(output or "[]")
    except json.JSONDecodeError as error:
        raise RuntimeError(f"invalid JSON from {executable}: {error}") from error
    instances = []
    for item in items:
        state = item.get("status") or "Unknown"
        instances.append({
            "name": item.get("name") or "Unknown",
            "id": item.get("location"),
            "state": state,
            "running": state.lower() == "running",
            "details": item.get("type"),
        })
    return instances, []


def collect_ctr(executable):
    output, error = execute(executable, ["namespaces", "list"])
    if error:
        raise RuntimeError(error)
    namespaces = []
    for line in output.splitlines()[1:]:
        fields = line.split()
        if fields and fields[0] not in ("NAME", "NAME:"):
            namespaces.append(fields[0])
    instances = []
    for namespace in namespaces:
        containers, container_error = execute(executable, ["--namespace", namespace, "containers", "list"])
        tasks, _ = execute(executable, ["--namespace", namespace, "tasks", "list"])
        active = {}
        task_lines = (tasks or "").splitlines()
        if task_lines:
            headers = task_lines[0].split()
            for line in task_lines[1:]:
                values = line.split()
                row = dict(zip(headers, values))
                if row.get("TASK"):
                    active[row["TASK"]] = row.get("STATUS", "Unknown")
        if container_error:
            continue
        for line in (containers or "").splitlines()[1:]:
            fields = line.split()
            if fields:
                state = active.get(fields[0], "Created")
                instances.append({"name": fields[0], "namespace": namespace, "image": fields[1] if len(fields) > 1 else None, "state": state, "running": state.upper() == "RUNNING"})
    return instances, []


def collect_crictl(executable):
    output, error = execute(executable, ["ps", "--all", "--output", "json"])
    if error:
        raise RuntimeError(error)
    try:
        items = json.loads(output or "{}").get("containers", [])
    except json.JSONDecodeError as error:
        raise RuntimeError(f"invalid JSON from crictl: {error}") from error
    instances = []
    for item in items:
        state = str(item.get("state", "Unknown"))
        instances.append({
            "id": item.get("id"),
            "name": (item.get("metadata") or {}).get("name") or "Unknown",
            "image": (item.get("image") or {}).get("image"),
            "state": state,
            "running": state.upper() == "CONTAINER_RUNNING",
            "details": item.get("podSandboxId"),
        })
    return instances, []


def collect_kubernetes(executable):
    output, error = execute(executable, ["get", "pods", "--all-namespaces", "--output", "json"])
    if error:
        raise RuntimeError(error)
    try:
        pods = json.loads(output or "{}").get("items", [])
    except json.JSONDecodeError as error:
        raise RuntimeError(f"invalid JSON from kubectl: {error}") from error
    instances = []
    for pod in pods:
        metadata = pod.get("metadata") or {}
        state = (pod.get("status") or {}).get("phase") or "Unknown"
        instances.append({
            "name": metadata.get("name") or "Unknown",
            "namespace": metadata.get("namespace") or "default",
            "state": state,
            "running": state.lower() == "running",
            "details": ", ".join(container.get("image", "") for container in (pod.get("spec") or {}).get("containers", [])),
        })
    return instances, []


def collect_report():
    providers = [
        solution_record("Libvirt", "Virtual machines", "virsh", collect_virsh),
        solution_record("Oracle VirtualBox", "Virtual machines", "VBoxManage", collect_virtualbox),
        solution_record("VMware Workstation", "Virtual machines", "vmrun", collect_vmrun,
                "vmrun lists running VMs only; stopped VMs are not enumerated."),
        solution_record("Multipass", "Virtual machines", "multipass", collect_multipass),
        solution_record("Podman machines", "Virtual machines", "podman", collect_podman_machines,
                "Queries Podman-managed VMs separately from Podman containers."),
        solution_record("Proxmox VE", "Virtual machines", "qm", collect_proxmox),
        solution_record("Docker", "Containers", "docker", collect_container_cli),
        solution_record("Podman", "Containers", "podman", collect_container_cli),
        solution_record("LXC", "Containers", "lxc-ls", collect_lxc_classic),
        solution_record("LXD", "Containers", "lxc", collect_lxd_style),
        solution_record("Incus", "Containers", "incus", collect_lxd_style),
        solution_record("containerd (ctr)", "Containers", "ctr", collect_ctr),
        solution_record("nerdctl", "Containers", "nerdctl", collect_container_cli),
        solution_record("CRI-O / CRI runtime (crictl)", "Containers", "crictl", collect_crictl),
        solution_record("Kubernetes workloads", "Orchestration", "kubectl", collect_kubernetes,
                        "Queries the current kubectl context; this may be a remote cluster."),
    ]
    qemu_binaries, qemu_instances = collect_qemu_processes()
    providers.append({
        "name": "QEMU/KVM processes",
        "category": "Virtual machines",
        "executable": "qemu-system-*",
        "installed": bool(qemu_binaries),
        "path": ", ".join(qemu_binaries) if qemu_binaries else None,
        "status": "Available" if qemu_binaries else "Not installed",
        "note": "Detected running QEMU processes from /proc; stopped VMs are managed by their frontend.",
        "instances": qemu_instances,
        "images": [],
    })
    return {
        "generated_at": datetime.datetime.now().astimezone().isoformat(timespec="seconds"),
        "providers": providers,
        "summary": {
            "installed_solutions": sum(1 for item in providers if item["installed"]),
            "running_instances": sum(1 for item in providers for instance in item["instances"] if instance.get("running")),
            "known_instances": sum(len(item["instances"]) for item in providers),
        },
    }


def render_text(report):
    lines = [
        "VIRTUALISATION STATUS REPORT",
        "============================",
        f"Generated: {report['generated_at']}",
        f"Installed solutions: {report['summary']['installed_solutions']}",
        f"Known instances: {report['summary']['known_instances']}",
        f"Running instances: {report['summary']['running_instances']}",
    ]
    for category in ("Virtual machines", "Containers", "Orchestration"):
        providers = [item for item in report["providers"] if item["category"] == category]
        lines.extend(["", category.upper(), "-" * len(category)])
        for provider in providers:
            state = "installed" if provider["installed"] else "not installed"
            lines.append(f"{provider['name']}: {state} [{provider['status']}]")
            if provider["path"]:
                lines.append(f"  Executable: {provider['path']}")
            if provider["note"]:
                lines.append(f"  Note: {provider['note']}")
            if provider["instances"]:
                for instance in provider["instances"]:
                    label = instance.get("name") or instance.get("id") or "Unknown instance"
                    details = [value for value in (instance.get("namespace"), instance.get("image"), instance.get("details")) if value]
                    suffix = f" ({'; '.join(str(value) for value in details)})" if details else ""
                    lines.append(f"  - {label}: {instance['state']}{suffix}")
            elif provider["installed"] and provider["status"] == "Available":
                lines.append("  No instances found.")
            elif not provider["installed"]:
                lines.append("  Skipped because the tool is not installed.")
            if provider["images"]:
                lines.append(f"  Local images: {len(provider['images'])}")
                for image in provider["images"]:
                    lines.append(f"    - {image.get('name')}:{image.get('tag')} [{image.get('id')}; {image.get('size')}]")
    return "\n".join(lines) + "\n"


def render_html(report):
    def esc(value):
        return html.escape("Unavailable" if value is None or value == "" else str(value))

    sections = []
    for category in ("Virtual machines", "Containers", "Orchestration"):
        providers = [item for item in report["providers"] if item["category"] == category]
        cards = []
        for provider in providers:
            status_class = "available" if provider["installed"] and provider["status"] == "Available" else "missing" if not provider["installed"] else "warning"
            rows = []
            for instance in provider["instances"]:
                state_class = "running" if instance.get("running") else "stopped"
                details = " · ".join(str(value) for value in (instance.get("namespace"), instance.get("image"), instance.get("details")) if value)
                rows.append(f"<tr><td>{esc(instance.get('name') or instance.get('id'))}</td><td><span class=\"{state_class}\">{esc(instance['state'])}</span></td><td>{esc(details)}</td></tr>")
            if rows:
                table = "<table><thead><tr><th>Instance</th><th>State</th><th>Details</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
            elif provider["installed"] and provider["status"] == "Available":
                table = "<p class=\"muted\">No instances found.</p>"
            elif not provider["installed"]:
                table = "<p class=\"muted\">Not installed.</p>"
            else:
                table = f"<p class=\"warning-text\">{esc(provider['note'] or provider['status'])}</p>"
            note = f"<p class=\"muted\">{esc(provider['note'])}</p>" if provider["note"] and provider["status"] == "Available" else ""
            image_detail = f"<p class=\"muted\">Local images: {len(provider['images'])}</p>" if provider["images"] else ""
            cards.append(
                f"<article class=\"provider\"><header><h3>{esc(provider['name'])}</h3><span class=\"badge {status_class}\">{esc(provider['status'])}</span></header>"
                f"<p class=\"path\">{esc(provider['path'])}</p>{note}{table}{image_detail}</article>"
            )
        sections.append(f"<section><h2>{html.escape(category)}</h2><div class=\"providers\">{''.join(cards)}</div></section>")
    summary = report["summary"]
    return (
        "<!doctype html><html lang=\"en\"><head><meta charset=\"utf-8\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"><title>Virtualisation Status</title>"
        "<style>:root{--ink:#1b282d;--muted:#62747b;--line:#d8e1e3;--paper:#f2f6f5;--panel:#fff;--teal:#087e80;--green:#237544;--red:#9c3934;--amber:#8a5c18}*{box-sizing:border-box}body{margin:0;background:var(--paper);color:var(--ink);font:15px/1.5 system-ui,-apple-system,\"Segoe UI\",sans-serif}main{max-width:1180px;margin:auto;padding:32px 22px 48px}.masthead{border-bottom:2px solid var(--teal);padding-bottom:16px}h1{margin:0;font-size:28px}.muted,.path{color:var(--muted);font-size:13px}.summary{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:12px;margin:18px 0}.metric,section{background:var(--panel);border:1px solid var(--line);padding:17px}.metric span,.metric strong{display:block}.metric span{color:var(--muted);font-size:13px}.metric strong{font-size:23px;margin-top:4px}section{margin-top:14px}h2{font-size:19px;margin:0 0 14px}.providers{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px}.provider{border:1px solid var(--line);padding:13px;min-width:0}.provider header{display:flex;justify-content:space-between;gap:12px;align-items:center}.provider h3{margin:0;font-size:16px}.badge{font-size:12px;font-weight:650}.badge.available,.running{color:var(--green)}.badge.missing,.stopped{color:var(--muted)}.badge.warning,.warning-text{color:var(--amber)}.path{overflow-wrap:anywhere}table{width:100%;border-collapse:collapse;text-align:left;font-size:13px}th,td{padding:7px 8px;border-bottom:1px solid var(--line);vertical-align:top}th{color:var(--muted);font-size:11px;text-transform:uppercase}@media(max-width:700px){main{padding:20px 12px}.summary{grid-template-columns:1fr 1fr}.providers{grid-template-columns:1fr}}</style></head><body><main>"
        f"<header class=\"masthead\"><h1>Virtualisation Status</h1><p>Generated {esc(report['generated_at'])}</p></header>"
        f"<div class=\"summary\"><article class=\"metric\"><span>Installed solutions</span><strong>{summary['installed_solutions']}</strong></article><article class=\"metric\"><span>Known instances</span><strong>{summary['known_instances']}</strong></article><article class=\"metric\"><span>Running instances</span><strong>{summary['running_instances']}</strong></article></div>"
        + "".join(sections)
        + "</main></body></html>\n"
    )


def ask(prompt, default):
    try:
        answer = input(f"{prompt} [{default}]: ").strip()
    except EOFError:
        return default
    return answer or default


def ask_yes_no(prompt, default):
    marker = "Y/n" if default else "y/N"
    try:
        answer = input(f"{prompt} [{marker}]: ").strip().lower()
    except EOFError:
        return default
    if not answer:
        return default
    return answer in ("y", "yes")


def infer_format(path, requested):
    if requested:
        return requested
    suffix = pathlib.Path(path).suffix.lower().lstrip(".")
    return suffix if suffix in ("txt", "json", "html") else "txt"


def render_report(report, format_name):
    if format_name == "json":
        return json.dumps(report, ensure_ascii=False, indent=2) + "\n"
    if format_name == "html":
        return render_html(report)
    return render_text(report)


def save_report(path_text, format_name, force, interactive, report):
    path = pathlib.Path(path_text).expanduser()
    if not path.parent.exists() or not path.parent.is_dir():
        raise OSError(f"output directory does not exist: {path.parent}")
    if path.exists() and not force:
        if not interactive or not ask_yes_no(f"{path} already exists. Overwrite it?", False):
            return False
    rendered = render_report(report, format_name)
    temporary = None
    try:
        with tempfile.NamedTemporaryFile("w", encoding="utf-8", dir=path.parent, delete=False) as output:
            temporary = pathlib.Path(output.name)
            output.write(rendered)
        os.replace(temporary, path)
    finally:
        if temporary is not None and temporary.exists():
            temporary.unlink()
    print(f"Report saved: {path}", file=sys.stderr)
    return True


def main():
    output_path, requested_format, force_value = sys.argv[1:4]
    force = force_value == "1"
    interactive = sys.stdin.isatty() and sys.stdout.isatty()
    report = collect_report()
    text_report = render_text(report)
    if output_path:
        format_name = infer_format(output_path, requested_format)
        if not save_report(output_path, format_name, force, interactive, report):
            print("Report not written; existing file was not overwritten.", file=sys.stderr)
            return 1 if not interactive else 0
        return 0
    if not interactive:
        print(render_report(report, requested_format or "txt"), end="")
        return 0
    print(text_report, end="")
    if not ask_yes_no("Save this report to a file?", True):
        return 0
    format_name = requested_format or ask("Report format (txt/json/html)", "txt").lower()
    if format_name not in ("txt", "json", "html"):
        print("Unsupported format; using txt.", file=sys.stderr)
        format_name = "txt"
    path = ask("Output path", str(pathlib.Path.home() / f"virtualisation-report.{format_name}"))
    if not save_report(path, format_name, force, interactive, report):
        print("Report not written; existing file was not overwritten.", file=sys.stderr)
    return 0


try:
    raise SystemExit(main())
except (OSError, RuntimeError, json.JSONDecodeError) as error:
    print(f"Error: {error}", file=sys.stderr)
    raise SystemExit(1)
PYCODE
)" "$OUTPUT_PATH" "$OUTPUT_FORMAT" "$FORCE"