//! Tests for the module loader.

use std::mem;

use std::testing;

use std::lang::ast;

use std::lang::alloc;

use std::lang::parser;

use std::lang::scanner;

use std::lang::strings;

use std::lang::lower;

/// Empty module for checked lowering cursor construction.

constant EMPTY_LOWER_MODULE: ast::Node = ast::Node {

    id: 0, span: ast::Span { offset: 0, length: 0 },

    value: ast::NodeValue::Block(ast::Block { statements: &[], isUnsafe: false }),

};

/// Module cursors begin without an active instance declaration.

@test fn testSafeLoweringCursor() throws (testing::TestError) {

    let cursor = try lower::moduleCursor(&EMPTY_LOWER_MODULE, true) catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(cursor.declarations.len == 0);

    try testing::expect(cursor.next == 0);

    try testing::expect(cursor.isRoot);

    try testing::expect(cursor.instanceState == nil);

}

/// Test arena backing storage.

static TEST_ARENA: [u8; 16384] = [0; 16384];

/// Interned string pool.

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

fn expectSliceEq(actual: *[u8], expected: *[u8])

    throws (testing::TestError)

{

    if not mem::eq(actual, expected) {

        throw testing::TestError::Failed;

    }

}

fn expectPathSegments(entry: *super::ModuleEntry, expected: *[*[u8]])

    throws (testing::TestError)

{

    let actual = super::moduleQualifiedPath(entry);

    try testing::expect(actual.len == expected.len);

    for i in 0..expected.len {

        try expectSliceEq(actual[i], expected[i]);

    }

}

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

    static storage: [?*super::ModuleEntry; 4] = [nil; 4];

    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);

    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "src/root.rad") catch {

        throw testing::TestError::Failed;

    };

    let root = super::get(&graph, rootId) else {

        throw testing::TestError::Failed;

    };

    try expectPathSegments(root, &["root"]);

    // First child.

    let firstId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "src/root/first.rad") catch {

        throw testing::TestError::Failed;

    };

    let first = super::get(&graph, firstId) else {

        throw testing::TestError::Failed;

    };

    try expectSliceEq(first.filePath, "src/root/first.rad");

    try expectSliceEq(first.name, "first");

    try expectPathSegments(first, &["root", "first"]);

    // Second child.

    let secondId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "src/root/second.rad") catch {

        throw testing::TestError::Failed;

    };

    let second = super::get(&graph, secondId) else {

        throw testing::TestError::Failed;

    };

    try expectSliceEq(second.filePath, "src/root/second.rad");

    try expectSliceEq(second.name, "second");

    try expectPathSegments(second, &["root", "second"]);

    let parent = super::get(&graph, rootId) else {

        throw testing::TestError::Failed;

    };

    try testing::expect(graph.entriesLen == 3);

    try testing::expect(super::childCount(parent) == 2);

    try testing::expect(super::childAt(parent, 0) == firstId);

    try testing::expect(super::childAt(parent, 1) == secondId);

}

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

    static storage: [?*super::ModuleEntry; 4] = [nil; 4];

    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);

    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "src/main.rad") catch {

        throw testing::TestError::Failed;

    };

    let firstId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "src/main/util.rad") catch {

        throw testing::TestError::Failed;

    };

    let secondId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "src/main/util.rad") catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(firstId == secondId);

    let parent = super::get(&graph, rootId) else {

        throw testing::TestError::Failed;

    };

    try testing::expect(graph.entriesLen == 2);

    try testing::expect(super::childCount(parent) == 1);

}

@test fn testTrimExtensionWithRadExtension() throws (testing::TestError) {

    let input = "parser.rad";

    let result = super::trimExtension(input)

        else throw testing::TestError::Failed;

    try expectSliceEq(result, "parser");

}

@test fn testTrimExtensionWithoutExtension() throws (testing::TestError) {

    let input = "parser";

    let result = super::trimExtension(input);

    try testing::expect(result == nil);

}

@test fn testTrimExtensionWithWrongExtension() throws (testing::TestError) {

    let input = "parser.txt";

    let result = super::trimExtension(input);

    try testing::expect(result == nil);

}

@test fn testParsePathSingleComponent() throws (testing::TestError) {

    let path = "std.rad";

    let mut components: [*[u8]; 8] = [""; 8];

    let count = super::parsePath(path, &mut components[..]) else {

        throw testing::TestError::Failed;

    };

    try testing::expect(count == 1);

    try expectSliceEq(components[0], "std");

}

@test fn testParsePathMultipleComponents() throws (testing::TestError) {

    let path = "std/lang/parser.rad";

    let mut components: [*[u8]; 8] = [""; 8];

    let count = super::parsePath(path, &mut components[..]) else {

        throw testing::TestError::Failed;

    };

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

    try expectSliceEq(components[0], "std");

    try expectSliceEq(components[1], "lang");

    try expectSliceEq(components[2], "parser");

}

@test fn testParsePathWithoutExtension() throws (testing::TestError) {

    let path = "std/lang/parser";

    let mut components: [*[u8]; 8] = [""; 8];

    let result = super::parsePath(path, &mut components[..]);

    try testing::expect(result == nil);

}

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

    static storage: [?*super::ModuleEntry; 8] = [nil; 8];

    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);

    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    // Register root module.

    let stdId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "lib/std.rad") catch {

        throw testing::TestError::Failed;

    };

    let std = super::get(&graph, stdId) else {

        throw testing::TestError::Failed;

    };

    try expectSliceEq(std.filePath, "lib/std.rad");

    try expectSliceEq(super::moduleDir(std), "lib/");

    try expectPathSegments(std, &["std"]);

    // Register child of root.

    let langId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, stdId, "lib/std/lang.rad") catch {

        throw testing::TestError::Failed;

    };

    let lang = super::get(&graph, langId) else {

        throw testing::TestError::Failed;

    };

    try expectSliceEq(lang.filePath, "lib/std/lang.rad");

    try expectSliceEq(lang.name, "lang");

    try expectSliceEq(super::moduleDir(lang), "lib/std/");

    try expectPathSegments(lang, &["std", "lang"]);

    // Register grandchild.

    let parserId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, stdId, "lib/std/lang/parser.rad") catch {

        throw testing::TestError::Failed;

    };

    let parser = super::get(&graph, parserId) else {

        throw testing::TestError::Failed;

    };

    try expectSliceEq(parser.filePath, "lib/std/lang/parser.rad");

    try expectSliceEq(parser.name, "parser");

    try expectSliceEq(super::moduleDir(parser), "lib/std/lang/");

    try expectPathSegments(parser, &["std", "lang", "parser"]);

    // Verify parent-child relationships.

    try testing::expect(graph.entriesLen == 3);

    try testing::expect(super::childCount(std) == 1);

    try testing::expect(super::childAt(std, 0) == langId);

    try testing::expect(super::childCount(lang) == 1);

    try testing::expect(super::childAt(lang, 0) == parserId);

    try testing::expect(super::childCount(parser) == 0);

}

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

    static storage: [?*super::ModuleEntry; 8] = [nil; 8];

    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);

    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "std.rad") catch {

        throw testing::TestError::Failed;

    };

    let _ = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "std/lang/parser.rad") catch {

        // Expected to fail due to missing intermediate parent.

        return;

    };

    throw testing::TestError::Failed;

}

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

    static storage: [?*super::ModuleEntry; 8] = [nil; 8];

    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);

    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "std.rad") catch {

        throw testing::TestError::Failed;

    };

    let _ = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "parser.rad") catch {

        // Expected to fail due to missing intermediate parent.

        return;

    };

    throw testing::TestError::Failed;

}

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

    static storage: [?*super::ModuleEntry; 8] = [nil; 8];

    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);

    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "lib/std.rad") catch {

        throw testing::TestError::Failed;

    };

    // Verify root module was registered with correct ID.

    try testing::expect(rootId == 0);

    let root = super::get(&graph, rootId) else {

        throw testing::TestError::Failed;

    };

    try expectSliceEq(root.name, "std");

    try expectSliceEq(root.filePath, "lib/std.rad");

    try expectPathSegments(root, &["std"]);

}

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

    static storage: [?*super::ModuleEntry; 8] = [nil; 8];

    let mut arena = ast::nodeArena(&mut TEST_ARENA[..]);

    let mut graph = super::moduleGraph(&mut storage[..], &mut arena);

    let rootId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, nil, "src/pkg/root.rad") catch {

        throw testing::TestError::Failed;

    };

    // Verify root module was registered with correct ID.

    try testing::expect(rootId == 0);

    let langId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "src/pkg/root/lang.rad") catch {

        throw testing::TestError::Failed;

    };

    let lang = super::get(&graph, langId) else {

        throw testing::TestError::Failed;

    };

    try expectSliceEq(lang.name, "lang");

    try expectPathSegments(lang, &["root", "lang"]);

    let parserId = try super::registerFromPath(&mut graph, &mut STRING_POOL, 0, rootId, "src/pkg/root/lang/parser.rad") catch {

        throw testing::TestError::Failed;

    };

    let parser = super::get(&graph, parserId) else {

        throw testing::TestError::Failed;

    };

    try expectSliceEq(parser.name, "parser");

    try expectPathSegments(parser, &["root", "lang", "parser"]);

}

/// Move the graph owner while its published entries retain their identities.

fn relocate(graph: super::ModuleGraph) -> super::ModuleGraph {

    return graph;

}

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

    static DATA: [u8; 16384] = [0; 16384];

    static ENTRIES: [?*super::ModuleEntry; 2] = [nil; 2];

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

    let mut arena = ast::nodeArena(&mut DATA[..]);

    let mut original = super::moduleGraph(&mut ENTRIES[..], &mut arena);

    let rootId = try! super::registerRoot(&mut original, &mut POOL, 0, "root.rad");

    let root = super::get(&original, rootId) else panic;

    let alias = root;

    let mut graph = relocate(original);

    let child = try! super::registerChild(&mut graph, &mut POOL, rootId, "child", "root/child.rad");

    try testing::expect(super::childCount(root) == 1);

    try testing::expect(super::childAt(alias, 0) == child);

    let published = super::get(&graph, rootId) else panic;

    try testing::expect(published as u64 == root as u64);

    let saved = alloc::used(&arena.arena);

    let reused = try! super::registerChild(&mut graph, &mut POOL, rootId, "child", "root/child.rad");

    try testing::expect(reused == child);

    try testing::expect(alloc::used(&arena.arena) == saved);

    let mut failed = false;

    try super::registerChild(&mut graph, &mut POOL, rootId, "full", "root/full.rad") catch {

        set failed = true;

    };

    try testing::expect(failed);

    try testing::expect(graph.entriesLen == 2);

    try testing::expect(super::childCount(alias) == 1);

    try testing::expect(alloc::used(&arena.arena) == saved);

    let source = "fn answer() -> u32 { return 42; }";

    let parsed: *ast::Node = try! parser::parse(scanner::SourceLoc::String, source, &mut arena, &mut POOL);

    try! super::setAst(&mut graph, rootId, parsed);

    try! super::setSource(&mut graph, rootId, source);

    let retainedAst = super::astFor(alias) else panic;

    try testing::expect(retainedAst as u64 == parsed as u64);

    let retainedSource = super::sourceFor(root) else panic;

    try testing::expect(mem::eq(retainedSource, source));

    try testing::expect(try! super::state(&graph, rootId) == super::ModuleState::Parsed);

}