from mapgenerator import *
import en_decoder
from textwrap import dedent

def _reset():
    Choice.count = 0
    Or.count = 0
    And_.count = 0
    Unordered_.count = 0
    Take.count = 0

def en_de_code(rule, context={}, **args):
    from copy import deepcopy

    encoder = en_decoder.PythonRenderer.get_encoder(rule, deepcopy(context))
    ns0 = {}
    exec(encoder + "\nret = encode(**%s)" % args, ns0)

    decoder = en_decoder.PythonRenderer.get_decoder(rule, deepcopy(context))
    ns1 = {"arg": ns0["ret"]}
    exec(decoder + "\nret = decode(arg)", ns1)

    for k in args:
        assert ns1["ret"][k] == args[k]
    return ns1

#======================================

def get_rule_test_or_and():
    _reset()
    x = Choice(3, "foo")
    y = Choice(5, "bar")
    z = Choice(2, "multi")
    return And(Or(x, y, "is_y"), z)

def test_or_and_encode_decode():
    ns = en_de_code(
        get_rule_test_or_and(),
        is_y=True, bar=3, multi=1)

    ns = en_de_code(
        get_rule_test_or_and(),
        is_y=False, foo=1, multi=0)


#======================================

def get_rule_unordered_or():
    _reset()
    x = Choice(3, "foo")
    y = Choice(5, "bar")
    rule = Unordered(Or(x, y, "is_bar"))
    return rule

def test_unordered_or_encode_decode():
    params = dict(is_bar_1=True, is_bar_0=False, foo_0=0, bar_1=3)
    ns = en_de_code(
        get_rule_unordered_or(),
        **params)

    params = dict(is_bar_1=False, is_bar_0=False, foo_0=0, foo_1=1)
    ns = en_de_code(
        get_rule_unordered_or(),
        **params)

    params = dict(is_bar_1=True, is_bar_0=True, bar_0=2, bar_1=3)
    ns = en_de_code(
        get_rule_unordered_or(),
        **params)

#====================

def get_rule_unordered_or_take():
    _reset()
    x = Choice(3, "foo")
    r = Resource(5, "X")
    y = r.take("bar")
    rule = Unordered(Or(x, y, "is_bar"))
    return rule

def test_unordered_or_take_encode_decode():
    params = dict(is_bar_1=True, is_bar_0=False, foo_0=0, bar_1=3)
    ns = en_de_code(
        get_rule_unordered_or_take(), {"X": []},
        **params)

    params = dict(is_bar_1=False, is_bar_0=False, foo_0=0, foo_1=1)
    ns = en_de_code(
        get_rule_unordered_or_take(), {"X": []},
        **params)

    params = dict(is_bar_1=True, is_bar_0=True, bar_0=2, bar_1=3)
    ns = en_de_code(
        get_rule_unordered_or_take(), {"X": []},
        **params)

#==============================

def test_kirin_size():
    r = Resource(10, "X")
    Mochigoma = Choice(1, "dummy")
    Player = Choice(2, "kirin_player")
    Kirin = Unordered(
        And(
            Or(r.take("kirin"), 
               Mochigoma,
               "kirin_is_not_mochigoma"),
            Player))

    assert Kirin.size({"X": []}) == 223


def test_kirin_encode_decode():
    _reset()
    r = Resource(10, "X")
    Mochigoma = Choice(1, "dummy")
    Player = Choice(2, "kirin_player")
    Kirin = Unordered(
        And(
            Or(r.take("kirin"), 
               Mochigoma,
               "kirin_is_mochigoma"),
            Player))

    params = dict(kirin_0=0, kirin_1=1, 
                  kirin_player_0=0, kirin_player_1=0, 
                  kirin_is_mochigoma_0=False, kirin_is_mochigoma_1=False,
                  )

    ns = en_de_code(
        Kirin, {"X": []},
        **params)

    params = dict(kirin_0=0, dummy_1=0,
                  kirin_player_0=0, kirin_player_1=0, 
                  kirin_is_mochigoma_0=False, kirin_is_mochigoma_1=True)
    ns = en_de_code(
        Kirin, {"X": []},
        **params)

    params = dict(dummy_0=0, dummy_1=0, 
                  kirin_player_0=0, kirin_player_1=0, 
                  kirin_is_mochigoma_0=True, kirin_is_mochigoma_1=True)
    ns = en_de_code(
        Kirin, {"X": []},
        **params)

def test_cpp():
    r = Resource(5, "X")
    koma1 = r.take("koma1")
    koma2 = r.take("koma2")
    koma3 = r.take("koma3")
    koma4 = r.take("koma4")
    All = And(And(And(koma1, koma2), koma3), koma4)
    s = en_decoder.CppRenderer.get_test(All, {"X": []})
    file("tmp.cpp", "w").write(s)

def test_cpp_2():
    "make doubutu shougi's minimum complete hash"
    r = Resource(3, "X")

    Mochigoma = Choice(1, "dummy3")
    Player = Choice(2, "hiyoko_player")

    Hiyoko = Unordered(
            Or(
                r.take("hiyoko"),
                Mochigoma,
                "is_hiyoko_mochigoma"),
            )

    All = Hiyoko
    s = en_decoder.CppRenderer.get_test(All, {"X": []})
    file("tmp.cpp", "w").write(s)

if __name__ == "__main__":
    test_kirin_size()
    test_kirin_encode_decode()
    test_or_and_encode_decode()
    test_unordered_or_encode_decode()
    test_unordered_or_take_encode_decode()