# serializers.py - Complete fixed version with absolute URLs
from rest_framework import serializers
from .models import (
    User, Category, StreamerProfile, LiveStream, 
    Clip, PastStream, Follow, Earning, Gifter
)


class UserSerializer(serializers.ModelSerializer):
    followers_count = serializers.IntegerField(source='followers.count', read_only=True)
    following_count = serializers.IntegerField(source='following.count', read_only=True)
    
    class Meta:
        model = User
        fields = [
            'id', 'username', 'email', 'avatar', 'cover_image',
            'bio', 'is_verified', 'is_creator', 'location',
            'website', 'followers_count', 'following_count',
            'total_likes', 'total_views', 'date_joined'
        ]


class TopStreamerSerializer(serializers.ModelSerializer):
    name = serializers.CharField(source='user.username', read_only=True)
    avatar = serializers.SerializerMethodField()
    followers = serializers.SerializerMethodField()
    category = serializers.CharField(source='category.name', read_only=True)

    class Meta:
        model = StreamerProfile
        fields = [
            'id', 'name', 'avatar', 'followers', 'category',
            'is_live', 'viewers', 'rank', 'earnings'
        ]

    def get_avatar(self, obj):
        """Return absolute URL of the avatar image"""
        request = self.context.get('request')
        if obj.user.avatar and hasattr(obj.user.avatar, 'url'):
            if request:
                return request.build_absolute_uri(obj.user.avatar.url)
            return obj.user.avatar.url
        return None

    def get_followers(self, obj):
        return obj.user.followers.count()


class LiveStreamSerializer(serializers.ModelSerializer):
    streamer = serializers.CharField(source='streamer.username')
    avatar = serializers.SerializerMethodField()
    category_name = serializers.CharField(source='category.name', allow_null=True)
    
    class Meta:
        model = LiveStream
        fields = [
            'id', 'streamer', 'title', 'thumbnail', 'viewers',
            'category_name', 'avatar', 'tags', 'is_live', 'started_at'
        ]
    
    def get_avatar(self, obj):
        """Return absolute URL of the streamer's avatar"""
        request = self.context.get('request')
        if obj.streamer.avatar and hasattr(obj.streamer.avatar, 'url'):
            if request:
                return request.build_absolute_uri(obj.streamer.avatar.url)
            return obj.streamer.avatar.url
        return None


class ClipSerializer(serializers.ModelSerializer):
    streamer_name = serializers.CharField(source='streamer.username')
    
    class Meta:
        model = Clip
        fields = ['id', 'title', 'thumbnail', 'views', 'duration', 'created_at']


class TrendingClipSerializer(serializers.ModelSerializer):
    title = serializers.CharField()
    views = serializers.CharField()
    duration = serializers.CharField()
    
    class Meta:
        model = Clip
        fields = ['id', 'title', 'views', 'duration', 'thumbnail']


class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ['id', 'name', 'icon']


class AllStreamSerializer(serializers.ModelSerializer):
    streamer = serializers.CharField(source='streamer.username')
    avatar = serializers.SerializerMethodField()
    category_name = serializers.CharField(source='category.name', allow_null=True)
    
    class Meta:
        model = LiveStream
        fields = [
            'id', 'streamer', 'title', 'thumbnail', 'viewers',
            'category_name', 'avatar', 'tags', 'is_live', 'started_at'
        ]
    
    def get_avatar(self, obj):
        """Return absolute URL of the streamer's avatar"""
        request = self.context.get('request')
        if obj.streamer.avatar and hasattr(obj.streamer.avatar, 'url'):
            if request:
                return request.build_absolute_uri(obj.streamer.avatar.url)
            return obj.streamer.avatar.url
        return None


class CategoryListSerializer(serializers.ModelSerializer):
    stream_count = serializers.IntegerField(source='livestream_set.count', read_only=True)
    
    class Meta:
        model = Category
        fields = ['id', 'name', 'icon', 'stream_count']


class StreamerProfileSerializer(serializers.ModelSerializer):
    username = serializers.CharField(source='user.username')
    name = serializers.CharField(source='user.username')
    avatar = serializers.SerializerMethodField()
    cover_image = serializers.SerializerMethodField()
    bio = serializers.CharField(source='user.bio', allow_null=True)
    followers = serializers.CharField(source='followers_count')
    following = serializers.SerializerMethodField()
    total_likes = serializers.IntegerField(source='user.total_likes', read_only=True)
    total_views = serializers.IntegerField(source='user.total_views', read_only=True)
    is_live = serializers.BooleanField()
    current_viewers = serializers.CharField(source='viewers')
    join_date = serializers.DateTimeField(source='user.date_joined')
    location = serializers.CharField(source='user.location', allow_null=True)
    website = serializers.URLField(source='user.website', allow_null=True)
    categories = serializers.SerializerMethodField()
    
    class Meta:
        model = StreamerProfile
        fields = [
            'id', 'username', 'name', 'avatar', 'cover_image', 'bio',
            'followers', 'following', 'total_likes', 'total_views',
            'is_live', 'current_viewers', 'join_date', 'location',
            'website', 'categories', 'rank', 'earnings'
        ]
    
    def get_avatar(self, obj):
        """Return absolute URL of the user's avatar"""
        request = self.context.get('request')
        if obj.user.avatar and hasattr(obj.user.avatar, 'url'):
            if request:
                return request.build_absolute_uri(obj.user.avatar.url)
            return obj.user.avatar.url
        return None
    
    def get_cover_image(self, obj):
        """Return absolute URL of the user's cover image"""
        request = self.context.get('request')
        if obj.user.cover_image and hasattr(obj.user.cover_image, 'url'):
            if request:
                return request.build_absolute_uri(obj.user.cover_image.url)
            return obj.user.cover_image.url
        return None
    
    def get_following(self, obj):
        return obj.user.following.count()
    
    def get_categories(self, obj):
        categories = []
        if obj.category and obj.category.name:
            categories.append(obj.category.name)
        return categories


class StreamVideoSerializer(serializers.ModelSerializer):
    isLive = serializers.BooleanField(source='is_live')
    date = serializers.SerializerMethodField()
    duration = serializers.SerializerMethodField()
    
    class Meta:
        model = LiveStream
        fields = ['id', 'title', 'thumbnail', 'viewers', 'date', 'duration', 'isLive']
    
    def get_date(self, instance):
        from django.utils.timesince import timesince
        return f"{timesince(instance.started_at)} ago"
    
    def get_duration(self, instance):
        return "0:00:00"


class StreamerClipSerializer(serializers.ModelSerializer):
    date = serializers.SerializerMethodField()
    
    class Meta:
        model = Clip
        fields = ['id', 'title', 'thumbnail', 'views', 'duration', 'date']
    
    def get_date(self, instance):
        from django.utils.timesince import timesince
        return f"{timesince(instance.created_at)} ago"


class FollowerSerializer(serializers.ModelSerializer):
    name = serializers.CharField(source='follower.username')
    avatar = serializers.SerializerMethodField()
    is_live = serializers.SerializerMethodField()
    
    class Meta:
        model = Follow
        fields = ['id', 'name', 'avatar', 'is_live']
    
    def get_avatar(self, obj):
        """Return absolute URL of the follower's avatar"""
        request = self.context.get('request')
        if obj.follower.avatar and hasattr(obj.follower.avatar, 'url'):
            if request:
                return request.build_absolute_uri(obj.follower.avatar.url)
            return obj.follower.avatar.url
        return None
    
    def get_is_live(self, obj):
        return obj.follower.streams.filter(is_live=True).exists()


class FollowingSerializer(serializers.ModelSerializer):
    name = serializers.CharField(source='following.username')
    avatar = serializers.SerializerMethodField()
    is_live = serializers.SerializerMethodField()
    
    class Meta:
        model = Follow
        fields = ['id', 'name', 'avatar', 'is_live']
    
    def get_avatar(self, obj):
        """Return absolute URL of the following user's avatar"""
        request = self.context.get('request')
        if obj.following.avatar and hasattr(obj.following.avatar, 'url'):
            if request:
                return request.build_absolute_uri(obj.following.avatar.url)
            return obj.following.avatar.url
        return None
    
    def get_is_live(self, obj):
        return obj.following.streams.filter(is_live=True).exists()
    


# serializers.py - Add these serializers
# serializers.py - Add these authentication serializers

from rest_framework import serializers
from django.contrib.auth import authenticate, get_user_model
from django.contrib.auth.password_validation import validate_password
from .models import User, EmailVerification
import random

User = get_user_model()


class SendVerificationCodeSerializer(serializers.Serializer):
    email = serializers.EmailField(required=True)
    
    def validate_email(self, value):
        # Check if user already exists
        if User.objects.filter(email=value).exists():
            raise serializers.ValidationError("User with this email already exists")
        return value


class VerifyCodeSerializer(serializers.Serializer):
    email = serializers.EmailField(required=True)
    code = serializers.CharField(max_length=6, required=True)
    
    def validate(self, attrs):
        email = attrs.get('email')
        code = attrs.get('code')
        
        try:
            verification = EmailVerification.objects.get(email=email, code=code)
            if verification.is_expired():
                raise serializers.ValidationError({"code": "Verification code has expired"})
            if verification.is_verified:
                raise serializers.ValidationError({"code": "Code already used"})
        except EmailVerification.DoesNotExist:
            raise serializers.ValidationError({"code": "Invalid verification code"})
        
        return attrs


class RegisterSerializer(serializers.ModelSerializer):
    password = serializers.CharField(write_only=True, required=True, validators=[validate_password])
    confirm_password = serializers.CharField(write_only=True, required=True)
    
    class Meta:
        model = User
        fields = ('email', 'password', 'confirm_password')
    
    def validate(self, attrs):
        if attrs['password'] != attrs['confirm_password']:
            raise serializers.ValidationError({"confirm_password": "Password fields didn't match."})
        
        # Check if email already exists
        if User.objects.filter(email=attrs['email']).exists():
            raise serializers.ValidationError({"email": "User with this email already exists"})
        
        return attrs
    
    def create(self, validated_data):
        validated_data.pop('confirm_password')
        user = User.objects.create_user(
            username=validated_data['email'].split('@')[0],
            email=validated_data['email'],
            password=validated_data['password']
        )
        return user


class LoginSerializer(serializers.Serializer):
    email = serializers.EmailField(required=True)
    password = serializers.CharField(required=True, write_only=True)
    
    def validate(self, attrs):
        email = attrs.get('email')
        password = attrs.get('password')
        
        try:
            user = User.objects.get(email=email)
        except User.DoesNotExist:
            raise serializers.ValidationError("Invalid email or password")
        
        user = authenticate(username=user.username, password=password)
        
        if not user:
            raise serializers.ValidationError("Invalid email or password")
        
        if not user.is_active:
            raise serializers.ValidationError("This account is inactive")
        
        attrs['user'] = user
        return attrs


class UserDetailSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ('id', 'username', 'email', 'avatar', 'bio', 'is_verified', 'is_creator', 'date_joined')




# serializers.py - Add this serializer

class ClipListSerializer(serializers.ModelSerializer):
    streamer_name = serializers.CharField(source='streamer.username')
    streamer_avatar = serializers.SerializerMethodField()
    category_name = serializers.SerializerMethodField()
    formatted_duration = serializers.SerializerMethodField()
    formatted_date = serializers.SerializerMethodField()
    
    class Meta:
        model = Clip
        fields = [
            'id', 'title', 'thumbnail', 'views', 'duration', 'created_at',
            'streamer_name', 'streamer_avatar', 'category_name',
            'formatted_duration', 'formatted_date', 'likes', 'comments_count'
        ]
    
    def get_streamer_avatar(self, obj):
        if obj.streamer.avatar and hasattr(obj.streamer.avatar, 'url'):
            return obj.streamer.avatar.url
        return None
    
    def get_category_name(self, obj):
        # You can add a category field to Clip model or derive from stream
        return "General"
    
    def get_formatted_duration(self, obj):
        return obj.duration
    
    def get_formatted_date(self, obj):
        from django.utils.timesince import timesince
        return f"{timesince(obj.created_at)} ago"


class ClipCategorySerializer(serializers.ModelSerializer):
    clip_count = serializers.IntegerField(source='clip_set.count', read_only=True)
    
    class Meta:
        model = Category
        fields = ['id', 'name', 'icon', 'clip_count']