from requests import Response
from rest_framework import serializers
from rest_framework_simplejwt.serializers import TokenObtainPairSerializer
from .models import UserAccount

from .models import Agent, UserAccount, UserProfile, Organization, Invitation, VerificationDiscount

class UserPhoneUpdateSerializer(serializers.Serializer):
    phone = serializers.CharField(required=True, max_length=15)

class MessageSerializer(serializers.Serializer):
    sender = serializers.IntegerField()
    recipient = serializers.IntegerField()
    message = serializers.CharField()
    # Add other fields as needed

    def to_representation(self, instance):
        return {
            'sender': instance.sender.id,
            'recipient': instance.recipient.id,
            'message': instance.message,
            # Add other fields as needed
        }
class UserAccountSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    email = serializers.CharField()
    # Add other fields as needed

    def to_representation(self, instance):
        return {
            'id': instance.id,
            'email': instance.email,
            # Add other fields as needed
        }

class UserProfileSerializer(serializers.ModelSerializer):
    class Meta:
        model = UserProfile
        fields = ['id', 'skype_link', 'facebook_link', 'linkedin_link', 'title', 'website', 'twitter', 'pinterest', 'description']

class UserProfilePictureSerializer(serializers.ModelSerializer):
    class Meta:
        model = UserAccount
        fields = ['profile_picture']
# class ConversationSerializer(serializers.ModelSerializer):
#     class Meta:
#         model = Conversation
#         fields = '__all__'

from rest_framework import serializers
from .models import Wallet, Subscription, SubscriptionPackage

class WalletSerializer(serializers.ModelSerializer):
    class Meta:
        model = Wallet
        fields = ['id', 'user', 'balance']
        read_only_fields = ['user']



class SubscriptionPackageSerializer(serializers.ModelSerializer):
    verification_discount = serializers.SerializerMethodField()

    class Meta:
        model = SubscriptionPackage
        fields = '__all__'  # This includes all model fields + the extra below

    def get_verification_discount(self, obj):
        # If there's a related verification discount, return its details
        discount = getattr(obj, 'verification_discount', None)
        if discount:
            return {
                'discount_type': discount.discount_type,
                'discount_value': str(discount.discount_value),
            }
        return None

class SubscriptionSerializer(serializers.ModelSerializer):
    is_active = serializers.SerializerMethodField()
    package = SubscriptionPackageSerializer(read_only=True)  
    verification_discount = serializers.SerializerMethodField()  # <-- NEW FIELD

    class Meta:
        model = Subscription
        fields = '__all__'
        read_only_fields = ['user', 'subscription_date', 'expiry_date']

    def get_is_active(self, obj):
        return obj.is_active()
    
    def get_verification_discount(self, obj):
        """
        Returns the discount info for the associated subscription package, if any.
        """
        try:
            discount = obj.package.verification_discount
            return {
                "discount_type": discount.discount_type,
                "discount_value": str(discount.discount_value),
            }
        except VerificationDiscount.DoesNotExist:
            return None

from .models import WalletTransaction

class WalletTransactionSerializer(serializers.ModelSerializer):
    class Meta:
        model = WalletTransaction
        fields = ['id', 'user', 'amount', 'transaction_type', 'purpose', 'timestamp']
        read_only_fields = ['user', 'timestamp']

from .models import StripeRecharge

class StripeRechargeSerializer(serializers.ModelSerializer):
    class Meta:
        model = StripeRecharge
        fields = '__all__'
        read_only_fields = ['user', 'success']

from .models import PayPalRecharge

class PayPalRechargeSerializer(serializers.ModelSerializer):
    class Meta:
        model = PayPalRecharge
        fields = '__all__'
        read_only_fields = ['user', 'success', 'created_at']

class AgentSerializer(serializers.ModelSerializer):
    full_name = serializers.CharField(source='user.full_name', read_only=True)
    email = serializers.CharField(source='user.email', read_only=True)
    phone = serializers.CharField(source='user.phone', read_only=True)
    is_verified = serializers.BooleanField(source='profile.is_verified', default=False)

    class Meta:
        model = Agent
        fields = ['id', 'full_name', 'email', 'phone', 'is_verified']

class OrganizationSerializer(serializers.ModelSerializer):
    user_full_name = serializers.CharField(source='user.full_name', read_only=True)
    user_email = serializers.CharField(source='user.email', read_only=True)
    user_phone = serializers.CharField(source='user.phone', read_only=True)
    user_profile_picture = serializers.SerializerMethodField()
    class Meta:
        model = Organization
        fields = ['id', 'user_id', 'user_full_name', 'user_email', 'user_phone', 'user_profile_picture', 'agents']

    def get_user_profile_picture(self, obj):
        request = self.context.get('request')
        if obj.user and obj.user.profile_picture:
            if request is not None:
                return request.build_absolute_uri(obj.user.profile_picture.url)
            return obj.user.profile_picture.url
        return None

class InvitationSerializer(serializers.ModelSerializer):
    organization = OrganizationSerializer(read_only=True)
    agent = AgentSerializer(read_only=True)
    class Meta:
        model = Invitation
        fields = ['id', 'organization', 'agent', 'is_accepted', 'is_rejected']

class CustomTokenObtainPairSerializer(TokenObtainPairSerializer):
    def validate(self, attrs):
        email = attrs.get("email")
        password = attrs.get("password")
        try:
            user = UserAccount.objects.get(email__iexact=email)
        except UserAccount.DoesNotExist:
            raise serializers.ValidationError({"detail": "No active account found with the given credentials"}, code="no_active_account")

        if not user.is_active:
            raise serializers.ValidationError({"detail": "Please activate your account first. Check your email for the verification link."}, code="no_active_account")

        if not user.check_password(password):
            raise serializers.ValidationError({"detail": "Invalid Credential"}, code="invalid_credentials")

        return super().validate(attrs)