from django.urls import reverse
from rest_framework.test import APITestCase

from vbv_lernwelt.course.creators.test_utils import (
    add_course_session_user,
    create_circle,
    create_course,
    create_course_session,
    create_learning_unit,
    create_performance_criteria_page,
    create_user,
)
from vbv_lernwelt.course.models import CourseSessionUser
from vbv_lernwelt.course.services import mark_course_completion
from vbv_lernwelt.learning_mentor.models import LearningMentor
from vbv_lernwelt.self_evaluation_feedback.models import SelfEvaluationFeedback


def create_self_evaluation_feedback(
    learning_unit, feedback_requester_user, feedback_provider_user
):
    return SelfEvaluationFeedback.objects.create(
        learning_unit=learning_unit,
        feedback_requester_user=feedback_requester_user,
        feedback_provider_user=feedback_provider_user,
    )


class SelfEvaluationFeedbackAPI(APITestCase):
    def setUp(self) -> None:
        self.member = create_user("member")
        self.mentor = create_user("mentor")

        self.course, self.course_page = create_course("Test Course")
        self.course_session = create_course_session(
            course=self.course, title="Test Bern 2022 a"
        )

        member_csu = add_course_session_user(
            course_session=self.course_session,
            user=self.member,
            role=CourseSessionUser.Role.MEMBER,
        )

        self.circle, _ = create_circle(
            title="Test Circle", course_page=self.course_page
        )

        learning_mentor = LearningMentor.objects.create(
            mentor=self.mentor,
            course=self.course_session.course,
        )

        learning_mentor.participants.add(member_csu)

        self.client.force_login(self.member)

    def test_start_self_evaluation_feedback(self):
        # GIVEN
        learning_unit = create_learning_unit(course=self.course, circle=self.circle)

        pc = create_performance_criteria_page(
            course=self.course,
            course_page=self.course_page,
            circle=self.circle,
            learning_unit=learning_unit,
        )

        mark_course_completion(
            page=pc,
            user=self.member,
            course_session=self.course_session,
            completion_status="SUCCESS",
        )

        # WHEN
        response = self.client.post(
            reverse("start_self_evaluation_feedback"),
            {
                "learning_unit_id": learning_unit.id,
                "feedback_provider_user_id": self.mentor.id,
            },
        )

        # THEN
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.data["success"], True)

        self.assertEqual(
            SelfEvaluationFeedback.objects.count(),
            1,
        )

        # just get the first one
        f = SelfEvaluationFeedback.objects.first()

        self.assertEqual(f.feedback_requester_user, self.member)
        self.assertEqual(f.feedback_provider_user, self.mentor)
        self.assertEqual(f.learning_unit, learning_unit)

    def test_start_self_evaluation_feedback_not_allowed_user(self):
        # GIVEN
        learning_unit = create_learning_unit(course=self.course, circle=self.circle)
        not_a_mentor = create_user("not_a_mentor")

        # WHEN
        response = self.client.post(
            reverse("start_self_evaluation_feedback"),
            {
                "learning_unit_id": learning_unit.id,
                "feedback_provider_user_id": not_a_mentor.id,
            },
        )

        # THEN
        self.assertEqual(response.status_code, 403)