//! 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 owner = super::Permission {};

    let permission: 'permission = &mut owner in {

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

        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(super::entryCount(&graph) == 3);

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

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

        try testing::expect(super::childAt(&graph, 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 owner = super::Permission {};

    let permission: 'permission = &mut owner in {

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

        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(super::entryCount(&graph) == 2);

        try testing::expect(super::childCount(&graph, 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 owner = super::Permission {};

    let permission: 'permission = &mut owner in {

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

        // 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(super::entryCount(&graph) == 3);

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

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

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

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

        try testing::expect(super::childCount(&graph, 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 owner = super::Permission {};

    let permission: 'permission = &mut owner in {

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

        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 owner = super::Permission {};

    let permission: 'permission = &mut owner in {

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

        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 owner = super::Permission {};

    let permission: 'permission = &mut owner in {

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

        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 owner = super::Permission {};

    let permission: 'permission = &mut owner in {

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

        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 'permission (

    graph: super::ModuleGraph 'permission

) -> super::ModuleGraph 'permission {

    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 owner = super::Permission {};

    let permission: 'permission = &mut owner in {

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

        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(&graph, root) == 1);

        try testing::expect(super::childAt(&graph, 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(super::entryCount(&graph) == 2);

        try testing::expect(super::childCount(&graph, 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(&graph, alias) else panic;

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

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

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

        try testing::expect(

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

        );

    }

}