from dataclasses import dataclass

from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept
from core.concept import Concept
from parsers.ExpressionParser import PropertyEqualsNode, PropertyEqualsSequenceNode, PropertyContainsNode, AndNode, \
    OrNode, NotNode, LambdaNode, IsaNode

from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


@dataclass
class Obj:
    prop_a: object
    prop_b: object = None
    prop_c: object = None
    parent: object = None


class TestExpressionParser(TestUsingMemoryBasedSheerka):

    def test_i_can_test_property_equals(self):
        node = PropertyEqualsNode("prop_a", "good value")

        assert node.eval(Obj(prop_a="good value"))
        assert not node.eval(Obj(prop_a="other value"))

    def test_i_can_test_property_equals_for_int(self):
        node = PropertyEqualsNode("prop_a", "1")

        assert node.eval(Obj(prop_a=1))
        assert node.eval(Obj(prop_a="1"))

    def test_i_can_test_property_equals_sequence(self):
        node = PropertyEqualsSequenceNode(["prop_b", "prop_a"], ["good parent", "good child"])

        assert node.eval(Obj(prop_a="good child", parent=Obj(prop_a="Don't care", prop_b="good parent")))
        assert not node.eval(Obj(prop_a="good child", parent=Obj(prop_a="Don't care", prop_b="wrong parent")))
        assert not node.eval(Obj(prop_a="good child"))
        assert not node.eval(Obj(prop_a="wrong child", parent=Obj(prop_a="Don't care", prop_b="good parent")))

    def test_i_can_test_property_contains(self):
        node = PropertyContainsNode("prop_a", "substring")

        assert node.eval(Obj(prop_a="it contains substring in it"))
        assert not node.eval(Obj(prop_a="it does not"))

    def test_i_can_test_property_contains_for_int(self):
        node = PropertyContainsNode("prop_a", "44")

        assert node.eval(Obj(prop_a=123445))
        assert not node.eval(Obj(prop_a=12435))

    def test_i_can_test_and(self):
        left = PropertyEqualsNode("prop_a", "good a")
        right = PropertyEqualsNode("prop_b", "good b")
        other = PropertyEqualsNode("prop_c", "good c")
        and_node = AndNode(left, right, other)

        assert and_node.eval(Obj("good a", "good b", "good c"))
        assert not and_node.eval(Obj("wrong a", "good b", "good c"))
        assert not and_node.eval(Obj("good a", "wrong b", "good c"))
        assert not and_node.eval(Obj("good a", "good b", "wrong c"))

    def test_i_can_test_or(self):
        left = PropertyEqualsNode("prop_a", "good a")
        right = PropertyEqualsNode("prop_b", "good b")
        other = PropertyEqualsNode("prop_c", "good c")
        or_node = OrNode(left, right, other)

        assert or_node.eval(Obj("wrong a", "good b", "good c"))
        assert or_node.eval(Obj("good a", "wrong b", "good c"))
        assert or_node.eval(Obj("good a", "good b", "wrong c"))
        assert not or_node.eval(Obj("wrong a", "wrong b", "wrong c"))

    def test_i_can_test_not(self):
        node = PropertyEqualsNode("prop_a", "good value")
        not_node = NotNode(node)

        assert not not_node.eval(Obj(prop_a="good value"))
        assert not_node.eval(Obj(prop_a="wrong value"))

    def test_i_can_test_lambda_node(self):
        node = LambdaNode(lambda o: o.prop_a + o.prop_b == "ab")

        assert node.eval(Obj(prop_a="a", prop_b="b"))
        assert not node.eval(Obj(prop_a="wrong value", prop_b="wrong value"))
        assert not node.eval(Obj(prop_a="wrong value"))  # exception is caught

    def test_i_can_test_isa_node(self):
        class_node = IsaNode(Obj)
        assert class_node.eval(Obj(prop_a="value"))
        assert not class_node.eval(TestExpressionParser())

        concept_node = IsaNode(BuiltinConcepts.RETURN_VALUE)
        assert concept_node.eval(ReturnValueConcept())
        assert concept_node.eval(Concept(name="foo", key=BuiltinConcepts.RETURN_VALUE))
        assert not concept_node.eval(Obj)
        assert not concept_node.eval(Concept())

        concept_node2 = IsaNode("foo")
        assert concept_node2.eval(Concept("foo").init_key())
        assert not concept_node2.eval(Obj)
        assert not concept_node2.eval(Concept())