#!/bin/sh
set -eu

: "${PRE15_DUT:?PRE15_DUT is required}"
: "${PRE15_ROOT:?PRE15_ROOT is required}"
: "${PRE15_CASE_TMP:?PRE15_CASE_TMP is required}"
: "${PRE15_RUN_DIR:?PRE15_RUN_DIR is required}"
: "${PRE15_LIB_DIR:?PRE15_LIB_DIR is required}"
. "$PRE15_LIB_DIR/runner.sh"

baseline=8a8761af91654a025fd991d14da906c0b612bd7d
fixture=$PRE15_DUT/tests/pre15/fixtures/B22-zmap-arithmetic.json
kld_builder=$PRE15_DUT/tests/pre15/fixtures/B22-build-kld.sh
zmap=$PRE15_DUT/src/zmap.c
linux_zmap=$PRE15_ROOT/src-linux/zmap.c
artifacts=$PRE15_RUN_DIR/artifacts

for tool in cc git python3 sha256sum; do
	command -v "$tool" >/dev/null 2>&1 || \
		pre15_infra_blocked "missing B22 host tool: $tool"
done

pre15_record_fixture b22-arithmetic "$fixture"
pre15_record_fixture b22-kld-builder "$kld_builder"
pre15_record_fixture b22-case "$PRE15_DUT/tests/pre15/cases/B22-zmap-arithmetic.sh"
pre15_record_fixture b22-zmap "$zmap"
pre15_record_fixture b22-linux-zmap "$linux_zmap"
mkdir -p "$artifacts"
pre15_target_reached

if python3 -B - "$PRE15_ROOT" "$PRE15_DUT" "$baseline" "$fixture" \
    "$artifacts" <<'PY'
from __future__ import annotations

import json
from pathlib import Path
import re
import subprocess
import sys


root = Path(sys.argv[1])
dut = Path(sys.argv[2])
baseline = sys.argv[3]
fixture_path = Path(sys.argv[4])
artifacts = Path(sys.argv[5])
src = dut / "src"
u32_max = (1 << 32) - 1
u64_max = (1 << 64) - 1
eintegrity = 97


def committed(path: str) -> str:
    completed = subprocess.run(
        ["git", "-C", str(root), "show", f"{baseline}:repo-pre-15/{path}"],
        check=False,
        text=True,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    if completed.returncode != 0:
        raise SystemExit(f"cannot read B22 baseline {path}: {completed.stderr}")
    return completed.stdout


def function(source: str, name: str) -> str:
    match = re.search(r"^" + re.escape(name) + r"\s*\(", source, re.MULTILINE)
    if match is None:
        raise SystemExit(f"missing function: {name}")
    name_line = source.rfind("\n", 0, match.start()) + 1
    start = source.rfind("\n", 0, name_line - 1) + 1
    brace = source.find("{", match.end())
    if brace < 0:
        raise SystemExit(f"missing function body: {name}")
    depth = 0
    state = "code"
    index = brace
    while index < len(source):
        char = source[index]
        following = source[index + 1] if index + 1 < len(source) else ""
        if state == "code":
            if char == "/" and following == "*":
                state = "block"
                index += 2
                continue
            if char == "/" and following == "/":
                state = "line"
                index += 2
                continue
            if char == '"':
                state = "string"
            elif char == "'":
                state = "character"
            elif char == "{":
                depth += 1
            elif char == "}":
                depth -= 1
                if depth == 0:
                    return source[start : index + 1]
        elif state == "block" and char == "*" and following == "/":
            state = "code"
            index += 2
            continue
        elif state == "line" and char == "\n":
            state = "code"
        elif state in {"string", "character"}:
            if char == "\\":
                index += 2
                continue
            if (state == "string" and char == '"') or (
                state == "character" and char == "'"
            ):
                state = "code"
        index += 1
    raise SystemExit(f"unterminated function: {name}")


def add(left: int, right: int) -> tuple[str, int | None]:
    value = left + right
    if value > u64_max:
        return ("EINTEGRITY", None)
    return ("PASS", value)


def multiply(left: int, right: int) -> tuple[str, int | None]:
    value = left * right
    if value > u64_max:
        return ("EINTEGRITY", None)
    return ("PASS", value)


def model(case: dict[str, object]) -> tuple[str, int | None]:
    operation = case["operation"]
    if operation == "compact_pblk":
        return add(int(case["base"]), int(case["nblk"]))
    if operation == "index_base":
        status, end = add(int(case["inode_off"]), int(case["inode_isize"]))
        if status != "PASS":
            return (status, None)
        status, end = add(int(end), int(case.get("xattr_isize", 0)))
        if status != "PASS":
            return (status, None)
        status, end = add(int(end), 7)
        if status != "PASS":
            return (status, None)
        end = int(end) & ~7
        return add(end, 8)
    if operation == "index_advance":
        status, delta = multiply(int(case["count"]), int(case["unit"]))
        if status != "PASS":
            return (status, None)
        return add(int(case["position"]), int(delta))
    if operation == "lcluster_count":
        bits = int(case["lclusterbits"])
        if bits >= 64:
            return ("EINTEGRITY", None)
        size = int(case["size"])
        count = size >> bits
        if size & ((1 << bits) - 1):
            return add(count, 1)
        return ("PASS", count)
    if operation == "lcluster_pos":
        bits = int(case["lclusterbits"])
        if bits >= 64:
            return ("EINTEGRITY", None)
        status, base = multiply(int(case["lcn"]), 1 << bits)
        if status != "PASS":
            return (status, None)
        return add(int(base), int(case["clusterofs"]))
    if operation == "lcn_advance":
        return add(int(case["lcn"]), int(case["delta"]))
    if operation == "physical_end":
        status, pend = add(int(case["pa"]), int(case["plen"]))
        if status != "PASS":
            return (status, None)
        limit = (1 << 48) * int(case["block_size"])
        if limit <= u64_max and int(pend) > limit:
            return ("EINTEGRITY", None)
        return ("PASS", None)
    if operation == "post_eof":
        la = int(case["la"])
        size = int(case["size"])
        if la < size:
            return ("EINTEGRITY", None)
        length = la - size + 1
        return ("PASS", min(length, u64_max))
    if operation == "fragment_offset":
        low = int(case["low"])
        high = int(case["high"])
        if low > u32_max or high > u32_max:
            return ("EINTEGRITY", None)
        return ("PASS", low | (high << 32))
    raise SystemExit(f"unknown B22 operation: {operation}")


fixture = json.loads(fixture_path.read_text(encoding="ascii"))
if fixture.get("schema") != 1 or fixture.get("batch") != "B22":
    raise SystemExit("invalid B22 fixture identity")
if fixture.get("test") != "TC170-zmap-arithmetic":
    raise SystemExit("invalid B22 test identity")
if fixture.get("candidates") != [
    "P15-047",
    "P15-059",
    "P15-071",
    "P15-079",
    "P15-084",
]:
    raise SystemExit("B22 candidate set changed")
if fixture.get("errno") != {
    "corruption": eintegrity,
    "provider_io": "unchanged",
    "sign": "positive",
}:
    raise SystemExit("B22 errno contract changed")

cases = fixture.get("cases")
if not isinstance(cases, list) or not cases:
    raise SystemExit("B22 fixture has no cases")
names: set[str] = set()
markers: set[str] = set()
operations: set[str] = set()
decoded: list[dict[str, object]] = []
for case in cases:
    if not isinstance(case, dict):
        raise SystemExit("B22 fixture case is not an object")
    name = str(case.get("name", ""))
    marker = str(case.get("target_marker", ""))
    if not name or name in names or not marker.startswith("TC170:"):
        raise SystemExit(f"invalid B22 case identity: {name!r}")
    names.add(name)
    markers.add(marker)
    operations.add(str(case.get("operation", "")))
    status, value = model(case)
    if status != case.get("status"):
        raise SystemExit(f"B22 independent status mismatch: {name}")
    if status == "PASS" and value is not None and value != case.get("expected"):
        raise SystemExit(f"B22 independent value mismatch: {name}")
    mutated = case.get("mutated_fields")
    if status == "EINTEGRITY" and (
        not isinstance(mutated, list) or len(mutated) != 1
    ):
        raise SystemExit(f"B22 negative is not single-field: {name}")
    if status == "PASS" and mutated != []:
        raise SystemExit(f"B22 positive declares a mutation: {name}")
    decoded.append({"name": name, "status": status, "value": value})

required_markers = {
    "TC170:compact-pblk-32bit-crossing",
    "TC170:index-position",
    "TC170:delta-lcn",
    "TC170:physical-end-48bit",
    "TC170:post-eof",
    "TC170:fragment-high-bits",
}
if markers != required_markers:
    raise SystemExit("B22 target-marker set is incomplete")
if operations != {
    "compact_pblk",
    "fragment_offset",
    "index_advance",
    "index_base",
    "lcluster_count",
    "lcluster_pos",
    "lcn_advance",
    "physical_end",
    "post_eof",
}:
    raise SystemExit("B22 operation set is incomplete")

current = (src / "zmap.c").read_text(encoding="utf-8")
base = committed("src/zmap.c")
linux = (root / "src-linux/zmap.c").read_text(encoding="utf-8")
helpers = [
    "z_erofs_index_base",
    "z_erofs_index_advance",
    "z_erofs_lcluster_count",
    "z_erofs_lcluster_pos",
    "z_erofs_lcn_advance",
    "z_erofs_compact_pblk",
    "z_erofs_fragment_offset",
    "z_erofs_post_eof_len",
    "z_erofs_physical_end",
]
for helper in helpers:
    if helper in base or current.count(helper) < 2:
        raise SystemExit(f"B22 helper is missing, duplicated, or pre-existing: {helper}")

old_freebsd = (
    "m->pblk = le32dec(in + packsize - sizeof(uint32_t)) + nblk;",
    "map->m_llen = map->m_la + 1 - vi->size;",
    "vi->z_fragmentoff |= map->m_pa << 32;",
    "lcn += m->delta[1];",
    "pos += lcn << amortizedshift;",
    "(pend >> sbi->blkszbits) >= (1ULL << 48)",
)
if not all(anchor in base for anchor in old_freebsd):
    raise SystemExit("B22 baseline arithmetic anchors changed")
if any(anchor in current for anchor in old_freebsd):
    raise SystemExit("B22 left an unchecked baseline arithmetic anchor")
linux_anchors = (
    "m->pblk = le32_to_cpu(*(__le32 *)in) + nblk;",
    "map->m_llen = map->m_la + 1 - inode->i_size;",
    "vi->z_fragmentoff |= map->m_pa << 32;",
    "lcn += m->delta[1];",
    "(pend >> sbi->blkszbits) >= BIT_ULL(48)",
)
if not all(anchor in linux for anchor in linux_anchors):
    raise SystemExit("Linux zmap semantic anchor changed")
if function(current, "z_erofs_read_index") != function(base, "z_erofs_read_index"):
    raise SystemExit("B22 changed the FreeBSD metadata/provider reader")
if current.count("erofs_read_metadata") != base.count("erofs_read_metadata"):
    raise SystemExit("B22 changed metadata I/O call count")
if current.count("erofs_put_metabuf") != base.count("erofs_put_metabuf"):
    raise SystemExit("B22 changed metadata release call count")
for public in ("z_erofs_fill_inode", "z_erofs_map_blocks"):
    old_signature = function(base, public).split("{", 1)[0]
    new_signature = function(current, public).split("{", 1)[0]
    if old_signature != new_signature:
        raise SystemExit(f"B22 changed public zmap ABI: {public}")
if re.search(r"return\s*\(\s*-E[A-Z0-9_]+", current):
    raise SystemExit("B22 introduced Linux negative errno")

legacy_mismatches: set[str] = set()
for case in cases:
    operation = case["operation"]
    status = case["status"]
    expected = case.get("expected")
    if operation == "compact_pblk" and status == "PASS":
        old = (int(case["base"]) + int(case["nblk"])) & u32_max
        if old != expected:
            legacy_mismatches.add("compact-pblk")
    elif operation == "index_advance" and status == "EINTEGRITY":
        old = (int(case["position"]) + int(case["count"]) * int(case["unit"])) & u64_max
        if old <= u64_max:
            legacy_mismatches.add("index-position")
    elif operation == "lcluster_pos" and status == "EINTEGRITY":
        old = ((int(case["lcn"]) << int(case["lclusterbits"])) + int(case["clusterofs"])) & u64_max
        if old <= u64_max:
            legacy_mismatches.add("delta-lcn")
    elif operation == "physical_end" and case["name"] == "physical-last-48bit-block":
        pend = int(case["pa"]) + int(case["plen"])
        if (pend >> 12) >= (1 << 48):
            legacy_mismatches.add("physical-end")
    elif operation == "post_eof" and case["name"] == "post-eof-saturates-empty-inode":
        old = ((int(case["la"]) + 1) & u64_max) - int(case["size"])
        if old != expected:
            legacy_mismatches.add("post-eof")
    elif operation == "fragment_offset" and status == "EINTEGRITY":
        old = int(case["low"]) | ((int(case["high"]) << 32) & u64_max)
        if old <= u64_max:
            legacy_mismatches.add("fragment-high")
if legacy_mismatches != {
    "compact-pblk",
    "delta-lcn",
    "fragment-high",
    "index-position",
    "physical-end",
    "post-eof",
}:
    raise SystemExit("B22 fixtures do not distinguish every legacy bug")

helper_source = "\n\n".join(function(current, name) for name in helpers)
c_lines = [
    "#include <stdint.h>",
    "#include <stdio.h>",
    "#define EINTEGRITY 97",
    "#define rounddown2(x, y) ((x) & ~((y) - 1))",
    "typedef uint64_t erofs_off_t;",
    "typedef uint64_t erofs_blk_t;",
    "struct z_erofs_map_header { uint8_t bytes[8]; };",
    "struct erofs_inode { erofs_off_t inode_off; unsigned int inode_isize; unsigned int xattr_isize; };",
    helper_source,
    "int main(void)",
    "{",
    "\tuint64_t value;",
    "\tint error, failures = 0;",
]


def u64(value: object) -> str:
    return f"UINT64_C({int(value)})"


for case in cases:
    name = str(case["name"])
    operation = case["operation"]
    expected_error = 0 if case["status"] == "PASS" else eintegrity
    c_lines.append(f"\t/* {name} */")
    if operation == "compact_pblk":
        call = f"z_erofs_compact_pblk(UINT32_C({int(case['base'])}), {int(case['nblk'])}U, &value)"
    elif operation == "index_base":
        c_lines.extend([
            "\t{",
            "\t\tstruct erofs_inode vi = {",
            f"\t\t\t.inode_off = {u64(case['inode_off'])},",
            f"\t\t\t.inode_isize = {int(case['inode_isize'])}U,",
            f"\t\t\t.xattr_isize = {int(case.get('xattr_isize', 0))}U,",
            "\t\t};",
        ])
        call = "z_erofs_index_base(&vi, &value)"
    elif operation == "index_advance":
        c_lines.append(f"\tvalue = {u64(case['position'])};")
        call = f"z_erofs_index_advance(&value, {u64(case['count'])}, {u64(case['unit'])})"
    elif operation == "lcluster_count":
        call = f"z_erofs_lcluster_count({u64(case['size'])}, {int(case['lclusterbits'])}U, &value)"
    elif operation == "lcluster_pos":
        call = f"z_erofs_lcluster_pos({u64(case['lcn'])}, {int(case['lclusterbits'])}U, {u64(case['clusterofs'])}, &value)"
    elif operation == "lcn_advance":
        c_lines.append(f"\tvalue = {u64(case['lcn'])};")
        call = f"z_erofs_lcn_advance(&value, {u64(case['delta'])})"
    elif operation == "physical_end":
        call = f"z_erofs_physical_end({u64(case['pa'])}, {u64(case['plen'])}, {u64(case['block_size'])})"
    elif operation == "post_eof":
        call = f"z_erofs_post_eof_len({u64(case['la'])}, {u64(case['size'])}, &value)"
    elif operation == "fragment_offset":
        call = f"z_erofs_fragment_offset({u64(case['low'])}, {u64(case['high'])}, &value)"
    else:
        raise SystemExit(f"cannot generate C for operation: {operation}")
    c_lines.append(f"\terror = {call};")
    c_lines.append(f"\tif (error != {expected_error}) {{")
    c_lines.append(f"\t\tfprintf(stderr, \"{name}: error=%d\\n\", error);")
    c_lines.append("\t\tfailures++;\n\t}")
    if case["status"] == "PASS" and "expected" in case:
        c_lines.append(f"\tif (value != {u64(case['expected'])}) {{")
        c_lines.append(f"\t\tfprintf(stderr, \"{name}: value mismatch\\n\");")
        c_lines.append("\t\tfailures++;\n\t}")
    if operation == "index_base":
        c_lines.append("\t}")
c_lines.extend([
    "\tif (failures != 0)",
    "\t\treturn (1);",
    f"\tprintf(\"B22 extracted arithmetic PASS cases={len(cases)}\\n\");",
    "\treturn (0);",
    "}",
])
c_path = artifacts / "B22-zmap-arithmetic.c"
binary = artifacts / "B22-zmap-arithmetic"
c_path.write_text("\n".join(c_lines) + "\n", encoding="ascii")
compiled = subprocess.run(
    ["cc", "-std=gnu11", "-Wall", "-Wextra", "-Werror", str(c_path), "-o", str(binary)],
    check=False,
    text=True,
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
)
(artifacts / "B22-compile.stdout").write_text(compiled.stdout, encoding="utf-8")
(artifacts / "B22-compile.stderr").write_text(compiled.stderr, encoding="utf-8")
if compiled.returncode != 0:
    raise SystemExit("B22 extracted arithmetic compilation failed")
executed = subprocess.run(
    [str(binary)],
    check=False,
    text=True,
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
)
(artifacts / "B22-extracted.stdout").write_text(executed.stdout, encoding="utf-8")
(artifacts / "B22-extracted.stderr").write_text(executed.stderr, encoding="utf-8")
if executed.returncode != 0:
    raise SystemExit("B22 extracted arithmetic execution failed")

result = {
    "status": "PASS",
    "batch": "B22",
    "test": "TC170-zmap-arithmetic",
    "baseline": baseline,
    "case_count": len(cases),
    "negative_count": sum(case["status"] == "EINTEGRITY" for case in cases),
    "target_markers": sorted(markers),
    "legacy_mismatches": sorted(legacy_mismatches),
    "freebsd_positive_errno": True,
    "linux_algorithm_locations_audited": True,
    "provider_io_calls_unchanged": True,
    "metadata_release_calls_unchanged": True,
    "decompressor_abi_unchanged": True,
    "ondisk_abi_unchanged": True,
    "qemu_scope": "exact-source KLD load plus extracted helper replay when PRE15_MODE=qemu",
    "full_feature_suite": "NOT_RUN",
}
(artifacts / "B22-decoded-cases.json").write_text(
    json.dumps(decoded, ensure_ascii=True, indent=2, sort_keys=True) + "\n",
    encoding="ascii",
)
(artifacts / "B22-result.json").write_text(
    json.dumps(result, ensure_ascii=True, indent=2, sort_keys=True) + "\n",
    encoding="ascii",
)
print(
    f"B22 host PASS cases={len(cases)} negatives={result['negative_count']} "
    f"markers={len(markers)}"
)
PY
then
	:
else
	pre15_dut_fail 'B22 source, fixture, or extracted arithmetic check failed'
fi

sha256sum "$artifacts/B22-zmap-arithmetic.c" \
    "$artifacts/B22-zmap-arithmetic" \
    "$artifacts/B22-decoded-cases.json" "$artifacts/B22-result.json" \
    > "$artifacts/SHA256SUMS"

if test "${PRE15_MODE:-host}" != qemu; then
	printf '%s\n' \
		'TC170 host extracted zmap arithmetic and fixture oracle PASS' \
		'QEMU exact-source KLD load and FreeBSD helper replay NOT_RUN in host mode'
	exit 0
fi

for tool in awk clang file nm scp; do
	command -v "$tool" >/dev/null 2>&1 || \
		pre15_infra_blocked "missing B22 QEMU tool: $tool"
done
: "${PRE15_QEMU_CONTROL_PATH:?QEMU control path is required}"
: "${PRE15_QEMU_SSH_KEY:?QEMU SSH key is required}"
: "${PRE15_QEMU_SSH_PORT:?QEMU SSH port is required}"
: "${PRE15_QEMU_SSH_USER:?QEMU SSH user is required}"

module=$PRE15_CASE_TMP/B22-erofs.ko
if ! /bin/sh "$kld_builder" "$PRE15_DUT" "$PRE15_FREEBSD_SRC" "$module" \
    "$PRE15_CASE_TMP/kld-work" >"$artifacts/B22-kld-build.stdout" \
    2>"$artifacts/B22-kld-build.stderr"; then
	pre15_dut_fail 'B22 cross-target KLD build failed'
fi
pre15_record_module "$module"
file "$module" > "$artifacts/B22-kld-file.txt"
sha256sum "$module" > "$artifacts/B22-kld-sha256.txt"
nm -u "$module" | LC_ALL=C sort > "$artifacts/B22-kld-nm-u.txt"

pre15_scp()
{
	timeout -k 5 "${PRE15_GUEST_COMMAND_TIMEOUT:-60}" scp -O -q \
		-o BatchMode=yes -o StrictHostKeyChecking=no \
		-o UserKnownHostsFile=/dev/null -o ConnectTimeout=5 \
		-o "ControlPath=$PRE15_QEMU_CONTROL_PATH" \
		-i "$PRE15_QEMU_SSH_KEY" -P "$PRE15_QEMU_SSH_PORT" \
		"$1" "$PRE15_QEMU_SSH_USER@127.0.0.1:$2"
}

if ! pre15_scp "$module" /root/B22-erofs.ko || \
    ! pre15_scp "$artifacts/B22-zmap-arithmetic.c" \
    /root/B22-zmap-arithmetic.c; then
	pre15_infra_blocked 'could not transfer B22 module or arithmetic source'
fi
if pre15_guest_ssh_bounded kldstat -n erofs >/dev/null 2>&1; then
	pre15_infra_blocked 'FreeBSD guest already has an EROFS module loaded'
fi
if ! pre15_guest_ssh_bounded kldload /root/B22-erofs.ko \
    >"$artifacts/B22-kldload.stdout" 2>"$artifacts/B22-kldload.stderr"; then
	if grep -q 'module already loaded or in kernel' \
	    "$artifacts/B22-kldload.stderr"; then
		pre15_infra_blocked 'guest kernel already owns the erofs.1 interface'
	fi
	pre15_dut_fail 'B22 exact-source KLD failed to load'
fi
pre15_own_guest_kld erofs 'B22 exact-source KLD'
if ! pre15_guest_ssh_bounded cc -std=gnu11 -Wall -Wextra -Werror \
    /root/B22-zmap-arithmetic.c -o /root/B22-zmap-arithmetic; then
	pre15_infra_blocked 'could not compile B22 arithmetic helper in the guest'
fi
if ! pre15_guest_ssh_bounded /root/B22-zmap-arithmetic \
    >"$artifacts/B22-guest-arithmetic.stdout" \
    2>"$artifacts/B22-guest-arithmetic.stderr"; then
	pre15_dut_fail 'B22 FreeBSD arithmetic helper replay failed'
fi
pre15_guest_ssh_bounded kldstat -n erofs > "$artifacts/B22-kldstat.txt"
printf '%s\n' \
	'TC170 QEMU PASS exact-source KLD load and FreeBSD arithmetic helper replay' \
	'No full feature suite or shared GEOM provider was used'