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 CourseCompletionStatus, 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 (
    CourseCompletionFeedback,
    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)

    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",
        )

        self.client.force_login(self.member)

        # 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")

        self.client.force_login(self.member)

        # 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)

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

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

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

        completion = mark_course_completion(
            page=performance_criteria_1,
            user=self.member,
            course_session=self.course_session,
            completion_status=CourseCompletionStatus.SUCCESS.value,
        )

        feedback = create_self_evaluation_feedback(
            learning_unit=learning_unit,
            feedback_requester_user=self.member,
            feedback_provider_user=self.mentor,
        )

        CourseCompletionFeedback.objects.create(
            feedback=feedback,
            course_completion=completion,
            feedback_assessment=CourseCompletionStatus.FAIL.value,
        )

        self.client.force_login(self.mentor)

        # WHEN
        response = self.client.get(reverse("list_self_evaluation_feedbacks_provider"))

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

        self.assertEqual(len(response.data), 1)
        self.assertEqual(response.data[0]["learning_unit_id"], learning_unit.id)

        provider_user = response.data[0]["feedback_provider_user"]
        self.assertEqual(provider_user["id"], str(self.mentor.id))  # noqa
        self.assertEqual(provider_user["first_name"], self.mentor.first_name)
        self.assertEqual(provider_user["last_name"], self.mentor.last_name)
        self.assertEqual(provider_user["avatar_url"], self.mentor.avatar_url)

        requester_user = response.data[0]["feedback_requester_user"]
        self.assertEqual(requester_user["id"], str(self.member.id))  # noqa
        self.assertEqual(requester_user["first_name"], self.member.first_name)
        self.assertEqual(requester_user["last_name"], self.member.last_name)
        self.assertEqual(requester_user["avatar_url"], self.member.avatar_url)

        self.assertEqual(len(response.data[0]["criteria"]), 2)

        first_criteria = response.data[0]["criteria"][0]
        self.assertEqual(first_criteria["course_completion_id"], completion.id)
        self.assertEqual(first_criteria["title"], performance_criteria_1.title)
        self.assertEqual(
            first_criteria["self_assessment"],
            CourseCompletionStatus.SUCCESS.value,
        )
        self.assertEqual(
            first_criteria["feedback_assessment"], CourseCompletionStatus.FAIL.value
        )

        second_criteria = response.data[0]["criteria"][1]
        self.assertEqual(second_criteria["course_completion_id"], None)
        self.assertEqual(second_criteria["title"], performance_criteria_1.title)
        self.assertEqual(
            second_criteria["self_assessment"], CourseCompletionStatus.UNKNOWN.value
        )
        self.assertEqual(
            second_criteria["feedback_assessment"],
            CourseCompletionStatus.UNKNOWN.value,
        )