import re
from rest_framework import serializers
from django.contrib.auth import authenticate, get_user_model
from django.contrib.auth.password_validation import validate_password
from django.core.exceptions import ValidationError as DjangoValidationError
from django.utils import timezone
from .models import Profile, RESERVED_USERNAMES, validate_username_format, UserSession, BlockedEmailDomain
from accounts.services import is_account_locked, record_failed_login, reset_failed_login

User = get_user_model()

class RegisterSerializer(serializers.Serializer):
    username = serializers.CharField(max_length=20, required=False, allow_blank=True)
    first_name = serializers.CharField(max_length=50, required=False, allow_blank=True)
    last_name = serializers.CharField(max_length=50, required=False, allow_blank=True)
    email = serializers.EmailField(max_length=255)
    password = serializers.CharField(write_only=True)
    birth_date = serializers.CharField(max_length=30, required=False, allow_blank=True)
    gender = serializers.CharField(max_length=20, required=False, allow_blank=True)
    phone_number = serializers.CharField(max_length=30, required=False, allow_blank=True)

    def validate_username(self, value):
        if not value or not value.strip():
            return ""
        val = value.strip().lower()
        try:
            validate_username_format(val)
        except DjangoValidationError as e:
            raise serializers.ValidationError(list(e.messages)[0])
        return val

    def validate_email(self, value):
        return value.strip().lower()

    def validate_password(self, value):
        if len(value) < 10:
            raise serializers.ValidationError("Password must be at least 10 characters.")
        try:
            validate_password(value)
        except DjangoValidationError as e:
            raise serializers.ValidationError(list(e.messages)[0])
        return value

    def validate(self, attrs):
        username = attrs.get('username')
        email = attrs.get('email')

        # If username was not provided, auto-generate from email prefix
        if not username and email:
            base_user = re.sub(r'[^a-z0-9_]', '', email.split('@')[0].lower())[:15]
            if len(base_user) < 3:
                base_user = f"user_{base_user}"
            candidate = base_user
            idx = 1
            while User.objects.filter(username__iexact=candidate).exists() or candidate in RESERVED_USERNAMES:
                candidate = f"{base_user[:14]}_{idx}"
                idx += 1
            attrs['username'] = candidate
            username = candidate

        # Generic duplicate check to prevent user enumeration
        if User.objects.filter(username__iexact=username).exists() or User.objects.filter(email__iexact=email).exists():
            raise serializers.ValidationError({"non_field_errors": ["registration_failed"]})
        return attrs

class LoginSerializer(serializers.Serializer):
    login = serializers.CharField()
    password = serializers.CharField(write_only=True)

    def validate(self, attrs):
        login_val = attrs.get('login', '').strip().lower()
        password = attrs.get('password', '')
        request = self.context.get('request')

        # Try username or email
        user_obj = User.objects.filter(username__iexact=login_val).first()
        if not user_obj:
            user_obj = User.objects.filter(email__iexact=login_val).first()

        if user_obj:
            locked, locked_until = is_account_locked(user_obj)
            if locked:
                raise serializers.ValidationError({
                    "code": "invalid_credentials",
                    "locked_until": locked_until.isoformat() if locked_until else None
                })

            if user_obj.is_suspended:
                raise serializers.ValidationError("account_suspended")

            user = authenticate(username=user_obj.username, password=password)
            if not user:
                locked_until = record_failed_login(user_obj, request=request)
                if locked_until:
                    raise serializers.ValidationError({
                        "code": "invalid_credentials",
                        "locked_until": locked_until.isoformat()
                    })
                raise serializers.ValidationError("invalid_credentials")

            reset_failed_login(user)
            attrs['user'] = user
            return attrs

        raise serializers.ValidationError("invalid_credentials")

class ProfileSerializer(serializers.ModelSerializer):
    avatar_url = serializers.SerializerMethodField()
    cover_url = serializers.SerializerMethodField()

    class Meta:
        model = Profile
        fields = ['display_name', 'bio', 'avatar', 'cover', 'avatar_url', 'cover_url', 'updated_at']
        extra_kwargs = {
            'avatar': {'write_only': True, 'required': False},
            'cover': {'write_only': True, 'required': False},
        }

    def get_avatar_url(self, obj):
        if obj.avatar:
            request = self.context.get('request')
            if request:
                return request.build_absolute_uri(obj.avatar.url)
            return obj.avatar.url
        return None

    def get_cover_url(self, obj):
        if obj.cover:
            request = self.context.get('request')
            if request:
                return request.build_absolute_uri(obj.cover.url)
            return obj.cover.url
        return None

    def validate_display_name(self, value):
        return (value or '').strip()[:50]

    def validate_bio(self, value):
        return (value or '').strip()[:160]


class UserSerializer(serializers.ModelSerializer):
    profile = ProfileSerializer(read_only=True)

    class Meta:
        model = User
        fields = [
            'id', 'username', 'email', 'role', 'email_verified',
            'is_suspended', 'date_joined', 'last_login', 'profile'
        ]
        read_only_fields = ['id', 'username', 'email', 'role', 'email_verified', 'is_suspended', 'date_joined', 'last_login']

class ChangeUsernameSerializer(serializers.Serializer):
    username = serializers.CharField(max_length=20)

    def validate_username(self, value):
        val = value.strip().lower()
        try:
            validate_username_format(val)
        except DjangoValidationError as e:
            raise serializers.ValidationError(list(e.messages)[0])
        if User.objects.filter(username__iexact=val).exists():
            raise serializers.ValidationError("Username is already taken.")
        return val


class ChangeEmailSerializer(serializers.Serializer):
    email = serializers.EmailField(max_length=255)

    def validate_email(self, value):
        val = value.strip().lower()
        if User.objects.filter(email__iexact=val).exists():
            raise serializers.ValidationError("Email is already registered.")
        return val


class DeleteAccountSerializer(serializers.Serializer):
    password = serializers.CharField(write_only=True, required=True)


class UserSessionSerializer(serializers.ModelSerializer):
    is_current = serializers.SerializerMethodField()

    class Meta:
        model = UserSession
        fields = ['id', 'session_key', 'device_label', 'created_at', 'last_seen_at', 'is_current']

    def get_is_current(self, obj):
        request = self.context.get('request')
        if request and hasattr(request, 'session'):
            return request.session.session_key == obj.session_key
        return False


class BlockedEmailDomainSerializer(serializers.ModelSerializer):
    created_by_username = serializers.CharField(source='created_by.username', read_only=True)

    class Meta:
        model = BlockedEmailDomain
        fields = ['id', 'domain', 'created_at', 'created_by', 'created_by_username']
        read_only_fields = ['id', 'created_at', 'created_by']


