#!/usr/bin/env bash
#
# JoeyLib toolchain installer.
#
# Installs all cross-compilers, assemblers, and libraries needed to build
# JoeyLib for Apple IIgs, Amiga, Atari ST, and MS-DOS into the local
# toolchains/ folder. Nothing is installed system-wide. Free tools are
# fetched and built; non-free tools (ORCA/C, GoldenGate) print clear
# placement instructions and the script verifies they were placed
# correctly on a subsequent run.
#
# Usage:
#   ./toolchains/install.sh                   install everything we can get
#   ./toolchains/install.sh --only iigs       install only one platform
#   ./toolchains/install.sh --force           wipe and reinstall
#   ./toolchains/install.sh --skip-emulators  skip emulators (cross tools only)
#   ./toolchains/install.sh --help            show this message
#
# Emulators: dosbox, fs-uae (Amiga), hatari (Atari ST), GSplus (Apple IIgs).
# On Linux with apt, the first three are installed via 'sudo apt install'.
# On macOS with Homebrew, they are installed via 'brew install'. GSplus is
# always built from source into toolchains/emulators/gsplus/.
#

set -euo pipefail

# Never prompt for git credentials. Missing / private GitHub repos
# otherwise ask for a username/password on HTTPS clones; we want those
# to fail fast so the installer reports clear instructions instead.
export GIT_TERMINAL_PROMPT=0
export GIT_ASKPASS=/bin/true

# ------------------------------------------------------------------------
# Paths and globals
# ------------------------------------------------------------------------

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
REPO_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
CACHE_DIR="${SCRIPT_DIR}/cache"
STATE_DIR="${SCRIPT_DIR}/.install_state"

ONLY_PLATFORM=""
FORCE_INSTALL=0
SKIP_EMULATORS=0

# Status tracking. Keys are component identifiers; values are "ok",
# "missing", or "failed".
declare -A STATUS
declare -A INSTRUCTIONS

# ------------------------------------------------------------------------
# Output helpers (ANSI color when stdout is a TTY)
# ------------------------------------------------------------------------

if [ -t 1 ]; then
    C_RESET=$'\033[0m'
    C_BOLD=$'\033[1m'
    C_RED=$'\033[31m'
    C_GREEN=$'\033[32m'
    C_YELLOW=$'\033[33m'
    C_CYAN=$'\033[36m'
else
    C_RESET=""
    C_BOLD=""
    C_RED=""
    C_GREEN=""
    C_YELLOW=""
    C_CYAN=""
fi

info()    { printf '%s[*]%s %s\n' "${C_CYAN}"   "${C_RESET}" "$*"; }
ok()      { printf '%s[ok]%s %s\n' "${C_GREEN}" "${C_RESET}" "$*"; }
warn()    { printf '%s[!!]%s %s\n' "${C_YELLOW}" "${C_RESET}" "$*"; }
err()     { printf '%s[xx]%s %s\n' "${C_RED}"   "${C_RESET}" "$*" 1>&2; }
header()  { printf '\n%s== %s ==%s\n' "${C_BOLD}" "$*" "${C_RESET}"; }

# ------------------------------------------------------------------------
# Utility functions
# ------------------------------------------------------------------------

usage() {
    sed -n '2,/^$/p' "$0" | sed 's/^# \{0,1\}//'
    exit 0
}

require_tool() {
    local tool="$1"
    if ! command -v "${tool}" >/dev/null 2>&1; then
        err "Required host tool not found: ${tool}"
        err "Install it via your system package manager and re-run."
        exit 1
    fi
}

detect_host_os() {
    case "$(uname -s)" in
        Linux*)   HOST_OS="linux" ;;
        Darwin*)  HOST_OS="macos" ;;
        MINGW*|MSYS*|CYGWIN*)
                  HOST_OS="windows" ;;
        *)
            err "Unsupported host OS: $(uname -s)"
            exit 1
            ;;
    esac
    info "Host OS: ${HOST_OS}"
}

ensure_dirs() {
    mkdir -p "${CACHE_DIR}" "${STATE_DIR}"
}

mark_done() {
    touch "${STATE_DIR}/$1.done"
}

is_done() {
    [ -f "${STATE_DIR}/$1.done" ]
}

clear_done() {
    rm -f "${STATE_DIR}/$1.done"
}

download() {
    local url="$1"
    local dest="$2"
    if [ -f "${dest}" ]; then
        info "Cached: $(basename "${dest}")"
        return 0
    fi
    info "Downloading $(basename "${dest}")"
    if command -v curl >/dev/null 2>&1; then
        curl -fL --retry 3 -o "${dest}" "${url}"
    elif command -v wget >/dev/null 2>&1; then
        wget -O "${dest}" "${url}"
    else
        err "Neither curl nor wget is installed"
        return 1
    fi
}

# ------------------------------------------------------------------------
# Argument parsing
# ------------------------------------------------------------------------

while [ $# -gt 0 ]; do
    case "$1" in
        --only)
            ONLY_PLATFORM="$2"
            shift 2
            ;;
        --force)
            FORCE_INSTALL=1
            shift
            ;;
        --skip-emulators)
            SKIP_EMULATORS=1
            shift
            ;;
        --help|-h)
            usage
            ;;
        *)
            err "Unknown argument: $1"
            usage
            ;;
    esac
done

should_install() {
    local platform="$1"
    if [ -z "${ONLY_PLATFORM}" ]; then
        return 0
    fi
    [ "${ONLY_PLATFORM}" = "${platform}" ]
}

# ------------------------------------------------------------------------
# IIgs: Merlin32 (free), ORCA/C (manual), GoldenGate (manual)
# ------------------------------------------------------------------------

install_iigs() {
    header "IIgs toolchain"
    local base="${SCRIPT_DIR}/iigs"
    mkdir -p "${base}"

    # Merlin32 -- 65816 cross-assembler from Brutal Deluxe.
    # The canonical distribution is a zip on brutaldeluxe.fr that bundles
    # prebuilt binaries for Linux / macOS / Windows plus the C source.
    # We prefer the host's prebuilt binary; if not present, we build
    # from source with plain gcc (the source has no Makefile).
    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        rm -rf "${base}/merlin32"
        clear_done "iigs_merlin32"
    fi

    if is_done "iigs_merlin32" && [ -x "${base}/merlin32/bin/merlin32" ]; then
        ok "Merlin32 already installed"
        STATUS[iigs_merlin32]="ok"
    else
        local merlin_installed=0
        local merlin_urls=(
            "https://brutaldeluxe.fr/products/crossdevtools/merlin/Merlin32_v1.1.zip"
            "https://brutaldeluxe.fr/products/crossdevtools/merlin/Merlin32.zip"
        )
        local merlin_zip="${CACHE_DIR}/merlin32.zip"
        local merlin_extract="${CACHE_DIR}/merlin32-extract"
        local prebuilt_subdir=""

        case "${HOST_OS}" in
            linux)  prebuilt_subdir="Linux" ;;
            macos)  prebuilt_subdir="MacOs" ;;
            *)      prebuilt_subdir=""       ;;
        esac

        for url in "${merlin_urls[@]}"; do
            if download "${url}" "${merlin_zip}" 2>/dev/null; then
                info "Extracting Merlin32"
                rm -rf "${merlin_extract}"
                mkdir -p "${merlin_extract}"
                if ! unzip -o "${merlin_zip}" -d "${merlin_extract}" >/dev/null 2>&1; then
                    continue
                fi
                mkdir -p "${base}/merlin32/bin"

                # 1. Try prebuilt binary for the host OS. Name may be
                #    capitalized ("Merlin32") or lowercase. No executable
                #    bit in the zip, so we chmod after copying.
                local mbin=""
                if [ -n "${prebuilt_subdir}" ]; then
                    mbin=$(find "${merlin_extract}" -type d -name "${prebuilt_subdir}" -print 2>/dev/null | head -n1)
                    if [ -n "${mbin}" ]; then
                        mbin=$(find "${mbin}" -maxdepth 1 -type f -iname "merlin32" 2>/dev/null | head -n1)
                    fi
                fi

                if [ -n "${mbin}" ] && [ -f "${mbin}" ]; then
                    cp "${mbin}" "${base}/merlin32/bin/merlin32"
                    chmod +x "${base}/merlin32/bin/merlin32"
                    mark_done "iigs_merlin32"
                    ok "Merlin32 installed (prebuilt ${prebuilt_subdir} binary)"
                    STATUS[iigs_merlin32]="ok"
                    merlin_installed=1
                    break
                fi

                # 2. No prebuilt for this host; build from Source/. The
                #    source has no Makefile; 'gcc -O2 *.c' produces the
                #    binary directly.
                local msrc
                msrc=$(find "${merlin_extract}" -type d -name "Source" 2>/dev/null | head -n1)
                if [ -n "${msrc}" ] && [ -f "${msrc}/Main.c" ]; then
                    info "Building Merlin32 from source"
                    (
                        cd "${msrc}"
                        gcc -O2 -o merlin32 *.c
                    ) && {
                        if [ -x "${msrc}/merlin32" ]; then
                            cp "${msrc}/merlin32" "${base}/merlin32/bin/merlin32"
                            mark_done "iigs_merlin32"
                            ok "Merlin32 built from source and installed"
                            STATUS[iigs_merlin32]="ok"
                            merlin_installed=1
                            break
                        fi
                    }
                fi
            fi
        done

        if [ "${merlin_installed}" -eq 0 ]; then
            STATUS[iigs_merlin32]="missing"
            INSTRUCTIONS[iigs_merlin32]=$(cat <<EOF
Merlin32 could not be installed automatically. Install manually:
  1. Visit https://brutaldeluxe.fr/products/crossdevtools/merlin/
  2. Download the latest Merlin32 zip.
  3. Either copy the prebuilt binary for your OS, or build from Source/
     with 'gcc -O2 -o merlin32 *.c'.
  4. Place the result at ${base}/merlin32/bin/merlin32 and chmod +x it.
  5. Re-run ./toolchains/install.sh to verify.
EOF
)
        fi
    fi

    # GoldenGate Unix-side host tools (iix, dumpobj, profuse, ...).
    # These are built from the GoldenGate source repo at stuff/GoldenGate/.
    # They must NOT live inside the IIgs filesystem tree that
    # $GOLDEN_GATE points at, because that tree represents the emulated
    # IIgs volume (case-insensitive, with its own bin/ of IIgs utilities).
    # Install layout:
    #   toolchains/iigs/gg-tools/bin/   Unix binaries on host PATH
    #   toolchains/iigs/goldengate/     $GOLDEN_GATE root (IIgs filesystem)
    local gg_tools_dir="${base}/gg-tools"
    local gg_root="${base}/goldengate"
    local stuff_dir="${REPO_DIR}/stuff"

    # Migrate any Unix tools the user may have placed at goldengate/bin/
    # over to gg-tools/bin/ so the goldengate directory can be repopulated
    # with the IIgs filesystem tree from gg-linux.tgz. iix's siblings gno
    # and orca are typically symlinks to iix -- use -e (not -f) so broken
    # symlinks from a prior partial migration also match.
    if [ -x "${gg_root}/bin/iix" ] && [ ! -x "${gg_tools_dir}/bin/iix" ]; then
        info "Relocating Unix host tools from goldengate/bin to gg-tools/bin"
        mkdir -p "${gg_tools_dir}/bin"
        # Move iix last so the symlinks that point at it resolve during mv.
        for f in dumpobj profuse mkfs-profuse opus-extractor orca gno iix; do
            if [ -e "${gg_root}/bin/${f}" ] || [ -L "${gg_root}/bin/${f}" ]; then
                mv "${gg_root}/bin/${f}" "${gg_tools_dir}/bin/"
            fi
        done
        rmdir "${gg_root}/bin" 2>/dev/null || true
    fi

    # Clean up any dangling symlinks that reference a now-moved iix.
    if [ -d "${gg_root}/bin" ]; then
        find "${gg_root}/bin" -maxdepth 1 -type l -xtype l -delete 2>/dev/null || true
    fi

    # Recreate gno/orca symlinks next to iix in gg-tools if they're
    # missing (iix behaves differently when invoked as 'gno' or 'orca').
    if [ -x "${gg_tools_dir}/bin/iix" ]; then
        for alias in gno orca; do
            if [ ! -e "${gg_tools_dir}/bin/${alias}" ]; then
                ln -s iix "${gg_tools_dir}/bin/${alias}"
            fi
        done
    fi

    # Verify Unix tools
    if [ -x "${gg_tools_dir}/bin/iix" ]; then
        ok "GoldenGate host tools present at ${gg_tools_dir}/bin/"
        STATUS[iigs_gg_tools]="ok"
    else
        STATUS[iigs_gg_tools]="missing"
        INSTRUCTIONS[iigs_gg_tools]=$(cat <<EOF
GoldenGate Unix host tools not found at ${gg_tools_dir}/bin/.
Build from the GoldenGate source repo (e.g. in stuff/GoldenGate):
  cd stuff/GoldenGate
  git submodule update --init
  mkdir -p build && cd build
  cmake .. && make iix dumpobj profuse mkfs-profuse opus-extractor
Then copy the built binaries to ${gg_tools_dir}/bin/ and re-run
./toolchains/install.sh to verify.
EOF
)
    fi

    # Populate the IIgs filesystem at $GOLDEN_GATE. Sources expected in
    # stuff/:
    #   gg-linux.tgz    IIgs support tree (bin, etc, Home, lib, System, usr)
    #   fst.tgz         File System Translators and fst-rom
    #   opus/           Opus II extract with Languages/Libraries/Shell/Utilities/
    local gg_linux_tgz="${stuff_dir}/gg-linux.tgz"
    local fst_tgz="${stuff_dir}/fst.tgz"
    local opus_dir="${stuff_dir}/opus"

    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        clear_done "iigs_goldengate"
        clear_done "iigs_orca"
        rm -rf "${gg_root}"
    fi

    if is_done "iigs_goldengate" && [ -f "${gg_root}/System/rom" ] && [ -d "${gg_root}/bin" ]; then
        ok "GoldenGate IIgs filesystem already populated"
        STATUS[iigs_goldengate]="ok"
    else
        if [ ! -f "${gg_linux_tgz}" ]; then
            STATUS[iigs_goldengate]="missing"
            INSTRUCTIONS[iigs_goldengate]=$(cat <<EOF
Cannot populate the $GOLDEN_GATE tree at ${gg_root}/.
Expected archive: ${gg_linux_tgz}
Place the gg-linux.tgz archive (from the GoldenGate distribution) into
${stuff_dir}/ and re-run ./toolchains/install.sh.
EOF
)
        else
            info "Extracting gg-linux.tgz into goldengate/"
            mkdir -p "${gg_root}"
            # The archive roots at gg-linux/GoldenGate/; strip both levels.
            tar -xzf "${gg_linux_tgz}" -C "${gg_root}" --strip-components=2 \
                gg-linux/GoldenGate/ 2>/dev/null || {
                STATUS[iigs_goldengate]="failed"
                INSTRUCTIONS[iigs_goldengate]="Extract of ${gg_linux_tgz} failed"
            }

            # Extract fix-filetypes.sh separately (it sits at gg-linux/ root).
            if [ ! -f "${CACHE_DIR}/fix-filetypes.sh" ]; then
                tar -xzf "${gg_linux_tgz}" -C "${CACHE_DIR}" --strip-components=1 \
                    gg-linux/fix-filetypes.sh 2>/dev/null || true
            fi

            # FST tarball: merge fst/orca/ subtree into goldengate/.
            if [ -f "${fst_tgz}" ]; then
                info "Merging fst.tgz into goldengate/System/"
                tar -xzf "${fst_tgz}" -C "${gg_root}" --strip-components=2 \
                    fst/orca/ 2>/dev/null || warn "fst.tgz extract reported issues"
            else
                warn "${fst_tgz} not found; FSTs will be missing"
            fi

            if [ -f "${gg_root}/System/rom" ] && [ -d "${gg_root}/bin" ]; then
                mark_done "iigs_goldengate"
                ok "GoldenGate IIgs filesystem populated"
                STATUS[iigs_goldengate]="ok"
            else
                STATUS[iigs_goldengate]="failed"
                INSTRUCTIONS[iigs_goldengate]="goldengate/ did not end up with System/rom and bin/; check ${gg_linux_tgz}"
            fi
        fi
    fi

    # Merge ORCA (from Opus II) directories into goldengate/.
    if is_done "iigs_orca" && [ -f "${gg_root}/Languages/cc" ]; then
        ok "ORCA/C merged into goldengate/"
        STATUS[iigs_orca]="ok"
    else
        if [ "${STATUS[iigs_goldengate]}" != "ok" ]; then
            STATUS[iigs_orca]="missing"
            INSTRUCTIONS[iigs_orca]="Install GoldenGate IIgs filesystem first."
        elif [ ! -d "${opus_dir}" ]; then
            STATUS[iigs_orca]="missing"
            INSTRUCTIONS[iigs_orca]=$(cat <<EOF
ORCA source directory not found at ${opus_dir}/.
Extract the Opus II ORCA distribution into ${opus_dir}/ so it contains:
  Languages/  Libraries/  Shell/  Utilities/
Then re-run ./toolchains/install.sh.
EOF
)
        else
            info "Merging Opus II ORCA directories into goldengate/"
            local orca_ok=1
            for sub in Languages Libraries Shell Utilities; do
                if [ -d "${opus_dir}/${sub}" ]; then
                    cp -rn "${opus_dir}/${sub}" "${gg_root}/" 2>/dev/null || orca_ok=0
                else
                    warn "${opus_dir}/${sub} missing"
                    orca_ok=0
                fi
            done

            # Run fix-filetypes.sh which sets IIgs filetype xattrs via chtyp.
            # chtyp is an IIgs binary inside goldengate/bin and is invoked
            # by fix-filetypes through iix, so we need iix on PATH and
            # GOLDEN_GATE exported first.
            if [ "${orca_ok}" -eq 1 ] && [ -f "${CACHE_DIR}/fix-filetypes.sh" ] \
               && [ -x "${gg_tools_dir}/bin/iix" ]; then
                info "Running fix-filetypes.sh"
                (
                    cd "${gg_root}"
                    export GOLDEN_GATE="${gg_root}"
                    export PATH="${gg_tools_dir}/bin:${PATH}"
                    bash "${CACHE_DIR}/fix-filetypes.sh" >/dev/null 2>&1
                ) || warn "fix-filetypes.sh reported issues; proceeding"
            fi

            if [ "${orca_ok}" -eq 1 ] && [ -f "${gg_root}/Languages/cc" ]; then
                mark_done "iigs_orca"
                ok "ORCA/C merged and filetypes fixed"
                STATUS[iigs_orca]="ok"
            else
                STATUS[iigs_orca]="failed"
                INSTRUCTIONS[iigs_orca]="ORCA merge did not produce ${gg_root}/Languages/cc; check ${opus_dir}/"
            fi
        fi
    fi
}

# ------------------------------------------------------------------------
# Amiga: Bebbo m68k-amigaos-gcc, vasm, NDK, PTPlayer
# ------------------------------------------------------------------------

install_amiga() {
    header "Amiga toolchain"
    local base="${SCRIPT_DIR}/amiga"
    mkdir -p "${base}"

    # Bebbo amiga-gcc -- build from source; long but reliable
    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        rm -rf "${base}/gcc"
        clear_done "amiga_gcc"
    fi

    if is_done "amiga_gcc" && [ -x "${base}/gcc/bin/m68k-amigaos-gcc" ]; then
        ok "m68k-amigaos-gcc already installed"
        STATUS[amiga_gcc]="ok"
    else
        ensure_build_deps "m68k-amigaos-gcc" \
            "build-essential bison flex m4 texinfo libgmp-dev libmpfr-dev libmpc-dev autoconf automake lhasa" \
            "bison flex m4 texinfo gmp mpfr libmpc autoconf automake lhasa" || true
        info "Cloning AmigaPorts/m68k-amigaos-gcc (this build takes a while)"
        local src="${CACHE_DIR}/amiga-gcc-src"
        if [ ! -d "${src}" ]; then
            if ! git clone https://github.com/AmigaPorts/m68k-amigaos-gcc.git "${src}"; then
                STATUS[amiga_gcc]="failed"
                INSTRUCTIONS[amiga_gcc]=$(cat <<EOF
Clone https://github.com/AmigaPorts/m68k-amigaos-gcc manually and build:
  git clone https://github.com/AmigaPorts/m68k-amigaos-gcc.git
  cd m68k-amigaos-gcc
  make all PREFIX=${base}/gcc
Build deps (Debian/Ubuntu):
  sudo apt install build-essential bison flex texinfo libgmp-dev libmpfr-dev libmpc-dev
EOF
)
                return
            fi
        fi
        (
            cd "${src}"
            make all PREFIX="${base}/gcc"
        ) && {
            mark_done "amiga_gcc"
            ok "m68k-amigaos-gcc installed"
            STATUS[amiga_gcc]="ok"
        } || {
            STATUS[amiga_gcc]="failed"
            INSTRUCTIONS[amiga_gcc]=$(cat <<EOF
m68k-amigaos-gcc build failed. Install build dependencies:
  Debian/Ubuntu:  sudo apt install build-essential bison flex texinfo libgmp-dev libmpfr-dev libmpc-dev
  macOS Homebrew: brew install bison flex texinfo gmp mpfr libmpc
Then delete ${src} and re-run ./toolchains/install.sh.
Source: ${src}
EOF
)
        }
    fi

    # vasm -- assembler used by Amiga and ST
    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        rm -rf "${base}/vasm"
        clear_done "vasm"
    fi

    if is_done "vasm" && [ -x "${base}/vasm/bin/vasmm68k_mot" ]; then
        ok "vasm already installed"
        STATUS[vasm]="ok"
    else
        info "Building vasm from source"
        local vasm_src="${CACHE_DIR}/vasm"
        if [ ! -d "${vasm_src}" ]; then
            download "http://sun.hasenbraten.de/vasm/release/vasm.tar.gz" \
                     "${CACHE_DIR}/vasm.tar.gz"
            mkdir -p "${vasm_src}"
            tar -xzf "${CACHE_DIR}/vasm.tar.gz" -C "${vasm_src}" --strip-components=1
        fi
        (
            cd "${vasm_src}"
            make CPU=m68k SYNTAX=mot
            mkdir -p "${base}/vasm/bin"
            cp vasmm68k_mot vobjdump "${base}/vasm/bin/" 2>/dev/null || true
        ) && {
            mark_done "vasm"
            ok "vasm installed"
            STATUS[vasm]="ok"
        } || {
            STATUS[vasm]="failed"
            INSTRUCTIONS[vasm]="vasm build failed; see ${vasm_src}"
        }
    fi

    # NDK -- AmigaOS includes (Bebbo's repo bundles these via 'make all')
    if [ -d "${base}/gcc/m68k-amigaos/sys-include" ] || [ -d "${base}/gcc/m68k-amigaos/include" ]; then
        ok "Amiga NDK headers present (bundled with amiga-gcc)"
        STATUS[amiga_ndk]="ok"
    else
        STATUS[amiga_ndk]="missing"
        INSTRUCTIONS[amiga_ndk]="Amiga NDK headers should be installed by Bebbo's amiga-gcc 'make all'. Re-run installer after fixing amiga-gcc."
    fi

    # PTPlayer -- MOD replayer by Frank Wille, distributed as an LHA
    # archive on Aminet. Extract with lhasa (installed as part of the
    # Amiga GCC build deps above).
    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        rm -rf "${base}/ptplayer"
        clear_done "amiga_ptplayer"
    fi

    if is_done "amiga_ptplayer" && [ -f "${base}/ptplayer/ptplayer.asm" ]; then
        ok "PTPlayer already installed"
        STATUS[amiga_ptplayer]="ok"
    else
        info "Downloading PTPlayer from Aminet"
        local ptp_lha="${CACHE_DIR}/ptplayer.lha"
        if ! download "http://aminet.net/mus/play/ptplayer.lha" "${ptp_lha}"; then
            STATUS[amiga_ptplayer]="failed"
            INSTRUCTIONS[amiga_ptplayer]="Could not download http://aminet.net/mus/play/ptplayer.lha"
        else
            local extractor=""
            if command -v lhasa >/dev/null 2>&1; then
                extractor="lhasa"
            elif command -v lha >/dev/null 2>&1; then
                extractor="lha"
            fi

            if [ -z "${extractor}" ]; then
                STATUS[amiga_ptplayer]="missing"
                INSTRUCTIONS[amiga_ptplayer]=$(cat <<EOF
PTPlayer was downloaded but no LHA extractor is available.
Install one and re-run:
  Debian/Ubuntu:  sudo apt install lhasa
  macOS Homebrew: brew install lhasa
Archive at: ${ptp_lha}
Target:     ${base}/ptplayer/
EOF
)
            else
                mkdir -p "${base}/ptplayer"
                local extract_ok=0
                if [ "${extractor}" = "lhasa" ]; then
                    (cd "${base}/ptplayer" && lhasa xq "${ptp_lha}") && extract_ok=1
                else
                    (cd "${base}/ptplayer" && lha xq "${ptp_lha}") && extract_ok=1
                fi
                if [ "${extract_ok}" -eq 1 ] && [ -f "${base}/ptplayer/ptplayer.asm" ]; then
                    mark_done "amiga_ptplayer"
                    ok "PTPlayer installed"
                    STATUS[amiga_ptplayer]="ok"
                else
                    STATUS[amiga_ptplayer]="failed"
                    INSTRUCTIONS[amiga_ptplayer]="LHA extract of ${ptp_lha} failed or did not produce ptplayer.asm"
                fi
            fi
        fi
    fi
}

# ------------------------------------------------------------------------
# Atari ST: m68k-atari-mint-gcc, MiNTLib (vasm shared with Amiga)
# ------------------------------------------------------------------------

install_atarist() {
    header "Atari ST toolchain"
    local base="${SCRIPT_DIR}/atarist"
    mkdir -p "${base}"

    # m68k-atari-mint-gcc, binutils, and MiNTLib come as three separate
    # tarballs from tho-otto.de (Vincent Riviere's official mirror).
    # Each tarball is rooted at 'usr/'; stripping that single component
    # places everything into ${base}/gcc/ cleanly, and the relocated
    # tree works without -B/--sysroot flags.
    local mint_host=""
    case "${HOST_OS}" in
        linux)
            if [ "$(uname -m)" = "x86_64" ]; then
                mint_host="linux64"
            else
                mint_host="linux32"
            fi
            ;;
        macos)  mint_host="macos" ;;
    esac

    local mint_base_url="https://tho-otto.de/download/mint"
    local mint_tarballs=(
        "gcc-15.2.0-mint-20250810-bin-${mint_host}.tar.xz"
        "binutils-2.45-mint-20250812-bin-${mint_host}.tar.xz"
    )
    local mintlib_tarball="mintlib-0.60.1-mint-20240718-dev.tar.xz"

    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        rm -rf "${base}/gcc"
        clear_done "atarist_gcc"
        clear_done "atarist_mintlib"
    fi

    # GCC + binutils
    if is_done "atarist_gcc" && [ -x "${base}/gcc/bin/m68k-atari-mint-gcc" ]; then
        ok "m68k-atari-mint-gcc already installed"
        STATUS[atarist_gcc]="ok"
    else
        if [ -z "${mint_host}" ]; then
            STATUS[atarist_gcc]="missing"
            INSTRUCTIONS[atarist_gcc]="No prebuilt m68k-atari-mint-gcc available for host '${HOST_OS}'. Install manually from https://tho-otto.de/download/mint/"
        else
            mkdir -p "${base}/gcc"
            local gcc_ok=1
            for tarball in "${mint_tarballs[@]}"; do
                local dest="${CACHE_DIR}/${tarball}"
                if ! download "${mint_base_url}/${tarball}" "${dest}"; then
                    gcc_ok=0
                    break
                fi
                if ! tar -xJf "${dest}" -C "${base}/gcc" --strip-components=1; then
                    gcc_ok=0
                    break
                fi
            done
            if [ "${gcc_ok}" -eq 1 ] && [ -x "${base}/gcc/bin/m68k-atari-mint-gcc" ]; then
                mark_done "atarist_gcc"
                ok "m68k-atari-mint-gcc installed (prebuilt ${mint_host})"
                STATUS[atarist_gcc]="ok"
            else
                STATUS[atarist_gcc]="failed"
                INSTRUCTIONS[atarist_gcc]="m68k-atari-mint-gcc tarball download or extract failed; see ${CACHE_DIR}"
            fi
        fi
    fi

    # MiNTLib -- headers and libc for cross-compile
    if is_done "atarist_mintlib" && [ -d "${base}/gcc/m68k-atari-mint/sys-root" ]; then
        ok "MiNTLib already installed"
        STATUS[atarist_mintlib]="ok"
    else
        if [ ! -x "${base}/gcc/bin/m68k-atari-mint-gcc" ]; then
            STATUS[atarist_mintlib]="missing"
            INSTRUCTIONS[atarist_mintlib]="Install m68k-atari-mint-gcc first; MiNTLib extracts into the same prefix."
        else
            local mlib_dest="${CACHE_DIR}/${mintlib_tarball}"
            if download "${mint_base_url}/${mintlib_tarball}" "${mlib_dest}" && \
               tar -xJf "${mlib_dest}" -C "${base}/gcc" --strip-components=1; then
                mark_done "atarist_mintlib"
                ok "MiNTLib installed"
                STATUS[atarist_mintlib]="ok"
            else
                STATUS[atarist_mintlib]="failed"
                INSTRUCTIONS[atarist_mintlib]="MiNTLib tarball download or extract failed; see ${mlib_dest}"
            fi
        fi
    fi

    # vasm -- symlink to the Amiga port's vasm
    if [ -L "${base}/vasm" ] || [ -d "${base}/vasm" ]; then
        ok "vasm symlink present for ST"
        STATUS[atarist_vasm]="ok"
    else
        if [ -d "${SCRIPT_DIR}/amiga/vasm" ]; then
            ln -s "../amiga/vasm" "${base}/vasm"
            ok "Linked atarist/vasm -> amiga/vasm"
            STATUS[atarist_vasm]="ok"
        else
            STATUS[atarist_vasm]="missing"
            INSTRUCTIONS[atarist_vasm]="vasm not yet installed for Amiga; install Amiga toolchain first."
        fi
    fi
}

# ------------------------------------------------------------------------
# DOS: DJGPP, NASM, CWSDPMI
# ------------------------------------------------------------------------

install_dos() {
    header "DOS toolchain"
    local base="${SCRIPT_DIR}/dos"
    mkdir -p "${base}"

    # DJGPP -- the canonical zip set
    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        rm -rf "${base}/djgpp"
        clear_done "dos_djgpp"
    fi

    if is_done "dos_djgpp" && [ -x "${base}/djgpp/bin/i586-pc-msdosdjgpp-gcc" ]; then
        ok "DJGPP already installed"
        STATUS[dos_djgpp]="ok"
    else
        # Use prebuilt DJGPP binaries from andrewwutw/build-djgpp
        # releases. Much faster than source build and avoids a long list
        # of build-dep prerequisites.
        info "Downloading DJGPP prebuilt binaries"
        local djgpp_arch=""
        local djgpp_url=""
        case "${HOST_OS}" in
            linux)
                if [ "$(uname -m)" = "x86_64" ]; then
                    djgpp_arch="linux64"
                else
                    djgpp_arch="linux32"
                fi
                ;;
            macos)
                djgpp_arch="osx"
                ;;
        esac

        if [ -n "${djgpp_arch}" ]; then
            djgpp_url="https://github.com/andrewwutw/build-djgpp/releases/download/v3.4/djgpp-${djgpp_arch}-gcc1220.tar.bz2"
        fi

        local djgpp_tar="${CACHE_DIR}/djgpp.tar.bz2"
        if [ -n "${djgpp_url}" ] && download "${djgpp_url}" "${djgpp_tar}" 2>/dev/null; then
            mkdir -p "${base}/djgpp"
            # The tarball extracts to a 'djgpp' directory at the top level.
            # Strip one component so contents land directly in ${base}/djgpp.
            tar -xjf "${djgpp_tar}" -C "${base}/djgpp" --strip-components=1 && {
                if [ -x "${base}/djgpp/bin/i586-pc-msdosdjgpp-gcc" ]; then
                    mark_done "dos_djgpp"
                    ok "DJGPP installed (prebuilt ${djgpp_arch})"
                    STATUS[dos_djgpp]="ok"
                else
                    STATUS[dos_djgpp]="failed"
                    INSTRUCTIONS[dos_djgpp]="DJGPP tarball extracted but i586-pc-msdosdjgpp-gcc not found under ${base}/djgpp/bin/"
                fi
            } || {
                STATUS[dos_djgpp]="failed"
                INSTRUCTIONS[dos_djgpp]="Failed to extract DJGPP tarball ${djgpp_tar}"
            }
        else
            STATUS[dos_djgpp]="failed"
            INSTRUCTIONS[dos_djgpp]=$(cat <<EOF
No prebuilt DJGPP is available for host '${HOST_OS}'. Build from source:
  git clone https://github.com/andrewwutw/build-djgpp.git
  cd build-djgpp
  DJGPP_PREFIX=${base}/djgpp ./build-djgpp.sh 12.2.0
Build deps (Debian/Ubuntu):
  sudo apt install build-essential bison flex texinfo zlib1g-dev unzip curl
EOF
)
        fi
    fi

    # NASM
    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        rm -rf "${base}/nasm"
        clear_done "dos_nasm"
    fi

    if is_done "dos_nasm" && [ -x "${base}/nasm/bin/nasm" ]; then
        ok "NASM already installed"
        STATUS[dos_nasm]="ok"
    else
        info "Building NASM"
        local nasm_ver="2.16.03"
        local nasm_url="https://www.nasm.us/pub/nasm/releasebuilds/${nasm_ver}/nasm-${nasm_ver}.tar.gz"
        download "${nasm_url}" "${CACHE_DIR}/nasm.tar.gz"
        local nasm_src="${CACHE_DIR}/nasm-src"
        rm -rf "${nasm_src}"
        mkdir -p "${nasm_src}"
        tar -xzf "${CACHE_DIR}/nasm.tar.gz" -C "${nasm_src}" --strip-components=1
        (
            cd "${nasm_src}"
            ./configure --prefix="${base}/nasm"
            make
            make install
        ) && {
            mark_done "dos_nasm"
            ok "NASM installed"
            STATUS[dos_nasm]="ok"
        } || {
            STATUS[dos_nasm]="failed"
            INSTRUCTIONS[dos_nasm]="NASM build failed; see ${nasm_src}"
        }
    fi

    # CWSDPMI
    if [ -f "${base}/cwsdpmi/bin/CWSDSTUB.EXE" ] && [ -f "${base}/cwsdpmi/bin/CWSDPMI.EXE" ]; then
        ok "CWSDPMI present"
        STATUS[dos_cwsdpmi]="ok"
    else
        info "Fetching CWSDPMI"
        download "https://sandmann.dotster.com/cwsdpmi/csdpmi7b.zip" \
                 "${CACHE_DIR}/cwsdpmi.zip" || {
            STATUS[dos_cwsdpmi]="failed"
            INSTRUCTIONS[dos_cwsdpmi]="Download CWSDPMI binaries from https://sandmann.dotster.com/cwsdpmi/ and unzip into ${base}/cwsdpmi/bin/"
            return
        }
        mkdir -p "${base}/cwsdpmi/bin"
        (cd "${base}/cwsdpmi/bin" && unzip -o "${CACHE_DIR}/cwsdpmi.zip" >/dev/null) && {
            ok "CWSDPMI installed"
            STATUS[dos_cwsdpmi]="ok"
        } || {
            STATUS[dos_cwsdpmi]="failed"
        }
    fi
}

# ------------------------------------------------------------------------
# Emulators: DOSBox, FS-UAE, Hatari, GSplus
#
# Package-manager-installable emulators (DOSBox, FS-UAE, Hatari) are
# installed via apt on Linux / brew on macOS and exist on the host PATH
# after install. GSplus has no package and is always built from source
# into toolchains/emulators/gsplus/.
# ------------------------------------------------------------------------

pkg_install() {
    # Install a list of package names on the current host. Returns 0 on
    # success, non-zero on any failure. Uses apt on Linux, brew on macOS.
    case "${HOST_OS}" in
        linux)
            if command -v apt-get >/dev/null 2>&1; then
                sudo apt-get install -y "$@"
                return $?
            fi
            ;;
        macos)
            if command -v brew >/dev/null 2>&1; then
                brew install "$@"
                return $?
            fi
            ;;
    esac
    return 1
}

# Install build dependencies. Args: label, apt-list, brew-list.
# The label identifies what we're about to build; the lists are the
# space-separated package names for each package manager. On failure,
# prints instructions but does not abort the installer (the build step
# will then fail with a clearer message).
ensure_build_deps() {
    local label="$1"
    local apt_pkgs="$2"
    local brew_pkgs="$3"
    local pkgs=""

    case "${HOST_OS}" in
        linux)  pkgs="${apt_pkgs}"  ;;
        macos)  pkgs="${brew_pkgs}" ;;
    esac

    if [ -z "${pkgs}" ]; then
        return 0
    fi

    info "Installing ${label} build dependencies"
    if ! pkg_install ${pkgs}; then
        warn "Failed to install ${label} dependencies via package manager."
        warn "You may need to install manually: ${pkgs}"
        return 1
    fi
    return 0
}

install_apt_emulator() {
    local key="$1"
    local cmd="$2"
    local aptpkg="$3"
    local brewpkg="$4"

    if command -v "${cmd}" >/dev/null 2>&1; then
        ok "${cmd} already on PATH"
        STATUS[${key}]="ok"
        return
    fi

    info "Installing ${cmd} via host package manager"
    local pkgs
    case "${HOST_OS}" in
        linux)  pkgs="${aptpkg}"  ;;
        macos)  pkgs="${brewpkg}" ;;
        *)      pkgs=""           ;;
    esac

    if [ -n "${pkgs}" ] && pkg_install ${pkgs}; then
        ok "${cmd} installed"
        STATUS[${key}]="ok"
    else
        STATUS[${key}]="missing"
        INSTRUCTIONS[${key}]=$(cat <<EOF
${cmd} was not installed. Install it manually:
  Debian/Ubuntu:  sudo apt install ${aptpkg}
  macOS Homebrew: brew install ${brewpkg}
  Windows:        install manually and ensure '${cmd}' is on PATH
Re-run ./toolchains/install.sh to verify.
EOF
)
    fi
}

install_gsplus() {
    local base="${SCRIPT_DIR}/emulators/gsplus"
    local bin="${base}/bin/gsplus"

    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        rm -rf "${base}"
        clear_done "emu_gsplus"
    fi

    if command -v gsplus >/dev/null 2>&1; then
        ok "gsplus already on PATH"
        STATUS[emu_gsplus]="ok"
        return
    fi

    if is_done "emu_gsplus" && [ -x "${bin}" ]; then
        ok "GSplus already built at ${bin}"
        STATUS[emu_gsplus]="ok"
        return
    fi

    ensure_build_deps "GSplus" \
        "build-essential libx11-dev libxext-dev libpulse-dev libpcap-dev libfreetype6-dev" \
        "libpcap freetype pulseaudio" || true

    info "Building GSplus from source (Apple IIgs emulator)"
    local src="${CACHE_DIR}/gsplus-src"
    if [ ! -d "${src}" ]; then
        if ! git clone --depth 1 https://github.com/digarok/gsplus.git "${src}"; then
            STATUS[emu_gsplus]="failed"
            INSTRUCTIONS[emu_gsplus]="git clone https://github.com/digarok/gsplus.git failed"
            return
        fi
    fi

    # GSplus build layout: source lives at gsplus/src/ and expects one
    # of the vars_* config files to be copied into 'vars' before make.
    # On Linux we use the X11/PulseAudio build; on macOS we use the
    # Mac X11 build for command-line use (the Swift/clang .app build
    # needs Xcode and is skipped here).
    local gsplus_src_dir="${src}/gsplus/src"
    local gsplus_target=""
    local vars_file=""
    case "${HOST_OS}" in
        linux)
            vars_file="vars_x86linux"
            gsplus_target="gsplus-x"
            ;;
        macos)
            vars_file="vars_mac_x"
            gsplus_target="gsplus-x"
            ;;
    esac

    if [ -z "${vars_file}" ] || [ ! -f "${gsplus_src_dir}/${vars_file}" ]; then
        STATUS[emu_gsplus]="failed"
        INSTRUCTIONS[emu_gsplus]=$(cat <<EOF
GSplus: no build configuration available for host '${HOST_OS}'.
Available configurations in ${gsplus_src_dir}/:
  $(ls ${gsplus_src_dir}/vars_* 2>/dev/null | xargs -n1 basename 2>/dev/null | tr '\n' ' ')
Copy the appropriate vars_* file to 'vars' and run make manually.
EOF
)
        return
    fi

    (
        cd "${gsplus_src_dir}"
        cp "${vars_file}" vars
        make clean >/dev/null 2>&1 || true
        make "${gsplus_target}"
    ) && {
        # Built binary lands at gsplus/src/../gsplus per the Makefile
        # (it's moved up one level after linking).
        local gsbin="${src}/gsplus/gsplus"
        if [ ! -f "${gsbin}" ]; then
            # Fallback: find anywhere under the tree
            gsbin=$(find "${src}" -maxdepth 4 -name gsplus -type f 2>/dev/null | head -n1)
        fi
        if [ -n "${gsbin}" ] && [ -f "${gsbin}" ]; then
            mkdir -p "${base}/bin"
            cp "${gsbin}" "${base}/bin/gsplus"
            chmod +x "${base}/bin/gsplus"
            # Also copy the support files GSplus reads at runtime
            if [ -d "${src}/gsplus/lib" ]; then
                mkdir -p "${base}/lib"
                cp -r "${src}/gsplus/lib/." "${base}/lib/"
            fi
            mark_done "emu_gsplus"
            ok "GSplus built and installed"
            STATUS[emu_gsplus]="ok"
        else
            STATUS[emu_gsplus]="failed"
            INSTRUCTIONS[emu_gsplus]="GSplus build succeeded but binary not found; check ${src}"
        fi
    } || {
        STATUS[emu_gsplus]="failed"
        INSTRUCTIONS[emu_gsplus]=$(cat <<EOF
GSplus '${gsplus_target}' target build failed in ${gsplus_src_dir}.
Dependencies expected (Debian/Ubuntu):
  sudo apt install build-essential libx11-dev libxext-dev libpulse-dev libpcap-dev libfreetype6-dev
Then delete ${src} and re-run ./toolchains/install.sh.
EOF
)
    }
}

install_support_emutos() {
    local support_dir="$1"
    local dest="${support_dir}/emutos-512k.img"
    local key="emu_support_emutos"

    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        rm -f "${dest}"
        clear_done "${key}"
    fi
    if is_done "${key}" && [ -f "${dest}" ]; then
        ok "EmuTOS already staged"
        STATUS[${key}]="ok"
        return 0
    fi

    local zip_path="${CACHE_DIR}/emutos-512k-1.4.zip"
    local extract_dir="${CACHE_DIR}/emutos-512k-1.4"
    local url="https://sourceforge.net/projects/emutos/files/emutos/1.4/emutos-512k-1.4.zip/download"

    download "${url}" "${zip_path}" || {
        STATUS[${key}]="failed"
        return 1
    }
    rm -rf "${extract_dir}"
    (cd "${CACHE_DIR}" && unzip -oq "${zip_path}") || {
        STATUS[${key}]="failed"
        return 1
    }
    if [ ! -f "${extract_dir}/etos512us.img" ]; then
        err "EmuTOS zip missing etos512us.img"
        STATUS[${key}]="failed"
        return 1
    fi
    cp "${extract_dir}/etos512us.img" "${dest}"
    mark_done "${key}"
    ok "EmuTOS staged at ${dest}"
    STATUS[${key}]="ok"
}


install_support_iigs_rom() {
    local support_dir="$1"
    local dest="${support_dir}/apple-iigs.rom"
    local key="emu_support_iigs_rom"

    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        rm -f "${dest}"
        clear_done "${key}"
    fi
    if is_done "${key}" && [ -f "${dest}" ]; then
        ok "Apple IIgs ROM already staged"
        STATUS[${key}]="ok"
        return 0
    fi

    local zip_path="${CACHE_DIR}/iigs_rom03.zip"
    local url="https://mirrors.apple2.org.za/ftp.apple.asimov.net/emulators/rom_images/iigs_rom03.zip"

    download "${url}" "${zip_path}" || {
        STATUS[${key}]="failed"
        return 1
    }
    local tmp
    tmp=$(mktemp -d)
    (cd "${tmp}" && unzip -oq "${zip_path}") || {
        rm -rf "${tmp}"
        STATUS[${key}]="failed"
        return 1
    }
    local rom_src
    rom_src=$(find "${tmp}" -maxdepth 2 -type f \( -iname 'APPLE2GS.ROM*' -o -iname '*.rom' -o -iname '*.bin' \) | head -1)
    if [ -z "${rom_src}" ] || [ ! -f "${rom_src}" ]; then
        err "Apple IIgs ROM zip did not contain a ROM file"
        rm -rf "${tmp}"
        STATUS[${key}]="failed"
        return 1
    fi
    cp "${rom_src}" "${dest}"
    rm -rf "${tmp}"
    mark_done "${key}"
    ok "Apple IIgs ROM staged at ${dest}"
    STATUS[${key}]="ok"
}


install_support_gsos() {
    local support_dir="$1"
    local sys_dest="${support_dir}/gsos-system.po"
    local tools_dest="${support_dir}/gsos-tools1.po"
    local key="emu_support_gsos"

    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        rm -f "${sys_dest}" "${tools_dest}"
        clear_done "${key}"
    fi
    if is_done "${key}" && [ -f "${sys_dest}" ]; then
        ok "GS/OS system disk already staged"
        STATUS[${key}]="ok"
        return 0
    fi

    local zip_path="${CACHE_DIR}/Apple_IIGS_System_6.0.4.zip"
    local extract_dir="${CACHE_DIR}/Apple_IIGS_System_6.0.4"
    local url="https://mirrors.apple2.org.za/ftp.apple.asimov.net/images/gs/os/gsos/Apple_IIGS_System_6.0.4.zip"

    download "${url}" "${zip_path}" || {
        STATUS[${key}]="failed"
        return 1
    }
    rm -rf "${extract_dir}"
    (cd "${CACHE_DIR}" && unzip -oq "${zip_path}") || {
        STATUS[${key}]="failed"
        return 1
    }
    local sys_src="${extract_dir}/PO Disk Images/System.Disk.po"
    local tools_src="${extract_dir}/PO Disk Images/SystemTools1.po"
    if [ ! -f "${sys_src}" ]; then
        err "GS/OS zip missing System.Disk.po"
        STATUS[${key}]="failed"
        return 1
    fi
    cp "${sys_src}"   "${sys_dest}"
    [ -f "${tools_src}" ] && cp "${tools_src}" "${tools_dest}"
    mark_done "${key}"
    ok "GS/OS system disk staged at ${sys_dest}"
    STATUS[${key}]="ok"
}


install_support_iigs_null_c600() {
    local support_dir="$1"
    local dest="${support_dir}/iigs-null-c600.rom"
    local key="emu_support_iigs_null_c600"

    if [ "${FORCE_INSTALL}" -eq 1 ]; then
        rm -f "${dest}"
        clear_done "${key}"
    fi
    if is_done "${key}" && [ -f "${dest}" ]; then
        ok "IIgs null slot-6 PROM already staged"
        STATUS[${key}]="ok"
        return 0
    fi

    # 256-byte null PROM for slot 6. Leading RTS (so any accidental
    # call returns cleanly), then zero-filled -- no Pascal 1.1 firmware
    # signature, so the IIgs boot ROM's slot scan skips slot 6 and the
    # two empty 5.25 drives never get probed. run-iigs.sh stages this
    # into each session's work dir as c600.rom; GSplus picks it up from
    # cwd and overrides its built-in Disk II PROM.
    { printf '\x60'; head -c 255 /dev/zero; } > "${dest}"
    mark_done "${key}"
    ok "IIgs null slot-6 PROM staged at ${dest}"
    STATUS[${key}]="ok"
}


install_emulator_support() {
    header "Emulator support files"
    local support_dir="${SCRIPT_DIR}/emulators/support"
    mkdir -p "${support_dir}"

    install_support_emutos           "${support_dir}"
    install_support_iigs_rom         "${support_dir}"
    install_support_iigs_null_c600   "${support_dir}"
    install_support_gsos             "${support_dir}"
}


install_emulators() {
    header "Emulators"

    install_apt_emulator emu_dosbox  dosbox  dosbox           dosbox-x
    install_apt_emulator emu_fsuae   fs-uae  fs-uae           fs-uae
    install_apt_emulator emu_hatari  hatari  hatari           hatari
    install_gsplus

    install_emulator_support
}

# ------------------------------------------------------------------------
# Final status report
# ------------------------------------------------------------------------

print_status_report() {
    header "Installation status"
    local any_missing=0
    local any_failed=0
    local key
    local s

    # First pass: compute overall status. Do this in the current shell
    # (not inside a pipeline) so variable assignments stick.
    for key in "${!STATUS[@]}"; do
        s="${STATUS[$key]}"
        case "$s" in
            missing) any_missing=1 ;;
            failed)  any_failed=1  ;;
        esac
    done

    # Second pass: render sorted output.
    {
        for key in "${!STATUS[@]}"; do
            s="${STATUS[$key]}"
            case "$s" in
                ok)
                    printf '  %s[ok]%s %s\n' "${C_GREEN}" "${C_RESET}" "$key"
                    ;;
                missing)
                    printf '  %s[--]%s %s (manual install required)\n' "${C_YELLOW}" "${C_RESET}" "$key"
                    ;;
                failed)
                    printf '  %s[xx]%s %s (install failed)\n' "${C_RED}" "${C_RESET}" "$key"
                    ;;
            esac
        done
    } | sort

    if [ "${any_missing}" -eq 1 ] || [ "${any_failed}" -eq 1 ]; then
        header "Action required"
        for key in "${!INSTRUCTIONS[@]}"; do
            if [ "${STATUS[$key]}" != "ok" ]; then
                printf '\n%s---- %s ----%s\n%s\n' "${C_BOLD}" "$key" "${C_RESET}" "${INSTRUCTIONS[$key]}"
            fi
        done
        echo ""
        warn "Some components are not yet installed. Re-run after addressing the items above."
        exit 1
    else
        echo ""
        ok "All requested toolchains are ready."
        info "Now: source ${SCRIPT_DIR}/env.sh"
    fi
}

# ------------------------------------------------------------------------
# Main
# ------------------------------------------------------------------------

main() {
    detect_host_os
    require_tool make
    require_tool tar
    require_tool unzip
    ensure_dirs

    if should_install iigs;    then install_iigs;    fi
    if should_install amiga;   then install_amiga;   fi
    if should_install atarist; then install_atarist; fi
    if should_install dos;     then install_dos;     fi

    if [ "${SKIP_EMULATORS}" -eq 0 ] && [ -z "${ONLY_PLATFORM}" ]; then
        install_emulators
    fi

    print_status_report
}

main "$@"