package org.shedlang.compiler.shid.instructions;

import org.shedlang.compiler.types.NamespaceName;
import org.shedlang.compiler.types.SimpleConcreteType;
import org.shedlang.compiler.types.SimpleStructType;
import org.shedlang.compiler.types.UserDefinedEffect;
import org.zwobble.precisely.Matcher;

import java.math.BigInteger;
import java.util.List;

import static org.zwobble.precisely.Matchers.*;

public class ShidMatchers {
    private ShidMatchers() {
    }

    public static Matcher<ShidInstruction> isShidBlock(
        Matcher<Iterable<? extends ShidInstruction>> instructions
    ) {
        return instanceOf(
            ShidBlock.class,
            has("instructions", x -> x.instructions(), instructions)
        );
    }

    public static Matcher<ShidInstruction> isShidCall(
        int positionalArgCount,
        List<String> namedArgNames
    ) {
        return instanceOf(
            ShidCall.class,
            has("positionalArgCount", x -> x.positionalArgCount(), equalTo(positionalArgCount)),
            has("namedArgNames", x -> x.namedArgNames(), equalTo(namedArgNames))
        );
    }

    public static Matcher<ShidParam> isShidDefineFunctionParam(String name) {
        return has("name", x -> x.name(), equalTo(name));
    }

    public static Matcher<ShidInstruction> isShidDiscard() {
        return instanceOf(
            ShidDiscard.class
        );
    }

    public static Matcher<ShidInstruction> isShidDuplicate() {
        return instanceOf(ShidDuplicate.class);
    }

    public static Matcher<ShidInstruction> isShidEffectHandlerBreak(UserDefinedEffect effect) {
        return instanceOf(
            ShidEffectHandlerBreak.class,
            has("effect", x -> x.effect(), equalTo(effect))
        );
    }

    public static Matcher<ShidInstruction> isShidFieldLoad(
        ShidFieldLoad.Receiver receiver,
        String fieldName
    ) {
        return instanceOf(
            ShidFieldLoad.class,
            has("receiver", x -> x.receiver(), equalTo(receiver)),
            has("fieldName", x -> x.fieldName(), equalTo(fieldName))
        );
    }

    public static Matcher<ShidInstruction> isShidFieldLoad(
        SimpleStructType receiverType,
        String fieldName
    ) {
        return isShidFieldLoad(
            new ShidFieldLoad.Receiver.Struct(receiverType),
            fieldName
        );
    }

    public static Matcher<ShidInstruction> isShidIf(
        Matcher<? super ShidBlock> trueBody,
        Matcher<? super ShidBlock> falseBody
    ) {
        return instanceOf(
            ShidIf.class,
            has("trueBody", x -> x.trueBody(), trueBody),
            has("falseBody", x -> x.falseBody(), falseBody)
        );
    }

    public static Matcher<ShidInstruction> isShidIntAdd() {
        return instanceOf(ShidIntAdd.class);
    }

    public static Matcher<ShidInstruction> isShidIntEquals() {
        return instanceOf(ShidIntEquals.class);
    }

    public static Matcher<ShidInstruction> isShidIntGreaterThan() {
        return instanceOf(ShidIntGreaterThan.class);
    }

    public static Matcher<ShidInstruction> isShidIntGreaterThanOrEqual() {
        return instanceOf(ShidIntGreaterThanOrEqual.class);
    }

    public static Matcher<ShidInstruction> isShidIntLessThan() {
        return instanceOf(ShidIntLessThan.class);
    }

    public static Matcher<ShidInstruction> isShidIntLessThanOrEqual() {
        return instanceOf(ShidIntLessThanOrEqual.class);
    }

    public static Matcher<ShidInstruction> isShidIntMultiply() {
        return instanceOf(ShidIntMultiply.class);
    }

    public static Matcher<ShidInstruction> isShidIntNotEqual() {
        return instanceOf(ShidIntNotEqual.class);
    }

    public static Matcher<ShidInstruction> isShidIntSub() {
        return instanceOf(ShidIntSub.class);
    }

    public static Matcher<ShidInstruction> isShidLocalLoad(String name) {
        return instanceOf(
            ShidLocalLoad.class,
            has("name", x -> x.name(), equalTo(name))
        );
    }

    public static Matcher<ShidInstruction> isShidLocalStore(String name) {
        return instanceOf(
            ShidLocalStore.class,
            has("name", x -> x.name(), equalTo(name))
        );
    }

    public static Matcher<ShidInstruction> isShidLoop(
        Matcher<? super ShidBlock> body
    ) {
        return instanceOf(
            ShidLoop.class,
            has("body", x -> x.body(), body)
        );
    }

    public static Matcher<ShidInstruction> isShidLoopBreak() {
        return instanceOf(ShidLoopBreak.class);
    }

    public static Matcher<ShidInstruction> isShidLoopContinue() {
        return instanceOf(ShidLoopContinue.class);
    }

    public static Matcher<ShidInstruction> isShidMethodLoad(
        SimpleConcreteType type,
        String methodName
    ) {
        return instanceOf(
            ShidMethodLoad.class,
            has("type", x -> x.type(), equalTo(type)),
            has("methodName", x -> x.methodName(), equalTo(methodName))
        );
    }

    public static Matcher<ShidInstruction> isShidMethodStore(
        SimpleConcreteType type,
        String methodName
    ) {
        return instanceOf(
            ShidMethodStore.class,
            has("type", x -> x.type(), equalTo(type)),
            has("methodName", x -> x.methodName(), equalTo(methodName))
        );
    }

    public static Matcher<ShidInstruction> isShidNamespaceFieldStore(
        NamespaceName namespaceName,
        String fieldName
    ) {
        return instanceOf(
            ShidNamespaceFieldStore.class,
            has("namespaceName", x -> x.namespaceName(), equalTo(namespaceName)),
            has("fieldName", x -> x.fieldName(), equalTo(fieldName))
        );
    }

    public static Matcher<ShidInstruction> isShidNamespaceImport(
        NamespaceName namespaceName
    ) {
        return instanceOf(
            ShidNamespaceImport.class,
            has("namespaceName", x -> x.namespaceName(), equalTo(namespaceName))
        );
    }

    public static Matcher<ShidInstruction> isShidPushBool(boolean value) {
        return instanceOf(
            ShidPushBool.class,
            has("value", x -> x.value(), equalTo(value))
        );
    }

    public static Matcher<ShidInstruction> isShidPushInt(int value) {
        return instanceOf(
            ShidPushInt.class,
            has("value", x -> x.value(), equalTo(BigInteger.valueOf(value)))
        );
    }

    public static Matcher<ShidInstruction> isShidPushString(String value) {
        return instanceOf(
            ShidPushString.class,
            has("value", x -> x.value(), equalTo(value))
        );
    }

    public static Matcher<ShidInstruction> isShidPushUnit() {
        return instanceOf(
            ShidPushUnit.class
        );
    }

    public static Matcher<ShidInstruction> isShidResume() {
        return instanceOf(
            ShidResume.class
        );
    }

    public static Matcher<ShidInstruction> isShidReturn() {
        return instanceOf(
            ShidReturn.class
        );
    }

    public static Matcher<ShidInstruction> isShidStringAdd() {
        return instanceOf(ShidStringAdd.class);
    }

    public static Matcher<ShidInstruction> isShidSwitch(
        Matcher<Iterable<? extends ShidSwitch.Case>> cases
    ) {
        return instanceOf(
            ShidSwitch.class,
            has("cases", x -> x.cases(), cases)
        );
    }

    public static Matcher<ShidSwitch.Case> isShidSwitchCase(
        SimpleStructType caseType,
        Matcher<? super ShidBlock> body
    ) {
        return allOf(
            has("caseType", x -> x.caseType(), equalTo(caseType)),
            has("body", x -> x.body(), body)
        );
    }

    public static Matcher<ShidInstruction> isShidTupleCreate(int elementCount) {
        return instanceOf(
            ShidTupleCreate.class,
            has("elementCount", x -> x.elementCount(), equalTo(elementCount))
        );
    }

    public static Matcher<ShidInstruction> isShidTupleGet(int elementIndex) {
        return instanceOf(
            ShidTupleGet.class,
            has("elementIndex", x -> x.elementIndex(), equalTo(elementIndex))
        );
    }

    public static Matcher<ShidInstruction> isShidVarLoad(String name) {
        return instanceOf(
            ShidVarLoad.class,
            has("name", x -> x.name(), equalTo(name))
        );
    }

    public static Matcher<ShidInstruction> isShidVarStore(String name) {
        return instanceOf(
            ShidVarStore.class,
            has("name", x -> x.name(), equalTo(name))
        );
    }
}