import random
import sys
import unittest
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent.parent))

import combat  # noqa: E402
import content  # noqa: E402
import game  # noqa: E402


def world_with(*players, now=1000.0, dev=True):
    world = game.new_world(now)
    world["config"]["dev"] = dev
    for uid, cls in players:
        world["players"][uid] = game.new_player(uid, uid.title(), cls, now)
    return world


def solo_fight(cls, level, mob, seed=1, watch=None, manual=()):
    player = game.new_player("p", "P", cls, 0)
    game.dev_level({"config": {}}, player, level, 0)
    player["manual"] = list(manual)
    fight = combat.new_fight("f", seed, 0, game.player_unit(player, 0, False),
                             [combat.mob_unit("e0", mob, level)], "hunt")
    return player, fight


class Content(unittest.TestCase):
    def test_every_spec_has_four_known_abilities(self):
        for spec in content.SPECS.values():
            self.assertEqual(len(spec["abilities"]), 4)
            self.assertEqual(sorted(spec["abilities"]), sorted(spec["priority"]))
            for ab in spec["abilities"]:
                self.assertIn(ab, content.ABILITIES)

    def test_places_link_both_ways_and_hunts_exist(self):
        for pid, place in content.PLACES.items():
            for other in place["links"]:
                self.assertIn(pid, content.PLACES[other]["links"], f"{pid} -> {other}")
            for hunt, pulls in place.get("hunts", {}).items():
                self.assertIn(hunt, content.MOBS)
                for pull in pulls:
                    for mob in pull:
                        self.assertIn(mob, content.MOBS)

    def test_quests_point_at_real_things(self):
        for qid, quest in content.QUESTS.items():
            self.assertIn(quest["giver"], content.PLACES)
            for req in quest.get("req", []):
                self.assertIn(req, content.QUESTS)
            for objective in quest["obj"]:
                if "kill" in objective:
                    self.assertIn(objective["kill"], content.MOBS)
                for mob in objective.get("from", []):
                    self.assertIn(mob, content.MOBS)
            for reward in quest.get("choice", []):
                self.assertIsNotNone(game.item(reward), reward)

    def test_loot_tables_resolve(self):
        for items in list(content.BOSS_LOOT.values()) + [content.TRASH_LOOT]:
            for item_id in items:
                self.assertIsNotNone(game.item(item_id), item_id)


class Items(unittest.TestCase):
    def test_generated_green_has_name_and_stats(self):
        green = game.item("g/chest/mail/bear/14")
        self.assertEqual(green["q"], "uncommon")
        self.assertIn("of the Bear", green["name"])
        self.assertGreater(green["sta"], green["power"])
        self.assertGreater(green["armor"], 0)

    def test_armour_rules(self):
        mage = game.new_player("m", "M", "mage", 0)
        self.assertIsNotNone(game.can_wear(mage, game.item("g/chest/mail/bear/2")))
        self.assertIsNone(game.can_wear(mage, game.item("g/chest/cloth/eagle/2")))
        warrior = game.new_player("w", "W", "warrior", 0)
        self.assertIsNone(game.can_wear(warrior, game.item("g/chest/cloth/eagle/2")))
        self.assertIn("level", game.can_wear(warrior, game.item("g/chest/mail/bear/14")))


class Combat(unittest.TestCase):
    def test_every_class_beats_an_even_mob_alone(self):
        for cls in content.CLASSES:
            _, fight = solo_fight(cls, 10, "riverpaw_gnoll")
            combat.advance(fight, 300)
            self.assertEqual(fight["state"], "won", cls)

    def test_same_seed_same_fight(self):
        a = solo_fight("mage", 8, "kobold_miner", seed=7)[1]
        b = solo_fight("mage", 8, "kobold_miner", seed=7)[1]
        combat.advance(a, 300)
        combat.advance(b, 300)
        self.assertEqual(a["t"], b["t"])
        self.assertEqual(a["units"]["p"]["hp"], b["units"]["p"]["hp"])

    def test_manual_ability_waits_for_the_player_while_watched(self):
        _, fight = solo_fight("warrior", 10, "riverpaw_gnoll", manual=["sunder"])
        combat.advance(fight, 6, watch={"p": 5})
        self.assertNotIn("sunder", fight["units"]["p"]["cds"])
        combat.press(fight, "p", "sunder", 6)
        combat.advance(fight, 7, watch={"p": 6})
        self.assertIn("sunder", fight["units"]["p"]["cds"])

    def test_manual_ability_falls_back_to_auto_when_nobody_watches(self):
        _, fight = solo_fight("warrior", 10, "riverpaw_gnoll", manual=["sunder"])
        combat.advance(fight, 6)
        self.assertIn("sunder", fight["units"]["p"]["cds"])

    def test_pressed_cooldown_is_shorter_than_auto(self):
        _, fight = solo_fight("shaman", 10, "riverpaw_gnoll", manual=["stormstrike"])
        combat.press(fight, "p", "stormstrike", 0)
        combat.advance(fight, 0.25, watch={"p": 0})
        pressed = fight["units"]["p"]["cds"]["stormstrike"]
        _, auto = solo_fight("shaman", 10, "riverpaw_gnoll")
        combat.advance(auto, 3)
        used = auto["units"]["p"]["cds"]["stormstrike"]
        self.assertAlmostEqual(pressed - 0.25, content.ABILITIES["stormstrike"]["cd"], places=2)
        self.assertGreater(used - pressed, content.ABILITIES["stormstrike"]["cd"] * 0.4)

    def test_interrupt_stops_a_cast(self):
        player = game.new_player("p", "P", "rogue", 0)
        game.dev_level({"config": {}}, player, 16, 0)
        player["manual"] = ["kick"]
        fight = combat.new_fight("f", 3, 0, game.player_unit(player, 0, False),
                                 [combat.mob_unit("e0", "defias_pillager", 16)], "hunt")
        for step in range(40):
            combat.advance(fight, (step + 1) * combat.STEP, watch={"p": step * combat.STEP})
            if fight["units"]["e0"]["cast"]:
                break
        self.assertTrue(fight["units"]["e0"]["cast"], "the pillager should start a Fireball")
        combat.press(fight, "p", "kick", fight["t"], "e0")
        combat.advance(fight, fight["t"] + 0.5, watch={"p": fight["t"]})
        self.assertIsNone(fight["units"]["e0"]["cast"])
        self.assertTrue(any("interrupts" in line["text"] for line in fight["log"]))

    def test_mob_turns_on_the_healer_and_taunt_takes_it_back(self):
        tank = game.new_player("tank", "Tank", "warrior", 0)
        healer = game.new_player("heal", "Heal", "priest", 0)
        for p in (tank, healer):
            game.dev_level({"config": {}}, p, 18, 0)
        party = game.player_unit(tank, 0, True) + game.player_unit(healer, 0, True)
        fight = combat.new_fight("f", 5, 0, party, [combat.mob_unit("e0", "defias_overseer", 18)], "dungeon")
        mob = fight["units"]["e0"]
        mob["threat"]["heal"] = 10000
        combat.advance(fight, 0.5)
        self.assertEqual(mob["target"], "heal")
        combat.advance(fight, 4)
        self.assertEqual(mob["target"], "tank")
        self.assertTrue(any("Taunt" in line["text"] for line in fight["log"]))

    def test_cc_breaks_on_damage_and_bosses_are_immune(self):
        player = game.new_player("p", "P", "mage", 0)
        game.dev_level({"config": {}}, player, 18, 0)
        fight = combat.new_fight("f", 2, 0, game.player_unit(player, 0, True),
                                 [combat.mob_unit("e0", "defias_miner", 18), combat.mob_unit("e1", "rhahkzor", 19)],
                                 "dungeon")
        rng = random.Random(1)
        combat._apply(fight, fight["units"]["p"], "polymorph", "e1", 0, rng)
        self.assertEqual(fight["units"]["e1"]["cc"], 0)
        combat._apply(fight, fight["units"]["p"], "polymorph", "e0", 0, rng)
        self.assertGreater(fight["units"]["e0"]["cc"], 0)
        combat._damage(fight, fight["units"]["p"], fight["units"]["e0"], 10, "frost", 0.5, rng)
        self.assertEqual(fight["units"]["e0"]["cc"], 0)

    def test_boss_phase_summons_adds(self):
        player = game.new_player("p", "P", "warrior", 0)
        game.dev_level({"config": {}}, player, 18, 0)
        fight = combat.new_fight("f", 2, 0, game.player_unit(player, 0, True),
                                 [combat.mob_unit("e0", "edwin_vancleef", 21)], "dungeon")
        boss = fight["units"]["e0"]
        boss["hp"] = boss["max_hp"] * 0.49
        combat.advance(fight, 0.25)
        self.assertEqual(sum(1 for u in fight["units"].values() if u.get("mob") == "defias_blackguard"), 2)


class World(unittest.TestCase):
    def test_hunting_earns_xp_and_quest_progress_while_away(self):
        world = world_with(("fred", "warrior"))
        fred = world["players"]["fred"]
        self.assertIsNone(game.accept(fred, "kobold_camp_cleanup"))
        fred["place"] = "northshire_valley"
        self.assertIsNone(game.start_hunt(world, fred, "kobold_vermin", 1000))
        game.process(world, 1000 + 20 * 60, random.Random(1))
        self.assertGreater(fred["level"], 1)
        self.assertEqual(fred["quests"]["kobold_camp_cleanup"], [10])

    def test_hunting_stops_after_the_offline_cap(self):
        world = world_with(("fred", "warrior"))
        fred = world["players"]["fred"]
        fred["place"] = "northshire_valley"
        game.start_hunt(world, fred, "kobold_vermin", 1000)
        game.process(world, 1000 + game.OFFLINE_CAP + 3600, random.Random(1))
        self.assertIsNone(fred["activity"])
        self.assertIsNone(fred["fight"])

    def test_turn_in_needs_the_right_place_and_a_reward_pick(self):
        world = world_with(("fred", "warrior"))
        fred = world["players"]["fred"]
        game.accept(fred, "kobold_camp_cleanup")
        fred["quests"]["kobold_camp_cleanup"] = [10]
        fred["place"] = "goldshire"
        self.assertIn("Turn it in", game.turn_in(world, fred, "kobold_camp_cleanup", 2, 0))
        fred["place"] = "northshire_abbey"
        self.assertEqual(game.turn_in(world, fred, "kobold_camp_cleanup", None, 0), "Pick a reward")
        self.assertIsNone(game.turn_in(world, fred, "kobold_camp_cleanup", 2, 0))
        self.assertIn("w/feet/mail/4", fred["bags"])
        self.assertIn("investigate_echo_ridge", game.available_quests(fred))

    def test_travel_takes_the_shortest_road(self):
        minutes, path = game.route("northshire_abbey", "moonbrook")
        self.assertEqual(path, ["northshire_abbey", "goldshire", "sentinel_hill", "moonbrook"])
        self.assertEqual(minutes, 14)
        world = world_with(("fred", "warrior"))
        fred = world["players"]["fred"]
        self.assertIsNone(game.travel(world, fred, "goldshire", 1000))
        game.process(world, 1000 + 4 * 60 - 1, random.Random(1))
        self.assertEqual(fred["place"], "northshire_abbey")
        game.process(world, 1000 + 4 * 60, random.Random(1))
        self.assertEqual(fred["place"], "goldshire")
        self.assertIsNone(fred["activity"])

    def test_a_group_clears_the_deadmines(self):
        world = world_with(*[(uid, cls) for uid, cls in
                             (("t", "warrior"), ("h", "priest"), ("m", "mage"), ("r", "rogue"), ("x", "hunter"))])
        for uid, player in world["players"].items():
            game.dev_level(world, player, 20, 1000)
            player["place"] = "moonbrook"
        leader = world["players"]["t"]
        game.create_group(world, leader)
        gid = leader["group"]
        for uid in "hmrx":
            self.assertIsNone(game.join_group(world, world["players"][uid], gid))
        self.assertIsNone(game.enter_dungeon(world, leader, 1000))
        game.process(world, 1000 + 3 * 3600, random.Random(4))
        dungeon = world["groups"][gid]["dungeon"]
        self.assertEqual(dungeon["state"], "done", dungeon)
        loot = sum(len(p["bags"]) for p in world["players"].values())
        self.assertGreater(loot, 0)

    def test_dungeon_needs_everyone_at_the_door(self):
        world = world_with(("a", "warrior"), ("b", "priest"), dev=False)
        a, b = world["players"]["a"], world["players"]["b"]
        a["place"] = "moonbrook"
        game.create_group(world, a)
        self.assertIn("at least 2", game.enter_dungeon(world, a, 0))
        game.join_group(world, b, a["group"])
        self.assertIn("Waiting on B", game.enter_dungeon(world, a, 0))
        b["place"] = "moonbrook"
        self.assertIsNone(game.enter_dungeon(world, a, 0))
        self.assertEqual(b["activity"]["kind"], "dungeon")
        game.leave_group(world, b, 10)
        self.assertIsNone(b["activity"])
        self.assertEqual(b["place"], "moonbrook")


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