import json
import unittest
import requests

import compLib.Seeding as Seeding
import compLib.Api as SeedingApi
import compLib.DoubleElimination as De


class SeedingTest(unittest.TestCase):
    def test_basic_seed(self):
        gamestate = Seeding.Gamestate(0)
        self.assertEqual(gamestate.seed, 0)
        self.assertEqual(gamestate.heu_color, 1)
        self.assertEqual(gamestate.get_heuballen(), 1)
        self.assertEqual(gamestate.get_logistic_plan(),
                         [12, 13, 10, 13, 12, 10, 11, 10, 12, 11, 12, 13, 10, 12, 10, 11, 13, 11, 13, 11, 12])
        self.assertEqual(gamestate.get_material_deliveries(), [[3, 1], [0, 3], [3, 1], [3, 1]])


def util_get_info():
    res = requests.get(SeedingApi.CONF_URL + "getInfo")
    return json.loads(res.text)


def util_set_seeding():
    res = requests.get(SeedingApi.CONF_URL + "setToSeeding")
    return res.status_code == 200


def util_set_de():
    res = requests.get(SeedingApi.CONF_URL + "setToDoubleElim")
    return res.status_code == 200


def util_start_match():
    res = requests.get(SeedingApi.CONF_URL + "startMatch")
    return res.status_code == 200


def util_reset_state():
    res = requests.get(SeedingApi.CONF_URL + "resetState")
    return res.status_code == 200


def util_set_seed(seed):
    res = requests.get(SeedingApi.CONF_URL + "resetState", params={"seed": seed})
    return res.status_code == 200


class SeedingApiTest(unittest.TestCase):
    def test_api_seeding_extensive(self):
        self.assertTrue(util_set_seeding())
        self.assertTrue(util_get_info()["is_seeding"])
        for seed in range(0, 256):
            print(f"Testing seed: {seed}")
            gamestate = Seeding.Gamestate(seed)
            self.assertTrue(util_set_seed(seed))
            seeding_api = SeedingApi.Seeding()
            self.assertEqual(seeding_api.get_heuballen(), gamestate.get_heuballen())
            self.assertEqual(seeding_api.get_logistic_plan(), gamestate.get_logistic_plan())
            self.assertEqual(seeding_api.get_material_deliveries(), gamestate.get_material_deliveries())

    def test_gamestate(self):
        seed = 42
        gamestate = Seeding.Gamestate(seed)
        print(gamestate)

        print(gamestate.get_heuballen())
        heu_color = gamestate.get_heuballen()
        if heu_color == 1:
            print("Heuballen liegen auf den gelben Linien")
            # TODO: code um die über die gelben Linien zu fahren
        elif heu_color == 2:
            print("Heuballen liegen auf den blauen Linien")
            # TODO: code um die über die blauen Linien zu fahren

        materials = gamestate.get_material_deliveries()
        print(materials)

        for material_pair in materials:
            print(f"Der Roboter sollte jetzt die beiden Materialien {material_pair} holen")

            for material in material_pair:
                if material == 0:
                    print(f"Der Roboter sollte jetzt Holz aufnehmen, Zone: {material}")
                    # TODO: code um in die Material Zone mit dem Holz zu fahren
                elif material == 1:
                    print(f"Der Roboter sollte jetzt Stahl aufnehmen, Zone: {material}")
                    # TODO: code um in die Material Zone mit dem Holz zu fahren
                elif material == 2:
                    print(f"Der Roboter sollte jetzt Beton aufnehmen, Zone: {material}")
                    # TODO: code um in die Material Zone mit dem Holz zu fahren
                elif material == 3:
                    print(f"Der Roboter sollte jetzt Ziegelsteine aufnehmen, Zone: {material}")
                    # TODO: code um in die Material Zone mit dem Holz zu fahren

            print("Der Roboter sollte jetzt die beiden Materialien zur Baustelle fahren")
            # TODO: code um zur Baustelle zu fahren

        logistic_plan = gamestate.get_logistic_plan()
        print(logistic_plan)

        for zone in logistic_plan:
            if zone == 10:
                print(f"Roboter sollte jetzt zur grünen Zone fahren: {zone}")
                # TODO: code um in die grüne Zone zu fahren
            elif zone == 11:
                print(f"Roboter sollte jetzt zur roten Zone fahren: {zone}")
                # TODO: code um in die rote Zone zu fahren
            elif zone == 12:
                print(f"Roboter sollte jetzt zur blauen Zone fahren: {zone}")
                # TODO: code um in die blaue Zone zu fahren
            elif zone == 13:
                print(f"Roboter sollte jetzt zur gelben Zone fahren: {zone}")
                # TODO: code um in die gelbe Zone zu fahren


class DeApiTest(unittest.TestCase):
    def test_api_de(self):
        self.assertTrue(util_set_de())
        self.assertTrue(util_reset_state())
        self.assertFalse(util_get_info()["is_seeding"])

        de = De.DoubleElim()
        self.assertEqual(de.get_pos(), (De.Position(0, 0, -1), 503))
        self.assertEqual(de.get_opponent(), (De.Position(0, 0, -1), 503))
        self.assertEqual(de.get_goal(), (De.Position(0, 0, -1), 503))
        self.assertEqual(de.get_items(), ([], 503))
        self.assertEqual(de.get_scores(), ({"self": 0, "opponent": 0}, 503))

        self.assertTrue(util_start_match())
        self.assertLessEqual(util_get_info()["timeleft"], 120)

        self.assertEqual(de.get_pos()[1], 200)
        self.assertEqual(de.get_opponent()[1], 200)
        self.assertEqual(de.get_goal()[1], 200)
        self.assertEqual(de.get_items()[1], 200)
        self.assertEqual(de.get_scores()[1], 200)

        self.assertTrue(0 <= de.get_pos()[0].x <= 250)
        self.assertTrue(0 <= de.get_pos()[0].y <= 250)
        self.assertTrue(0 <= de.get_pos()[0].degrees <= 360)
        self.assertEqual(de.get_items(), ([], 200))

        self.assertTrue(util_reset_state())


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