package org.shedlang.compiler.parser;

import org.junit.jupiter.api.Test;
import org.shedlang.compiler.types.Visibility;

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

public class ParserEffectDefinitionTests {
    @Test
    public void canParseEffectName() {
        var source = """
            effect State {
            }""";

        var node = parseString(source, Parser::parseNamespaceStatement);

        assertThat(
            node,
            isUntypedEffectDefinitionNode()
                .withName("State")
        );
    }

    @Test
    public void defaultVisibilityIsPrivate() {
        var source = """
            effect State {
            }""";

        var node = parseString(source, Parser::parseNamespaceStatement);

        assertThat(
            node,
            isUntypedEffectDefinitionNode().withVisibility(Visibility.PRIVATE)
        );
    }

    @Test
    public void whenEffectIsPrefixedWithPubThenVisibilityIsPublic() {
        var source = """
            pub effect State {
            }""";

        var node = parseString(source, Parser::parseNamespaceStatement);

        assertThat(
            node,
            isUntypedEffectDefinitionNode().withVisibility(Visibility.PUBLIC)
        );
    }

    @Test
    public void canParseEffectWithNoFields() {
        var source = """
            effect State {
            }""";

        var node = parseString(source, Parser::parseNamespaceStatement);

        assertThat(
            node,
            isUntypedEffectDefinitionNode()
                .withFields(isSequence())
        );
    }

    @Test
    public void canParseEffectFields() {
        var source = """
            effect State {
                fun getValue() -> Int;
                fun setValue(Int) -> Unit;
            }""";

        var node = parseString(source, Parser::parseNamespaceStatement);

        assertThat(
            node,
            isUntypedEffectDefinitionNode()
                .withFields(isSequence(
                    isUntypedEffectDefinitionFieldNode(
                        "getValue",
                        isUntypedFunctionTypeNode()
                            .withParams(isUntypedFunctionTypeParamsNode(isSequence(), isSequence()))
                            .withReturnType(isUntypedTypeLevelReferenceNode("Int"))
                    ),
                    isUntypedEffectDefinitionFieldNode(
                        "setValue",
                        isUntypedFunctionTypeNode()
                            .withParams(isUntypedFunctionTypeParamsNode(
                                isSequence(isUntypedTypeLevelReferenceNode("Int")),
                                isSequence()
                            ))
                            .withReturnType(isUntypedTypeLevelReferenceNode("Unit"))
                    )
                ))
        );
    }
}