//! Standalone lowering pass test runner.

//!

//! Runs a single test that compares generated IL against expected output.

//! The test path should be a .rad source file; the expected .ril file is

//! derived by replacing the extension.

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;

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

use std::lang::parser;

use std::lang::scanner;

use std::lang::module;

use std::lang::resolver;

use std::lang::strings;

use std::lang::lower;

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

const SOURCE_BUF_SIZE: u32 = 4096;

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

const EXPECTED_BUF_SIZE: u32 = 4096;

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

const OUTPUT_BUF_SIZE: u32 = 4096;

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

const ARENA_SIZE: u32 = 65536;

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

/// 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(testName: *[u8], 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 expected .ril path from a .rad source path. Replaces the .rad

/// extension with .ril. The output is null-terminated for use with syscalls.

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

    let len = sourcePath.len;

    if len < 4 {

        return nil;

    }

    // Check for .rad extension.

    let extStart = len - 4; // TODO: language support for additions in ranges.

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

        return nil;

    }

    if len + 1 > buf.len {

        return nil;

    }

    // Copy full path then overwrite extension with 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 lowering test case. Returns `true` on success.

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

    // Buffers for file I/O.

    let mut sourceBuf: [u8; SOURCE_BUF_SIZE] = undefined;

    let mut expectedBuf: [u8; EXPECTED_BUF_SIZE] = undefined;

    let mut outputBuf: [u8; OUTPUT_BUF_SIZE] = undefined;

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

    // Parser and resolver storage.

    let mut astArenaStorage: [u8; ARENA_SIZE] = undefined;

    let mut ilArenaStorage: [u8; ARENA_SIZE] = undefined;

    let mut printArenaStorage: [u8; ARENA_SIZE] = undefined;

    let mut resolverArenaStorage: [u8; ARENA_SIZE] = undefined;

    let mut moduleArenaStorage: [u8; 1024] = undefined;

    let mut nodeDataStorage: [resolver::NodeData; 256] = undefined;

    let mut errorStorage: [resolver::Error; 4] = undefined;

    let mut pkgScope: resolver::Scope = undefined;

    let mut moduleEntries: [module::ModuleEntry; 4] = undefined;

    // Derive expected path from source path.

    let expectedPath = deriveExpectedPath(sourcePath, &mut expectedPathBuf[..]) else {

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

        io::printLn(sourcePath);

        return false;

    };

    // Read source file.

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

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

        io::printLn(sourcePath);

        return false;

    };

    // Read expected IL.

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

        io::print("error: Could not read expected: ");

        io::printLn(expectedPath);

        return false;

    };

    // Parse source.

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

    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 mut moduleArena = ast::nodeArena(&mut moduleArenaStorage[..]);

    let mut moduleGraph = module::moduleGraph(&mut moduleEntries[..], &mut STRING_POOL, &mut moduleArena);

    let storage = resolver::ResolverStorage {

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

        nodeData: &mut nodeDataStorage[..],

        pkgScope: &mut pkgScope,

        errors: &mut errorStorage[..],

    };

    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 ilArenaStorage[..]);

    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 printArenaStorage[..]);

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

    // Compare ignoring comments.

    if not stringsEqual(actual, expected) {

        io::printLn("FAILED");

        printDiff(sourcePath, 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 name and file path");

        return 1;

    }

    let sourcePath = args[1];

    io::print("test ");

    io::print(sourcePath);

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

    if runTest(sourcePath) {

        return 0;

    } else {

        return 1;

    }

}