from datetime import timedelta

from django.test import TestCase
from django.utils.timezone import now

from apps.payment.models import Discount
from project.tests.factories import CourseFactory, DiscountFactory, UserFactory, PackageFactory


class DiscountForCoursesModelTestCase(TestCase):

    def setUp(self):
        self.user = UserFactory.create()

    def test_discounts_for_courses_without_user(self):
        course_1 = CourseFactory.create()
        course_2 = CourseFactory.create()
        course_3 = CourseFactory.create()

        DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course_1,
                               product=Discount.PRODUCT_ONE_COURSE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course_2,
                               product=Discount.PRODUCT_ONE_COURSE)

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
        self.assertEqual(all_curses_discounts, {'max_discount': None})
        self.assertEqual(discounts_for_courses[0], {'course': course_1.pk, 'max_discount': 30})
        self.assertEqual(discounts_for_courses[1], {'course': course_2.pk, 'max_discount': 50})

    def test_greater_value_discount_without_user(self):
        course = CourseFactory.create()
        DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course,
                               product=Discount.PRODUCT_ONE_COURSE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course,
                               product=Discount.PRODUCT_ONE_COURSE)

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
        self.assertEqual(all_curses_discounts, {'max_discount': None})
        self.assertEqual(discounts_for_courses[0], {'course': course.pk, 'max_discount': 50})

    def test_exclude_personal_discounts_without_user(self):
        user_1 = UserFactory.create()
        course = CourseFactory.create()
        DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course,
                               product=Discount.PRODUCT_ONE_COURSE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course,
                               product=Discount.PRODUCT_ONE_COURSE, client=user_1)
        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
        self.assertEqual(all_curses_discounts, {'max_discount': None})
        self.assertEqual(discounts_for_courses[0], {'course': course.pk, 'max_discount': 30})

    def test_discount_for_one_course_and_all_courses(self):
        course = CourseFactory.create()
        DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course,
                               product=Discount.PRODUCT_ONE_COURSE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course,
                               product=Discount.PRODUCT_ONE_COURSE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_COURSES)

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
        self.assertEqual(all_curses_discounts, {'max_discount': 10})
        self.assertEqual(discounts_for_courses[0], {'course': course.pk, 'max_discount': 50})

    def test_personal_discounts(self):
        course = CourseFactory.create()
        DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course,
                               product=Discount.PRODUCT_ONE_COURSE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course,
                               product=Discount.PRODUCT_ONE_COURSE, client=self.user)
        DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_COURSES)

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=self.user)
        self.assertEqual(all_curses_discounts, {'max_discount': 10})
        self.assertEqual(discounts_for_courses[0], {'course': course.pk, 'max_discount': 50})

    def test_personal_discounts_multiple_users(self):
        user_1 = UserFactory()
        course = CourseFactory.create()
        DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course,
                               product=Discount.PRODUCT_ONE_COURSE, client=user_1)

        DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course,
                               product=Discount.PRODUCT_ONE_COURSE, client=self.user)
        DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_COURSES,
                               client=self.user)

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=self.user)
        self.assertEqual(all_curses_discounts, {'max_discount': 10})
        self.assertEqual(discounts_for_courses[0], {'course': course.pk, 'max_discount': 50})

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=user_1)
        self.assertEqual(all_curses_discounts, {'max_discount': None})
        self.assertEqual(discounts_for_courses[0], {'course': course.pk, 'max_discount': 30})

    def test_discount_for_one_course_without_user(self):
        course_1 = CourseFactory.create()
        course_2 = CourseFactory.create()
        course_3 = CourseFactory.create()

        DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course_1,
                               product=Discount.PRODUCT_ONE_COURSE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course_2,
                               product=Discount.PRODUCT_ONE_COURSE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=60, course=course_3,
                               product=Discount.PRODUCT_ONE_COURSE)

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=None, course=course_1)
        self.assertEqual(all_curses_discounts, {'max_discount': None})
        self.assertEqual(len(discounts_for_courses), 1)
        self.assertEqual(discounts_for_courses[0], {'course': course_1.pk, 'max_discount': 30})

    def test_discount_for_one_course_with_multiple_users(self):
        user_1 = UserFactory.create()
        course_1 = CourseFactory.create()
        course_2 = CourseFactory.create()

        DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_COURSES)

        DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course_1,
                               product=Discount.PRODUCT_ONE_COURSE, client=user_1)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course_2,
                               product=Discount.PRODUCT_ONE_COURSE, client=user_1)

        DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course_1,
                               product=Discount.PRODUCT_ONE_COURSE, client=self.user)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course_2,
                               product=Discount.PRODUCT_ONE_COURSE, client=self.user)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, product=Discount.PRODUCT_ALL_COURSES,
                               client=self.user)

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=user_1,
                                                                                             course=course_1)
        self.assertEqual(all_curses_discounts, {'max_discount': 10})
        self.assertEqual(len(discounts_for_courses), 1)
        self.assertEqual(discounts_for_courses[0], {'course': course_1.pk, 'max_discount': 30})

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=self.user,
                                                                                             course=course_1)
        self.assertEqual(all_curses_discounts, {'max_discount': 50})
        self.assertEqual(len(discounts_for_courses), 1)
        self.assertEqual(discounts_for_courses[0], {'course': course_1.pk, 'max_discount': 30})

    def test_not_active_discount(self):
        DiscountFactory.create(end=now() + timedelta(days=5), value=60, product=Discount.PRODUCT_ALL_COURSES,
                               is_active=False)
        DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_COURSES)

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()

        self.assertEqual(all_curses_discounts, {'max_discount': 40})
        self.assertEqual(len(discounts_for_courses), 0)

    def test_old_discount(self):
        DiscountFactory.create(start=now() - timedelta(days=2), end=now() - timedelta(days=1), value=60,
                               product=Discount.PRODUCT_ALL_COURSES)
        DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_COURSES)

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()

        self.assertEqual(all_curses_discounts, {'max_discount': 40})
        self.assertEqual(len(discounts_for_courses), 0)

    def test_discount_from_the_future(self):
        DiscountFactory.create(start=now() + timedelta(days=2), end=now() + timedelta(days=3), value=60,
                               product=Discount.PRODUCT_ALL_COURSES)
        DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_COURSES)

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()

        self.assertEqual(all_curses_discounts, {'max_discount': 40})
        self.assertEqual(len(discounts_for_courses), 0)


class DiscountForPackagesModelTestCase(TestCase):

    def setUp(self):
        self.user = UserFactory.create()

    def test_discounts_for_packages_without_user(self):
        package_1 = PackageFactory.create()
        package_2 = PackageFactory.create()
        package_3 = PackageFactory.create()

        DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package_1,
                               product=Discount.PRODUCT_ONE_PACKAGE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package_2,
                               product=Discount.PRODUCT_ONE_PACKAGE)

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
        self.assertEqual(all_packages_discounts, {'max_discount': None})
        self.assertEqual(discounts_for_packages[0], {'package': package_1.pk, 'max_discount': 30})
        self.assertEqual(discounts_for_packages[1], {'package': package_2.pk, 'max_discount': 50})

    def test_greater_value_discount_without_user(self):
        package = PackageFactory.create()
        DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package,
                               product=Discount.PRODUCT_ONE_PACKAGE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package,
                               product=Discount.PRODUCT_ONE_PACKAGE)

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
        self.assertEqual(all_packages_discounts, {'max_discount': None})
        self.assertEqual(discounts_for_packages[0], {'package': package.pk, 'max_discount': 50})

    def test_exclude_personal_discounts_without_user(self):
        user_1 = UserFactory.create()
        package = PackageFactory.create()
        DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package,
                               product=Discount.PRODUCT_ONE_PACKAGE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package,
                               product=Discount.PRODUCT_ONE_PACKAGE, client=user_1)
        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
        self.assertEqual(all_packages_discounts, {'max_discount': None})
        self.assertEqual(discounts_for_packages[0], {'package': package.pk, 'max_discount': 30})

    def test_discount_for_one_package_and_all_packages(self):
        package = PackageFactory.create()
        DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package,
                               product=Discount.PRODUCT_ONE_PACKAGE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package,
                               product=Discount.PRODUCT_ONE_PACKAGE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_PACKAGES)

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
        self.assertEqual(all_packages_discounts, {'max_discount': 10})
        self.assertEqual(discounts_for_packages[0], {'package': package.pk, 'max_discount': 50})

    def test_personal_discounts(self):
        package = PackageFactory.create()
        DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package,
                               product=Discount.PRODUCT_ONE_PACKAGE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package,
                               product=Discount.PRODUCT_ONE_PACKAGE, client=self.user)
        DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_PACKAGES)

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=self.user)
        self.assertEqual(all_packages_discounts, {'max_discount': 10})
        self.assertEqual(discounts_for_packages[0], {'package': package.pk, 'max_discount': 50})

    def test_personal_discounts_multiple_users(self):
        user_1 = UserFactory()
        package = PackageFactory.create()
        DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package,
                               product=Discount.PRODUCT_ONE_PACKAGE, client=user_1)

        DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package,
                               product=Discount.PRODUCT_ONE_PACKAGE, client=self.user)
        DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_PACKAGES,
                               client=self.user)

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=self.user)
        self.assertEqual(all_packages_discounts, {'max_discount': 10})
        self.assertEqual(discounts_for_packages[0], {'package': package.pk, 'max_discount': 50})

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=user_1)
        self.assertEqual(all_packages_discounts, {'max_discount': None})
        self.assertEqual(discounts_for_packages[0], {'package': package.pk, 'max_discount': 30})

    def test_discount_for_one_package_without_user(self):
        package_1 = PackageFactory.create()
        package_2 = PackageFactory.create()
        package_3 = PackageFactory.create()

        DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package_1,
                               product=Discount.PRODUCT_ONE_PACKAGE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package_2,
                               product=Discount.PRODUCT_ONE_PACKAGE)
        DiscountFactory.create(end=now() + timedelta(days=5), value=60, package=package_3,
                               product=Discount.PRODUCT_ONE_PACKAGE)

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=None,
                                                                                                 package=package_1)
        self.assertEqual(all_packages_discounts, {'max_discount': None})
        self.assertEqual(len(discounts_for_packages), 1)
        self.assertEqual(discounts_for_packages[0], {'package': package_1.pk, 'max_discount': 30})

    def test_discount_for_one_package_with_multiple_users(self):
        user_1 = UserFactory.create()
        package_1 = PackageFactory.create()
        package_2 = PackageFactory.create()

        DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_PACKAGES)

        DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package_1,
                               product=Discount.PRODUCT_ONE_PACKAGE, client=user_1)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package_2,
                               product=Discount.PRODUCT_ONE_PACKAGE, client=user_1)

        DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package_1,
                               product=Discount.PRODUCT_ONE_PACKAGE, client=self.user)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package_2,
                               product=Discount.PRODUCT_ONE_PACKAGE, client=self.user)
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, product=Discount.PRODUCT_ALL_PACKAGES,
                               client=self.user)

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=user_1,
                                                                                                 package=package_1)
        self.assertEqual(all_packages_discounts, {'max_discount': 10})
        self.assertEqual(len(discounts_for_packages), 1)
        self.assertEqual(discounts_for_packages[0], {'package': package_1.pk, 'max_discount': 30})

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=self.user,
                                                                                                 package=package_1)
        self.assertEqual(all_packages_discounts, {'max_discount': 50})
        self.assertEqual(len(discounts_for_packages), 1)
        self.assertEqual(discounts_for_packages[0], {'package': package_1.pk, 'max_discount': 30})

    def test_not_active_discount(self):
        DiscountFactory.create(end=now() + timedelta(days=5), value=60, product=Discount.PRODUCT_ALL_PACKAGES,
                               is_active=False)
        DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_PACKAGES)

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()

        self.assertEqual(all_packages_discounts, {'max_discount': 40})
        self.assertEqual(len(discounts_for_packages), 0)

    def test_old_discount(self):
        DiscountFactory.create(start=now() - timedelta(days=2), end=now() - timedelta(days=1), value=60,
                               product=Discount.PRODUCT_ALL_PACKAGES)
        DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_PACKAGES)

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()

        self.assertEqual(all_packages_discounts, {'max_discount': 40})
        self.assertEqual(len(discounts_for_packages), 0)

    def test_discount_from_the_future(self):
        DiscountFactory.create(start=now() + timedelta(days=2), end=now() + timedelta(days=3), value=60,
                               product=Discount.PRODUCT_ALL_PACKAGES)
        DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_PACKAGES)

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()

        self.assertEqual(all_packages_discounts, {'max_discount': 40})
        self.assertEqual(len(discounts_for_packages), 0)