from django.db import models
from django.utils.text import slugify
import uuid
from django.utils import timezone
import random
from datetime import timedelta
class ProductCategory(models.Model):
    name = models.CharField(max_length=1500)

    is_active = models.BooleanField(default=True)

    parent = models.ForeignKey(
        'self',
        on_delete=models.CASCADE,
        null=True,
        blank=True,
        related_name='children'
    )

    def __str__(self):
        return self.name

def product_video_upload_path(instance, filename):
    return f'media/products/{instance.id}/videos/{filename}'

def product_image_upload_path(instance, filename):
    return f'media/products/{instance.product.id}/images/{filename}'

class Product(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    product_name = models.CharField(max_length=1500)

    rating = models.FloatField(default=0.0, editable=False)

    category = models.ForeignKey(ProductCategory, on_delete=models.CASCADE)
    description = models.TextField(max_length=10000)
    video = models.FileField(
        upload_to=product_video_upload_path,
        null=True,
        blank=True,
        max_length=1500
    )

    key_highlights = models.JSONField(default=list, blank=True)
    specifications = models.JSONField(default=dict, blank=True)
    sizes = models.JSONField(default=list, blank=True)
    colors = models.JSONField(default=list, blank=True)

    is_featured = models.BooleanField(default=False)
    is_arrival = models.BooleanField(default=False)
    is_special_offer = models.BooleanField(default=False)
    special_discount_percentage = models.IntegerField(null=True, blank=True)

    is_featured_store = models.BooleanField(default=False)
    is_arrival_store = models.BooleanField(default=False)
    is_special_offer_store = models.BooleanField(default=False)
    special_discount_percentage_store = models.IntegerField(null=True, blank=True)

    is_stock = models.BooleanField(default=True)
    is_draft = models.BooleanField(default=False)
    is_active = models.BooleanField(default=True)

    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"{self.product_name}-{self.category.name}-{uid}"
            self.id = slugify(base_slug)

        super().save(*args, **kwargs)

    def __str__(self):
        return self.product_name
        


class BlogHero(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)

    title = models.CharField(max_length=1500)
    subtitle = models.TextField(blank=True, null=True)

    badge_text = models.CharField(
        max_length=1500,
        default="Inspiring Stories"
    )

    hero_image = models.ImageField(
        upload_to='media/blog-hero/'
    )

    is_active = models.BooleanField(default=True)

    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            self.id = slugify(f"blog-hero-{uid}")

        super().save(*args, **kwargs)

    def __str__(self):
        return self.title



class AboutHero(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)

    title = models.CharField(max_length=1500)
    subtitle = models.TextField(blank=True, null=True)

    badge_text = models.CharField(
        max_length=1500,
        default="About Us"
    )

    hero_image = models.ImageField(
        upload_to='media/about-hero/'
    )

    is_active = models.BooleanField(default=True)

    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            self.id = slugify(f"about-hero-{uid}")

        super().save(*args, **kwargs)

    def __str__(self):
        return self.title




class TestimonialHero(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)

    title = models.CharField(max_length=500)
    subtitle = models.TextField(blank=True, null=True)

    badge_text = models.CharField(
        max_length=1500,
        default="Testimonials"
    )

    hero_image = models.ImageField(
        upload_to='media/testimonial-hero/'
    )

    is_active = models.BooleanField(default=True)

    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            self.id = slugify(f"testimonial-hero-{uid}")

        super().save(*args, **kwargs)

    def __str__(self):
        return self.title

class product_seo(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE, related_name='seo')
    meta_description = models.CharField(max_length=1600, blank=True)
    meta_keywords = models.CharField(max_length=5000, blank=True)
    og_title = models.CharField(max_length=600, blank=True)
    og_description = models.CharField(max_length=1600, blank=True)
    og_image = models.URLField(blank=True)
    twitter_card = models.CharField(max_length=200, default="summary_large_image")
    twitter_title = models.CharField(max_length=600, blank=True)
    twitter_description = models.CharField(max_length=1600, blank=True)
    twitter_image = models.URLField(blank=True)
    canonical_url = models.URLField(blank=True)
    robots_tag = models.CharField(max_length=5000, default="index, follow")
    structured_data = models.JSONField(default=dict, blank=True)
    focus_keyword = models.CharField(max_length=1000, blank=True)
    
from django.db.models import Avg


class Platform(models.Model):
    product = models.ForeignKey(
        Product,
        on_delete=models.CASCADE,
        related_name="platforms"
    )
    name = models.CharField(max_length=500)
    url = models.URLField()
    price = models.DecimalField(
        max_digits=10,
        decimal_places=2,
        default=100.00
    )
    rating = models.FloatField(default=0.0)
    is_active = models.BooleanField(default=True)

    def save(self, *args, **kwargs):
        super().save(*args, **kwargs)

        average_rating = self.product.platforms.filter(
            is_active=True
        ).aggregate(
            avg_rating=Avg("rating")
        )["avg_rating"] or 0

        Product.objects.filter(
            pk=self.product_id
        ).update(
            rating=round(average_rating, 1)
        )

    def delete(self, *args, **kwargs):
        product_id = self.product_id

        super().delete(*args, **kwargs)

        average_rating = Platform.objects.filter(
            product_id=product_id,
            is_active=True
        ).aggregate(
            avg_rating=Avg("rating")
        )["avg_rating"] or 0

        Product.objects.filter(
            pk=product_id
        ).update(
            rating=round(average_rating, 1)
        )

    def __str__(self):
        return self.name
    
class ProductImage(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    product = models.ForeignKey(Product, on_delete=models.CASCADE, related_name='images')
    image = models.ImageField(
    upload_to=product_image_upload_path,
    max_length=1500
)
    is_active = models.BooleanField(default=True)
    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"{self.product.product_name}-image-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)
    
    def __str__(self):
        return self.product.product_name


class ProductClick(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    product = models.ForeignKey(Product, on_delete=models.CASCADE, related_name='clicks')
    clicked_on = models.DateField(auto_now_add=True)
    
    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"{self.product.product_name}-click-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)

    def __str__(self):
        return f"{self.product.product_name} - {self.clicked_on}"
    

class MarketplaceClick(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    platform = models.ForeignKey(Platform, on_delete=models.CASCADE, related_name='marketplace_clicks')
    clicked_on = models.DateField(auto_now_add=True)
    
    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:10]
            base_slug = f"{self.platform.name}-click-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)

    def __str__(self):
        return f"{self.platform.product.product_name} - {self.platform.name} - {self.clicked_on}"



class Tag(models.Model):
    tag = models.CharField(max_length=1000)
    created_on = models.DateTimeField(auto_now_add=True)
    is_active = models.BooleanField(default=True) 

    def __str__(self):
        return self.tag



class Blog(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    tag = models.ForeignKey(Tag, on_delete=models.CASCADE, related_name="blogs")
    title = models.CharField(max_length=5000)
    author = models.CharField(max_length=1000)
    description = models.TextField()
    meta_title = models.CharField(max_length=600, blank=True)
    meta_description = models.CharField(max_length=1600, blank=True)
    meta_keywords = models.CharField(max_length=5000, blank=True)
    og_title = models.CharField(max_length=600, blank=True)
    og_description = models.CharField(max_length=1600, blank=True)
    og_image = models.URLField(blank=True)
    twitter_card = models.CharField(max_length=200, default="summary_large_image")
    twitter_title = models.CharField(max_length=600, blank=True)
    twitter_description = models.CharField(max_length=1600, blank=True)
    twitter_image = models.URLField(blank=True)
    canonical_url = models.URLField(blank=True)
    robots_tag = models.CharField(max_length=500, default="index, follow")
    structured_data = models.JSONField(default=dict, blank=True)
    focus_keyword = models.CharField(max_length=1000, blank=True)
    
    posted_on = models.DateTimeField(auto_now_add=True)
    likes = models.IntegerField(default=0)
    publish = models.BooleanField(default=False)

    active = models.BooleanField(default=True)  

 
    image = models.ImageField(
        upload_to='blog_manager/blogs/',
        null=True,
        blank=True
    )

    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"{self.title}-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)
    
    def __str__(self):
        return self.title

class BlogPageViewEvent(models.Model):

    blog = models.ForeignKey(
        Blog,
        on_delete=models.CASCADE,
        related_name="page_view_events"
    )

    ip_address = models.GenericIPAddressField(
        null=True,
        blank=True
    )

    user_agent = models.TextField(
        blank=True,
        default=""
    )

    source = models.CharField(
        max_length=500,
        blank=True,
        default=""
    )

    viewed_at = models.DateTimeField(
        auto_now_add=True
    )

    class Meta:
        indexes = [
            models.Index(
                fields=[
                    "blog",
                    "ip_address",
                    "viewed_at"
                ]
            ),
        ]

    def __str__(self):
        return (
            f"{self.blog.title} - "
            f"{self.source} - "
            f"{self.viewed_at}"
        )

class BlogLikes(models.Model):
    blog = models.ForeignKey(Blog, on_delete=models.CASCADE, related_name='bloglikes')
    liked_on = models.DateTimeField(auto_now_add=True)


class Testimonial(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    name = models.CharField(max_length=1000)
    avatar_url = models.FileField(upload_to='testimonial/', null=True, blank=True)  
    product_name = models.CharField(max_length=1000, blank=True, null=True)
    rating_value = models.FloatField()              
    rating_stars = models.IntegerField()                
    description = models.TextField()
    posted_on = models.DateTimeField(auto_now_add=True)
    active = models.BooleanField(default=True)
    photos = models.JSONField(default=list, blank=True)   
    videos = models.JSONField(default=list, blank=True)
    order = models.PositiveIntegerField(
        default=0,
        unique=True,
        db_index=True
    )

    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"{self.name}-{self.product_name}-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)
    
    def __str__(self):
        return self.name
    
class NewsletterSubscriber(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    source = models.CharField(max_length=1000, blank=True, null=True)
    email = models.EmailField(blank=True, null=True)
    ip_address = models.GenericIPAddressField(null=True, blank=True)
    city = models.CharField(max_length=1000, null=True, blank=True)
    country = models.CharField(max_length=1000, null=True, blank=True)
    user_agent = models.TextField(null=True, blank=True)

    mobile_number = models.CharField(max_length=20, null=True, blank=True)
    subscriber_type = models.CharField(max_length=20, default='email')  
    subscribed_on = models.DateTimeField(auto_now_add=True)
    status = models.CharField(max_length=20, default='subscribed')  
    unsubscribe_on = models.DateTimeField(
        null=True,
        blank=True
    )
    
    email_verified = models.BooleanField(default=False)
    
    is_active = models.BooleanField(default=True)

    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"{self.email}-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)
    
    def __str__(self):
        return self.email

import uuid
from datetime import timedelta
from django.db import models
from django.utils import timezone


class NewsletterOTP(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)

    email = models.EmailField()

    otp = models.CharField(max_length=6)

    created_at = models.DateTimeField(auto_now_add=True)

    expires_at = models.DateTimeField()

    verified = models.BooleanField(default=False)

    def save(self, *args, **kwargs):
        if not self.expires_at:
            self.expires_at = timezone.now() + timedelta(minutes=10)
        super().save(*args, **kwargs)

class ContactMessage(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    customer_name = models.CharField(max_length=1000)
    email = models.EmailField(blank=True, null=True)
    mobile_number = models.CharField(max_length=20, blank=True, null=True)
    inquiry_type = models.CharField(max_length=1000)
    message = models.TextField()
    submitted_on = models.DateTimeField(auto_now_add=True)
    is_active = models.BooleanField(default=True)
    
    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"{self.customer_name}-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)
    
    def __str__(self):
        return self.customer_name
    
class MessagesToSubscribers(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    subject = models.CharField(max_length=5000)
    content = models.TextField()
    attachment = models.FileField(upload_to='subscriber_messages/attachments/', null=True, blank=True)
    sent_on = models.DateTimeField(auto_now_add=True)

    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"{self.subject}-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)
    
    def __str__(self):
        return self.subject
    
class CollectionList(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    name = models.CharField(max_length=5000)
    image = models.ImageField(upload_to='media/collection-list/')
    product_type = models.CharField(max_length=5000)
    is_active = models.BooleanField(default=True)
    
    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"{self.name}-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)

class BandStory(models.Model):
    heading = models.CharField(max_length=5000)
    tag = models.CharField(max_length=500)
    wall_image = models.ImageField(upload_to='media/band-story/')
    image_instance = models.ForeignKey(CollectionList, on_delete=models.SET_NULL, null=True, blank=True)
    youtube_url = models.URLField(blank=True)
    is_active = models.BooleanField(default=True)

class MarketplaceLink(models.Model):
    name = models.CharField(max_length=5000)
    logo = models.ImageField(upload_to='media/marketplace-logos/',blank=True, null=True)
    url = models.URLField()
    place = models.CharField(max_length=5000, blank=True)
    is_featured = models.BooleanField(default=False)
    is_active = models.BooleanField(default=True)

class Instagramgallery(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    title = models.CharField(max_length=5000)
    image = models.ImageField(upload_to='media/instagram-gallery/')
    insta_url = models.URLField(blank=True)
    
    place = models.CharField(max_length=5000, blank=True)
    is_active = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"{self.title}-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)

class Herobanner(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)

    title = models.CharField(max_length=5000, blank=True)
    subtitle = models.CharField(max_length=5000, blank=True)

    
    hero_image = models.ImageField(
        upload_to='media/hero-banners/desktop/'
    )

    
    mobile_image = models.ImageField(
        upload_to='media/hero-banners/mobile/',
        null=True,
        blank=True
    )

    place = models.CharField(max_length=5000, blank=True)

    is_active = models.BooleanField(default=True)

    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            self.id = slugify(f"hero-banner-{uid}")
        super().save(*args, **kwargs)

    def __str__(self):
        return f"Hero Banner - {self.place}"

class Promises(models.Model):
    title = models.CharField(max_length=5000)
    slogan = models.TextField()
    icon = models.ImageField(upload_to='media/promises/')
    is_active = models.BooleanField(default=True)
    updated_at = models.DateTimeField(auto_now=True)

class Lead(models.Model):
    email = models.EmailField()
    phone = models.CharField(max_length=15, null=True, blank=True)
    whatsapp_number = models.CharField(max_length=15, null=True, blank=True)

    source = models.CharField(max_length=50)
    coupon = models.CharField(max_length=50,blank=True,null=True)
    
    ip_address = models.GenericIPAddressField(null=True, blank=True)
    user_agent = models.TextField(null=True, blank=True)
    city = models.CharField(max_length=100, null=True, blank=True)
    country = models.CharField(max_length=100, null=True, blank=True)

    created_at = models.DateTimeField(auto_now_add=True)
    

class LeadOTP(models.Model):
    email = models.EmailField(db_index=True)

    otp = models.CharField(max_length=6)

    
    lead_data = models.JSONField()

    is_verified = models.BooleanField(default=False)

    created_at = models.DateTimeField(auto_now_add=True)
    expires_at = models.DateTimeField()

    attempts = models.PositiveIntegerField(default=0)

    def save(self, *args, **kwargs):
        if not self.otp:
            self.otp = str(random.randint(100000, 999999))

        if not self.expires_at:
            self.expires_at = timezone.now() + timedelta(minutes=5)

        super().save(*args, **kwargs)

    @property
    def is_expired(self):
        return timezone.now() > self.expires_at


class DescriptionAboutUs(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    title = models.CharField(max_length=500)
    content = models.TextField()
    photo = models.ImageField(upload_to='media/about-us/')
    is_active = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"{self.title}-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)
    
class TeamMember(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    name = models.CharField(max_length=500)
    role = models.CharField(max_length=5000)
    member_photo = models.ImageField(upload_to='media/team-members/')
    about = models.TextField()
    is_active = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"{self.name}-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)

class Factors(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)
    photo = models.ImageField(upload_to='media/factors/')
    factors_value = models.JSONField(default=list, blank=True)
    is_active = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            base_slug = f"factors-{uid}"
            self.id = slugify(base_slug)
        super().save(*args, **kwargs)


class LogoText(models.Model):
    text = models.CharField(max_length=200)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.text  
class Satisfied_Customer(models.Model):
    cust_count = models.CharField(max_length=5)

class ContactInfo(models.Model):
    address = models.CharField(max_length=500)
    mobile = models.CharField(max_length=13)
    email = models.EmailField()
class SocialLinks(models.Model):
    platform = models.CharField(max_length=500)
    account_link = models.URLField(blank=True, null=True)
    
    def __str__(self):
        return self.platform
class Widget(models.Model):
    name = models.CharField(max_length=1000, unique=True)
    data = models.JSONField(default=list)

    def __str__(self):
        return self.name

class Traffic(models.Model):
    date = models.DateField(auto_now_add=True)
    ip_address = models.GenericIPAddressField(null=True, blank=True)
    user_agent = models.TextField(null=True, blank=True)

    def __str__(self):
        return str(self.date)


class Permission(models.Model):
    module = models.CharField(max_length=50)
    action = models.CharField(max_length=50)

    def __str__(self):
        return f"{self.module} - {self.action}"

class Role(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField()
    permissions = models.ManyToManyField(Permission, blank=True)

    def __str__(self):
        return self.name
        


def admin_avatar_upload_path(instance, filename):
    
    ext = filename.split('.')[-1]
    new_filename = f"{uuid.uuid4().hex}.{ext}"
    return f'admin_avatars/{new_filename}'

from django.contrib.auth.models import AbstractUser

class AdminUser(AbstractUser):
    role = models.ForeignKey(Role, on_delete=models.SET_NULL, null=True, blank=True)
    is_super_admin = models.BooleanField(default=False)
    avatar = models.ImageField(upload_to=admin_avatar_upload_path, null=True, blank=True)
    forgot_otp = models.CharField(
        max_length=6,
        null=True,
        blank=True
    )

    otp_verified = models.BooleanField(
        default=False
    )
    last_active = models.DateTimeField(blank=True, null=True)






from django.db import models
from django.contrib.auth.models import User


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

    coupon_code = models.CharField(
        max_length=50,
        unique=True
    )

    offer_value = models.CharField(
        max_length=500,
        default="10% OFF"
    )

    def __str__(self):
        return self.name



class Chat(models.Model):
    sender = models.ForeignKey(AdminUser, on_delete=models.CASCADE, related_name='sent_messages')
    receiver = models.ForeignKey(AdminUser, on_delete=models.CASCADE, related_name='received_messages')

    message = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    is_read = models.BooleanField(default=False) 
    def __str__(self):
        return f"{self.sender} -> {self.receiver}"
    




class ModalSetting(models.Model):
    STRATEGY_CHOICES = [
        ('WELCOME', 'Welcome Modal'),
        ('EXIT', 'Exit Intent Modal'),
        ('WHATSAPP', 'WhatsApp Modal'),
        ('PRODUCT_ENGAGEMENT', 'Product Engagement Offer Modal'),
        ('PUSH', 'Push Notification'),
    ]

    TRIGGER_CHOICES = [
        ('page_load', 'On Page Load'),
        ('exit_intent', 'On Exit Intent'),
        ('delay', 'After Delay'),
        ('product_engagement', 'On Product Engagement'),
    ]

    strategy = models.CharField(
        max_length=3000,
        choices=STRATEGY_CHOICES,
        unique=True
    )

    is_enabled = models.BooleanField(default=False)

    trigger_type = models.CharField(
        max_length=30,
        choices=TRIGGER_CHOICES,
        default='page_load'
    )

    delay_seconds = models.PositiveIntegerField(default=5)

    show_once_per_session = models.BooleanField(default=True)

    coupon = models.ForeignKey(
        'Coupon',
        on_delete=models.SET_NULL,
        null=True,
        blank=True
    )

    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        status = "Enabled" if self.is_enabled else "Disabled"
        return f"{self.get_strategy_display()} - {status}"
        
class GroupChatMessage(models.Model):
    sender = models.ForeignKey('AdminUser', on_delete=models.CASCADE, related_name='sent_group_messages')
    message = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ['created_at']

    def __str__(self):
        return f"{self.sender.username}: {self.message[:20]}"

class GroupChatReadStatus(models.Model):
    user = models.OneToOneField('AdminUser', on_delete=models.CASCADE, related_name='group_chat_status')
    last_read_time = models.DateTimeField(default=timezone.now)

    def __str__(self):
        return f"{self.user.username} last read at {self.last_read_time}"
        
        
        
class HeaderLogo(models.Model):
    image = models.ImageField(upload_to='header_logos/')
    link = models.URLField(blank=True, null=True)
    order = models.PositiveSmallIntegerField(default=0)
    is_active = models.BooleanField(default=True)

    class Meta:
        ordering = ['order']

    def __str__(self):
        return f"Header Logo {self.order}"
    


class PageSEO(models.Model):
    PAGE_CHOICES = [
        ('home', 'Home'),
        ('store', 'Store'),
        ('about', 'About Us'),
        ('contact', 'Contact'),
        ('blog', 'Blog'),
        ('reviews', 'Testimonials'),
    ]
    page = models.CharField(max_length=20, choices=PAGE_CHOICES, unique=True)
    meta_title = models.CharField(max_length=60, blank=True)
    meta_description = models.CharField(max_length=160, blank=True)
    meta_keywords = models.CharField(max_length=500, blank=True)
    og_title = models.CharField(max_length=60, blank=True)
    og_description = models.CharField(max_length=160, blank=True)
    og_image = models.URLField(blank=True)
    twitter_card = models.CharField(max_length=20, default='summary_large_image')
    twitter_title = models.CharField(max_length=60, blank=True)
    twitter_description = models.CharField(max_length=160, blank=True)
    twitter_image = models.URLField(blank=True)
    canonical_url = models.URLField(blank=True)
    robots_tag = models.CharField(max_length=50, default='index, follow')
    updated_at = models.DateTimeField(auto_now=True)
    
    def __str__(self):
        return f'SEO for {self.get_page_display()}'




class AboutCoreValue(models.Model):
    id = models.SlugField(primary_key=True, blank=True, max_length=1000)

    section_title = models.CharField(
        max_length=500,
        default="Our Core Values"
    )

    section_subtitle = models.TextField(
        default="The principles that guide everything we do"
    )

    title = models.CharField(max_length=500)

    description = models.TextField()

    icon_image = models.ImageField(
        upload_to='media/about-core-values/'
    )

    order = models.IntegerField(default=0)

    is_active = models.BooleanField(default=True)

    created_at = models.DateTimeField(auto_now_add=True)

    updated_at = models.DateTimeField(auto_now=True)

    def save(self, *args, **kwargs):
        if not self.id:
            uid = str(uuid.uuid4())[:8]
            self.id = slugify(f"core-value-{uid}")

        super().save(*args, **kwargs)

    def __str__(self):
        return self.title
        
        
        
        
        
        
        
        
        
        
        
        
        
        

class BlogAnalytics(models.Model):
    blog = models.ForeignKey(Blog, on_delete=models.CASCADE, related_name='analytics')
    date = models.DateField(auto_now_add=True)
    total_views = models.PositiveIntegerField(default=0)
    unique_visitors = models.PositiveIntegerField(default=0)
    total_read_time_seconds = models.PositiveIntegerField(default=0)  
    bounce_count = models.PositiveIntegerField(default=0)  
    scroll_depth_25 = models.PositiveIntegerField(default=0)
    scroll_depth_50 = models.PositiveIntegerField(default=0)
    scroll_depth_75 = models.PositiveIntegerField(default=0)
    scroll_depth_100 = models.PositiveIntegerField(default=0)

    class Meta:
        unique_together = ('blog', 'date')

    def avg_read_time(self):
        if self.total_views == 0:
            return 0
        return self.total_read_time_seconds / self.total_views

class BlogUniqueVisitor(models.Model):
    blog = models.ForeignKey(
        Blog,
        on_delete=models.CASCADE,
        related_name="unique_visitors_log"
    )

    date = models.DateField()

    ip_address = models.GenericIPAddressField()

    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ("blog", "date", "ip_address")

class BlogScrollSession(models.Model):
    blog = models.ForeignKey(
        Blog,
        on_delete=models.CASCADE,
        related_name="scroll_sessions"
    )

    date = models.DateField()

    ip_address = models.GenericIPAddressField()

    max_scroll = models.PositiveSmallIntegerField(default=0)

    read_time_seconds = models.PositiveIntegerField(default=0)

    created_at = models.DateTimeField(auto_now_add=True)

    updated_at = models.DateTimeField(auto_now=True)


class BlogTrafficSource(models.Model):

    SOURCE_CHOICES = [
        ("google", "Google"),
        ("instagram", "Instagram"),
        ("facebook", "Facebook"),
        ("whatsapp", "WhatsApp"),
        ("youtube", "YouTube"),
        ("linkedin", "LinkedIn"),
        ("twitter", "Twitter"),
        ("telegram", "Telegram"),
        ("referral", "Referral"),
        ("direct", "Direct"),
    ]

    blog = models.ForeignKey(
        Blog,
        on_delete=models.CASCADE,
        related_name="traffic_sources"
    )

    source = models.CharField(
        max_length=20,
        choices=SOURCE_CHOICES
    )

    count = models.PositiveIntegerField(default=0)

    date = models.DateField(
        auto_now_add=True
    )

    class Meta:
        unique_together = ("blog", "source", "date")

    def __str__(self):
        return f"{self.blog.title} - {self.source} - {self.date}"

class BlogProductClick(models.Model):
    blog = models.ForeignKey(Blog, on_delete=models.CASCADE, related_name='product_clicks')
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    click_count = models.PositiveIntegerField(default=0)
    date = models.DateField(auto_now_add=True)

    class Meta:
        unique_together = ('blog', 'product', 'date')

class BlogMarketplaceClick(models.Model):
    blog = models.ForeignKey(Blog, on_delete=models.CASCADE, related_name='marketplace_clicks')
    platform = models.ForeignKey(Platform, on_delete=models.CASCADE)
    click_count = models.PositiveIntegerField(default=0)
    date = models.DateField(auto_now_add=True)

    class Meta:
        unique_together = ('blog', 'platform', 'date')
        
        
        
        
        
        


class SubscriberTag(models.Model):
    name = models.CharField(max_length=50, unique=True)
    color = models.CharField(max_length=7, default="#B68A5D")  
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.name

class SubscriberTagAssignment(models.Model):
    subscriber = models.ForeignKey(NewsletterSubscriber, on_delete=models.CASCADE, related_name='tags')
    tag = models.ForeignKey(SubscriberTag, on_delete=models.CASCADE)
    assigned_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ('subscriber', 'tag')



class EmailCampaign(models.Model):

    STATUS_CHOICES = [
        ('sent', 'Sent'),
        ('failed', 'Failed'),
    ]

    RECIPIENT_TYPE_CHOICES = [
        ('all', 'All Subscribers'),
        ('tags', 'Segment by Tags'),
        ('segment', 'Segment'),
        ('selected', 'Selected Subscribers'),
    ]

    subject = models.CharField(max_length=5000)

    content = models.TextField()

    attachment = models.FileField(
        upload_to='campaign_attachments/',
        null=True,
        blank=True
    )
    recipient_tags = models.ManyToManyField(
        SubscriberTag,
        blank=True,
        related_name="email_campaigns"
    )
    recipient_type = models.CharField(
        max_length=200,
        choices=RECIPIENT_TYPE_CHOICES,
        default='all'
    )

    recipient_sources = models.JSONField(
        default=list,
        blank=True
    )

    selected_subscribers = models.ManyToManyField(
        NewsletterSubscriber,
        blank=True,
        related_name='email_campaigns'
    )

    recipient_count = models.PositiveIntegerField(default=0)

    status = models.CharField(
        max_length=20,
        choices=STATUS_CHOICES,
        default='draft'
    )
    draft = models.CharField(max_length=2000,default='sent')
    sent_at = models.DateTimeField(null=True, blank=True)
    removed = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    total_opens = models.PositiveIntegerField(default=0)
    unique_opens = models.PositiveIntegerField(default=0)
    total_clicks = models.PositiveIntegerField(default=0)
    unique_clicks = models.PositiveIntegerField(default=0)
    unsubscribe_count = models.PositiveIntegerField(default=0)
    bounce_count = models.PositiveIntegerField(default=0)

    def __str__(self):
        return self.subject

class EmailTrackingEvent(models.Model):
    EVENT_TYPES = [
        ("gmail_proxy", "Gmail Proxy"),
        ("apple_proxy", "Apple Mail Privacy"),
        ("outlook_proxy", "Outlook Proxy"),
        ("open", "Verified Open"),
        ("click", "Click"),
        ("unsubscribe", "Unsubscribe"),
        ("bounce", "Bounce"),
        ("sent", "Sent")
    ]
    campaign = models.ForeignKey(EmailCampaign, on_delete=models.CASCADE, related_name='events')
    subscriber = models.ForeignKey(NewsletterSubscriber, on_delete=models.CASCADE, null=True, blank=True)
    event_type = models.CharField(max_length=200, choices=EVENT_TYPES)
    user_agent = models.TextField(blank=True, null=True)
    ip_address = models.GenericIPAddressField(null=True, blank=True)
    city = models.CharField(max_length=100, blank=True, null=True)
    country = models.CharField(max_length=100, blank=True, null=True)
    device_type = models.CharField(max_length=20, blank=True, null=True)  # mobile, desktop, tablet
    clicked_url = models.URLField(blank=True, null=True)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        indexes = [
            models.Index(fields=['campaign', 'event_type']),
            models.Index(fields=['subscriber', 'campaign']),
        ]
        
        
        
        


class ActiveVisitor(models.Model):
    session_id = models.CharField(max_length=1000, unique=True)

    ip_address = models.GenericIPAddressField(null=True, blank=True)

    email = models.EmailField(null=True, blank=True)

    city = models.CharField(max_length=1000, null=True, blank=True)
    country = models.CharField(max_length=1000, null=True, blank=True)

    user_agent = models.TextField(blank=True, null=True)

    last_active = models.DateTimeField(auto_now=True)
    first_seen = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"{self.ip_address} - {self.email or 'anonymous'} - last {self.last_active}"
        
        



class SubscriberSegment(models.Model):

    CONDITION_CHOICES = (
        ('AND', 'AND'),
        ('OR', 'OR')
    )

    name = models.CharField(max_length=2000)

    filters = models.JSONField(default=dict)

    condition = models.CharField(
        max_length=1000,
        choices=CONDITION_CHOICES,
        default='AND'
    )

    auto_update = models.BooleanField(default=True)

    created_at = models.DateTimeField(auto_now_add=True)
    
    



class CampaignEvent(models.Model):

    EVENTS = (
        ('open','open'),
        ('click','click'),
        ('bounce','bounce'),
        ('unsubscribe','unsubscribe')
    )

    campaign = models.ForeignKey(
    EmailCampaign,
    on_delete=models.CASCADE,
    related_name='campaign_events'
)

    subscriber = models.ForeignKey(
        NewsletterSubscriber,
        on_delete=models.CASCADE,
        null=True
    )

    event_type = models.CharField(
        max_length=200,
        choices=EVENTS
    )

    device_type = models.CharField(
        max_length=50,
        blank=True
    )

    ip_address = models.CharField(
        max_length=100,
        blank=True
    )

    clicked_url = models.URLField(
        blank=True,
        null=True
    )

    created_at = models.DateTimeField(
        auto_now_add=True
    )


from django.db import models


class ModalSettingsUI(models.Model):
    modal = models.OneToOneField(
        "ModalSetting",
        on_delete=models.CASCADE,
        related_name="ui_settings"
    )

    title = models.CharField(max_length=5000)

    subtitle = models.TextField(blank=True)

    cta_button_text = models.CharField(
        max_length=1000,
        default="Get Started"
    )

    background_image = models.ImageField(
        upload_to="modal/backgrounds/",
        blank=True,
        null=True
    )

    
    background_color = models.CharField(
        max_length=7,
        default="#FFFFFF"
    )

    title_color = models.CharField(
        max_length=7,
        default="#000000"
    )

    subtitle_color = models.CharField(
        max_length=7,
        default="#666666"
    )

    
    cta_button_background_color = models.CharField(
        max_length=7,
        default="#007BFF"
    )

    cta_button_text_color = models.CharField(
        max_length=7,
        default="#FFFFFF"
    )

    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        return f"{self.modal.get_strategy_display()} UI"
        
class SearchQuery(models.Model):
    query = models.CharField(max_length=5000)
    normalized_query = models.CharField(max_length=500, blank=True)

    result_count = models.PositiveIntegerField(default=0)

    selected_product = models.ForeignKey(
        Product,
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='search_selections'
    )

    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        indexes = [
            models.Index(fields=['normalized_query']),
            models.Index(fields=['created_at']),
        ]

    def __str__(self):
        return self.query
        
class privecy(models.Model):
    pdf = models.FileField(
        upload_to='privecy/',
        null=True,
        blank=True
    )

    def __str__(self):
        return "Privacy Policy"


class terms(models.Model):
    pdf = models.FileField(
        upload_to='terms/',
        null=True,
        blank=True
    )

    def __str__(self):
        return "Terms & Conditions"
        
class Watch_Buy(models.Model):
    LOCATION_CHOICES = [
        ('homepage', 'Homepage'),
        ('store', 'Store'),
    ]

    product = models.ForeignKey(
        Product,
        on_delete=models.CASCADE,
        unique=True
    )

    video = models.FileField(
        upload_to="watchbuy/"
    )

    price = models.DecimalField(
        max_digits=10,
        decimal_places=2,
        default=0.00
    )

    location = models.CharField(
        max_length=20,
        choices=LOCATION_CHOICES,
        default='homepage'
    )

    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        return f"{self.product.name} - ₹{self.price}"
    
class Our_Journey(models.Model):
    title = models.CharField(max_length=500)
    subtitle = models.TextField()
    logo = models.ImageField(
        upload_to='journey_logo/'
    )