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

if [[ $# != 7 ]]; then
    printf 'Usage: %s PROJECT ORIGINAL_ELF PRIOR.bc CERTIFIED_ELF BRANCH_CERT NEW.bc OUTPUT_DIRECTORY\n' "$0" >&2
    exit 2
fi

project=$(realpath -e "$1")
original=$(realpath -e "$2")
prior=$(realpath -e "$3")
branches=$(realpath -e "$4")
branch_certificate=$(realpath -e "$5")
guest=$(realpath -e "$6")
out=$(realpath -m "$7")
patch="$project/scripts/patch-aot-resource"

mkdir "$out"
"$patch" rewrite "$original" "$prior" "$out/branch-parent" > "$out/branch-parent-resource.json"
"$patch" rewrite "$original" "$guest" "$out/resource-image" > "$out/guest-resource.json"
cp "$branch_certificate" "$out/branches.json"
python3 - "$out" "$branches" <<'PY'
from contextlib import ExitStack
from hashlib import sha256
from pathlib import Path
import json
import mmap
import shutil
import sys


def required(condition, detail):
    if not condition:
        raise ValueError(detail)


def require_range_equal(left, right, start, end):
    chunk_size = 1024 * 1024
    for offset in range(start, end, chunk_size):
        limit = min(offset + chunk_size, end)
        required(left[offset:limit] == right[offset:limit],
                 f"uncertified byte difference in [{offset}, {limit})")


directory = Path(sys.argv[1])
branch_file = Path(sys.argv[2])
parents = [json.loads((directory / name).read_text()) for name in (
    "branch-parent-resource.json", "guest-resource.json", "branches.json",
)]
prior, guest, branches = parents
start, end = guest["replacement_interval"]
required(prior["replacement_interval"] == [start, end], "mismatched resource intervals")
required(prior["original_image_sha256"] == guest["original_image_sha256"], "mismatched pristine ELF")
required(branches["format"] == "graalc-elf-wide-branch-threading-v1", "unexpected branch certificate format")
required(branches["original_sha256"] == prior["patched_image_sha256"], "branch input digest mismatch")
output = directory / "sqlite-coalesced-elf"

with ExitStack() as stack:
    mapped = []
    for path in (directory / "branch-parent", directory / "resource-image", branch_file):
        file = stack.enter_context(path.open("rb"))
        mapped.append(stack.enter_context(mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_READ)))
    branch_input, resource_image, branch_image = mapped
    required(len(branch_input) == len(resource_image) == len(branch_image) == guest["image_bytes"],
             "ELF layout length mismatch")
    required(sha256(branch_input).hexdigest() == branches["original_sha256"], "branch input changed")
    required(sha256(resource_image).hexdigest() == guest["patched_image_sha256"], "resource image changed")
    required(sha256(branch_image).hexdigest() == branches["optimized_sha256"], "certified branch image changed")
    require_range_equal(branch_input, resource_image, 0, start)
    require_range_equal(branch_input, resource_image, end, len(branch_input))

    cursor = 0
    patches = sorted(branches["patches"], key=lambda patch: patch["file_offset"])
    for patch in patches:
        offset = patch["file_offset"]
        old = bytes.fromhex(patch["original_bytes"])
        new = bytes.fromhex(patch["replacement_bytes"])
        stop = offset + len(old)
        required(len(old) == len(new) and cursor <= offset < stop <= len(branch_image),
                 "invalid or overlapping branch edit")
        required(stop <= start or offset >= end, "branch edit overlaps the guest resource")
        require_range_equal(branch_input, branch_image, cursor, offset)
        required(branch_input[offset:stop] == old, "original branch bytes differ")
        required(branch_image[offset:stop] == new, "replacement branch bytes differ")
        cursor = stop
    require_range_equal(branch_input, branch_image, cursor, len(branch_image))

    shutil.copy2(branch_file, output)
    writable = stack.enter_context(output.open("r+b"))
    candidate = stack.enter_context(mmap.mmap(writable.fileno(), 0))
    candidate[start:end] = resource_image[start:end]
    candidate.flush()
    require_range_equal(candidate, resource_image, start, end)
    require_range_equal(candidate, branch_image, 0, start)
    require_range_equal(candidate, branch_image, end, len(candidate))
    manifest = {
        "format": "graalc-disjoint-elf-guest-composition-v1",
        "pristine_sha256": guest["original_image_sha256"],
        "branch_input_sha256": branches["original_sha256"],
        "branch_optimized_sha256": branches["optimized_sha256"],
        "resource_image_sha256": guest["patched_image_sha256"],
        "guest_bitcode_sha256": guest["raw_replacement_sha256"],
        "combined_elf_sha256": sha256(candidate).hexdigest(),
        "replacement_interval": [start, end],
        "verified_disjoint_branch_edits": len(patches),
        "elf_bytes": len(candidate),
    }
(directory / "composition.json").write_text(json.dumps(manifest, indent=2) + "\n")
print(json.dumps(manifest, indent=2))
PY
