#!/usr/bin/env bats
# Seam: the frank-small llama.cpp root unit on dankclaw.
# frank-small is the RTX 3090 endpoint; since 2026-10-01 night it serves
# bartowski/MiMo-V2.6-Distill-Qwen-9B-GGUF:Q6_K via a CUDA (sm_86) build of
# llama.cpp master, chosen for the ASYMMETRIC KV Frank asked for: K f16
# (unquantized) + V q8_0, which only llama.cpp exposes per-tensor. This
# seam runs the serve script against a stub engine and asserts on the argv
# it actually execs, so what is pinned is the command the operator gets.

load helpers

UNIT="$REPO_ROOT/scripts/frank-small.service"
SERVE="$REPO_ROOT/scripts/serve-frank-small.sh"
ENV_FILE="$REPO_ROOT/scripts/frank-small.env"
REMOTE_DEPLOY="$REPO_ROOT/scripts/deploy-remote.sh"
ENV_LARGE="$REPO_ROOT/scripts/frank-large.env"
TARGET_STUB="MiMo-V2.6-Distill-Qwen-9B-Q6_K.gguf"

setup() {
    STAGE="$(mktemp -d)"
    RUNTIME_DIR="$STAGE/llama"
    MODEL_DIR="$STAGE/models"
    mkdir -p "$RUNTIME_DIR/bin" "$MODEL_DIR"
    cat > "$RUNTIME_DIR/bin/llama-server" <<'STUB'
#!/usr/bin/env bash
printf '%s\n' "$@"
STUB
    chmod +x "$RUNTIME_DIR/bin/llama-server" "$RUNTIME_DIR/bin" 2>/dev/null || chmod +x "$RUNTIME_DIR/bin/llama-server"
    touch "$MODEL_DIR/$TARGET_STUB"
}

teardown() {
    rm -rf "$STAGE"
}

# serve_argv [env-file] — run the serve script and capture the engine's
# argv, one token per line, in $output.
serve_argv() {
    local envf="${1:-$STAGE/test.env}"
    cat > "$envf" <<EOF
LLAMA_BIN=$RUNTIME_DIR/bin/llama-server
MODEL_FILE=$MODEL_DIR/$TARGET_STUB
ALIAS=frank-small
BIND_ADDR=0.0.0.0
LISTEN_PORT=7771
CTX_SIZE=$(sed -nE 's/^CTX_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")
PARALLEL=$(sed -nE 's/^PARALLEL=([0-9]+)$/\1/p' "$ENV_FILE")
CACHE_TYPE_K=$(sed -nE 's/^CACHE_TYPE_K=(.+)$/\1/p' "$ENV_FILE")
CACHE_TYPE_V=$(sed -nE 's/^CACHE_TYPE_V=(.+)$/\1/p' "$ENV_FILE")
NGL=$(sed -nE 's/^NGL=([0-9]+)$/\1/p' "$ENV_FILE")
EOF
    run env FRANK_SMALL_ENV_FILE="$envf" nvidia-modprobe=true bash "$SERVE"
}

argv_value() {
    grep -A1 -xF -- "$1" <<<"$output" | tail -1
}

@test "frank-small unit, serve script and env exist in scripts/" {
    [ -f "$UNIT" ]
    [ -f "$SERVE" ]
    [ -f "$ENV_FILE" ]
}

@test "frank-small is boot-persistent, self-healing and unprivileged" {
    grep -q '^WantedBy=multi-user.target$' "$UNIT"
    grep -q '^Restart=on-failure$' "$UNIT"
    grep -q '^RestartSec=' "$UNIT"
    grep -q '^User=dank$' "$UNIT"
    grep -q '^LimitMEMLOCK=infinity$' "$UNIT"
    grep -q '^ExecStart=/home/dank/serverAppConfigs/scripts/serve-frank-small.sh$' "$UNIT"
    grep -q 'FRANK_SMALL_ENV_FILE=/home/dank/serverAppConfigs/scripts/frank-small.env' "$UNIT"
}

@test "the shipped env points at the llama.cpp runtime and the Q6_K GGUF" {
    grep -qE '^LLAMA_BIN=/home/dank/GitPackages/llama-master/build-cuda/bin/llama-server$' "$ENV_FILE"
    grep -qE "^MODEL_FILE=/home/dank/models/MiMo-Q6K/$TARGET_STUB$" "$ENV_FILE"
}

@test "the shipped env serves the fleet shape: two full native windows" {
    serve_argv
    [ "$status" -eq 0 ]
    [ "$(argv_value --alias)" = "frank-small" ]
    [ "$(argv_value --port)" = "7771" ]
    [ "$(argv_value --host)" = "0.0.0.0" ]
    [ "$(argv_value --model)" = "$MODEL_DIR/$TARGET_STUB" ]
    [ "$(argv_value --parallel)" -eq 2 ]
    [ "$(argv_value --n-gpu-layers)" -gt 0 ]
    # llama.cpp divides --ctx-size across slots: two slots means the pool
    # must be 2 x the window, and the window never exceeds the native one.
    ctx="$(argv_value --ctx-size)"
    par="$(argv_value --parallel)"
    [ $((ctx / par)) -eq 262144 ]
}

@test "the KV contract is asymmetric: unquantized K, q8_0 V, flash-attn on" {
    serve_argv
    [ "$status" -eq 0 ]
    [ "$(argv_value --cache-type-k)" = "f16" ]
    [ "$(argv_value --cache-type-v)" = "q8_0" ]
    # q8_0 on V only exists on the flash-attention path; without this flag
    # pair the KV contract in the env file is a lie the engine never sees.
    [ "$(argv_value --flash-attn)" = "on" ]
}

@test "the KV budget fits the 3090 with room for checkpoints" {
    # K f16 (16 KiB/token) + V q8_0 (~8.5, budget 25 with slack) over the
    # whole pool, plus 7.8 GiB weights and ~2 GiB of compute buffers and
    # CUDA graphs, must stay under the card's 24 GiB. This is arithmetic,
    # not a boot log: change CTX_SIZE and it bites before deploy does.
    ctx="$(sed -nE 's/^CTX_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")"
    kv_gib=$((ctx * 25 / 1048576))
    [ $((kv_gib + 8 + 2)) -le 24 ]
}

@test "no speculative draft ships by default" {
    # The qwen35 GGUF has no MTP tensors, and the cross-model DFlash draft
    # is a measured decision the harness makes later, not a default.
    ! grep -q -- '--model-draft' "$SERVE"
    ! grep -q -- '--spec-type' "$SERVE"
    ! grep -q '^DRAFT' "$ENV_FILE"
}

@test "frank-small stays text-only on the GGUF path and speaks the fleet reasoning field" {
    # The GGUF carries no vision projector; the image path left with the
    # SGLang checkpoint. models.yml declares frank-small text-only since
    # the 2026-10-01 night swap.
    ! grep -q -- '--mmproj' "$SERVE"
    # deepseek format = thinking lands in reasoning_content, the field the
    # harness has always read on this endpoint (SGLang parity).
    serve_argv
    [ "$(argv_value --reasoning-format)" = "deepseek" ]
    argv_value --jinja >/dev/null
    grep -qxF -- '--jinja' <<<"$output"
}

@test "the serve script refuses a missing runtime or payload" {
    rm -f "$RUNTIME_DIR/bin/llama-server"
    serve_argv
    [ "$status" -ne 0 ]
    [[ "$output" == *"frank-small: missing"* ]]
}

@test "the deploy handler gates on the binary and the GGUF, then MainPID-hardens health" {
    grep -q 'deploy_llm_small' "$REMOTE_DEPLOY"
    grep -q 'LLM_SMALL_RUNTIME' "$REMOTE_DEPLOY"
    grep -q 'LLM_SMALL_MODEL_FILE' "$REMOTE_DEPLOY"
    grep -q 'relink_unit frank-small' "$REMOTE_DEPLOY"
    grep -q 'systemctl enable frank-small.service' "$REMOTE_DEPLOY"
    grep -q '127.0.0.1:7771/health' "$REMOTE_DEPLOY"
    grep -q 'frank-small.service has no MainPID' "$REMOTE_DEPLOY"
}

@test "the two endpoints keep separate ports and the large handler never pkills llama-server" {
    # frank-large's gufo sweep must not take down frank-small, whose
    # process is llama-server on the SAME host since this swap.
    grep -q '^LISTEN_PORT=7771$' "$ENV_FILE"
    local large
    large="$(sed -n '/^deploy_llm_large() {/,/^}/p' "$REMOTE_DEPLOY")"
    ! grep -q 'pkill -x llama-server' <<<"$large"
}