import pytest

from base import BaseTest
from common.global_symbols import NotInit
from conftest import NewOntology
from core.concept import ConceptDefaultProps
from core.python_fragment import PythonFragment
from helpers import define_new_concept, get_metadata
from services.SheerkaConceptEvaluator import ConceptEvaluator
from services.SheerkaPython import EvaluationRef


class TestConceptManager(BaseTest):

    @pytest.fixture()
    def service(self, sheerka) -> ConceptEvaluator:
        return sheerka.services[ConceptEvaluator.NAME]

    def test_i_can_build_concept(self, context, service):
        metadata = get_metadata(
            name="foo",
            where="isinstance(x, Concept)",
            pre="in_context(IS_QUESTION)",
            body="one + a",
            post="'post parameter'",
            ret="self",
            variables=(("a", "1"), ("b", "NotInit"))
        )

        compiled = service.build(context, metadata)
        pf = getattr(compiled, ConceptDefaultProps.WHERE)
        assert isinstance(pf, PythonFragment)
        assert pf.source_code == metadata.where

        pf = getattr(compiled, ConceptDefaultProps.PRE)
        assert isinstance(pf, PythonFragment)
        assert pf.source_code == metadata.pre

        pf = getattr(compiled, ConceptDefaultProps.BODY)
        assert isinstance(pf, PythonFragment)
        assert pf.source_code == metadata.body

        pf = getattr(compiled, ConceptDefaultProps.POST)
        assert isinstance(pf, PythonFragment)
        assert pf.source_code == metadata.post

        pf = getattr(compiled, ConceptDefaultProps.RET)
        assert isinstance(pf, PythonFragment)
        assert pf.source_code == metadata.ret

        pf = getattr(compiled, "a")
        assert isinstance(pf, PythonFragment)
        assert pf.source_code == metadata.variables[0][1]

        pf = getattr(compiled, "b")
        assert isinstance(pf, PythonFragment)
        assert pf.source_code == metadata.variables[1][1]

    def test_i_can_manage_when_no_source_code(self, context, service):
        metadata = get_metadata(name="foo")

        compiled = service.build(context, metadata)
        assert getattr(compiled, ConceptDefaultProps.WHERE) is None
        assert getattr(compiled, ConceptDefaultProps.PRE) is None
        assert getattr(compiled, ConceptDefaultProps.BODY) is None
        assert getattr(compiled, ConceptDefaultProps.POST) is None
        assert getattr(compiled, ConceptDefaultProps.RET) is None

    def test_i_can_detect_when_requested_names_are_concept_variables(self, context, service):
        metadata = get_metadata(
            name="foo",
            body="one + a",
            variables=(("a", "1"), ("b", "NotInit")))

        compiled = service.build(context, metadata)
        pf = getattr(compiled, ConceptDefaultProps.BODY)
        assert isinstance(pf, PythonFragment)
        assert pf.namespace == {"a": EvaluationRef("self", "a"),
                                "b": EvaluationRef("self", "b")}

    def test_i_can_eval_concept_attributes(self, context, service):
        with NewOntology(context, "test_i_can_eval_concept_attributes"):
            foo_metadata = get_metadata(name="foo",
                                        where="isinstance(a, int)",
                                        pre="True",
                                        body="2 + a",
                                        post="'post parameter'",
                                        ret="self",
                                        variables=(("a", "1"), ("b", "NotInit")))
            foo = define_new_concept(context, foo_metadata)

            res = service.evaluate_concept(context, foo)

            assert context.sheerka.isinstance(res, foo)
            assert res.get_value("a") == 1
            assert res.get_value("b") == NotInit
            assert res.get_value(ConceptDefaultProps.WHERE) is True
            assert res.get_value(ConceptDefaultProps.PRE) is True
            assert res.get_value(ConceptDefaultProps.BODY) == 3
            assert res.get_value(ConceptDefaultProps.POST) == "post parameter"
            assert res.get_value(ConceptDefaultProps.RET) == res