from django.contrib.auth.models import User
from django.db import models
from django.utils.text import slugify
from django.db.models.signals import pre_save
from datetime import datetime
from dateutil.relativedelta import relativedelta

import random

# Create your models here.
class Categories(models.Model):
    icon = models.CharField(max_length=200, null=True)
    name = models.CharField(max_length=200)

    def __str__(self):
        return self.name

    def get_all_category(self):
        return Categories.objects.all().order_by('id')


class Author(models.Model):
    author_profile = models.ImageField(upload_to='Media/author')
    name = models.CharField(max_length=100, null=True)
    about_author = models.TextField()

    def __str__(self):
        return self.name

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    avatar = models.ImageField(upload_to='Media/student', null=True)
    about_user = models.TextField(blank=True, null=True)

    def __str__(self):
        return self.user.first_name


class Level(models.Model):
    name = models.CharField(max_length=100)

    def __str__(self):
        return self.name

class Language(models.Model):
    language = models.CharField(max_length=100)

    def __str__(self):
        return self.language

class Course(models.Model):
    STATUS = (
        ('PUBLISH', 'PUBLISH'),
        ('DRAFT', 'DRAFT'),
    )

    featured_image = models.ImageField(upload_to="Media/featured_img",null=True)
    featured_video = models.CharField(max_length=300,null=True)
    title = models.CharField(max_length=500)
    created_at = models.DateField(auto_now_add=True)
    author = models.ForeignKey(Author,on_delete=models.CASCADE,null=True)
    category = models.ForeignKey(Categories,on_delete=models.CASCADE)
    level = models.ForeignKey(Level, on_delete=models.CASCADE, null=True)
    description = models.TextField()
    price = models.IntegerField(null=True,default=0)
    discount = models.IntegerField(null=True)
    language = models.ForeignKey(Language, on_delete=models.CASCADE, null=True) 
    Deadline = models.CharField(max_length=100, null=True)
    slug = models.SlugField(default='', max_length=500, null=True, blank=True)
    status = models.CharField(choices=STATUS,max_length=100,null=True)
    Certificate = models.CharField(max_length = 100, null=True)


    def __str__(self):
        return self.title


    def get_absolute_url(self):
        from django.urls import reverse
        return reverse("course_details", kwargs={'slug': self.slug})

    
def create_slug(instance, new_slug=None):
    slug = slugify(instance.title)
    if new_slug is not None:
        slug = new_slug
    qs = Course.objects.filter(slug=slug).order_by('-id')
    exists = qs.exists()
    if exists:
        new_slug = "%s-%s" % (slug, qs.first().id)
        return create_slug(instance, new_slug=new_slug)
    return slug


def pre_save_post_receiver(sender, instance, *args, **kwargs):
    if not instance.slug:
        instance.slug = create_slug(instance)

pre_save.connect(pre_save_post_receiver, Course)

class What_you_learn(models.Model):
    course = models.ForeignKey(Course, on_delete=models.CASCADE)
    points = models.CharField(max_length=500)

    def __str__(self):
        return self.points

class Requirements(models.Model):
    cuorse = models.ForeignKey(Course, on_delete=models.CASCADE)
    points = models.CharField(max_length=500)

    def __str__(self):
        return self.points

class Lesson(models.Model):
    course = models.ForeignKey(Course, on_delete=models.CASCADE)
    name = models.CharField(max_length=200)

    def __str__(self):
        return self.name + " - " + self.course.title


class video(models.Model):
    serial_number = models.IntegerField(null=True)
    thumbnail = models.ImageField(upload_to="Media/Yt_Thumbnail", null=True)
    course = models.ForeignKey(Course, on_delete=models.CASCADE)
    lesson = models.ForeignKey(Lesson, on_delete=models.CASCADE)
    title = models.CharField(max_length=100)
    youtube_id = models.CharField(max_length=200)
    file = models.FileField(upload_to="Media/course_file", blank=True, null=True)
    time_duration = models.IntegerField(null=True)
    preview = models.BooleanField(default=False)

    def __str__(self):
        return self.lesson.name + " - " + self.course.title


class UserCourse(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    course = models.ForeignKey(Course, on_delete=models.CASCADE)
    paid = models.BooleanField(default=0)
    date = models.DateTimeField(auto_now_add=True)


    def __str__(self):
        return self.user.first_name + " - " + self.course.title


class Subscription(models.Model):
	user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='subscription')
	start_date = models.DateTimeField()
	end_date = models.DateTimeField()

	def __str__(self):
		return f"{self.user.username}'s Subscription"

	def extend_subscription(self, months=0, years=0):
		self.end_date += relativedelta(months=months, years=years)
		self.save()


class Application(models.Model):
    TYPE_CHOICES = [
        ('type_1', '1 Year'),
        ('type_2', '3 Years'),
        ('type_3', '5 Years'),
    ]
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='applications')  # Allows multiple applications per user
    application_type = models.CharField(max_length=10, choices=TYPE_CHOICES, default='type_1')
    name = models.CharField(max_length=150)
    amount = models.DecimalField(max_digits=10, decimal_places=2)
    tran_id = models.CharField(max_length=15, unique=True)
    is_approved = models.BooleanField(default=False)
    tran_date = models.DateTimeField(auto_now_add=True)
    currency = models.CharField(max_length=10)
    created_at = models.DateTimeField(auto_now_add=True, null=True)
    
    def save(self, *args, **kwargs):
        if not self.tran_id:
            self.tran_id = self.generate_unique_tran_id()
        super().save(*args, **kwargs)

    def generate_unique_tran_id(self):
        prefix = "ELCMA"
        while True:
            random_part = ''.join(random.choices('0123456789', k=5))
            tran_id = f"{prefix}{random_part}"
            if not Application.objects.filter(tran_id=tran_id).exists():
                return tran_id

    def __str__(self):
        return f"{self.user.first_name}'s Application"



class Review(models.Model):
    RATING_CHOICES = [
        (1, '1 Star'),
        (1.5, '1.5 Stars'),
        (2, '2 Stars'),
        (2.5, '2.5 Stars'),
        (3, '3 Stars'),
        (3.5, '3.5 Stars'),
        (4, '4 Stars'),
        (4.5, '4.5 Stars'),
        (5, '5 Stars'),
    ]

    user = models.ForeignKey(User, on_delete=models.CASCADE)
    course = models.ForeignKey(Course, on_delete=models.CASCADE)
    rating = models.FloatField(choices=RATING_CHOICES)
    review_title = models.CharField(max_length=255)
    review_content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f'{self.review_title} - {self.course.title}'