#!/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_FREEBSD_SRC:?PRE15_FREEBSD_SRC is required}"
: "${PRE15_LIB_DIR:?PRE15_LIB_DIR is required}"
. "$PRE15_LIB_DIR/runner.sh"

probe=$PRE15_DUT/tests/pre15/probes/ondisk_layout.c
freebsd_header=$PRE15_DUT/src/erofs_fs.h
internal_header=$PRE15_DUT/src/internal.h
linux_header=$PRE15_ROOT/src-linux/erofs_fs.h
sys=$PRE15_FREEBSD_SRC/sys
target=x86_64-unknown-freebsd15.0
artifacts=$PRE15_RUN_DIR/artifacts
include_root=$PRE15_CASE_TMP/include

for tool in clang python3 sha256sum; do
	command -v "$tool" >/dev/null 2>&1 || \
		pre15_infra_blocked "missing B02 host tool: $tool"
done
test -d "$sys/amd64/include" || \
	pre15_infra_blocked "FreeBSD amd64 headers are absent: $sys"

pre15_record_fixture b02-layout-probe "$probe"
pre15_record_fixture b02-freebsd-ondisk-header "$freebsd_header"
pre15_record_fixture b02-freebsd-internal-header "$internal_header"
pre15_record_fixture b02-linux-ondisk-header "$linux_header"

mkdir -p "$artifacts" "$include_root"
ln -s "$sys/amd64/include" "$include_root/machine"
ln -s "$sys/x86/include" "$include_root/x86"
resource_include=$(clang -print-resource-dir)/include
pre15_target_reached

if clang --target="$target" -fsyntax-only -std=gnu17 -Wall -Wextra -Werror \
	-nostdinc -isystem "$resource_include" \
	-isystem "$PRE15_FREEBSD_SRC/include" -isystem "$include_root" \
	-isystem "$sys" -Xclang -fdump-record-layouts "$probe" \
	> "$artifacts/freebsd-record-layouts.txt" \
	2> "$artifacts/freebsd-layout.stderr"; then
	:
else
	pre15_dut_fail 'FreeBSD ondisk layout/type/macro oracle failed'
fi
if clang -DB02_LINUX_REFERENCE -fsyntax-only -std=gnu17 \
	-Wall -Wextra -Werror -Xclang -fdump-record-layouts "$probe" \
	> "$artifacts/linux-record-layouts.txt" \
	2> "$artifacts/linux-layout.stderr"; then
	:
else
	pre15_dut_fail 'Linux reference layout/type/macro oracle failed'
fi

clang --target="$target" -E -dM -std=gnu17 -nostdinc \
	-isystem "$resource_include" -isystem "$PRE15_FREEBSD_SRC/include" \
	-isystem "$include_root" -isystem "$sys" "$probe" | \
	awk '$2 ~ /^(EROFS_|Z_EROFS_)/ { print }' | LC_ALL=C sort \
	> "$artifacts/freebsd-macros.txt"
clang -DB02_LINUX_REFERENCE -E -dM -std=gnu17 "$probe" | \
	awk '$2 ~ /^(EROFS_|Z_EROFS_)/ { print }' | LC_ALL=C sort \
	> "$artifacts/linux-macros.txt"

if python3 - "$PRE15_ROOT" "$artifacts/static-check.json" <<'PY'
from __future__ import annotations

import json
from pathlib import Path
import re
import sys


root = Path(sys.argv[1])
output = Path(sys.argv[2])
dut = root / "repo-pre-15"
src = dut / "src"
ondisk = (src / "erofs_fs.h").read_text(encoding="utf-8")
internal = (src / "internal.h").read_text(encoding="utf-8")
linux = (root / "src-linux/erofs_fs.h").read_text(encoding="utf-8")


def require_once(source: str, token: str) -> None:
    count = source.count(token)
    if count != 1:
        raise SystemExit(f"expected one occurrence of {token!r}, found {count}")


def require_order(source: str, tokens: tuple[str, ...], label: str) -> None:
    positions = []
    for token in tokens:
        require_once(source, token)
        positions.append(source.index(token))
    if positions != sorted(positions):
        raise SystemExit(f"{label} section order mismatch: {tokens!r}")


ondisk_markers = (
    "struct erofs_deviceslot {",
    "struct erofs_super_block {",
    "EROFS_INODE_CHUNK_BASED",
    "#define EROFS_CHUNK_FORMAT_BLKBITS_MASK",
    "#define EROFS_INODE_LAYOUT_COMPACT",
    "struct erofs_inode_chunk_info {",
    "struct erofs_inode_compact {",
    "struct erofs_inode_extended {",
    "struct erofs_xattr_ibody_header {",
    "struct erofs_xattr_entry {",
    "struct erofs_xattr_long_prefix {",
    "#define EROFS_NULL_ADDR",
    "struct erofs_inode_chunk_index {",
    "#define EROFS_DIRENT_NID_METABOX_BIT",
    "struct erofs_dirent {",
    "#define EROFS_NAME_LEN",
    "struct z_erofs_lz4_cfgs {",
    "struct z_erofs_map_header {",
    "Z_EROFS_LCLUSTER_TYPE_PLAIN",
    "struct z_erofs_lcluster_index {",
    "struct z_erofs_extent {",
)
require_order(ondisk, ondisk_markers, "FreeBSD ondisk")
require_order(linux, ondisk_markers, "Linux ondisk")

aliases = {
    "EROFS_INODE_LAYOUT_COMPACT": "0",
    "EROFS_INODE_LAYOUT_EXTENDED": "1",
    "EROFS_INODE_LAYOUT_PLAIN": "EROFS_INODE_FLAT_PLAIN",
}
for name, value in aliases.items():
    pattern = rf"^#define[ \t]+{name}[ \t]+{value}$"
    if len(re.findall(pattern, ondisk, re.MULTILINE)) != 1:
        raise SystemExit(f"layout alias mismatch: {name}")

if not re.search(
    r"^#define[ \t]+EROFS_DEVT_SLOT_SIZE[ \t]+"
    r"sizeof\(struct erofs_deviceslot\)$",
    ondisk,
    re.MULTILINE,
):
    raise SystemExit("EROFS_DEVT_SLOT_SIZE is not derived from its record")
if re.search(r"^#if.*EROFS_DEVT_SLOT_SIZE", ondisk, re.MULTILINE):
    raise SystemExit("sizeof-based EROFS_DEVT_SLOT_SIZE is used in #if")

internal_markers = (
    "struct erofs_mount_opts {",
    "struct erofs_sb_lz4_info {",
    "struct erofs_device_info {",
    "struct erofs_xattr_prefix_item {",
    "struct erofs_zextent_cache {",
    "struct erofs_mount {",
    "#define EROFS_FEATURE_FUNCS",
    "EROFS_FEATURE_FUNCS(lz4_0padding",
    "struct erofs_node {",
    "struct erofs_fid {",
    "erofs_inode_version(unsigned int ifmt)",
    "#define EROFS_MAP_MAPPED",
    "struct erofs_map_blocks {",
    "struct erofs_map_dev {",
    "/* Buffer and device I/O. */",
    "/* Logical mapping and file data. */",
    "/* Inode and vnode lifecycle. */",
    "/* Directory operations. */",
    "/* Compressed mapping and data. */",
    "/* Compression configuration. */",
    "/* VOP vectors. */",
)
require_order(internal, internal_markers, "FreeBSD internal")
if re.search(r"return[ \t]+-E[A-Z0-9_]+", internal):
    raise SystemExit("Linux negative-errno convention entered FreeBSD internal.h")

vnops = (src / "erofs_vnops.c").read_text(encoding="utf-8")
super_source = (src / "super.c").read_text(encoding="utf-8")
inode = (src / "inode.c").read_text(encoding="utf-8")


def initializer(source: str, declaration: str, prefix: str) -> list[tuple[str, str]]:
    match = re.search(re.escape(declaration) + r"\s*=\s*\{(.*?)\n\};", source, re.DOTALL)
    if not match:
        raise SystemExit(f"initializer absent: {declaration}")
    return re.findall(
        rf"^\s*\.({prefix}_[A-Za-z0-9_]+)\s*=\s*([^,]+),",
        match.group(1),
        re.MULTILINE,
    )


vnode = initializer(vnops, "struct vop_vector erofs_vnodeops", "vop")
fifo = initializer(vnops, "struct vop_vector erofs_fifoops", "vop")
vfs = initializer(super_source, "static struct vfsops erofs_vfsops", "vfs")
expected_vnode = [
    ("vop_default", "&default_vnodeops"),
    ("vop_inactive", "erofs_inactive"),
    ("vop_reclaim", "erofs_reclaim"),
    ("vop_lookup", "vfs_cache_lookup"),
    ("vop_cachedlookup", "erofs_lookup"),
    ("vop_readdir", "erofs_readdir"),
    ("vop_readlink", "erofs_readlink"),
    ("vop_open", "erofs_open"),
    ("vop_read", "erofs_read"),
    ("vop_bmap", "erofs_bmap"),
    ("vop_getpages", "vnode_pager_local_getpages"),
    ("vop_getpages_async", "vnode_pager_local_getpages_async"),
    ("vop_getattr", "erofs_getattr"),
    ("vop_setattr", "erofs_setattr"),
    ("vop_access", "erofs_access"),
    ("vop_pathconf", "erofs_pathconf"),
    ("vop_getextattr", "erofs_getextattr"),
    ("vop_listextattr", "erofs_listextattr"),
    ("vop_deleteextattr", "erofs_deleteextattr"),
    ("vop_setextattr", "erofs_setextattr"),
    ("vop_getacl", "erofs_vop_getacl"),
    ("vop_aclcheck", "erofs_aclcheck"),
    ("vop_setacl", "erofs_setacl"),
    ("vop_vptofh", "erofs_vptofh"),
]
expected_fifo = [
    ("vop_default", "&fifo_specops"),
    ("vop_access", "erofs_access"),
    ("vop_aclcheck", "erofs_aclcheck"),
    ("vop_deleteextattr", "erofs_deleteextattr"),
    ("vop_getacl", "erofs_vop_getacl"),
    ("vop_getextattr", "erofs_getextattr"),
    ("vop_getattr", "erofs_getattr"),
    ("vop_listextattr", "erofs_listextattr"),
    ("vop_pathconf", "erofs_pathconf"),
    ("vop_reclaim", "erofs_reclaim"),
    ("vop_setacl", "erofs_setacl"),
    ("vop_setattr", "erofs_setattr"),
    ("vop_setextattr", "erofs_setextattr"),
    ("vop_vptofh", "erofs_vptofh"),
]
expected_vfs = [
    ("vfs_fhtovp", "erofs_fhtovp"),
    ("vfs_mount", "erofs_mount"),
    ("vfs_root", "erofs_root"),
    ("vfs_statfs", "erofs_statfs"),
    ("vfs_unmount", "erofs_unmount"),
    ("vfs_vget", "erofs_vgetf"),
]
if vnode != expected_vnode or fifo != expected_fifo or vfs != expected_vfs:
    raise SystemExit("VOP/VFS callback targets changed")

hash_calls = re.findall(
    r"vfs_hash_(?:get|insert)\s*\([^;]*?erofs_vfs_hash_cmp", inode, re.DOTALL
)
if len(hash_calls) != 2:
    raise SystemExit(f"hash comparator callsites changed: {len(hash_calls)}")

decompressors = []
for path in sorted(src.glob("decompressor*.c")):
    for line in path.read_text(encoding="utf-8").splitlines():
        match = re.match(r"\s*\.(config|decompress)\s*=\s*([^,]+),", line)
        if match:
            decompressors.append((path.name, match.group(1), match.group(2)))
expected_decompressors = [
    ("decompressor.c", "decompress", "z_erofs_transform_plain"),
    ("decompressor.c", "decompress", "z_erofs_transform_plain"),
    ("decompressor.c", "config", "z_erofs_load_lz4_config"),
    ("decompressor.c", "decompress", "z_erofs_lz4_decompress"),
    ("decompressor_deflate.c", "config", "z_erofs_load_deflate_config"),
    ("decompressor_deflate.c", "decompress", "z_erofs_deflate_decompress"),
    ("decompressor_lzma.c", "config", "z_erofs_load_lzma_config"),
    ("decompressor_lzma.c", "decompress", "z_erofs_lzma_decompress"),
    ("decompressor_zstd.c", "config", "z_erofs_load_zstd_config"),
    ("decompressor_zstd.c", "decompress", "z_erofs_zstd_decompress"),
]
if decompressors != expected_decompressors:
    raise SystemExit("decompressor callback targets changed")

result = {
    "status": "PASS",
    "source_symbol_denominator": {
        "baseline_physical": 464,
        "baseline_unique": 389,
        "b02_macro_delta": 3,
        "expected_physical": 467,
        "expected_unique": 392,
        "added_names": sorted(aliases),
        "kld_symbol_delta": 0,
    },
    "callbacks": {
        "vnode_slots": len(vnode),
        "fifo_slots": len(fifo),
        "vfs_slots": len(vfs),
        "hash_comparator_callsites": len(hash_calls),
        "decompressor_fields": len(decompressors),
    },
    "freebsd_adaptations": [
        "packed ondisk records",
        "little-endian typedefs",
        "explicit supported incompat mask",
        "FreeBSD VOP/VFS types",
        "positive errno convention",
    ],
}
with output.open("x", encoding="ascii") as stream:
    json.dump(result, stream, ensure_ascii=True, indent=2, sort_keys=True)
    stream.write("\n")
print(
    "static PASS source-symbols=464+3 callbacks=24+14/6 hash=2 decompress=10"
)
PY
then
	:
else
	pre15_dut_fail 'header order, symbol denominator, or callback oracle failed'
fi

sha256sum \
	"$artifacts/freebsd-record-layouts.txt" \
	"$artifacts/linux-record-layouts.txt" \
	"$artifacts/freebsd-macros.txt" \
	"$artifacts/linux-macros.txt" \
	"$artifacts/static-check.json" \
	> "$artifacts/SHA256SUMS"

printf 'layout PASS FreeBSD and Linux size/offset/alignment/type/macro oracles\n'