from core.builtin_concepts_ids import BuiltinConcepts
from core.concept import get_concept_attrs, Concept, ALL_ATTRIBUTES
from core.sheerka.services.SheerkaConceptManager import SheerkaConceptManager
from parsers.BnfNodeParser import OrderedChoice, StrMatch, Sequence, ConceptExpression, Optional
from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka


class TestSheerkaNonRegFile(TestUsingFileBasedSheerka):
    def test_i_can_def_several_concepts(self):
        sheerka = self.get_sheerka()
        sheerka.evaluate_user_input("def concept foo")

        sheerka = self.get_sheerka()
        res = sheerka.evaluate_user_input("def concept bar")

        assert len(res) == 1
        assert res[0].status
        assert res[0].body.body.id == "1002"

    def test_i_can_create_concept_with_bnf_definition(self):
        sheerka = self.get_sheerka()
        concept_a = self.bnf_concept("a", expression=OrderedChoice(StrMatch("one"), StrMatch("two")))
        sheerka.create_new_concept(self.get_context(sheerka), concept_a)

        res = sheerka.evaluate_user_input("def concept plus from bnf a ('plus' plus)?")
        assert len(res) == 1
        assert res[0].status
        assert sheerka.isinstance(res[0].value, BuiltinConcepts.NEW_CONCEPT)

        saved_concept = sheerka.om.current_sdp().get(SheerkaConceptManager.CONCEPTS_BY_KEY_ENTRY, "plus")
        assert saved_concept.key == "plus"
        assert saved_concept.get_metadata().definition == "a ('plus' plus)?"
        assert "a" in saved_concept.values()
        assert "plus" in saved_concept.values()

        expected_bnf = Sequence(
            ConceptExpression(concept_a, rule_name="a"),
            Optional(Sequence(StrMatch("plus"), ConceptExpression("plus"))))

        new_concept = res[0].value.body
        assert new_concept.get_metadata().name == "plus"
        assert new_concept.get_metadata().definition == "a ('plus' plus)?"
        assert new_concept.get_bnf() == expected_bnf
        assert "a" in new_concept.values()
        assert "plus" in new_concept.values()

    def test_i_can_recognize_bnf_definitions_from_separate_instances(self):
        sheerka = self.get_sheerka()
        concept_a = sheerka.evaluate_user_input("def concept a from bnf 'one' 'two'")[0].body.body

        sheerka = self.get_sheerka()
        res = sheerka.evaluate_user_input("one two")
        assert len(res) == 1
        assert res[0].status
        assert sheerka.isinstance(res[0].value, concept_a)

        # add another bnf definition
        concept_b = sheerka.evaluate_user_input("def concept b from bnf a 'three'")[0].body.body

        sheerka = self.get_sheerka()
        res = sheerka.evaluate_user_input("one two")  # previous one still works
        assert len(res) == 1
        assert res[0].status
        assert sheerka.isinstance(res[0].value, concept_a)

        res = self.get_sheerka().evaluate_user_input("one two three")  # new one works
        assert len(res) == 1
        assert res[0].status
        assert sheerka.isinstance(res[0].value, concept_b)

        evaluated = sheerka.evaluate_concept(self.get_context(eval_body=True), res[0].value)
        assert evaluated.body == "one two three"
        assert evaluated.get_value("a") == sheerka.new(concept_a.key, body="one two").init_key()

    def test_i_can_eval_sophisticated_bnf_concepts_after_restart(self):
        self.init_scenario([
            "def concept one as 1",
            "def concept number",
            "set_isa(one, number)",
            "def concept twenty as 20",
            "set_isa(twenty, number)",
            "def concept twenties from bnf twenty number where number < 10 as twenty + number",
            "set_isa(twenties, number)",
            "def concept thirty as 30",
            "set_isa(thirty, number)",
            "def concept thirties from bnf thirty number where number < 10 as thirty + number",
            "set_isa(thirties, number)",
        ], global_truth=True)

        sheerka = self.new_sheerka_instance()

        assert sheerka.evaluate_user_input("eval twenty one")[0].body == 21
        assert sheerka.evaluate_user_input("eval thirty one")[0].body == 31

    def test_i_can_pop_ontology_after_restart(self):
        sheerka = self.get_sheerka()
        sheerka.evaluate_user_input("push_ontology('test')")

        sheerka = self.new_sheerka_instance()

        res = sheerka.evaluate_user_input("pop_ontology()")

        assert len(res) == 1
        assert res[0].status
        assert sheerka.isinstance(res[0].body, BuiltinConcepts.ONTOLOGY_REMOVED)

    def test_i_can_read_concept_with_dynamic_variables_at_restart(self):
        sheerka = self.init_scenario([
            "def concept foo",
            "def concept prop_name",
            "def concept prop_value",
            "eval foo",
            "set_attr(foo, prop_name, prop_value)",
        ])

        ALL_ATTRIBUTES.clear()

        res = sheerka.evaluate_user_input("in_memory()")
        res = sheerka.evaluate_user_input("memory(foo)")
        assert len(res) == 1
        assert res[0].status

        assert get_concept_attrs(Concept("foo")) == []
        assert get_concept_attrs(res[0].body) == ['c:prop_name|1002:']