#!/usr/bin/env python3

import os
import pprint
import sys

sys.path.append(os.getcwd())

from solver import *

def test_is_swappable():

    swappable_grids = [
            [Kana("norm", "su"), Kana("norm", "su")],
            [Kana("froz", "su"), Kana("norm", "su")],
            [Kana("norm", "su"), Kana("norm"      )],
            [Kana("norm"      ), Kana("froz", "su")],
    ]

    for swappable_grid in swappable_grids:
        kanagrid = KanaGrid((2, 1), swappable_grid)
        print(kanagrid.grid)
        assert kanagrid.is_swappable((0, 0), (1, 0))

    not_swappable_grids = [
            [Kana("norm", "su"), Kana("rock", "su")],
            [Kana("froz", "su"), Kana("froz", "su")],
            [Kana("norm"      ), Kana("norm"      )],
    ]

    for not_swappable_grid in not_swappable_grids:
        kanagrid = KanaGrid((2, 1), not_swappable_grid)
        print(kanagrid.grid)
        assert not kanagrid.is_swappable((0, 0), (1, 0))


def test_action_reveal():

    kanagrid_orig = KanaGrid((1, 1), [Kana("myst", "ko")])
    kanagrid_new = kanagrid_orig.action(pos=(0, 0), action_type="reveal")
    expected_grid = KanaGrid((1, 1), [Kana("norm", "ko")], action_count=1)

    assert kanagrid_new == expected_grid


def test_action_slime_infest():

    kanagrid_orig = KanaGrid((2, 1), [Kana("norm", "ko"), Kana("slim", "e")])
    kanagrid_new_1 = kanagrid_orig.action(pos=(1, 0), action_type="left")
    kanagrid_new_2 = kanagrid_orig.action(pos=(0, 0), action_type="right")
    expected_grid = KanaGrid((2, 1), [Kana("norm", "ke"), Kana("void")], action_count=1)

    assert kanagrid_new_1 == expected_grid
    # Move of slime only is implemented, not other to slime
    assert kanagrid_new_2 == None


def test_kana_grid():

    initial_grid = [
        kana_void         , Kana("myst", "su"), kana_void         , Kana("myst", "ko"), kana_void         ,
        Kana("froz", "se"), Kana("norm"      ), Kana("norm"      ), Kana("norm"      ), Kana("froz", "so"),
        Kana("froz", "ku"), Kana("norm"      ), Kana("norm"      ), Kana("norm"      ), Kana("froz", "no"),
        kana_void         , kana_void         , Kana("rock", "ka"), kana_void         , kana_void         ,
    ]
    initial_grid_size = 5, 4
    chain_target = 7

    expected_grid = [
        kana_void         , Kana("myst", "su"), kana_void         , Kana("myst", "ko"), kana_void         ,
        Kana("norm"      ), Kana("norm"      ), Kana("norm"      ), Kana("froz", "se"), Kana("froz", "so"),
        Kana("froz", "ku"), Kana("norm"      ), Kana("norm"      ), Kana("norm"      ), Kana("froz", "no"),
        kana_void         , kana_void         , Kana("rock", "ka"), kana_void         , kana_void         ,
    ]

    kanagrid_orig = KanaGrid(initial_grid_size, initial_grid)
    kanagrid_new  = kanagrid_orig.action(pos=(0, 1), action_type="right")

    print("kanagrid_orig")
    print(kanagrid_orig)
    print("kanagrid_new")
    print(kanagrid_new)
    print("expected_grid")
    display_grid(expected_grid, initial_grid_size)

    assert kanagrid_new.grid == expected_grid


def test_kana_arrow_swap():
    kanagrid_orig = KanaGrid((2, 1), [Kana("ar_r", "su"), Kana("norm",)])
    kanagrid_new = kanagrid_orig.action(pos=(0, 0), action_type="right")
    expected_grid = KanaGrid((2, 1), [Kana("norm",), Kana("ar_r", "su")])

    print("kanagrid_orig")
    print(kanagrid_orig)
    print("kanagrid_new")
    print(kanagrid_new)
    print("expected_grid")
    print(expected_grid)

    assert kanagrid_new.grid == expected_grid.grid

def test_kana_arrow_swap():
    moves = [
        {
            'move_ok': 'up',
            'other_move_ok': 'down',
            'dest_pos': (1, 0),
            'orig': KanaGrid((3, 3), [
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
                Kana("norm"      ), Kana("ar_u", "ko"), Kana("norm"      ),
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
            ]),
            'moved': KanaGrid((3, 3), [
                Kana("void"      ), Kana("ar_u", "ko"), Kana("void"      ),
                Kana("norm"      ), Kana("norm"      ), Kana("norm"      ),
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
            ], action_count=1),
        },
        {
            'move_ok': 'right',
            'other_move_ok': 'left',
            'dest_pos': (2, 1),
            'orig': KanaGrid((3, 3), [
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
                Kana("norm"      ), Kana("ar_r", "ko"), Kana("norm"      ),
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
            ]),
            'moved': KanaGrid((3, 3), [
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
                Kana("norm"      ), Kana("norm"      ), Kana("ar_r", "ko"),
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
            ], action_count=1),
        },
        {
            'move_ok': 'down',
            'other_move_ok': 'up',
            'dest_pos': (1, 2),
            'orig': KanaGrid((3, 3), [
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
                Kana("norm"      ), Kana("ar_d", "ko"), Kana("norm"      ),
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
            ]),
            'moved': KanaGrid((3, 3), [
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
                Kana("norm"      ), Kana("norm"      ), Kana("norm"      ),
                Kana("void"      ), Kana("ar_d", "ko"), Kana("void"      ),
            ], action_count=1),
        },
        {
            'move_ok': 'left',
            'other_move_ok': 'right',
            'dest_pos': (0, 1),
            'orig': KanaGrid((3, 3), [
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
                Kana("norm"      ), Kana("ar_l", "ko"), Kana("norm"      ),
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
            ]),
            'moved': KanaGrid((3, 3), [
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
                Kana("ar_l", "ko"), Kana("norm"      ), Kana("norm"      ),
                Kana("void"      ), Kana("norm"      ), Kana("void"      ),
            ], action_count=1),
        },
    ]

    for move in moves:
        print("pprint.pprint(move):")
        pprint.pprint(move)
        for action in ("up", "right", "down", "left"):
            print("\n"*3)
            print("action:", action)

            # try to move arrowed kana
            kanagrid_test = move['orig'].copy()
            kanagrid_test = kanagrid_test.action((1, 1), action)
            print("=== move arrowed kana ===")
            print(kanagrid_test)
            if action == move['move_ok']:
                assert move['orig'].is_swappable((1, 1), move['dest_pos'])
                assert kanagrid_test == move['moved']
            else:
                assert kanagrid_test is None

            for other_pos in ((1, 0), (2, 1), (1, 2), (0, 1)):
                # try to move other kana with the arrowed one
                kanagrid_test = move['orig'].copy()
                kanagrid_test = kanagrid_test.action(other_pos, action)
                print("=== move other kana ===")
                print(kanagrid_test)
                if action == move['other_move_ok'] \
                        and other_pos == move['dest_pos']:
                    assert move['orig'].is_swappable(other_pos, (1, 1))
                    assert kanagrid_test == move['moved']
                else:
                    assert kanagrid_test is None


def test_solver_load_and_type_1():
    # ./solver.py tests_solver/level_test_type.yaml

    kanagrid_orig = KanaGrid((6, 2), [
                Kana("ar_r", "sa"), Kana("norm"      ), Kana("norm", "so"), Kana("rock", "se"), Kana("myst", "ka"), Kana("ar_d", "na"),
                Kana("ar_u", "su"), Kana("ar_l", "nu"), Kana("void"      ), Kana("void"      ), Kana("froz"      ), Kana("froz", "ke"),
            ])

    expected_grid = KanaGrid((6, 2), [
                Kana("ar_u", "su"), Kana("ar_r", "sa"), Kana("norm", "so"), Kana("rock", "se"), Kana("froz", "ke"), Kana("norm", "ka"),
                Kana("ar_l", "nu"), Kana("norm"      ), Kana("void"      ), Kana("void"      ), Kana("froz"      ), Kana("ar_d", "na"),
            ], action_count=6, score=8)

    type_yaml_level_file = 'tests_solver/level_test_type.yaml'
    with open(type_yaml_level_file, encoding='utf8') as stream:
        input_dict = yaml.safe_load(stream)
    loaded_grid = KanaGrid.load(input_dict)
    target_score = input_dict['target_score']
    max_actions = input_dict['max_actions']

    assert loaded_grid == kanagrid_orig

    grids = list(search_all_solution(loaded_grid, target_score, max_actions))

    assert len(grids) == 1
    assert grids[0] == expected_grid