//! IL snapshot test runner and `.ras` asm helper.

//!

//! Given a `.rad` source file, lowers it to IL and compares the output

//! against the corresponding `.ril` snapshot file. It also supports an

//! `assemble <input.ras> <output.rv64>` subcommand used by `bin-test`.

use std::io;

use std::mem;

use std::sys;

use std::sys::unix;

use std::lang::alloc;

use std::lang::ast;

use std::lang::il::printer;

use std::lang::parser;

use std::lang::scanner;

use std::lang::resolver;

use std::lang::strings;

use std::lang::lower;

use std::arch::rv64;

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

/// Buffer size for reading source files (8 KB).

constant SOURCE_BUF_SIZE: u32 = 8192;

/// Buffer size for reading expected IL files (32 KB).

constant EXPECTED_BUF_SIZE: u32 = 32768;

/// Buffer size for generated IL output (32 KB).

constant OUTPUT_BUF_SIZE: u32 = 32768;

/// Arena size for AST/IL allocations (512 KB).

constant ARENA_SIZE: u32 = 524288;

/// Maximum path length for expected IL file path.

constant MAX_PATH_LEN: u32 = 256;

/// Source file extension for binary tests.

constant SOURCE_EXT: *[u8] = ".rad";

/// IL snapshot file extension for binary tests.

constant SNAPSHOT_EXT: *[u8] = ".ril";

/// String pool.

static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Maximum number of AST nodes per test file.

constant MAX_NODE_DATA: u32 = 4096;

/// Maximum number of resolver errors per test file.

constant MAX_ERRORS: u32 = 16;

/// Maximum number of text words in a `.ras` test binary.

constant ASM_TEXT_CAPACITY: u32 = 256;

/// Maximum number of data bytes in a `.ras` test binary.

constant ASM_DATA_CAPACITY: u32 = 1024;

// Static storage for large buffers to avoid stack overflow.

// Tests run serially so sharing these is safe.

static SOURCE_BUF: [u8; SOURCE_BUF_SIZE] = undefined;

static EXPECTED_BUF: [u8; EXPECTED_BUF_SIZE] = undefined;

static OUTPUT_BUF: [u8; OUTPUT_BUF_SIZE] = undefined;

static AST_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;

static IL_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;

static RESOLVER_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;

static NODE_DATA_STORAGE: [resolver::NodeData; MAX_NODE_DATA] = undefined;

static ERROR_STORAGE: [resolver::Error; MAX_ERRORS] = undefined;

static ASM_TEXT_STORAGE: [u32; ASM_TEXT_CAPACITY] = undefined;

static ASM_DATA_STORAGE: [u8; ASM_DATA_CAPACITY] = undefined;

/// Strip a `//` comment from a line, preserving `//` inside quoted strings.

/// Returns the content before the comment, trimmed of trailing whitespace.

fn stripLine(line: *[u8]) -> *[u8] {

    let mut end = line.len;

    let mut i: u32 = 0;

    let mut inString = false;

    let mut escaped = false;

    while i < line.len {

        let ch = line[i];

        if inString {

            if escaped {

                set escaped = false;

            } else if ch == '\\' {

                set escaped = true;

            } else if ch == '"' {

                set inString = false;

            }

        } else if ch == '"' {

            set inString = true;

        } else if ch == '/' and i + 1 < line.len and line[i + 1] == '/' {

            set end = i;

            break;

        }

        set i += 1;

    }

    while end > 0 and (line[end - 1] == ' ' or line[end - 1] == '\t') {

        set end -= 1;

    }

    return &line[..end];

}

/// Get next line from string at offset. Returns the line and updates offset past newline.

fn nextLine(s: *[u8], offset: *mut u32) -> *[u8] {

    let start = *offset;

    let mut i = start;

    while i < s.len and s[i] <> '\n' {

        set i += 1;

    }

    let line = &s[start..i];

    if i < s.len {

        set *offset = i + 1;

    } else {

        set *offset = i;

    }

    return line;

}

/// Compare two strings ignoring comments, line by line.

fn stringsEqual(a: *[u8], b: *[u8]) -> bool {

    let mut ai: u32 = 0;

    let mut bi: u32 = 0;

    while ai < a.len or bi < b.len {

        let mut aLine = "";

        while ai < a.len and aLine.len == 0 {

            set aLine = stripLine(nextLine(a, &mut ai));

        }

        let mut bLine = "";

        while bi < b.len and bLine.len == 0 {

            set bLine = stripLine(nextLine(b, &mut bi));

        }

        if not mem::eq(aLine, bLine) {

            return false;

        }

    }

    return true;

}

/// Print diff between expected and actual output.

fn printDiff(expected: *[u8], actual: *[u8]) {

    io::printLn("\n// Expected");

    io::print(expected);

    io::print("\n");

    io::printLn("// Actual");

    io::print(actual);

    io::print("\n");

}

/// Derive the `.ril` path from a `.rad` source path. Returns nil if the path

/// does not end in `.rad` or the buffer is too small. The result is

/// null-terminated for use with syscalls.

fn deriveRilPath(sourcePath: *[u8], buf: *mut [u8]) -> ?*[u8] {

    let len = sourcePath.len;

    if len < SOURCE_EXT.len {

        return nil;

    }

    let extStart = len - SOURCE_EXT.len;

    // Check for .rad extension.

    if not mem::eq(&sourcePath[extStart..len], SOURCE_EXT) {

        return nil;

    }

    if len + 1 > buf.len {

        return nil;

    }

    // Copy full path then overwrite extension and add null terminator.

    try mem::copy(buf, sourcePath) catch {

        return nil;

    };

    try mem::copy(&mut buf[extStart..len], SNAPSHOT_EXT) catch {

        return nil;

    };

    set buf[len] = 0;

    return &buf[..len];

}

/// Write a self-contained RV64 image containing text and data sections.

fn writeImage(code: *[u32], roData: *[u8], rwData: *[u8], path: *[u8]) -> bool {

    let mut header = rv64::imageHeader(code.len * rv64::INSTR_SIZE as u32, roData.len, rwData.len);

    let headerWords = &header[..];

    let headerBytes = @sliceOf(headerWords.ptr as *u8, headerWords.len * rv64::WORD_SIZE as u32);

    let codeBytes = @sliceOf(code.ptr as *u8, code.len * rv64::INSTR_SIZE as u32);

    return unix::writeFileParts(path, &[headerBytes, codeBytes, roData, rwData]);

}

fn assembleBinary(sourcePath: *[u8], outputPath: *[u8]) -> bool {

    let source = unix::readFile(sourcePath, &mut SOURCE_BUF[..]) else {

        io::printError("error: could not read source: ");

        io::printError(sourcePath);

        io::printError("\n");

        return false;

    };

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

    let program = try asm::assemble(

        asm::scanner::SourceKind::File { path: sourcePath },

        source,

        &mut ASM_TEXT_STORAGE[..],

        &mut ASM_DATA_STORAGE[..],

        &mut arena,

        &mut STRING_POOL,

        rv64::RO_DATA_BASE

    ) catch {

        io::printError("error: assembly failed: ");

        io::printError(sourcePath);

        io::printError("\n");

        return false;

    };

    if not writeImage(program.text, program.data, &[], outputPath) {

        io::printError("error: could not write output: ");

        io::printError(outputPath);

        io::printError("\n");

        return false;

    }

    return true;

}

/// Run a single IL snapshot test case. Returns `true` on success.

fn runTest(sourcePath: *[u8]) -> bool {

    // Path buffer.

    let mut rilPathBuf: [u8; MAX_PATH_LEN] = undefined;

    let mut pkgScope: resolver::Scope = undefined;

    // Derive .ril path from source path.

    let rilPath = deriveRilPath(sourcePath, &mut rilPathBuf[..]) else {

        io::print("error: invalid source path (must end in .rad): ");

        io::printLn(sourcePath);

        return false;

    };

    // Read expected IL.

    let expected = unix::readFile(rilPath, &mut EXPECTED_BUF[..]) else {

        io::print("error: could not read expected IL: ");

        io::printLn(rilPath);

        return false;

    };

    // Read source file.

    let source = unix::readFile(sourcePath, &mut SOURCE_BUF[..]) else {

        io::print("error: could not read source: ");

        io::printLn(sourcePath);

        return false;

    };

    // Parse source.

    let mut astArena = ast::nodeArena(&mut AST_ARENA_STORAGE[..]);

    let root = try parser::parse(scanner::SourceLoc::String, source, &mut astArena, &mut STRING_POOL) catch {

        io::printLn("error: parsing failed");

        return false;

    };

    // Run resolver.

    let storage = resolver::ResolverStorage {

        arena: alloc::new(&mut RESOLVER_ARENA_STORAGE[..]),

        nodeData: &mut NODE_DATA_STORAGE[..],

        pkgScope: &mut pkgScope,

        errors: &mut ERROR_STORAGE[..],

    };

    let config = resolver::Config { buildTest: false };

    let mut res = resolver::resolver(storage, config);

    let diag = try resolver::resolveModuleRoot(&mut res, root) catch {

        io::printLn("error: resolver failed");

        return false;

    };

    if not resolver::success(&diag) {

        io::printLn("error: resolver failed");

        return false;

    }

    // Lower to IL.

    let mut ilArena = alloc::new(&mut IL_ARENA_STORAGE[..]);

    let program = try lower::lower(&res, root, "test", &mut ilArena) catch err {

        io::print("error: lowering failed: ");

        lower::printError(err);

        io::printLn("");

        return false;

    };

    // Print IL to buffer.

    let actual = printer::printProgramToBuffer(&program, &mut OUTPUT_BUF[..]);

    // Compare ignoring comments.

    if not stringsEqual(actual, expected) {

        io::printLn("FAILED");

        printDiff(expected, actual);

        return false;

    }

    io::printLn("ok");

    return true;

}

/// Run a single test specified as an argument.

@default fn main(env: *sys::Env) -> i32 {

    let args = env.args;

    if args.len == 4 and mem::eq(args[1], "assemble") {

        if assembleBinary(args[2], args[3]) {

            return 0;

        } else {

            return 1;

        }

    }

    if args.len <> 2 {

        io::printError("error: expected test file path as argument");

        return 1;

    }

    let sourcePath = args[1];

    io::print("test ");

    io::print(sourcePath);

    io::print(" ... ");

    if runTest(sourcePath) {

        return 0;

    } else {

        return 1;

    }

}