"""
Integration tests for gated content.
"""
import ddt
from milestones import api as milestones_api
from milestones.tests.utils import MilestonesTestCaseMixin
from nose.plugins.attrib import attr

from lms.djangoapps.courseware.access import has_access
from lms.djangoapps.grades.course_grade_factory import CourseGradeFactory
from lms.djangoapps.grades.tests.utils import answer_problem
from openedx.core.djangolib.testing.utils import get_mock_request
from openedx.core.lib.gating import api as gating_api
from request_cache.middleware import RequestCache
from student.tests.factories import UserFactory
from xmodule.modulestore.django import modulestore
from xmodule.modulestore.tests.django_utils import SharedModuleStoreTestCase
from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory


@attr(shard=3)
@ddt.ddt
class TestGatedContent(MilestonesTestCaseMixin, SharedModuleStoreTestCase):
    """
    Base TestCase class for setting up a basic course structure
    and testing the gating feature
    """
    @classmethod
    def setUpClass(cls):
        super(TestGatedContent, cls).setUpClass()
        cls.set_up_course()

    def setUp(self):
        super(TestGatedContent, self).setUp()
        self.setup_gating_milestone(50)
        self.non_staff_user = UserFactory()
        self.staff_user = UserFactory(is_staff=True, is_superuser=True)
        self.request = get_mock_request(self.non_staff_user)

    @classmethod
    def set_up_course(cls):
        """
        Set up a course for testing gated content.
        """
        cls.course = CourseFactory.create(
            org='edX',
            number='EDX101',
            run='EDX101_RUN1',
            display_name='edX 101'
        )
        with modulestore().bulk_operations(cls.course.id):
            cls.course.enable_subsection_gating = True
            grading_policy = {
                "GRADER": [{
                    "type": "Homework",
                    "min_count": 3,
                    "drop_count": 0,
                    "short_label": "HW",
                    "weight": 1.0
                }]
            }
            cls.course.grading_policy = grading_policy
            cls.course.save()
            cls.store.update_item(cls.course, 0)

            # create chapter
            cls.chapter1 = ItemFactory.create(
                parent_location=cls.course.location,
                category='chapter',
                display_name='chapter 1'
            )

            # create sequentials
            cls.seq1 = ItemFactory.create(
                parent_location=cls.chapter1.location,
                category='sequential',
                display_name='gating sequential 1',
                graded=True,
                format='Homework',
            )
            cls.seq2 = ItemFactory.create(
                parent_location=cls.chapter1.location,
                category='sequential',
                display_name='gated sequential 2',
                graded=True,
                format='Homework',
            )
            cls.seq3 = ItemFactory.create(
                parent_location=cls.chapter1.location,
                category='sequential',
                display_name='sequential 3',
                graded=True,
                format='Homework',
            )

            # create problem
            cls.gating_prob1 = ItemFactory.create(
                parent_location=cls.seq1.location,
                category='problem',
                display_name='gating problem 1',
            )
            cls.gated_prob2 = ItemFactory.create(
                parent_location=cls.seq2.location,
                category='problem',
                display_name='gated problem 2',
            )
            cls.prob3 = ItemFactory.create(
                parent_location=cls.seq3.location,
                category='problem',
                display_name='problem 3',
            )

    def setup_gating_milestone(self, min_score):
        """
        Setup a gating milestone for testing.
        Gating content: seq1 (must be fulfilled before access to seq2)
        Gated content: seq2 (requires completion of seq1 before access)
        """
        gating_api.add_prerequisite(self.course.id, str(self.seq1.location))
        gating_api.set_required_content(self.course.id, str(self.seq2.location), str(self.seq1.location), min_score)
        self.prereq_milestone = gating_api.get_gating_milestone(self.course.id, self.seq1.location, 'fulfills')

    def assert_access_to_gated_content(self, user, expected_access):
        """
        Verifies access to gated content for the given user is as expected.
        """
        # clear the request cache to flush any cached access results
        RequestCache.clear_request_cache()

        # access to gating content (seq1) remains constant
        self.assertTrue(bool(has_access(user, 'load', self.seq1, self.course.id)))

        # access to gated content (seq2) is as expected
        self.assertEquals(bool(has_access(user, 'load', self.seq2, self.course.id)), expected_access)

    def assert_user_has_prereq_milestone(self, user, expected_has_milestone):
        """
        Verifies whether or not the user has the prereq milestone
        """
        self.assertEquals(
            milestones_api.user_has_milestone({'id': user.id}, self.prereq_milestone),
            expected_has_milestone,
        )

    def assert_course_grade(self, user, expected_percent):
        """
        Verifies the given user's course grade is the expected percentage.
        Also verifies the user's grade information contains values for
        all problems in the course, whether or not they are currently
        gated.
        """
        course_grade = CourseGradeFactory().read(user, self.course)
        for prob in [self.gating_prob1, self.gated_prob2, self.prob3]:
            self.assertIn(prob.location, course_grade.problem_scores)

        self.assertEquals(course_grade.percent, expected_percent)

    def test_gated_for_nonstaff(self):
        self.assert_user_has_prereq_milestone(self.non_staff_user, expected_has_milestone=False)
        self.assert_access_to_gated_content(self.non_staff_user, expected_access=False)

    def test_not_gated_for_staff(self):
        self.assert_user_has_prereq_milestone(self.staff_user, expected_has_milestone=False)
        self.assert_access_to_gated_content(self.staff_user, expected_access=True)

    def test_gated_content_always_in_grades(self):
        # start with a grade from a non-gated subsection
        answer_problem(self.course, self.request, self.prob3, 10, 10)

        # verify gated status and overall course grade percentage
        self.assert_user_has_prereq_milestone(self.non_staff_user, expected_has_milestone=False)
        self.assert_access_to_gated_content(self.non_staff_user, expected_access=False)
        self.assert_course_grade(self.non_staff_user, .33)

        # fulfill the gated requirements
        answer_problem(self.course, self.request, self.gating_prob1, 10, 10)

        # verify gated status and overall course grade percentage
        self.assert_user_has_prereq_milestone(self.non_staff_user, expected_has_milestone=True)
        self.assert_access_to_gated_content(self.non_staff_user, expected_access=True)
        self.assert_course_grade(self.non_staff_user, .67)

    @ddt.data((1, 1, True), (1, 2, True), (1, 3, False), (0, 1, False))
    @ddt.unpack
    def test_ungating_when_fulfilled(self, earned, max_possible, result):
        self.assert_user_has_prereq_milestone(self.non_staff_user, expected_has_milestone=False)
        self.assert_access_to_gated_content(self.non_staff_user, expected_access=False)

        answer_problem(self.course, self.request, self.gating_prob1, earned, max_possible)

        self.assert_user_has_prereq_milestone(self.non_staff_user, expected_has_milestone=result)
        self.assert_access_to_gated_content(self.non_staff_user, expected_access=result)
