# -*- coding: utf-8 -*-

from ..syntax import macros, test, test_raises, the  # noqa: F401
from ..test.fixtures import session, testset

from ..let import let, letrec, dlet, dletrec, blet, bletrec

from ..env import env as _envcls
from ..misc import call
from ..seq import begin

def runtests():
    with testset("order-preserving list uniqifier example"):
        def uniqify_test():
            def f(lst):  # classical solution
                seen = set()
                def see(x):
                    seen.add(x)
                    return x
                return [see(x) for x in lst if x not in seen]

            # one-liner
            f2 = lambda lst: (lambda seen: [seen.add(x) or x for x in lst if x not in seen])(seen=set())

            # context manager only
            def f3(lst):
                with _envcls(seen=set()) as myenv:
                    return [myenv.seen.add(x) or x for x in lst if x not in myenv.seen]
                # myenv itself still lives due to Python's scoping rules.
                # This is why we provide a separate let construct
                # and not just the env class.

            # solution using let
            f4 = lambda lst: let(seen=set(),
                                 body=lambda e: [e.seen.add(x) or x for x in lst if x not in e.seen])

            f5 = lambda lst: letrec(seen=set(),
                                    see=lambda e: lambda x: begin(e.seen.add(x), x),
                                    body=lambda e: [e.see(x) for x in lst if x not in e.seen])

            L = [1, 1, 3, 1, 3, 2, 3, 2, 2, 2, 4, 4, 1, 2, 3]

            # Call each implementation twice to make sure that a fresh `seen`
            # is indeed created at each call.
            test[the[f(L)] == the[f(L)]]
            test[the[f2(L)] == the[f2(L)]]
            test[the[f3(L)] == the[f3(L)]]
            test[the[f4(L)] == the[f4(L)]]
            test[the[f5(L)] == the[f5(L)]]

            test[the[f(L)] == the[f2(L)] == the[f3(L)] == the[f4(L)] == the[f5(L)] == [1, 3, 2, 4]]

        uniqify_test()

    with testset("let over lambda"):
        # Let over lambda. The inner lambda is the definition of the function f.
        counter = let(x=0,
                      body=lambda e: lambda: begin(e.set("x", e.x + 1),
                                                   e.x))
        counter()
        counter()
        test[counter() == 3]

    with testset("let over def"):
        @dlet(count=0)
        def counter2(*, env=None):  # env: named argument containing the let bindings
            env.count += 1
            return env.count
        counter2()
        counter2()
        test[counter2() == 3]

        @dlet(y=23)
        def foo(x, *, env):
            return x + env.y
        test[foo(17) == 40]

        @dlet(x=5)
        def bar(*, env):
            test[env.x == 5]

            @dlet(x=42)
            def baz(*, env):  # this env shadows the outer env
                test[env.x == 42]
            baz()

            test[env.x == 5]
        bar()

    with testset("let block"):
        @call
        @dlet(x=5)
        def _ignored1(*, env):  # this is now the let block, run immediately
            test[env.x == 5]

            @call
            @dlet(x=42)
            def _(*, env):
                test[env.x == 42]

            test[env.x == 5]

        # same effect
        @blet(x=5)
        def _ignored2(*, env):
            test[env.x == 5]

            @blet(x=42)
            def _ignored3(*, env):
                test[env.x == 42]

            test[env.x == 5]

    # example from https://docs.racket-lang.org/reference/let.html
    with testset("evenp-oddp example"):
        t = letrec(evenp=lambda e: lambda x: (x == 0) or e.oddp(x - 1),
                   oddp=lambda e: lambda x: (x != 0) and e.evenp(x - 1),
                   body=lambda e: e.evenp(42))
        test[t is True]

        # somewhat pythonic solution:
        @call
        def t():
            def evenp(x): return x == 0 or oddp(x - 1)
            def oddp(x): return x != 0 and evenp(x - 1)
            return evenp(42)
        test[t is True]

        # letrec over def
        @dletrec(evenp=lambda e: lambda x: (x == 0) or e.oddp(x - 1),
                 oddp=lambda e: lambda x: (x != 0) and e.evenp(x - 1))
        def is_even(x, *, env):
            return env.evenp(x)
        test[is_even(23) is False]

        # code block with letrec
        @bletrec(evenp=lambda e: lambda x: (x == 0) or e.oddp(x - 1),
                 oddp=lambda e: lambda x: (x != 0) and e.evenp(x - 1))
        def result(*, env):
            return env.evenp(23)
        test[result is False]

    with testset("error cases"):
        test_raises[AttributeError,
                    letrec(a=lambda e: e.b + 1,  # error, e.b does not exist yet (simple value refers to binding below it)
                           b=42,
                           body=lambda e: e.a)]

        test_raises[AttributeError,
                    let(x=0,
                        body=lambda e: e.set('y', 3)),
                    "e.y should not be defined"]

        with test_raises[AttributeError, "let environment should be final (should not be able to create new bindings in it inside the let body)"]:
            @blet(x=1)
            def error1(*, env):
                env.y = 2  # error, cannot introduce new bindings into a let environment

        test_raises[TypeError, let(body="not a callable")]
        test_raises[TypeError, let(body=lambda: None)]  # body callable must be able to take in environment
        # Reassigning the same name is blocked by Python itself (SyntaxError), so no test for that.
        test_raises[TypeError, letrec(x=lambda: 1,
                                      body=lambda e: e.x)]  # callable value must be able to take in environment

if __name__ == '__main__':  # pragma: no cover
    with session(__file__):
        runtests()