import ast

import pytest

from base import BaseTest, DummyObj
from common.global_symbols import NoFirstToken, NotFound, NotInit, Removed
from conftest import NewOntology
from core.BuiltinConcepts import BuiltinConcepts
from core.ExecutionContext import ContextActions
from core.concept import ConceptDefaultProps
from core.error import MethodAccessError
from core.python_fragment import PythonFragment
from evaluators.PythonParser import PythonParser
from helpers import _rv, define_new_concept, get_concepts, get_evaluated_concept, get_evaluated_concepts, get_metadata
from parsers.ParserInput import ParserInput
from parsers.tokenizer import Token, TokenKind
from services.SheerkaConceptManager import ConceptRef
from services.SheerkaPython import EvalMethod, EvaluationContext, Expando, MultipleResults, ObjectRef, SheerkaPython


def get_python_fragment(sheerka, context, command):
    pi = ParserInput(command)
    pi.init()
    parser_start = _rv(sheerka.newn(BuiltinConcepts.PARSER_INPUT, pi=pi))
    ret = PythonParser().eval(context, None, parser_start)
    return ret.new[0].value.pf


class TestSheerkaPython(BaseTest):
    @pytest.fixture()
    def service(self, sheerka) -> SheerkaPython:
        return sheerka.services[SheerkaPython.NAME]

    @pytest.mark.parametrize("text, expected", [
        ("1 + 1", 2),
        ("echo('I have access to Sheerka !')", "I have access to Sheerka !"),
        ("sheerka.echo('I have access to Sheerka !')", "I have access to Sheerka !"),
        ("a=10\na", 10),
        ("NotInit", NotInit),
        ("NotFound", NotFound),
        ("Removed", Removed),
        ("NoFirstToken", NoFirstToken),
    ])
    def test_i_can_evaluate_simple_expression(self, sheerka, context, service, text, expected):
        with NewOntology(context, "test_i_can_evaluate_simple_expression"):
            python_fragment = get_python_fragment(sheerka, context, text)
            ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
            assert ret == expected

    def test_i_can_eval_isinstance_with_a_type(self, sheerka, context, service):
        python_fragment = get_python_fragment(sheerka, context, "isinstance('some string', str)")
        ret = service.evaluate_python(context, EvaluationContext(), python_fragment)

        assert ret is True

    def test_i_can_eval_isinstance_with_a_concept(self, sheerka, context, service):
        with NewOntology(context, "test_i_can_eval_isinstance_for_concept"):
            get_concepts(context, "foo", use_sheerka=True)
            python_fragment = get_python_fragment(sheerka, context, "isinstance(foo, 'foo')")
            ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
            assert ret is True

            # 'foo' is also a Concept
            python_fragment = get_python_fragment(sheerka, context, "isinstance(foo, Concept)")
            ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
            assert ret is True

    def test_i_can_use_value_from_global_namespace(self, sheerka, context, service):
        python_fragment = get_python_fragment(sheerka, context, "self.a")

        ret = service.evaluate_python(context, EvaluationContext(), python_fragment,
                                      {"self": DummyObj("my dummy value")})
        assert ret == "my dummy value"

    def test_i_can_eval_using_eval_ref(self, sheerka, context, service):
        python_fragment = get_python_fragment(sheerka, context, "a")
        python_fragment.namespace = {"a": ObjectRef("self", "a")}

        ret = service.evaluate_python(context, EvaluationContext(), python_fragment,
                                      {"self": DummyObj("my dummy value")})
        assert ret == "my dummy value"

    def test_i_can_eval_concept_properties(self, sheerka, context, service):
        with NewOntology(context, "test_i_can_eval_concept_properties"):
            foo_meta = get_metadata("foo", variables=[("a", "'hello world'")])
            define_new_concept(context, foo_meta)

            python_fragment = get_python_fragment(sheerka, context, "foo.a")
            ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
            assert ret == "hello world"

    def test_i_can_eval_python_mixed_with_concept(self, sheerka, context, service):
        with NewOntology(context, "test_i_can_eval_python_mixed_with_concept"):
            foo_meta = get_metadata("foo", variables=[("a", "1")])
            bar_meta = get_metadata("bar", body="2")
            get_concepts(context, foo_meta, bar_meta, use_sheerka=True)

            python_fragment = get_python_fragment(sheerka, context, "bar + foo.a")
            ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
            assert ret == 3

    def test_i_can_eval_when_multiple_concepts(self, sheerka, context, service):
        with NewOntology(context, "test_i_can_eval_when_multiple_concepts"):
            get_concepts(context,
                         get_metadata("one", body="'one'"),
                         get_metadata("one", body="1"),
                         use_sheerka=True)
            python_fragment = get_python_fragment(sheerka, context, "one + 1")

            ret = service.evaluate_python(context, EvaluationContext(), python_fragment)

            assert ret == 2

    def test_i_can_eval_when_multiple_result_in_local_namespace(self, sheerka, context, service):
        # In the test, the PythonFragment contains a MultipleResult in its namespace
        # (normally, the MultipleResult is created inside the evaluate_python)
        # We need to make sure that multiple results are created in the same way
        with NewOntology(context, "test_i_can_eval_when_multiple_result_in_local_namespace"):
            one1, one2 = get_concepts(context,
                                      get_metadata("one", body="'one'"),
                                      get_metadata("one", body="1"),
                                      use_sheerka=True)

            concept_ref = "__concept_id__"
            ast_tree = ast.parse(concept_ref, "<user input>", 'eval')
            ref = MultipleResults(ConceptRef(one1), ConceptRef(one2))
            python_fragment = PythonFragment(concept_ref, ast_tree=ast_tree, namespace={concept_ref: ref})

            ret = service.evaluate_python(context, EvaluationContext(eval_method=EvalMethod.All), python_fragment)

            evaluated_one1, evaluated_one2 = get_evaluated_concepts(context, one1, one2, use_sheerka=True)
            assert ret == MultipleResults(evaluated_one1, "one", evaluated_one2, 1)

    def test_i_can_remember_previous_results(self, sheerka, context, service):
        python_fragment = get_python_fragment(sheerka, context, "a=10")
        ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
        assert ret is None

        python_fragment = get_python_fragment(sheerka, context, "a")
        ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
        assert ret == 10

    def test_i_can_import_module(self, sheerka, context, service):
        python_fragment = get_python_fragment(sheerka, context, "import math")
        ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
        assert ret is None

        python_fragment = get_python_fragment(sheerka, context, "math.sqrt(4)")
        ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
        assert ret == 2

    def test_i_can_import_function_from_module(self, sheerka, context, service):
        python_fragment = get_python_fragment(sheerka, context, "from math import sqrt")
        ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
        assert ret is None

        python_fragment = get_python_fragment(sheerka, context, "sqrt(4)")
        ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
        assert ret == 2

    def test_i_can_eval_when_context_is_needed(self, sheerka, context, service):
        with NewOntology(context, "test_i_can_eval_when_context_is_needed"):
            python_fragment = get_python_fragment(sheerka, context, "define_new_concept('foo')")
            ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
            assert sheerka.isinstance(ret.value, BuiltinConcepts.NEW_CONCEPT)
            # for info, there are two level of value
            # one for PythonEvaluator return value
            # one for the ConceptManager return value

    def test_i_can_return_multiple_results(self, sheerka, context, service):
        with NewOntology(context, "test_i_can_return_multiple_values"):
            foo_1, foo_2, foo_3 = get_concepts(context,
                                               get_metadata("foo", body="'foo'"),
                                               get_metadata("foo", body="True"),
                                               get_metadata("foo", body="'bar'"),
                                               use_sheerka=True)

            python_fragment = get_python_fragment(sheerka, context, "foo")

            evaluation_context = EvaluationContext(eval_method=EvalMethod.All)
            ret = service.evaluate_python(context, evaluation_context, python_fragment)

            assert ret == MultipleResults(get_evaluated_concept(foo_1, body='foo'),
                                          "foo",
                                          get_evaluated_concept(foo_2, body=True),
                                          True,
                                          get_evaluated_concept(foo_3, body='bar'),
                                          "bar")

    def test_i_can_eval_until_a_successful_result_is_found(self, sheerka, context, service):
        with NewOntology(context, "test_i_can_eval_when_multiple_concepts"):
            get_concepts(context,
                         get_metadata("one", body="'one'"),
                         get_metadata("one", body="1"),
                         get_metadata("one", body="2"),
                         use_sheerka=True)
            python_fragment = get_python_fragment(sheerka, context, "one + 1")
            service.evaluate_python(context, EvaluationContext(), python_fragment)

            # check the number of evaluated namespaces
            # there are 3 concepts, so there must be 6 results
            # But we stop after the second 'one' concept
            ec = next(filter(lambda _ec: _ec.action == ContextActions.EVALUATING_PYTHON, context.get_children()))
            assert len(ec.values["all_results"]) == 4

    def test_i_can_eval_all_namespaces(self, sheerka, context, service):
        with NewOntology(context, "test_i_can_return_multiple_values"):
            foo_1, foo_2, foo_3 = get_concepts(context,
                                               get_metadata("foo", body="'foo'"),
                                               get_metadata("foo", body="True"),
                                               get_metadata("foo", body="'bar'"),
                                               use_sheerka=True)

            python_fragment = get_python_fragment(sheerka, context, "foo")

            evaluation_context = EvaluationContext(eval_method=EvalMethod.All)
            service.evaluate_python(context, evaluation_context, python_fragment)

            # check the number of evaluated namespaces
            ec = next(filter(lambda _ec: _ec.action == ContextActions.EVALUATING_PYTHON, context.get_children()))
            assert len(ec.values["all_results"]) == 6

    def test_i_can_eval_until_true(self, sheerka, context, service):
        with NewOntology(context, "test_i_can_return_multiple_values"):
            get_concepts(context,
                         get_metadata("foo", body="False"),
                         get_metadata("foo", body="True"),
                         get_metadata("foo", body="'bar'"),
                         use_sheerka=True)

            python_fragment = get_python_fragment(sheerka, context, "foo")

            evaluation_context = EvaluationContext(eval_method=EvalMethod.UntilTrue)
            res = service.evaluate_python(context, evaluation_context, python_fragment)

            assert res is True

            # check the number of evaluated namespaces
            # We stop after the second 'one' concept, so only 4 results
            ec = next(filter(lambda _ec: _ec.action == ContextActions.EVALUATING_PYTHON, context.get_children()))
            assert len(ec.values["all_results"]) == 4

    def test_eval_until_success_return_false_if_true_is_not_found(self, sheerka, context, service):
        with NewOntology(context, "test_i_can_return_multiple_values"):
            get_concepts(context,
                         get_metadata("foo", body="False"),
                         get_metadata("foo", body="'bar'"),
                         use_sheerka=True)

            python_fragment = get_python_fragment(sheerka, context, "foo")

            evaluation_context = EvaluationContext(eval_method=EvalMethod.UntilTrue)
            ret = service.evaluate_python(context, evaluation_context, python_fragment)

            assert ret is False

    def test_i_can_return_empty_list(self, sheerka, context, service):
        python_fragment = get_python_fragment(sheerka, context, "[]")
        ret = service.evaluate_python(context, EvaluationContext(), python_fragment)

        assert ret == []

    def test_can_create_namespaces(self, context, service):
        with NewOntology(context, "test_i_can_eval_when_context_is_needed"):
            namespace = service.create_namespace(context, ['in_context'], None, {}, {}, False)
            assert namespace == {"in_context": context.in_context}

            namespace = service.create_namespace(context, ['isinstance'], None, {}, {}, False)
            assert namespace == {"isinstance": context.sheerka.extended_isinstance}

            namespace = service.create_namespace(context, ['print'], None, {}, {}, False)
            assert namespace == {"print": print}

            namespace = service.create_namespace(context, ['print'], None, {}, {}, True)
            assert namespace == {}  # print method has side effect, so it's excluded

            # ###################
            # sheerka expando
            # ###################
            namespace = service.create_namespace(context, ['sheerka'], set(), {}, {}, False)
            assert isinstance(namespace["sheerka"], Expando)
            assert len(vars(namespace["sheerka"])) == 1  # 'expando_name' only

            namespace = service.create_namespace(context, ['sheerka'], {"new", "echo"}, {}, {}, False)
            assert isinstance(namespace["sheerka"], Expando)
            assert len(vars(namespace["sheerka"])) == 3  # 'expando_name' + new() + echo()

            with pytest.raises(MethodAccessError):
                # new method is not allowed if expression_only is True
                service.create_namespace(context, ['sheerka'], {"new", "echo"}, {}, {}, True)

            # ###################
            # sheerka methods
            # ###################
            namespace = service.create_namespace(context, ['new'], None, {}, {}, False)
            assert namespace == {"new": context.sheerka.new}  # Sheerka methods are not set

            with pytest.raises(MethodAccessError):
                # new method is not allowed if expression_only is True
                service.create_namespace(context, ['new'], None, {}, {}, True)

            # ###################
            context.sheerka.add_to_short_term_memory("key", "short term memory value")
            namespace = service.create_namespace(context, ['key'], None, {}, {}, False)
            assert namespace == {"key": "short term memory value"}

            foo = define_new_concept(context, get_metadata("foo", body="1"))
            foo_token = Token(TokenKind.CONCEPT, ("foo", None), 0, 1, 1)
            namespace = service.create_namespace(context, ['foo'], None, {"foo": foo_token}, {}, False)
            assert context.sheerka.isinstance(namespace["foo"], foo)
            assert namespace["foo"].body == 1  # local namespace are evaluated

            namespace = service.create_namespace(context, ['foo'], None, {}, {"foo": foo}, False)
            assert context.sheerka.isinstance(namespace["foo"], foo)
            assert namespace["foo"].body is NotInit  # global namespace are used as is

            namespace = service.create_namespace(context, ['foo'], None, {}, {}, False)
            assert context.sheerka.isinstance(namespace["foo"], foo)
            assert namespace["foo"].body == 1  # concept instantiation are evaluated

    def test_i_can_manage_concept_synonyms(self, context, service):
        foo, bar, baz = get_concepts(context, "foo", "bar", "baz", use_sheerka=False)
        # foo, bar and baz are supposed to be concept synonyms
        namespace = {"a": "value a",
                     "foo": MultipleResults(foo, bar, baz),
                     "b": "value b",
                     "bar": MultipleResults(baz, bar)}

        res = service.manage_multiple_choices(namespace)

        assert len(res) == 6
        assert res[0] == {"a": "value a", "b": "value b", "foo": foo, "bar": baz}
        assert res[1] == {"a": "value a", "b": "value b", "foo": foo, "bar": bar}
        assert res[2] == {"a": "value a", "b": "value b", "foo": bar, "bar": baz}
        assert res[3] == {"a": "value a", "b": "value b", "foo": bar, "bar": bar}
        assert res[4] == {"a": "value a", "b": "value b", "foo": baz, "bar": baz}
        assert res[5] == {"a": "value a", "b": "value b", "foo": baz, "bar": bar}

    def test_i_can_manage_namespaces_when_concepts_have_values(self, context, service):
        foo, bar, baz = get_concepts(context, "foo", "bar", "baz", use_sheerka=False)
        foo.set_value(ConceptDefaultProps.BODY, "foo value")
        foo.get_runtime_info().is_evaluated = True
        bar.set_value(ConceptDefaultProps.BODY, "bar value")
        bar.get_runtime_info().is_evaluated = True

        namespaces = [
            {"a": "value a", "foo": foo, "baz": baz},
            {"a": "value a", "foo": bar, "baz": baz},
        ]

        res = service.manage_concepts_with_body(context, namespaces)

        assert len(res) == 4
        assert res == [
            {"a": "value a", "baz": baz, "foo": foo},
            {"a": "value a", "baz": baz, "foo": "foo value"},
            {"a": "value a", "baz": baz, "foo": bar},
            {"a": "value a", "baz": baz, "foo": "bar value"},
        ]

    def test_multiple_results_concept_only_return_concepts(self, context):
        foo, bar = get_concepts(context, "foo", "bar")
        assert MultipleResults(foo, "one", bar, 1).concepts_only() == MultipleResults(foo, bar)
        assert MultipleResults("one", 1).concepts_only() == MultipleResults()

    def test_i_can_add_multiple_results_of_multiple_results(self, context):
        foo, bar, baz, qux = get_concepts(context, "foo", "bar", "baz", "qux")
        m1 = MultipleResults(foo, bar)
        m2 = MultipleResults(bar, baz, m1)

        assert m2.items == [bar, baz, foo, bar]