//! IL snapshot test runner.

//!

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

//! against the corresponding `.ril` snapshot file. Called by `test/run`

//! for every test that has a `.ril` file.

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;

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

const SOURCE_BUF_SIZE: u32 = 8192;

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

const EXPECTED_BUF_SIZE: u32 = 32768;

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

const OUTPUT_BUF_SIZE: u32 = 32768;

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

const ARENA_SIZE: u32 = 524288;

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

const MAX_PATH_LEN: u32 = 256;

/// String pool.

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

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

const MAX_NODE_DATA: u32 = 4096;

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

const MAX_ERRORS: u32 = 16;

// 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 PRINT_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;

/// Strip comment from a line. Returns sub-slice up to ';', trimmed of trailing whitespace.

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

    let mut end: u32 = 0;

    let mut i: u32 = 0;

    while i < line.len and line[i] != ';' {

        if line[i] != ' ' and line[i] != '\t' {

            end = i + 1;

        }

        i += 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' {

        i += 1;

    }

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

    if i < s.len {

        *offset = i + 1;

    } else {

        *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 {

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

        }

        let mut bLine = "";

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

            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 < 4 {

        return nil;

    }

    // Check for .rad extension.

    if not mem::eq(&sourcePath[len - 4..len], ".rad") {

        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;

    };

    // TODO: Rewrite this once we fix the compiler bug and add support for

    // additions in ranges.

    buf[len - 3] = 'r';

    buf[len - 2] = 'i';

    buf[len - 1] = 'l';

    buf[len] = 0;

    return &buf[..len];

}

/// 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 mut printArena = alloc::new(&mut PRINT_ARENA_STORAGE[..]);

    let actual = printer::printProgramToBuffer(&program, &mut printArena, &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 != 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;

    }

}