import uuid
from decimal import Decimal
from django.db import models
from django.db.models import F
from django.conf import settings
from django.utils import timezone
from django.utils.text import slugify
from django.core.validators import MinValueValidator


class SubscriptionPlan(models.Model):
    name = models.CharField(max_length=120)
    description = models.TextField(blank=True)
    price_cents = models.PositiveIntegerField(validators=[MinValueValidator(0)])
    currency = models.CharField(max_length=10, default="USD")
    duration_days = models.PositiveIntegerField(default=30)
    max_active_threads = models.PositiveIntegerField(default=20)
    max_message_credits = models.PositiveIntegerField(default=1000)
    is_active = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ["price_cents", "duration_days"]

    def __str__(self):
        return f"{self.name} ({self.currency} {self.price_cents / 100:.2f})"

    @property
    def price_amount(self):
        return self.price_cents / 100


class UserSubscription(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="subscriptions")
    plan = models.ForeignKey(SubscriptionPlan, on_delete=models.PROTECT, related_name="subscriptions")
    started_at = models.DateTimeField(default=timezone.now)
    expires_at = models.DateTimeField()
    is_active = models.BooleanField(default=True)
    auto_renew = models.BooleanField(default=False)
    payment_provider = models.CharField(max_length=64, blank=True)
    provider_subscription_id = models.CharField(max_length=128, blank=True)
    metadata = models.JSONField(default=dict, blank=True)

    class Meta:
        ordering = ["-started_at"]

    def __str__(self):
        return f"{self.user.username} subscription to {self.plan.name}"

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


class UserWallet(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="wallet")
    balance = models.BigIntegerField(default=0)
    is_locked = models.BooleanField(default=False)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        verbose_name = "Wallet"
        verbose_name_plural = "Wallets"

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit amount must be positive.")
        self.balance = F("balance") + amount
        self.save(update_fields=["balance"])
        self.refresh_from_db()

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive.")
        if self.balance < amount:
            raise ValueError("Insufficient wallet balance.")
        self.balance = F("balance") - amount
        self.save(update_fields=["balance"])
        self.refresh_from_db()

    def __str__(self):
        return f"{self.user.username} wallet"


class WalletTransaction(models.Model):
    class Type(models.TextChoices):
        DEPOSIT = "deposit", "Deposit"
        WITHDRAWAL = "withdrawal", "Withdrawal"

    class Provider(models.TextChoices):
        USDT = "usdt", "USDT"
        BTC = "btc", "BTC"
        BANK = "bank", "Bank Transfer"

    class Status(models.TextChoices):
        INITIATED = "initiated", "Initiated"
        PENDING = "pending", "Pending"
        COMPLETED = "completed", "Completed"
        FAILED = "failed", "Failed"

    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="wallet_transactions")
    transaction_type = models.CharField(max_length=16, choices=Type.choices)
    provider = models.CharField(max_length=16, choices=Provider.choices)
    amount = models.PositiveIntegerField(validators=[MinValueValidator(1)])
    currency = models.CharField(max_length=10, default="USD")
    status = models.CharField(max_length=16, choices=Status.choices, default=Status.INITIATED)
    reference = models.UUIDField(default=uuid.uuid4, unique=True, editable=False)
    metadata = models.JSONField(default=dict, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ["-created_at"]

    def __str__(self):
        return f"{self.user.username} wallet {self.transaction_type} {self.amount / 100:.2f} {self.provider}"

class InvestmentPlan(models.Model):
    name = models.CharField(max_length=120)
    description = models.TextField(blank=True)
    
    # Amount in dollars
    amount = models.DecimalField(
        max_digits=12, 
        decimal_places=2, 
        validators=[MinValueValidator(Decimal("0.01"))]
    )
    currency = models.CharField(max_length=10, default="USD")
    duration_days = models.PositiveIntegerField()
    profit_percent = models.DecimalField(max_digits=5, decimal_places=2)
    is_active = models.BooleanField(default=True)
    
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ["amount", "duration_days"]

    def __str__(self):
        return f"{self.name} ({self.currency} {self.amount})"

    @property
    def profit_amount(self):
        """Profit in dollars"""
        return (self.amount * self.profit_percent / Decimal("100")).quantize(Decimal("0.01"))

    @property
    def payout_amount(self):
        """Total payout (capital + profit) in dollars"""
        return self.amount + self.profit_amount


class Investment(models.Model):
    class Status(models.TextChoices):
        ACTIVE = "active", "Active"
        COMPLETED = "completed", "Completed"
        CANCELLED = "cancelled", "Cancelled"

    user = models.ForeignKey(
        settings.AUTH_USER_MODEL, 
        on_delete=models.CASCADE, 
        related_name="investments"
    )
    plan = models.ForeignKey(
        InvestmentPlan, 
        on_delete=models.PROTECT, 
        related_name="investments"
    )
    
    started_at = models.DateTimeField(default=timezone.now)
    ends_at = models.DateTimeField()
    status = models.CharField(
        max_length=32, 
        choices=Status.choices, 
        default=Status.ACTIVE
    )

    # All values in dollars
    amount = models.DecimalField(
        max_digits=12, 
        decimal_places=2, 
        validators=[MinValueValidator(Decimal("0.01"))]
    )
    profit = models.DecimalField(
        max_digits=12, 
        decimal_places=2, 
        validators=[MinValueValidator(Decimal("0.00"))]
    )
    payout = models.DecimalField(
        max_digits=12, 
        decimal_places=2, 
        validators=[MinValueValidator(Decimal("0.01"))]
    )

    is_withdrawn = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ["-started_at"]

    def __str__(self):
        return f"{self.user.username} investment in {self.plan.name}"

    @property
    def is_mature(self):
        return timezone.now() >= self.ends_at

    def mark_completed(self):
        self.status = self.Status.COMPLETED
        self.save(update_fields=["status", "updated_at"])
        
class WithdrawalRequest(models.Model):
    class Status(models.TextChoices):
        PENDING = "pending", "Pending"
        APPROVED = "approved", "Approved"
        REJECTED = "rejected", "Rejected"

    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="withdrawal_requests")
    amount = models.PositiveIntegerField(validators=[MinValueValidator(0)])
    currency = models.CharField(max_length=10, default="USD")
    provider = models.CharField(max_length=64, default="bank")
    status = models.CharField(max_length=32, choices=Status.choices, default=Status.PENDING)
    reference = models.CharField(max_length=128, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    processed_at = models.DateTimeField(null=True, blank=True)

    class Meta:
        ordering = ["-created_at"]

    def __str__(self):
        return f"Withdrawal {self.user.username} {self.amount / 100:.2f} {self.currency}"


class ReferralBonus(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="referral_bonuses")
    referred_user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="referral_sources")
    investment = models.ForeignKey('Investment', null=True, blank=True, on_delete=models.SET_NULL)
    bonus_cents = models.PositiveIntegerField(validators=[MinValueValidator(0)])
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ["-created_at"]

    def __str__(self):
        return f"Referral bonus for {self.user.username} from {self.referred_user.username}"


class PaymentTransaction(models.Model):
    class Status(models.TextChoices):
        INITIATED = "initiated", "Initiated"
        PENDING = "pending", "Pending"
        COMPLETED = "completed", "Completed"
        FAILED = "failed", "Failed"
        CANCELLED = "cancelled", "Cancelled"

    class Provider(models.TextChoices):
        STRIPE = "stripe", "Stripe"
        PAYSTACK = "paystack", "Paystack"
        FLUTTERWAVE = "flutterwave", "Flutterwave"
        BTC = "btc", "Bitcoin"
        USDT = "usdt", "USDT"

    user = models.ForeignKey(
        settings.AUTH_USER_MODEL, 
        on_delete=models.CASCADE, 
        related_name="payment_transactions"
    )
    plan = models.ForeignKey(
        SubscriptionPlan, 
        on_delete=models.PROTECT, 
        related_name="payments"
    )
    provider = models.CharField(max_length=32, choices=Provider.choices)
    reference = models.UUIDField(default=uuid.uuid4, unique=True, editable=False)
    provider_payment_id = models.CharField(max_length=128, blank=True)
    
    # Store amount in dollars
    amount = models.DecimalField(
        max_digits=12, 
        decimal_places=2,
        validators=[MinValueValidator(Decimal("0.01"))]
    )
    currency = models.CharField(max_length=10, default="USD")
    
    status = models.CharField(
        max_length=32, 
        choices=Status.choices, 
        default=Status.INITIATED
    )
    redirect_url = models.URLField(blank=True)
    metadata = models.JSONField(default=dict, blank=True)
    
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ["-created_at"]

    def __str__(self):
        return f"{self.user.username} {self.provider} payment for {self.plan.name}"

    @property
    def is_successful(self):
        return self.status == self.Status.COMPLETED

    def mark_completed(self, provider_payment_id=None, metadata=None):
        self.status = self.Status.COMPLETED
        if provider_payment_id:
            self.provider_payment_id = provider_payment_id
        if metadata:
            self.metadata = {**self.metadata, **metadata}
        self.save(update_fields=["status", "provider_payment_id", "metadata", "updated_at"])

    def mark_failed(self, metadata=None):
        self.status = self.Status.FAILED
        if metadata:
            self.metadata.update(metadata)
        self.save(update_fields=["status", "metadata", "updated_at"])

class Notification(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="notifications")
    actor = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True, on_delete=models.SET_NULL, related_name="sent_notifications")
    verb = models.CharField(max_length=220)
    target_url = models.CharField(max_length=260, blank=True)
    data = models.JSONField(default=dict, blank=True)
    unread = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ["-created_at"]

    def __str__(self):
        return f"Notification for {self.user.username}: {self.verb}"


def create_notification(user, actor=None, verb="", target_url="", data=None):
    if data is None:
        data = {}
    return Notification.objects.create(
        user=user,
        actor=actor,
        verb=verb,
        target_url=target_url,
        data=data,
    )


class ConnectionRequest(models.Model):
    class Status(models.TextChoices):
        PENDING = "pending", "Pending"
        ACCEPTED = "accepted", "Accepted"
        DECLINED = "declined", "Declined"
        BLOCKED = "blocked", "Blocked"

    from_user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="sent_connection_requests")
    to_user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="received_connection_requests")
    status = models.CharField(max_length=32, choices=Status.choices, default=Status.PENDING)
    message = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    responded_at = models.DateTimeField(null=True, blank=True)

    class Meta:
        constraints = [
        models.UniqueConstraint(fields=["from_user", "to_user"], name="unique_connection_request")
    ]
        ordering = ["-created_at"]

    def __str__(self):
        return f"{self.from_user.username} → {self.to_user.username} ({self.status})"


class MessageThread(models.Model):
    participants = models.ManyToManyField(settings.AUTH_USER_MODEL, related_name="threads")
    title = models.CharField(max_length=220, blank=True)
    is_private = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    last_message_at = models.DateTimeField(null=True, blank=True)

    class Meta:
        ordering = ["-last_message_at", "-updated_at"]

    def __str__(self):
        participants = self.participants.all()
        return self.title or ", ".join(user.username for user in participants[:2])

    def update_last_message(self, timestamp=None):
        self.last_message_at = timestamp or timezone.now()
        self.save(update_fields=["last_message_at"])


class Message(models.Model):
    class Status(models.TextChoices):
        SENT = "sent", "Sent"
        DELIVERED = "delivered", "Delivered"
        READ = "read", "Read"
        DELETED = "deleted", "Deleted"

    thread = models.ForeignKey(MessageThread, on_delete=models.CASCADE, related_name="messages")
    sender = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="sent_messages")
    body = models.TextField(blank=True)
    attachment = models.FileField(upload_to="messages/attachments/", null=True, blank=True)
    status = models.CharField(max_length=32, choices=Status.choices, default=Status.SENT)
    is_system = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    read_at = models.DateTimeField(null=True, blank=True)

    class Meta:
        ordering = ["created_at"]

    def __str__(self):
        return f"Message from {self.sender.username} in {self.thread_id}"

    def mark_read(self):
        if not self.read_at:
            self.read_at = timezone.now()
            self.status = self.Status.READ
            self.save(update_fields=["read_at", "status"])
            self.thread.update_last_message(self.read_at)


class PaidContent(models.Model):
    author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="paid_contents")
    title = models.CharField(max_length=220)
    summary = models.TextField(blank=True)
    body = models.TextField()
    price_cents = models.PositiveIntegerField(validators=[MinValueValidator(0)])
    currency = models.CharField(max_length=10, default="USD")
    is_published = models.BooleanField(default=False)
    is_featured = models.BooleanField(default=False)
    max_access_count = models.PositiveIntegerField(null=True, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ["-created_at"]

    def __str__(self):
        return self.title


class ContentPurchase(models.Model):
    buyer = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="content_purchases")
    content = models.ForeignKey(PaidContent, on_delete=models.CASCADE, related_name="purchases")
    purchased_at = models.DateTimeField(auto_now_add=True)
    price_cents = models.PositiveIntegerField(validators=[MinValueValidator(0)])
    currency = models.CharField(max_length=10, default="USD")
    access_expires_at = models.DateTimeField(null=True, blank=True)
    metadata = models.JSONField(default=dict, blank=True)

    class Meta:
        constraints = [
        models.UniqueConstraint(fields=["buyer", "content"], name="unique_content_purchase")
    ]

        ordering = ["-purchased_at"]

    def __str__(self):
        return f"{self.buyer.username} bought {self.content.title}"

    @property
    def is_active(self):
        if self.access_expires_at:
            return timezone.now() < self.access_expires_at
        return True


class UserReport(models.Model):
    class Status(models.TextChoices):
        NEW = "new", "New"
        REVIEWING = "reviewing", "Reviewing"
        RESOLVED = "resolved", "Resolved"
        REJECTED = "rejected", "Rejected"

    reporter = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="reports_made")
    reported_user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="reports_received")
    reason = models.CharField(max_length=220)
    details = models.TextField(blank=True)
    status = models.CharField(max_length=32, choices=Status.choices, default=Status.NEW)
    created_at = models.DateTimeField(auto_now_add=True)
    reviewed_at = models.DateTimeField(null=True, blank=True)
    review_notes = models.TextField(blank=True)

    class Meta:
        ordering = ["-created_at"]

    def __str__(self):
        return f"Report by {self.reporter.username} against {self.reported_user.username}"


class CreatorMedia(models.Model):
    class MediaType(models.TextChoices):
        IMAGE = "image", "Image"
        VIDEO = "video", "Video"

    class Category(models.TextChoices):
        BEAUTIFUL_GAILS = "beautiful_gails", "Beautiful Gails"
        HANDSOME_BOYS = "handsome_boys", "Handsome Boys"
        PREMIUM_CREW = "premium_crew", "Premium Crew"
        FEATURED_COLLECTION = "featured_collection", "Featured Collection"

    creator = models.ForeignKey("users.Profile", on_delete=models.CASCADE, related_name="media_items")
    title = models.CharField(max_length=180, blank=True)
    description = models.TextField(blank=True)
    category = models.CharField(max_length=64, choices=Category.choices, default=Category.FEATURED_COLLECTION)
    media_type = models.CharField(max_length=16, choices=MediaType.choices, default=MediaType.IMAGE)
    media_file = models.FileField(upload_to="profile_media/")
    is_active = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ["-created_at"]

    def __str__(self):
        return f"{self.creator} media {self.title or self.get_media_type_display()}"

    @property
    def is_video(self):
        return self.media_type == self.MediaType.VIDEO


class ProfileFollow(models.Model):
    follower = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="following_profiles")
    profile = models.ForeignKey("users.Profile", on_delete=models.CASCADE, related_name="followers")
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        
        constraints = [models.UniqueConstraint(fields=["follower", "profile"], name="unique_connection_profile_follow")]
        ordering = ["-created_at"]

    def __str__(self):
        return f"{self.follower.username} follows {self.profile.user.username}"


class MediaLike(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="media_likes")
    media_item = models.ForeignKey(CreatorMedia, on_delete=models.CASCADE, related_name="likes")
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        constraints = [models.UniqueConstraint(fields=["user", "media_item"], name="unique_connection_media_like")]
        ordering = ["-created_at"]

    def __str__(self):
        return f"{self.user.username} likes {self.media_item}"


class BookingRequest(models.Model):
    class Status(models.TextChoices):
        PENDING = "pending", "Pending"
        CONFIRMED = "confirmed", "Confirmed"
        DECLINED = "declined", "Declined"
        CANCELLED = "cancelled", "Cancelled"

    requester = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="booking_requests")
    profile = models.ForeignKey("users.Profile", on_delete=models.CASCADE, related_name="booking_requests")
    preferred_date = models.DateField(null=True, blank=True)
    message = models.TextField(blank=True)
    status = models.CharField(max_length=32, choices=Status.choices, default=Status.PENDING)
    company_notes = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ["-created_at"]

    def __str__(self):
        return f"Booking request for {self.profile.user.username} by {self.requester.username}"


class MediaReaction(models.Model):
    class Type(models.TextChoices):
        LIKE = "like", "Like"
        LOVE = "love", "Love"
        LAUGH = "laugh", "Laugh"
        FIRE = "fire", "Fire"

    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    media_item = models.ForeignKey("CreatorMedia", on_delete=models.CASCADE, related_name="reactions")
    type = models.CharField(max_length=10, choices=Type.choices, default=Type.LIKE)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        constraints = [models.UniqueConstraint(fields=["user", "media_item"], name="unique_connection_media_reaction")]
        
class MediaBookmark(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    media_item = models.ForeignKey("CreatorMedia", on_delete=models.CASCADE, related_name="bookmarks")
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        constraints = [models.UniqueConstraint(fields=["user", "media_item"], name="unique_connection_media_bookmark")]
        
class MediaComment(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    media_item = models.ForeignKey("CreatorMedia", on_delete=models.CASCADE, related_name="comments")
    body = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ["-created_at"]        


class ChatMessage(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='chat_messages')
    message = models.TextField()
    is_from_support = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        ordering = ['created_at']
    
    def __str__(self):
        return f"{self.user.username}: {self.message[:50]}"
    

class PaymentGateway(models.Model):
    class Provider(models.TextChoices):
        STRIPE = "stripe", "Stripe"
        PAYSTACK = "paystack", "Paystack"
        FLUTTERWAVE = "flutterwave", "Flutterwave"
        BTC = "btc", "Bitcoin"
        USDT = "usdt", "USDT (TRC20)"
        BANK = "bank", "Bank Transfer"
        MANUAL = "manual", "Manual / Offline"

    class Status(models.TextChoices):
        ACTIVE = "active", "Active"
        INACTIVE = "inactive", "Inactive"
        MAINTENANCE = "maintenance", "Under Maintenance"

    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    name = models.CharField(max_length=100)
    provider = models.CharField(max_length=32, choices=Provider.choices, unique=True)
    status = models.CharField(max_length=20, choices=Status.choices, default=Status.ACTIVE)
    
    # Display
    logo = models.ImageField(upload_to="gateways/", blank=True, null=True)
    description = models.TextField(blank=True)
    display_order = models.PositiveIntegerField(default=10)
    
    # Configuration
    public_key = models.CharField(max_length=255, blank=True)
    secret_key = models.CharField(max_length=255, blank=True)
    webhook_secret = models.CharField(max_length=255, blank=True)
    is_test_mode = models.BooleanField(default=True)
    
    # Limits & Fees (in Dollars)
    min_amount = models.DecimalField(
        max_digits=12, 
        decimal_places=2, 
        default=Decimal("1.00"),
        validators=[MinValueValidator(Decimal("0.01"))]
    )
    max_amount = models.DecimalField(
        max_digits=12, 
        decimal_places=2, 
        null=True, 
        blank=True
    )
    fixed_fee = models.DecimalField(
        max_digits=10, 
        decimal_places=2, 
        default=Decimal("0.00")
    )
    percentage_fee = models.DecimalField(
        max_digits=5, 
        decimal_places=2, 
        default=Decimal("0.00")
    )
    
    # Extra config
    config = models.JSONField(default=dict, blank=True)
    
    # Meta
    is_active = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ["display_order", "name"]
        verbose_name = "Payment Gateway"
        verbose_name_plural = "Payment Gateways"

    def __str__(self):
        return f"{self.name} ({self.get_provider_display()})"

    @property
    def is_available(self):
        return self.is_active and self.status == self.Status.ACTIVE

    def calculate_fee(self, amount: Decimal) -> Decimal:
        """Calculate fee based on amount in dollars"""
        percentage = (amount * self.percentage_fee) / Decimal("100")
        return self.fixed_fee + percentage



class EntertainmentBrand(models.Model):
    class Category(models.TextChoices):
        MUSIC = "music", "Music"
        FILM = "film", "Film & TV"
        SPORTS = "sports", "Sports"
        FASHION = "fashion", "Fashion"
        GAMING = "gaming", "Gaming"
        LIFESTYLE = "lifestyle", "Lifestyle"
        MEDIA = "media", "Media & Publishing"
        OTHER = "other", "Other"

    class Status(models.TextChoices):
        TRUSTED = "trusted", "Trusted"
        PENDING = "pending", "Pending Review"
        SUSPENDED = "suspended", "Suspended"
        REJECTED = "rejected", "Rejected"

    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    
    # Basic Info
    name = models.CharField(max_length=150)
    slug = models.SlugField(max_length=160, unique=True, blank=True)
    logo = models.ImageField(upload_to="brands/logos/", blank=True, null=True)
    website = models.URLField(blank=True)
    description = models.TextField(blank=True)
    
    # Classification
    category = models.CharField(max_length=30, choices=Category.choices, default=Category.OTHER)
    status = models.CharField(max_length=20, choices=Status.choices, default=Status.PENDING)
    
    # Trust & Verification
    is_verified = models.BooleanField(default=False)
    is_featured = models.BooleanField(default=False)
    trust_score = models.PositiveIntegerField(default=0, help_text="0 - 100")
    
    # Contact
    contact_email = models.EmailField(blank=True)
    contact_phone = models.CharField(max_length=30, blank=True)
    
    # Social Links
    instagram = models.URLField(blank=True)
    twitter = models.URLField(blank=True)
    youtube = models.URLField(blank=True)
    linkedin = models.URLField(blank=True)
    
    # Meta
    notes = models.TextField(blank=True, help_text="Internal notes for admins")
    display_order = models.PositiveIntegerField(default=10)
    is_active = models.BooleanField(default=True)
    
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    verified_at = models.DateTimeField(null=True, blank=True)

    class Meta:
        ordering = ["display_order", "name"]
        verbose_name = "Entertainment Brand"
        verbose_name_plural = "Entertainment Brands"

    def __str__(self):
        return self.name

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.name)
        super().save(*args, **kwargs)

    @property
    def is_trusted(self):
        return self.status == self.Status.TRUSTED and self.is_verified
    
class BrandPartnership(models.Model):
    class PartnershipType(models.TextChoices):
        ENDORSEMENT = "endorsement", "Endorsement"
        SPONSORSHIP = "sponsorship", "Sponsorship"
        COLLABORATION = "collaboration", "Collaboration"
        AMBASSADOR = "ambassador", "Brand Ambassador"

    brand = models.ForeignKey(EntertainmentBrand, on_delete=models.CASCADE, related_name="partnerships")
    celebrity = models.ForeignKey("users.Profile", on_delete=models.CASCADE, related_name="brand_partnerships")
    
    partnership_type = models.CharField(max_length=30, choices=PartnershipType.choices)
    start_date = models.DateField(null=True, blank=True)
    end_date = models.DateField(null=True, blank=True)
    is_active = models.BooleanField(default=True)
    notes = models.TextField(blank=True)
    
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ("brand", "celebrity", "partnership_type")
        ordering = ["-created_at"]

    def __str__(self):
        return f"{self.celebrity} × {self.brand} ({self.get_partnership_type_display()})"