from datetime import timedelta
from decimal import Decimal

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, None)
        self.assertEqual(discounts_for_courses, {course_1.pk: 30, course_2.pk: 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, None)
        self.assertEqual(discounts_for_courses, {course.pk: 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, None)
        self.assertEqual(discounts_for_courses, {course.pk: 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, 10)
        self.assertEqual(discounts_for_courses, {course.pk: 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, 10)
        self.assertEqual(discounts_for_courses, {course.pk: 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, 10)
        self.assertEqual(discounts_for_courses, {course.pk: 50})

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=user_1)
        self.assertEqual(all_curses_discounts, None)
        self.assertEqual(discounts_for_courses, {course.pk: 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, None)
        self.assertEqual(len(discounts_for_courses), 1)
        self.assertEqual(discounts_for_courses, {course_1.pk: 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, 10)
        self.assertEqual(len(discounts_for_courses), 1)
        self.assertEqual(discounts_for_courses, {course_1.pk: 30})

        all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=self.user,
                                                                                             course=course_1)
        self.assertEqual(all_curses_discounts, 50)
        self.assertEqual(len(discounts_for_courses), 1)
        self.assertEqual(discounts_for_courses, {course_1.pk: 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, 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, 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, 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, None)
        self.assertEqual(discounts_for_packages, {package_1.pk: 30, package_2.pk: 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, None)
        self.assertEqual(discounts_for_packages, {package.pk: 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, None)
        self.assertEqual(discounts_for_packages, {package.pk: 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, 10)
        self.assertEqual(discounts_for_packages, {package.pk: 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, 10)
        self.assertEqual(discounts_for_packages, {package.pk: 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, 10)
        self.assertEqual(discounts_for_packages, {package.pk: 50})

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=user_1)
        self.assertEqual(all_packages_discounts, None)
        self.assertEqual(discounts_for_packages, {package.pk: 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, None)
        self.assertEqual(len(discounts_for_packages), 1)
        self.assertEqual(discounts_for_packages, {package_1.pk: 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, 10)
        self.assertEqual(len(discounts_for_packages), 1)
        self.assertEqual(discounts_for_packages, {package_1.pk: 30})

        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=self.user,
                                                                                                 package=package_1)
        self.assertEqual(all_packages_discounts, 50)
        self.assertEqual(len(discounts_for_packages), 1)
        self.assertEqual(discounts_for_packages, {package_1.pk: 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, 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, 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, 40)
        self.assertEqual(len(discounts_for_packages), 0)


class DiscountCalculateTestCase(TestCase):

    def test_discount_with_package(self):
        package = PackageFactory.create(price=Decimal('5000.5'))
        DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ONE_PACKAGE,
                               package=package)
        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
        value = Discount.get_price_with_discount(package.pk, package.price, discounts_for_packages,
                                                 all_packages_discounts)
        self.assertEqual(value, Decimal('3000.3'))

    def test_discount_with_package_discount_for_all(self):
        package = PackageFactory.create(price=Decimal('5000'))
        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()
        value = Discount.get_price_with_discount(package.pk, package.price, discounts_for_packages,
                                                 all_packages_discounts)
        self.assertEqual(value, Decimal('3000'))

    def test_discount_with_package_if_all_discount_gt_discount_package(self):
        package = PackageFactory.create(price=Decimal('5000'))
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, product=Discount.PRODUCT_ALL_PACKAGES)
        DiscountFactory.create(end=now() + timedelta(days=5), value=30, product=Discount.PRODUCT_ONE_PACKAGE,
                               package=package)
        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
        value = Discount.get_price_with_discount(package.pk, package.price, discounts_for_packages,
                                                 all_packages_discounts)
        self.assertEqual(value, Decimal('2500'))

    def test_discount_with_package_if_all_discount_lt_discount_package(self):
        package = PackageFactory.create(price=Decimal('5000'))
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, product=Discount.PRODUCT_ALL_PACKAGES)
        DiscountFactory.create(end=now() + timedelta(days=5), value=60, product=Discount.PRODUCT_ONE_PACKAGE,
                               package=package)
        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
        value = Discount.get_price_with_discount(package.pk, package.price, discounts_for_packages,
                                                 all_packages_discounts)
        self.assertEqual(value, Decimal('2000'))

    def test_discount_with_package_without_discount(self):
        package = PackageFactory.create(price=Decimal('5000'))
        all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
        value = Discount.get_price_with_discount(package.pk, package.price, discounts_for_packages,
                                                 all_packages_discounts)
        self.assertEqual(value, Decimal('5000'))

    def test_discount_with_course(self):
        course = CourseFactory.create(price=Decimal('5000.5'))
        DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ONE_COURSE,
                               course=course)
        all_courses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
        value = Discount.get_price_with_discount(course.pk, course.price, discounts_for_courses,
                                                 all_courses_discounts)
        self.assertEqual(value, Decimal('3000.3'))

    def test_discount_with_course_discount_for_all(self):
        course = CourseFactory.create(price=Decimal('5000'))
        DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_COURSES)
        all_courses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
        value = Discount.get_price_with_discount(course.pk, course.price, discounts_for_courses, all_courses_discounts)
        self.assertEqual(value, Decimal('3000'))

    def test_discount_with_course_if_all_discount_gt_discount_course(self):
        course = CourseFactory.create(price=Decimal('5000'))
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, product=Discount.PRODUCT_ALL_COURSES)
        DiscountFactory.create(end=now() + timedelta(days=5), value=30, product=Discount.PRODUCT_ONE_COURSE,
                               course=course)
        all_courses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
        value = Discount.get_price_with_discount(course.pk, course.price, discounts_for_courses,
                                                 all_courses_discounts)
        self.assertEqual(value, Decimal('2500'))

    def test_discount_with_course_if_all_discount_lt_discount_course(self):
        course = CourseFactory.create(price=Decimal('5000'))
        DiscountFactory.create(end=now() + timedelta(days=5), value=50, product=Discount.PRODUCT_ALL_COURSES)
        DiscountFactory.create(end=now() + timedelta(days=5), value=60, product=Discount.PRODUCT_ONE_COURSE,
                               course=course)
        all_courses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
        value = Discount.get_price_with_discount(course.pk, course.price, discounts_for_courses,
                                                 all_courses_discounts)
        self.assertEqual(value, Decimal('2000'))

    def test_discount_with_course_without_discount(self):
        course = CourseFactory.create(price=Decimal('5000'))
        all_courses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
        value = Discount.get_price_with_discount(course.pk, course.price, discounts_for_courses,
                                                 all_courses_discounts)
        self.assertEqual(value, Decimal('5000'))