//! Tests for the module loader.

use std::mem;

use std::testing;

use std::lang::ast;

use std::lang::strings;

/// Test arena backing storage.

static TEST_ARENA: [u8; 4096] = undefined;

/// Interned string pool.

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 fn testRegisterChildren() throws (testing::TestError) {

    let mut storage: [super::ModuleEntry; 4] = undefined;

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

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

    let rootId = try super::registerFromPath(&mut graph, 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, 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, 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(parent.childrenLen == 2);

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

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

}

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

    let mut storage: [super::ModuleEntry; 4] = undefined;

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

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

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

        throw testing::TestError::Failed;

    };

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

        throw testing::TestError::Failed;

    };

    let secondId = try super::registerFromPath(&mut graph, 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(parent.childrenLen == 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] = undefined;

    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] = undefined;

    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] = undefined;

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

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

}

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

    let mut storage: [super::ModuleEntry; 8] = undefined;

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

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

    // Register root module.

    let stdId = try super::registerFromPath(&mut graph, 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, 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, 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(std.childrenLen == 1);

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

    try testing::expect(lang.childrenLen == 1);

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

    try testing::expect(parser.childrenLen == 0);

}

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

    let mut storage: [super::ModuleEntry; 8] = undefined;

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

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

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

        throw testing::TestError::Failed;

    };

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

        // Expected to fail due to missing intermediate parent.

        return;

    };

    throw testing::TestError::Failed;

}

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

    let mut storage: [super::ModuleEntry; 8] = undefined;

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

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

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

        throw testing::TestError::Failed;

    };

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

        // Expected to fail due to missing intermediate parent.

        return;

    };

    throw testing::TestError::Failed;

}

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

    let mut storage: [super::ModuleEntry; 8] = undefined;

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

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

    let rootId = try super::registerFromPath(&mut graph, 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 fn testRegisterFromPathIgnoresLeadingDirectories() throws (testing::TestError) {

    let mut storage: [super::ModuleEntry; 8] = undefined;

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

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

    let rootId = try super::registerFromPath(&mut graph, 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, 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, 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"]);

}