//! Private template relocation and bounded linking checks.

use std::testing;

use std::mem;

use std::arch::rv64::shared::catalog;

use std::arch::rv64::asm;

use std::lang::alloc;

use std::lang::il;

use std::lang::il::binary;

use std::lang::gen::data;

/// Code generation workspace reused between checks.

static ARENA: [u8; 16777216] = [0; 16777216];

/// Function allocation workspace.

static SCRATCH: [u8; 16777216] = [0; 16777216];

/// Persistent catalog symbols.

unsafe static SYMBOLS: [super::Symbol; 8] = undefined;

/// Persistent exported symbols.

unsafe static EXPORTS: [super::Symbol; 8] = undefined;

/// Data layout workspace.

unsafe static DATA: [data::DataSym; 8] = undefined;

/// Persistent initialized bytes.

static TEMPLATE: [u8; 64] = [0; 64];

/// Persistent private data relocations.

unsafe static RELOCS: [super::Relocation; 8] = undefined;

/// Aligned storage for a native boot catalog and its retained payloads.

static CATALOG: [u64; 512] = [0; 512];

/// Exported assembly boundaries occupy the same code extent as their package.

@test unsafe fn assemblyPrefix() throws (testing::TestError) {

    let input = binary::Package {

        symbols: &[], name: "p", dependencies: &[],

        exports: &[binary::Export { name: "p::entry", kind: binary::ExportKind::Function }],

        entry: "p::entry", program: il::Program { data: &[], fns: &[] },

    };

    let assembly = asm::Program {

        text: &[0x02a00513 as u32, 0x00008067], data: &[],

        symbols: &[asm::Symbol { name: "p::entry", section: asm::Section::Text, offset: 0, isExported: true }],

        externalFixups: &[],

    };

    let mut arena = alloc::new(&mut ARENA[..]);

    let mut scratch = alloc::new(&mut SCRATCH[..]);

    let package = try super::compileAssembly(super::AssemblyInput { package: &input, assembly }, 0, 0x180000000, &[],

        super::Storage {

            data: &mut DATA[..], symbols: &mut SYMBOLS[..], exports: &mut EXPORTS[..],

            template: &mut TEMPLATE[..], relocations: &mut RELOCS[..],

        }, &mut arena, &mut scratch) catch {

            throw testing::TestError::Failed;

        };

    let entry = package.entry else {

        throw testing::TestError::Failed;

    };

    try testing::expect(entry == 0x180000000 and package.code.len == 2);

    try testing::expect(package.code[0] == 0x02a00513 and package.exports[0].target == super::Target::Function(entry));

}

/// Packed catalog pointers resolve to retained metadata at the supplied native base.

@test unsafe fn nativeCatalog() throws (testing::TestError) {

    let package = try compile(imports(), 64) catch {

        throw testing::TestError::Failed;

    };

    let output = @sliceOf(&mut CATALOG[0] as *mut u8, @sizeOf([u64; 512]));

    let base = output.ptr as u64;

    let used = try catalog::pack(&[catalog::Entry { source: "trusted binary", package }], base, output)

        catch {

            throw testing::TestError::Failed;

        };

    let storage = &CATALOG[0] as *opaque;

    let entry = storage as *catalog::Entry;

    try testing::expect(used > @sizeOf(catalog::Entry) and used <= output.len);

    try testing::expect(mem::eq(entry.source, "trusted binary") and mem::eq(entry.package.name, "p"));

    try testing::expect(mem::eq(entry.package.dependencies[0], "dep"));

    try testing::expect(entry.package.code.ptr as u64 == package.codeAddress and entry.package.code.len == package.code.len);

    try testing::expect(entry.source.ptr as u64 >= base and entry.source.ptr as u64 < base + used as u64);

    set TEMPLATE[0] = 91;

    set EXPORTS[0].name = "changed";

    try testing::expect(entry.package.template[0] == 0 and mem::eq(entry.package.exports[0].name, "p::refs"));

    let mut state: [u8; 48] = [255; 48];

    try super::instantiate(&entry.package, &[0, 0x180002000, 0x180008000], &mut state[..])

        catch {

            throw testing::TestError::Failed;

        };

    try testing::expect(pointer(&state[..], 0) == 0x180004000 and pointer(&state[..], 16) == 0x180001234);

    let relocated = try catalog::pack(&[catalog::Entry { source: "trusted binary", package }], 0x180000000, output)

        catch {

            throw testing::TestError::Failed;

        };

    try testing::expect(entry.source.ptr as u64 >= 0x180000000 and entry.source.ptr as u64 < 0x180000000 + relocated as u64);

}

/// Catalog bounds and native alignment failures are recoverable.

@test unsafe fn nativeCatalogBounds() throws (testing::TestError) {

    let package = try compile(imports(), 64) catch {

        throw testing::TestError::Failed;

    };

    let entries = [catalog::Entry { source: "binary", package }];

    let output = @sliceOf(&mut CATALOG[0] as *mut u8, @sizeOf([u64; 512]));

    let mut failures: u32 = 0;

    try catalog::pack(&entries[..], 0x80000000, &mut output[..@sizeOf(catalog::Entry)]) catch err {

        try testing::expect(err == super::Error::Capacity); set failures += 1;

    };

    try catalog::pack(&entries[..], 0x80000001, output) catch err {

        try testing::expect(err == super::Error::Alignment); set failures += 1;

    };

    try catalog::pack(&entries[..], 0xfffffffffffffff8, output) catch err {

        try testing::expect(err == super::Error::Range); set failures += 1;

    };

    try testing::expect(failures == 3);

    let used = try catalog::pack(&entries[..], 0x80000000, output) catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(used > @sizeOf(catalog::Entry));

}

/// Build a package with repeated dependency pointers and a high code pointer.

unsafe fn input() -> binary::Package {

    return binary::Package {

        symbols: &[], name: "p", dependencies: &["dep"],

        exports: &[binary::Export { name: "p::refs", kind: binary::ExportKind::Data }],

        entry: nil,

        program: il::Program {

            data: &[

                il::Data {

                    name: "p::refs", size: 32, alignment: 8, readOnly: true, isZeroInit: false,

                    values: &[

                        il::DataValue { item: il::DataItem::Sym("dep::value"), count: 2 },

                        il::DataValue { item: il::DataItem::Fn("dep::call"), count: 1 },

                    ],

                },

                il::Data {

                    name: "p::zero", size: 16, alignment: 16, readOnly: false, isZeroInit: true, values: &[],

                },

            ],

            fns: &[],

        },

    };

}

/// Compile into small persistent tables.

unsafe fn compile(imports: &[super::Symbol], capacity: u32) -> super::Package throws (super::Error) {

    let mut arena = alloc::new(&mut ARENA[..]);

    let mut scratch = alloc::new(&mut SCRATCH[..]);

    let package = input();

    return try super::compile(&package, 2, 0x180000000, imports,

        super::Storage {

            data: &mut DATA[..], symbols: &mut SYMBOLS[..], exports: &mut EXPORTS[..],

            template: &mut TEMPLATE[..capacity], relocations: &mut RELOCS[..],

        }, &mut arena, &mut scratch);

}

/// Dependency exports with a full-width function pointer and a large data offset.

fn imports() -> *[super::Symbol] {

    return &[

        super::Symbol { name: "dep::value", target: super::Target::Data(super::DataRef { slot: 1, offset: 8192 }) },

        super::Symbol { name: "dep::call", target: super::Target::Function(0x180001234) },

    ];

}

/// Read a little-endian pointer without requiring buffer alignment.

fn pointer(bytes: &[u8], offset: u32) -> u64 {

    let mut value: u64 = 0;

    for i in 0..8 {

        set value |= bytes[offset + i] as u64 << (i as u64 * 8);

    }

    return value;

}

/// Check repeated pointers, full-width code addresses, padding, and zero-filled tails.

@test unsafe fn privateRelocations() throws (testing::TestError) {

    let package = try compile(imports(), 64) catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(package.template.len == 32 and package.memory == 48 and package.alignment == 16);

    try testing::expect(package.relocations.len == 1 and package.relocations[0].count == 2);

    try testing::expect(pointer(package.template, 16) == 0x180001234);

    let mut first: [u8; 48] = [255; 48];

    let mut second: [u8; 48] = [255; 48];

    try super::instantiate(&package, &[0, 0x180002000, 0x180008000], &mut first[..])

        catch {

            throw testing::TestError::Failed;

        };

    try super::instantiate(&package, &[0, 0x280002000, 0x280008000], &mut second[..])

        catch {

            throw testing::TestError::Failed;

        };

    try testing::expect(pointer(&first[..], 0) == 0x180004000 and pointer(&first[..], 8) == 0x180004000);

    try testing::expect(pointer(&second[..], 0) == 0x280004000 and pointer(&second[..], 8) == 0x280004000);

    try testing::expect(pointer(&first[..], 16) == pointer(&second[..], 16));

    for i in 24..48 {

        try testing::expect(first[i] == 0 and second[i] == 0);

    }

}

/// A missing instance, bad base, or short buffer leaves instance bytes untouched.

@test unsafe fn instanceFailures() throws (testing::TestError) {

    let package = try compile(imports(), 64) catch {

        throw testing::TestError::Failed;

    };

    let mut bytes: [u8; 48] = [255; 48];

    let mut failed: u32 = 0;

    try super::instantiate(&package, &[0, 0, 0x8000], &mut bytes[..]) catch err {

        try testing::expect(err == super::Error::Instance); set failed += 1;

    };

    try super::instantiate(&package, &[0, 0x2000, 0x8008], &mut bytes[..]) catch err {

        try testing::expect(err == super::Error::Alignment); set failed += 1;

    };

    try super::instantiate(&package, &[0, 0x2000, 0x8000], &mut bytes[..47]) catch err {

        try testing::expect(err == super::Error::Capacity); set failed += 1;

    };

    try super::instantiate(&package, &[0, 0xffffffffffffffff, 0x8000], &mut bytes[..]) catch err {

        try testing::expect(err == super::Error::Range); set failed += 1;

    };

    try testing::expect(failed == 4);

    for byte in &bytes[..] {

        try testing::expect(byte == 255);

    }

}

/// Missing symbols, duplicate imports, kind mismatches, and short output fail explicitly.

@test unsafe fn linkFailures() throws (testing::TestError) {

    let mut failed: u32 = 0;

    try compile(&[], 64) catch err {

        try testing::expect(err == super::Error::Symbol); set failed += 1;

    };

    let names = imports();

    try compile(&[names[0], names[0]], 64) catch err {

        try testing::expect(err == super::Error::Symbol); set failed += 1;

    };

    try compile(&[

        super::Symbol { name: "dep::value", target: super::Target::Function(0x8000) }, names[1],

    ], 64) catch err {

        try testing::expect(err == super::Error::Symbol); set failed += 1;

    };

    try compile(names, 31) catch err {

        try testing::expect(err == super::Error::Capacity); set failed += 1;

    };

    try testing::expect(failed == 4);

    let package = try compile(names, 64) catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(package.exports.len == 1);

}