from unittest.mock import patch

from django.contrib.auth import get_user_model
from django.test import TestCase

from fupogfakta.models import Category, GameSession, Guess, LieAnswer, Player, Question, RoundConfig, RoundQuestion, ScoreEvent
from fupogfakta.payloads import build_lie_started_payload, build_reveal_payload
from fupogfakta.services import get_current_round_question, prepare_mixed_answers, resolve_scores, select_round_question

User = get_user_model()


class FupOgFaktaExtractionSliceTests(TestCase):
    def setUp(self):
        self.host = User.objects.create_user(username="host", password="secret123")
        self.session = GameSession.objects.create(host=self.host, code="ABCD23")
        self.category = Category.objects.create(name="Historie", slug="historie", is_active=True)
        self.question_one = Question.objects.create(
            category=self.category,
            prompt="Hvornår faldt muren?",
            correct_answer="1989",
            is_active=True,
        )
        self.question_two = Question.objects.create(
            category=self.category,
            prompt="Hvornår kom euroen?",
            correct_answer="1999",
            is_active=True,
        )
        self.round_config = RoundConfig.objects.create(session=self.session, number=1, category=self.category)
        self.alice = Player.objects.create(session=self.session, nickname="Alice")
        self.bob = Player.objects.create(session=self.session, nickname="Bob")
        self.clara = Player.objects.create(session=self.session, nickname="Clara")

    def test_select_round_question_skips_already_used_questions_for_session(self):
        RoundQuestion.objects.create(
            session=self.session,
            round_number=99,
            question=self.question_one,
            correct_answer=self.question_one.correct_answer,
        )

        round_question = select_round_question(self.session, self.round_config)

        self.assertEqual(round_question.question, self.question_two)
        self.assertEqual(get_current_round_question(self.session), round_question)

    def test_prepare_mixed_answers_dedupes_blank_and_case_variants(self):
        round_question = RoundQuestion.objects.create(
            session=self.session,
            round_number=1,
            question=self.question_one,
            correct_answer="1989",
        )
        LieAnswer.objects.create(round_question=round_question, player=self.alice, text=" 1989 ")
        LieAnswer.objects.create(round_question=round_question, player=self.bob, text="Nitten niogfirs")
        LieAnswer.objects.create(round_question=round_question, player=self.clara, text="   ")

        with patch("fupogfakta.services.random.shuffle", side_effect=lambda answers: None):
            answers = prepare_mixed_answers(round_question)

        self.assertEqual(answers, ["1989", "Nitten niogfirs"])
        round_question.refresh_from_db()
        self.assertEqual(round_question.mixed_answers, answers)

    def test_resolve_scores_applies_correct_and_bluff_points(self):
        round_question = RoundQuestion.objects.create(
            session=self.session,
            round_number=1,
            question=self.question_one,
            correct_answer="1989",
        )
        Guess.objects.create(
            round_question=round_question,
            player=self.alice,
            selected_text="1989",
            is_correct=True,
        )
        Guess.objects.create(
            round_question=round_question,
            player=self.bob,
            selected_text="Berlin",
            is_correct=False,
            fooled_player=self.clara,
        )
        Guess.objects.create(
            round_question=round_question,
            player=self.clara,
            selected_text="Berlin",
            is_correct=False,
            fooled_player=self.clara,
        )

        score_events, leaderboard = resolve_scores(self.session, round_question, self.round_config)

        self.assertEqual(len(score_events), 2)
        self.alice.refresh_from_db()
        self.clara.refresh_from_db()
        self.assertEqual(self.alice.score, self.round_config.points_correct)
        self.assertEqual(self.clara.score, self.round_config.points_bluff * 2)
        self.assertEqual(ScoreEvent.objects.filter(session=self.session, meta__round_question_id=round_question.id).count(), 2)
        self.assertEqual([entry["nickname"] for entry in leaderboard], ["Alice", "Clara", "Bob"])

    def test_payload_builders_expose_fupogfakta_round_contract(self):
        round_question = RoundQuestion.objects.create(
            session=self.session,
            round_number=1,
            question=self.question_one,
            correct_answer="1989",
        )
        lie = LieAnswer.objects.create(round_question=round_question, player=self.bob, text="1991")
        Guess.objects.create(
            round_question=round_question,
            player=self.alice,
            selected_text="1991",
            is_correct=False,
            fooled_player=self.bob,
        )

        lie_payload = build_lie_started_payload(self.session, self.round_config, round_question)
        reveal_payload = build_reveal_payload(round_question)

        self.assertEqual(lie_payload["category"], {"slug": self.category.slug, "name": self.category.name})
        self.assertEqual(lie_payload["round_question_id"], round_question.id)
        self.assertEqual(reveal_payload["correct_answer"], "1989")
        self.assertEqual(reveal_payload["lies"][0]["player_id"], lie.player_id)
        self.assertEqual(reveal_payload["guesses"][0]["fooled_player_nickname"], self.bob.nickname)