#!/usr/bin/env bash
set -euo pipefail

script_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
state_dir="${WIN11_VM_STATE_DIR:-${script_dir}/.vm/windows11}"
disk_image="${WIN11_VM_DISK_IMAGE:-${state_dir}/disk.qcow2}"
seed_iso="${WIN11_VM_SEED_ISO:-$(dirname -- "$disk_image")/seed.iso}"
disk_size="${WIN11_VM_DISK_SIZE:-64G}"
memory="${WIN11_VM_MEMORY:-8G}"
cpus="${WIN11_VM_CPUS:-8}"
rdp_port="${WIN11_VM_RDP_PORT:-3389}"
ssh_port="${WIN11_VM_SSH_PORT:-2222}"
uefi_code="${WIN11_VM_UEFI_CODE:-/usr/share/OVMF/OVMF_CODE_4M.fd}"
uefi_vars_template="${WIN11_VM_UEFI_VARS:-/usr/share/OVMF/OVMF_VARS_4M.fd}"
uefi_vars="${state_dir}/OVMF_VARS_4M.fd"
pid_file="${state_dir}/qemu.pid"
log_file="${state_dir}/console.log"
monitor_socket="${state_dir}/qemu-monitor.sock"
guest_agent_socket="${state_dir}/qemu-guest-agent.sock"
daemonize=false
install_from_iso=false
extra_args=()

usage() {
  cat <<EOF
Usage: $(basename "$0") [--daemon] [--install-from-iso] [-- QEMU_ARGUMENT ...]

If ${disk_image} is missing, create it from the Windows 11 QCOW2 base image.
Use --install-from-iso to perform an automatic ISO installation instead.
If it exists, start Windows normally without attaching installation media.

Options:
  --daemon            Run QEMU in the background
  --install-from-iso  Install from ISO when the system disk is missing
  -h, --help          Show this help

Environment variables:
  WIN11_VM_BASE_IMAGE   Windows 11 base QCOW2 image (default: beside shared images)
  WIN11_VM_INSTALL_ISO  Windows 11 installation ISO used with --install-from-iso
  WIN11_VM_TOOLS_ISO    VirtIO Windows tools ISO (default: resolved by shared image helper)
  WIN11_VM_MEMORY       Guest memory (default: 8G)
  WIN11_VM_CPUS         Virtual CPU count (default: 8)
  WIN11_VM_RDP_PORT     Host RDP port (default: 3389)
  WIN11_VM_SSH_PORT     Host SSH port (default: 2222)
  WIN11_VM_STATE_DIR    Runtime directory (default: .vm/windows11)
  WIN11_VM_DISK_IMAGE   System disk path
  WIN11_VM_DISK_SIZE    New system disk size (default: 64G)
  WIN11_VM_SEED_ISO     Answer-file ISO path (default: alongside the VM disk)
  WIN11_VM_UEFI_CODE    OVMF read-only firmware path
  WIN11_VM_UEFI_VARS    OVMF variable-store template path
EOF
}

while (($#)); do
  case "$1" in
    --daemon) daemonize=true; shift ;;
    --install-from-iso) install_from_iso=true; shift ;;
    -h|--help) usage; exit 0 ;;
    --) shift; extra_args+=("$@"); break ;;
    *) printf 'Error: unknown option: %s\n' "$1" >&2; usage >&2; exit 2 ;;
  esac
done

installing=false
if [[ ! -f "$disk_image" ]]; then
  installing=true
  if [[ -n "${VM_IMAGE_HELPER:-}" ]]; then
    image_downloader="$VM_IMAGE_HELPER"
  elif [[ -x "${script_dir}/vm-images/download-images.sh" ]]; then
    image_downloader="${script_dir}/vm-images/download-images.sh"
  else
    image_downloader="${script_dir}/../vm-images/download-images.sh"
  fi
  [[ -x "$image_downloader" ]] || { printf 'Error: shared image helper is unavailable: %s\n' "$image_downloader" >&2; exit 1; }
  if [[ "$install_from_iso" == true ]]; then
    install_iso="${WIN11_VM_INSTALL_ISO:-$("$image_downloader" --print-path windows11 --iso)}"
    uses_shared_tools_iso=false
    if [[ -n "${WIN11_VM_TOOLS_ISO:-}" ]]; then
      tools_iso="$WIN11_VM_TOOLS_ISO"
    else
      tools_iso="$("$image_downloader" --print-path virtio-win)"
      uses_shared_tools_iso=true
    fi
  else
    base_image="${WIN11_VM_BASE_IMAGE:-$("$image_downloader" --print-path windows11)}"
  fi
fi

for command_name in qemu-system-x86_64; do
  command -v "$command_name" >/dev/null 2>&1 || { printf 'Error: %s is not installed.\n' "$command_name" >&2; exit 1; }
done
if [[ "$installing" == true ]]; then
  command -v qemu-img >/dev/null 2>&1 || { printf 'Error: qemu-img is not installed.\n' >&2; exit 1; }
  if [[ "$install_from_iso" == true ]]; then
    [[ -f "$install_iso" ]] || { printf 'Error: Windows 11 ISO was not found: %s\n' "$install_iso" >&2; exit 1; }
  else
    [[ -f "$base_image" ]] || { printf 'Error: Windows 11 base QCOW2 image was not found: %s\n' "$base_image" >&2; exit 1; }
  fi
fi
for firmware_file in "$uefi_code" "$uefi_vars_template"; do
  [[ -f "$firmware_file" ]] || { printf 'Error: required UEFI firmware was not found: %s\n' "$firmware_file" >&2; exit 1; }
done

mkdir -p "$state_dir"
if [[ "$installing" == true && "$install_from_iso" == true ]]; then
  if [[ ! -f "$tools_iso" ]]; then
    if [[ "$uses_shared_tools_iso" == true ]]; then
      "$image_downloader" virtio-win
    else
      printf 'Error: VirtIO Windows tools ISO was not found: %s\n' "$tools_iso" >&2
      exit 1
    fi
  fi
  [[ -f "$tools_iso" ]] || { printf 'Error: downloader did not create: %s\n' "$tools_iso" >&2; exit 1; }

  if [[ ! -f "$seed_iso" ||
        "${script_dir}/seediso/windows11/Autounattend.xml" -nt "$seed_iso" ||
        "${script_dir}/seediso/windows11/Configure-Windows.ps1" -nt "$seed_iso" ]]; then
    "${script_dir}/seediso/windows11/build-seed.sh" "$seed_iso"
  fi
fi
if [[ -f "$pid_file" ]]; then
  old_pid="$(<"$pid_file")"
  if [[ "$old_pid" =~ ^[0-9]+$ ]] && kill -0 "$old_pid" 2>/dev/null; then
    printf 'Error: Windows 11 VM is already running (PID %s).\n' "$old_pid" >&2
    exit 1
  fi
  rm -f "$pid_file"
fi
rm -f "$monitor_socket" "$guest_agent_socket"
[[ -f "$uefi_vars" ]] || cp -- "$uefi_vars_template" "$uefi_vars"
if [[ "$installing" == true ]]; then
  if [[ "$install_from_iso" == true ]]; then
    qemu-img create -q -f qcow2 "$disk_image" "$disk_size"
  else
    qemu-img create -q -f qcow2 -F qcow2 -b "$base_image" "$disk_image" "$disk_size"
  fi
  printf 'Created Windows 11 system disk: %s\n' "$disk_image"
fi

qemu_args=(
  -name windows11 -machine q35 -m "$memory" -smp "$cpus"
  -display gtk
  # -display none -spice port=5900,addr=127.0.0.1,disable-ticketing=on,agent-mouse=off -device virtio-vga
  -drive "if=pflash,format=raw,readonly=on,file=${uefi_code}"
  -drive "if=pflash,format=raw,file=${uefi_vars}"
  -drive "file=${disk_image},if=none,id=system_disk,format=qcow2"
  -device "ide-hd,drive=system_disk,bus=ide.0,bootindex=1"
  -nic "user,model=e1000e,hostfwd=tcp::${rdp_port}-:3389,hostfwd=tcp::${ssh_port}-:22"
  -device "virtio-serial-pci,id=virtio_serial"
  -chardev "qemu-vdagent,id=vdagent,name=vdagent,clipboard=on,mouse=off"
  -device "virtserialport,chardev=vdagent,name=com.redhat.spice.0"
  # Register the USB tablet after vdagent so QEMU selects it as the active pointer.
  -device "qemu-xhci,id=usb_controller" -device "usb-tablet,bus=usb_controller.0"
  -chardev "socket,path=${guest_agent_socket},server=on,wait=off,id=qga"
  -device "virtserialport,chardev=qga,name=org.qemu.guest_agent.0"
  -monitor "unix:${monitor_socket},server=on,wait=off"
)
if [[ "$installing" == true && "$install_from_iso" == true ]]; then
  qemu_args+=(
    -drive "file=${install_iso},if=none,id=install_media,media=cdrom,readonly=on"
    -device "ide-cd,drive=install_media,bus=ide.1,bootindex=2"
    -drive "file=${seed_iso},if=none,id=answer_media,media=cdrom,readonly=on"
    -device "ide-cd,drive=answer_media,bus=ide.2,bootindex=3"
    -drive "file=${tools_iso},if=none,id=tools_media,media=cdrom,readonly=on"
    -device "ide-cd,drive=tools_media,bus=ide.3,bootindex=4"
  )
fi
if [[ -r /dev/kvm && -w /dev/kvm ]]; then
  qemu_args+=(-enable-kvm -cpu host)
  accelerator=KVM
else
  qemu_args+=(-accel tcg -cpu max)
  accelerator=TCG
fi
if [[ "$installing" == true && "$install_from_iso" == true ]]; then
  printf 'Starting Windows 11 automatic installation with %s acceleration.\n' "$accelerator"
elif [[ "$installing" == true ]]; then
  printf 'Starting Windows 11 from the QCOW2 base image with %s acceleration.\n' "$accelerator"
else
  printf 'Starting Windows 11 normally with %s acceleration.\n' "$accelerator"
fi
printf 'Account: guofang / password; RDP: localhost:%s; SSH: localhost:%s\n' "$rdp_port" "$ssh_port"

if [[ "$daemonize" == true ]]; then
  : >"$log_file"
  qemu_args+=(-serial "file:${log_file}" -daemonize -pidfile "$pid_file")
  qemu-system-x86_64 "${qemu_args[@]}" "${extra_args[@]}"
  printf 'VM started (PID %s); console log: %s\n' "$(<"$pid_file")" "$log_file"
else
  exec qemu-system-x86_64 "${qemu_args[@]}" "${extra_args[@]}"
fi