import unittest

from logic.knights_queue import KnightsQueue
from models.knight import Knight


class KnightsQueueTest(unittest.TestCase):
    def test_should_skip_dead_knights(self):
        knight1 = Knight(None)
        knight1.max_hp = 0

        knight2 = Knight(None)
        knight2.max_hp = 0

        knight3 = Knight(None)
        knight3.max_hp = 1

        knight4 = Knight(None)
        knight4.max_hp = 0

        knight5 = Knight(None)
        knight5.max_hp = 0

        knight6 = Knight(None)
        knight6.max_hp = 1

        knights_queue = KnightsQueue([knight1, knight2, knight3], [knight4, knight5, knight6])

        res1 = knights_queue.dequeue_knight()
        res2 = knights_queue.dequeue_knight()

        self.assertEqual(res1.max_hp, 1)
        self.assertEqual(res2.max_hp, 1)

    def test_should_return_first_alive_knight(self):
        knight1 = Knight(None)
        knight1.max_hp = 222

        knight2 = Knight(None)
        knight2.max_hp = -1

        knight3 = Knight(None)
        knight3.max_hp = 1

        knights_queue = KnightsQueue([knight1, knight2], [knight3])

        res1 = knights_queue.dequeue_knight()
        res2 = knights_queue.dequeue_knight()
        res3 = knights_queue.dequeue_knight()
        res4 = knights_queue.dequeue_knight()

        self.assertEqual(res1, res3)
        self.assertEqual(res2, res4)

    def test_should_raise_when_knight_died_and_whole_team_dead(self):
        with self.assertRaises(Exception):
            knight1 = Knight(None)
            knight1.max_hp = 222
            knight2 = Knight(None)
            knight2.max_hp = 1

            knights_queue = KnightsQueue([knight1], [knight2])
            knights_queue.dequeue_knight()
            knights_queue.dequeue_knight()
            knight2.max_hp = -2
            knights_queue.dequeue_knight()
            knights_queue.dequeue_knight()

    def test_should_make_valid_next_turn(self):
        knight1 = Knight(None)
        knight1.max_hp = 222
        knight2 = Knight(None)
        knight2.max_hp = 1

        knights_queue = KnightsQueue([knight1], [knight2])
        previous_turn = knights_queue.team_idx_turn
        knights_queue.dequeue_knight()
        current_turn = knights_queue.team_idx_turn

        self.assertNotEqual(previous_turn, current_turn)

    def test_should_raise_when_team_has_dead_knights(self):
        with self.assertRaises(Exception):
            knight1 = Knight(None)
            knight1.max_hp = 0
            knight2 = Knight(None)
            knight2.max_hp = -1
            knight3 = Knight(None)
            knight3.max_hp = -2
            knight4 = Knight(None)
            knight4.max_hp = 20

            knights_queue = KnightsQueue([knight1, knight2, knight3], [knight4])

            knights_queue.dequeue_knight()
            knights_queue.dequeue_knight()

    def test_should_return_knight_from_any_team_and_add_to_queue_again(self):
        knight1 = Knight(None)
        knight1.max_hp = 10
        knight2 = Knight(None)
        knight2.max_hp = 20
        knights_queue = KnightsQueue([knight1], [knight2])

        result1 = knights_queue.dequeue_knight()
        result2 = knights_queue.dequeue_knight()
        result3 = knights_queue.dequeue_knight()

        self.assertIsNotNone(result1)
        self.assertIsNotNone(result2)
        self.assertIsNotNone(result3)
        self.assertTrue(result1.max_hp == result3.max_hp)

    def test_should_raise_when_only_one_team_alive(self):
        with self.assertRaises(Exception):
            knight = Knight(None)
            knight.max_hp = 21
            knights_queue = KnightsQueue([knight], [])
            knights_queue.dequeue_knight()

    def test_should_raise_when_no_team_alive(self):
        with self.assertRaises(Exception):
            knights_queue = KnightsQueue([], [])
            knights_queue.dequeue_knight()


if __name__ == '__main__':
    unittest.main()