package org.shedlang.compiler.parser;

import org.junit.jupiter.api.Test;
import org.shedlang.compiler.ast.untyped.UntypedNamespaceNode;
import org.shedlang.compiler.types.NamespaceName;

import static org.shedlang.compiler.ast.untyped.UntypedNodeMatchers.isUntypedFunctionDefinitionNode;
import static org.shedlang.compiler.ast.untyped.UntypedNodeMatchers.isUntypedImportNode;
import static org.shedlang.compiler.parser.ParserTesting.parseString;
import static org.zwobble.precisely.AssertThat.assertThat;
import static org.zwobble.precisely.Matchers.*;

public class ParserNamespaceTests {
    @Test
    public void canParseEmptyNamespace() {
        var source = "";

        var node = parseString(
            source,
            tokens -> Parser.parseNamespace(tokens, NamespaceName.of("Example", "Project"))
        );

        assertThat(node, instanceOf(
            UntypedNamespaceNode.class,
            has("namespaceName", x -> x.namespaceName(), equalTo(NamespaceName.of("Example", "Project"))),
            has("body", x -> x.body(), isSequence())
        ));
    }

    @Test
    public void canParseNamespaceWithStatements() {
        var source = """
            fun f() -> Unit {
            }
            
            fun g() -> Unit {
            }
            """;

        var node = parseString(
            source,
            tokens -> Parser.parseNamespace(tokens, NamespaceName.of("Example", "Project"))
        );

        assertThat(node, instanceOf(
            UntypedNamespaceNode.class,
            has("body", x -> x.body(), isSequence(
                isUntypedFunctionDefinitionNode().withName("f"),
                isUntypedFunctionDefinitionNode().withName("g")
            ))
        ));
    }

    @Test
    public void canParseNamespaceWithImports() {
        var source = """
            import One;
            import Two/Three;""";

        var node = parseString(
            source,
            tokens -> Parser.parseNamespace(tokens, NamespaceName.of("Example", "Project"))
        );

        assertThat(node, instanceOf(
            UntypedNamespaceNode.class,
            has("imports", x -> x.imports(), isSequence(
                isUntypedImportNode(NamespaceName.of("One")),
                isUntypedImportNode(NamespaceName.of("Two", "Three"))
            ))
        ));
    }
}