import lxml.html

from django.test import TestCase
from django.urls import reverse

from apps.applets.models import Applet, UserApplet
from apps.epic.models import DeckVariant, Room, TableSeat
from apps.lyric.models import Token, User


class GameboardViewTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="gamer@test.io")
        self.client.force_login(self.user)
        Applet.objects.get_or_create(slug="new-game", defaults={"name": "New Game", "context": "gameboard"})
        Applet.objects.get_or_create(slug="my-games", defaults={"name": "My Games", "context": "gameboard"})
        Applet.objects.get_or_create(slug="game-kit", defaults={"name": "Game Kit", "context": "gameboard"})
        response = self.client.get("/gameboard/")
        self.parsed = lxml.html.fromstring(response.content)

    def test_gameboard_requires_login(self):
        self.client.logout()
        response = self.client.get("/gameboard/")
        self.assertRedirects(
            response, "/?next=/gameboard/", fetch_redirect_response=False
        )
    
    def test_gameboard_renders(self):
        response = self.client.get("/gameboard/")
        self.assertEqual(response.status_code, 200)

    def test_gameboard_shows_my_games_applet(self):
        [_] = self.parsed.cssselect("#id_applet_my_games")

    def test_gameboard_shows_new_game_applet(self):
        [_] = self.parsed.cssselect("#id_applet_new_game")
    
    def test_gameboard_shows_game_kit(self):
        [_] = self.parsed.cssselect("#id_game_kit")

    def test_gameboard_shows_game_gear(self):
        [_] = self.parsed.cssselect(".gear-btn")

    def test_my_games_has_no_game_items_for_new_user(self):
        game_items = self.parsed.cssselect("#id_applet_my_games .game-item")
        self.assertEqual(len(game_items), 0)

    def test_my_games_row_shows_latest_event_prose_and_ts(self):
        from apps.drama.models import GameEvent, record
        room = Room.objects.create(name="StampedRoom", owner=self.user)
        record(
            room, GameEvent.SLOT_FILLED, actor=self.user,
            slot_number=1, token_type="coin",
            token_display="Coin-on-a-String", renewal_days=7,
        )
        response = self.client.get("/gameboard/")
        body = response.content.decode()
        self.assertIn("StampedRoom", body)
        # Row carries a ts cell from the recorded event
        self.assertRegex(
            body,
            r'#id_applet_my_games|class="[^"]*row-ts'.replace("#", ""),
        )
        # A .row-body cell carries some event prose
        self.assertRegex(body, r'<time[^>]+class="[^"]*row-ts')

    def test_game_kit_has_coin_on_a_string(self):
        [_] = self.parsed.cssselect("#id_game_kit #id_kit_coin_on_a_string")

    def test_game_kit_has_free_token(self):
        [_] = self.parsed.cssselect("#id_game_kit #id_kit_free_token")

    def test_game_kit_shows_deck_variant_cards(self):
        decks = self.parsed.cssselect("#id_game_kit .deck-variant")
        self.assertGreater(len(decks), 0)
        # Earthman deck (seeded by migration) should have its own card
        [_] = self.parsed.cssselect("#id_game_kit #id_kit_earthman_deck")

    def test_game_kit_has_dice_set_placeholder(self):
        [_] = self.parsed.cssselect("#id_game_kit #id_kit_dice_set")


class GameboardDeckInUseTest(TestCase):
    """Sprint 2: game kit applet renders in-use state for a deck assigned to an active seat."""

    def setUp(self):
        self.user = User.objects.create(email="gamer@test.io")
        self.client.force_login(self.user)
        Applet.objects.get_or_create(slug="game-kit", defaults={"name": "Game Kit", "context": "gameboard"})
        self.earthman = DeckVariant.objects.get(slug="earthman")
        self.room = Room.objects.create(name="Wildfire", owner=self.user)
        self.seat = TableSeat.objects.create(
            room=self.room, gamer=self.user, slot_number=1,
            deck_variant=self.earthman,
        )
        response = self.client.get("/gameboard/")
        self.parsed = lxml.html.fromstring(response.content)

    def test_in_use_deck_don_is_disabled(self):
        [don] = self.parsed.cssselect("#id_kit_earthman_deck .btn-equip")
        self.assertIn("btn-disabled", don.get("class", ""))

    def test_in_use_deck_doff_is_absent(self):
        active_doff = self.parsed.cssselect(
            "#id_kit_earthman_deck .btn-unequip:not(.btn-disabled)"
        )
        self.assertEqual(len(active_doff), 0)

    def test_in_use_deck_carries_room_name_for_mini_portal(self):
        [el] = self.parsed.cssselect("#id_kit_earthman_deck")
        self.assertEqual("Wildfire", el.get("data-in-use-room-name"))

    def test_non_in_use_deck_has_normal_don(self):
        fiorentine = DeckVariant.objects.get(slug="fiorentine-minchiate")
        self.user.unlocked_decks.add(fiorentine)
        response = self.client.get("/gameboard/")
        parsed = lxml.html.fromstring(response.content)
        [don] = parsed.cssselect("#id_kit_fiorentine_deck .btn-equip")
        self.assertNotIn("btn-disabled", don.get("class", ""))


class ToggleGameAppletsViewTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="gamer@test.io")
        self.client.force_login(self.user)
        self.new_game, _ = Applet.objects.get_or_create(
            slug="new-game", defaults={"name": "New Game", "context": "gameboard"}
        )
        self.my_games, _ = Applet.objects.get_or_create(
            slug="my-games", defaults={"name": "My Games", "context": "gameboard"}
        )
        self.url = reverse("toggle_game_applets")
    
    def test_unauthenticated_user_is_redirected(self):
        self.client.logout()
        response = self.client.post(self.url)
        self.assertRedirects(
            response, f"/?next={self.url}", fetch_redirect_response=False
        )

    def test_unchecked_applet_gets_user_applet_with_visible_false(self):
        self.client.post(self.url, {"applets": ["new-game"]})
        ua = UserApplet.objects.get(user=self.user, applet=self.my_games)
        self.assertFalse(ua.visible)

    def test_redirects_on_normal_post(self):
        response = self.client.post(self.url, {"applets": ["new-game", "my-games"]})
        self.assertRedirects(
            response, reverse("gameboard"), fetch_redirect_response=False
        )

    def test_returns_200_on_htmx_post(self):
        response = self.client.post(
            self.url,
            {"applets": ["new-game", "my-games"]},
            HTTP_HX_REQUEST="true",
        )
        self.assertEqual(response.status_code, 200)

    def test_does_not_affect_dash_applets(self):
        dash_applet, _ = Applet.objects.get_or_create(
            slug="username", defaults={"name": "Username", "context": "dashboard"}
        )
        self.client.post(self.url, {"applets": ["new-game", "my-games"]})
        self.assertFalse(UserApplet.objects.filter(user=self.user, applet=dash_applet).exists())


class EquipDeckViewTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="gamer@test.io")
        self.client.force_login(self.user)
        self.deck = DeckVariant.objects.first()

    def test_get_returns_405(self):
        response = self.client.get(reverse("equip_deck", kwargs={"deck_id": self.deck.pk}))
        self.assertEqual(response.status_code, 405)

    def test_post_equips_deck(self):
        response = self.client.post(reverse("equip_deck", kwargs={"deck_id": self.deck.pk}))
        self.assertEqual(response.status_code, 204)
        self.user.refresh_from_db()
        self.assertEqual(self.user.equipped_deck, self.deck)


class UnequipDeckViewTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="gamer@test.io")
        self.deck = DeckVariant.objects.first()
        self.user.equipped_deck = self.deck
        self.user.save(update_fields=["equipped_deck"])
        self.client.force_login(self.user)

    def test_get_returns_405(self):
        response = self.client.get(reverse("unequip_deck", kwargs={"deck_id": self.deck.pk}))
        self.assertEqual(response.status_code, 405)

    def test_post_clears_equipped_deck_when_matches(self):
        response = self.client.post(reverse("unequip_deck", kwargs={"deck_id": self.deck.pk}))
        self.assertEqual(response.status_code, 204)
        self.user.refresh_from_db()
        self.assertIsNone(self.user.equipped_deck)

    def test_post_ignores_non_matching_deck(self):
        other_deck = DeckVariant.objects.exclude(pk=self.deck.pk).first()
        if other_deck is None:
            self.skipTest("Only one deck variant in DB")
        self.client.post(reverse("unequip_deck", kwargs={"deck_id": other_deck.pk}))
        self.user.refresh_from_db()
        self.assertEqual(self.user.equipped_deck, self.deck)


class UnequipTrinketViewTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="gamer@test.io")
        self.client.force_login(self.user)

    def test_get_returns_405(self):
        from apps.lyric.models import Token
        token = Token.objects.filter(user=self.user).first()
        if token is None:
            self.skipTest("No token for user")
        response = self.client.get(reverse("unequip_trinket", kwargs={"token_id": token.pk}))
        self.assertEqual(response.status_code, 405)


class GameKitViewTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="gamer@test.io")
        self.client.force_login(self.user)
        Applet.objects.get_or_create(slug="gk-trinkets", defaults={"name": "Trinkets", "context": "game-kit"})
        Applet.objects.get_or_create(slug="gk-tokens", defaults={"name": "Tokens", "context": "game-kit"})
        Applet.objects.get_or_create(slug="gk-decks", defaults={"name": "Card Decks", "context": "game-kit"})
        Applet.objects.get_or_create(slug="gk-dice", defaults={"name": "Dice Sets", "context": "game-kit"})
        Applet.objects.get_or_create(slug="pronouns", defaults={"name": "Pronouns", "context": "game-kit"})
        response = self.client.get("/gameboard/game-kit/")
        self.parsed = lxml.html.fromstring(response.content)

    def test_game_kit_requires_login(self):
        self.client.logout()
        response = self.client.get("/gameboard/game-kit/")
        self.assertRedirects(response, "/?next=/gameboard/game-kit/", fetch_redirect_response=False)

    def test_game_kit_shows_gear_btn(self):
        [_] = self.parsed.cssselect(".gear-btn")

    def test_game_kit_shows_applet_menu(self):
        [_] = self.parsed.cssselect("#id_game_kit_menu")

    def test_game_kit_applet_menu_has_trinkets_checkbox(self):
        [inp] = self.parsed.cssselect("#id_game_kit_menu input[value='gk-trinkets']")
        self.assertEqual(inp.get("type"), "checkbox")

    def test_game_kit_applet_menu_has_tokens_checkbox(self):
        [inp] = self.parsed.cssselect("#id_game_kit_menu input[value='gk-tokens']")
        self.assertEqual(inp.get("type"), "checkbox")

    def test_game_kit_applet_menu_has_decks_checkbox(self):
        [inp] = self.parsed.cssselect("#id_game_kit_menu input[value='gk-decks']")
        self.assertEqual(inp.get("type"), "checkbox")

    def test_game_kit_applet_menu_has_dice_checkbox(self):
        [inp] = self.parsed.cssselect("#id_game_kit_menu input[value='gk-dice']")
        self.assertEqual(inp.get("type"), "checkbox")

    def test_game_kit_sections_container_present(self):
        [_] = self.parsed.cssselect("#id_gk_sections_container")

    def test_all_sections_visible_by_default(self):
        sections = self.parsed.cssselect("#id_gk_sections_container section")
        # Trinkets, Tokens, Card Decks, Dice Sets, Pronouns
        self.assertEqual(len(sections), 5)

    def test_pronouns_section_renders_five_cards(self):
        [section] = self.parsed.cssselect("#id_gk_pronouns")
        cards = section.cssselect(".gk-pronoun-card")
        self.assertEqual(len(cards), 5)
        slugs = [c.get("data-pronoun") for c in cards]
        self.assertEqual(
            slugs,
            ["pluralism", "bawlmorese", "misogyny", "misandry", "misanthropy"],
        )

    def test_pronouns_section_marks_current_choice_active(self):
        # Default user pronouns = "pluralism" — that card should carry .active.
        [active] = self.parsed.cssselect("#id_gk_pronouns .gk-pronoun-card.active")
        self.assertEqual(active.get("data-pronoun"), "pluralism")

    def test_game_kit_applet_menu_has_pronouns_checkbox(self):
        [inp] = self.parsed.cssselect("#id_game_kit_menu input[value='pronouns']")
        self.assertEqual(inp.get("type"), "checkbox")


class ToggleGameKitSectionsViewTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="gamer@test.io")
        self.client.force_login(self.user)
        self.trinkets, _ = Applet.objects.get_or_create(
            slug="gk-trinkets", defaults={"name": "Trinkets", "context": "game-kit"}
        )
        self.tokens, _ = Applet.objects.get_or_create(
            slug="gk-tokens", defaults={"name": "Tokens", "context": "game-kit"}
        )
        self.decks, _ = Applet.objects.get_or_create(
            slug="gk-decks", defaults={"name": "Card Decks", "context": "game-kit"}
        )
        self.dice, _ = Applet.objects.get_or_create(
            slug="gk-dice", defaults={"name": "Dice Sets", "context": "game-kit"}
        )
        self.url = reverse("toggle_game_kit_sections")

    def test_unauthenticated_user_is_redirected(self):
        self.client.logout()
        response = self.client.post(self.url)
        self.assertRedirects(response, f"/?next={self.url}", fetch_redirect_response=False)

    def test_unchecked_section_gets_user_applet_with_visible_false(self):
        self.client.post(self.url, {"applets": ["gk-trinkets"]})
        ua = UserApplet.objects.get(user=self.user, applet=self.tokens)
        self.assertFalse(ua.visible)

    def test_redirects_on_normal_post(self):
        response = self.client.post(self.url, {"applets": ["gk-trinkets", "gk-tokens"]})
        self.assertRedirects(response, reverse("game_kit"), fetch_redirect_response=False)

    def test_returns_200_on_htmx_post(self):
        response = self.client.post(
            self.url,
            {"applets": ["gk-trinkets", "gk-tokens"]},
            HTTP_HX_REQUEST="true",
        )
        self.assertEqual(response.status_code, 200)

    def test_does_not_affect_gameboard_applets(self):
        gb_applet, _ = Applet.objects.get_or_create(
            slug="new-game", defaults={"name": "New Game", "context": "gameboard"}
        )
        self.client.post(self.url, {"applets": ["gk-trinkets"]})
        self.assertFalse(UserApplet.objects.filter(user=self.user, applet=gb_applet).exists())

    def test_hidden_section_absent_from_htmx_response(self):
        response = self.client.post(
            self.url,
            {"applets": ["gk-trinkets"]},
            HTTP_HX_REQUEST="true",
        )
        parsed = lxml.html.fromstring(response.content)
        sections = parsed.cssselect("section")
        self.assertEqual(len(sections), 1)


class EquipTrinketViewTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="gamer@test.io")
        self.client.force_login(self.user)
        self.token = Token.objects.filter(user=self.user, token_type=Token.COIN).first()

    def test_get_returns_trinket_button_partial(self):
        response = self.client.get(
            reverse("equip_trinket", kwargs={"token_id": self.token.pk})
        )
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "apps/gameboard/_partials/_equip_trinket_btn.html")


class TarotFanViewTest(TestCase):
    def setUp(self):
        from apps.epic.models import DeckVariant
        self.earthman = DeckVariant.objects.get(slug="earthman")
        self.fiorentine = DeckVariant.objects.get(slug="fiorentine-minchiate")
        self.user = User.objects.create(email="fan@test.io")
        self.client.force_login(self.user)

    def test_returns_fan_partial_for_unlocked_deck(self):
        response = self.client.get(reverse("tarot_fan", kwargs={"deck_id": self.earthman.pk}))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "apps/gameboard/_partials/_tarot_fan.html")

    def test_returns_403_for_locked_deck(self):
        response = self.client.get(reverse("tarot_fan", kwargs={"deck_id": self.fiorentine.pk}))
        self.assertEqual(response.status_code, 403)