from adrf.serializers import (
    ModelSerializer, Serializer, CharField, IntegerField, EmailField,
    ChoiceField, IPAddressField, DateTimeField, ImageField,
)
from rest_framework.exceptions import ValidationError
from django.contrib.auth import get_user_model
from django.utils import timezone
from utils.async_cache import aget_cache, aset_cache, adelete_cache
import os
import re

from utils import RandCode

FUser = get_user_model()


def get_fields_to_extract(validated_data, fields_to_extract):
    extracted = {}
    for field in fields_to_extract:
        if field in validated_data:
            extracted[field] = validated_data[field]
    return extracted

class UserSerializer(ModelSerializer):
    PROTECTED_FIELDS = ['is_active', 'password', 'email', 'is_staff', 'is_superuser', 'last_login']
    class Meta:
        model = FUser
        fields = [
            'id',
            'username',
            'email',
            'is_active',
            'is_staff',
            'is_superuser',
            'password',
            'last_login',
            'date_joined',
            'phone_number',
            'avatar',
            'bio',
            'isSetPassword',
            'gender',
            'location',
            'points',
            'coins',
        ]
        extra_kwargs = {
            'password': {'write_only': True},
            'is_active': {'read_only': True},
            'is_staff': {'read_only': True},
            'is_superuser': {'read_only': True},
            'last_login': {'read_only': True},
            'date_joined': {'read_only': True},
            'id': {'read_only': True},
            'isSetPassword': {'read_only': True},
            'points': {'read_only': True},
            'coins': {'read_only': True},

        }


    async def acreate_by_email(self, validated_data):
        fields_to_extract = ['email']
        extracted = get_fields_to_extract(validated_data, fields_to_extract)

        extracted['username'] = extracted['email']
        extracted['password'] = RandCode.get_alphanumeric_characters_code_8()

        # 2. 创建用户（create_user 内含密码哈希，为同步调用，sync_to_async 兜底）
        from asgiref.sync import sync_to_async
        user = await sync_to_async(FUser.objects.create_user)(**extracted)

        user.is_active = True
        user.is_staff = False
        user.is_superuser = False
        await user.asave()

        return user

    async def aupdate(self, instance, validated_data):
        for attr, value in validated_data.items():
            if attr in self.PROTECTED_FIELDS :
                continue
            setattr(instance, attr, value)
        await instance.asave()
        return instance

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

        # 将所有字段设为非必填
        for field_name, field in self.fields.items():
            field.required = False


class ChangePasswordSerializer(Serializer):
    old_password = CharField(required=False, allow_blank=True)
    new_password = CharField(required=True, min_length=8, max_length=128)
    confirm_password = CharField(required=True, min_length=8, max_length=128)

    def validate_old_password(self, value):
        user = self.context['request'].user
        # check_password 为 CPU 密集（argon2），同步调用（is_valid 由视图 sync_to_async 包裹）
        if user.has_usable_password() and not user.check_password(value):
            raise ValidationError('当前密码错误')
        return value

    def validate_new_password(self, value):
        if len(value) < 8:
            raise ValidationError('密码长度不能少于8位')
        has_letter = any(c.isalpha() for c in value)
        has_digit = any(c.isdigit() for c in value)
        if not (has_letter and has_digit):
            raise ValidationError('密码必须包含字母和数字')
        return value

    def validate(self, attrs):
        if attrs['new_password'] != attrs['confirm_password']:
            raise ValidationError({'confirm_password': '两次输入的新密码不一致'})
        return attrs

    async def asave(self):
        from asgiref.sync import sync_to_async
        user = self.context['request'].user
        # 密码哈希 CPU 密集，sync_to_async 兜底
        await sync_to_async(user.set_password)(self.validated_data['new_password'])
        if not user.isSetPassword:
            user.isSetPassword = True
        await user.asave()
        return user


class UserUpdateSerializer(ModelSerializer):
    username = CharField(
        required=False,
        max_length=150,
        min_length=2,
        error_messages={
            'max_length': '用户名不能超过150个字符',
            'min_length': '用户名至少2个字符',
        }
    )
    gender = ChoiceField(
        required=False,
        choices=[(0, '保密'), (1, '男'), (2, '女')],
        error_messages={
            'invalid_choice': '性别值无效，可选值为：0（保密）、1（男）、2（女）',
        }
    )
    bio = CharField(
        required=False,
        max_length=500,
        allow_blank=True,
        error_messages={
            'max_length': '个人简介不能超过500个字符',
        }
    )
    location = CharField(
        required=False,
        max_length=100,
        allow_blank=True,
        error_messages={
            'max_length': '所在地区不能超过100个字符',
        }
    )
    phone_number = CharField(
        required=False,
        max_length=15,
        allow_blank=True,
        error_messages={
            'max_length': '手机号不能超过15个字符',
        }
    )

    class Meta:
        model = FUser
        fields = [
            'username',
            'gender',
            'bio',
            'location',
            'phone_number',
        ]
        extra_kwargs = {
            'username': {'validators': []},
        }

    def validate_username(self, value):
        user = self.context['request'].user
        # is_valid 由视图侧 sync_to_async 包裹（DB 查询）
        if FUser.objects.filter(username=value).exclude(id=user.id).exists():
            raise ValidationError('该用户名已被使用')
        return value

    def validate_phone_number(self, value):
        if value and not value.isdigit():
            raise ValidationError('手机号只能包含数字')
        return value

    async def aupdate(self, instance, validated_data):
        for attr, value in validated_data.items():
            setattr(instance, attr, value)
        await instance.asave()
        return instance


class PointTransactionSerializer(Serializer):
    id = IntegerField(read_only=True)
    transaction_type = CharField(read_only=True)
    currency_type = CharField(read_only=True)
    amount = IntegerField(read_only=True)
    balance_after = IntegerField(read_only=True)
    description = CharField(read_only=True)
    created_at = DateTimeField(read_only=True)

    async def ato_representation(self, instance):
        return {
            'id': instance.id,
            'transaction_type': instance.transaction_type,
            'transaction_type_display': instance.get_transaction_type_display(),
            'currency_type': instance.currency_type,
            'currency_type_display': instance.get_currency_type_display(),
            'amount': instance.amount,
            'balance_after': instance.balance_after,
            'description': instance.description,
            'created_at': instance.created_at.strftime('%Y-%m-%d %H:%M:%S'),
        }


class SendEmailCodeSerializer(Serializer):
    email = EmailField(required=True, error_messages={
        'required': '邮箱地址不能为空',
        'invalid': '邮箱格式不正确',
    })
    target = ChoiceField(
        required=True,
        choices=['old', 'new'],
        error_messages={
            'required': '验证目标不能为空',
            'invalid_choice': '验证目标无效',
        }
    )

    def validate_email(self, value):
        user = self.context['request'].user
        target = self.initial_data.get('target', '')

        if target == 'old':
            if user.email != value:
                raise ValidationError('请输入当前绑定的邮箱地址')
        elif target == 'new':
            if user.email == value:
                raise ValidationError('新邮箱与当前邮箱相同')
            # is_valid 由视图侧 sync_to_async 包裹（DB 查询）
            if FUser.objects.filter(email=value).exists():
                raise ValidationError('该邮箱已被其他账号使用')

        return value

    async def asave(self):
        from utils.safe_task import submit_task
        from asgiref.sync import sync_to_async
        email = self.validated_data['email']
        target = self.validated_data['target']
        user = self.context['request'].user

        code = RandCode.get_digit_characters_code_6()
        cache_key = f"email_change_{target}_{user.id}"
        await aset_cache(cache_key, {'code': code, 'email': email}, timeout=600)

        from ..tasks import send_change_email_task
        await sync_to_async(submit_task)(send_change_email_task, email, code, target)

        return email


class BlacklistSerializer(ModelSerializer):
    blocked_user_id = IntegerField(write_only=True)
    blocked_user_username = CharField(source='blocked_user.username', read_only=True)
    blocked_user_email = CharField(source='blocked_user.email', read_only=True)
    blocked_user_avatar = ImageField(source='blocked_user.avatar', read_only=True)

    class Meta:
        model = None
        fields = ['id', 'blocked_user_id', 'blocked_user_username', 'blocked_user_email', 'blocked_user_avatar', 'reason', 'created_at']
        read_only_fields = ['id', 'created_at']

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        from ..models import Blacklist
        self.Meta.model = Blacklist

    def validate_blocked_user_id(self, value):
        from ..models import FUser
        # is_valid 由视图侧 sync_to_async 包裹（DB 查询）
        try:
            FUser.objects.get(id=value)
        except FUser.DoesNotExist:
            raise ValidationError('用户不存在')
        return value

    def validate(self, attrs):
        user = self.context['request'].user
        blocked_user_id = attrs.get('blocked_user_id')
        if user.id == blocked_user_id:
            raise ValidationError({'blocked_user_id': '不能将自己加入黑名单'})
        from ..models import Blacklist
        if Blacklist.objects.filter(user=user, blocked_user_id=blocked_user_id).exists():
            raise ValidationError({'blocked_user_id': '该用户已在黑名单中'})
        return attrs

    async def acreate(self, validated_data):
        from ..models import Blacklist, FUser
        user = self.context['request'].user
        blocked_user = await FUser.objects.aget(id=validated_data['blocked_user_id'])
        blacklist = await Blacklist.objects.acreate(
            user=user,
            blocked_user=blocked_user,
            reason=validated_data.get('reason', '')
        )
        return blacklist


class ChangeEmailSerializer(Serializer):
    new_email = EmailField(required=True, error_messages={
        'required': '新邮箱地址不能为空',
        'invalid': '邮箱格式不正确',
    })
    code = CharField(required=True, max_length=6, min_length=6, error_messages={
        'required': '验证码不能为空',
        'min_length': '验证码必须为6位',
        'max_length': '验证码必须为6位',
    })

    def validate_new_email(self, value):
        user = self.context['request'].user
        if user.email == value:
            raise ValidationError('新邮箱与当前邮箱相同')
        # is_valid 由视图侧 sync_to_async 包裹（DB 查询）
        if FUser.objects.filter(email=value).exists():
            raise ValidationError('该邮箱已被其他账号使用')
        return value

    async def avalidate(self, attrs):
        """异步版 validate（验证码在 Redis），由视图在 is_valid 后调用 await serializer.avalidate(attrs) 复核"""
        user = self.context['request'].user
        code = attrs['code']
        new_email = attrs['new_email']

        cache_key = f"email_change_new_{user.id}"
        cached = await aget_cache(cache_key)

        if cached is None:
            raise ValidationError({'code': '验证码已过期，请重新获取'})
        if cached['code'] != code:
            raise ValidationError({'code': '验证码错误'})
        if cached['email'] != new_email:
            raise ValidationError({'new_email': '邮箱与发送验证码时的邮箱不一致'})

        return attrs

    async def asave(self):
        user = self.context['request'].user
        user.email = self.validated_data['new_email']
        await user.asave()

        cache_key_old = f"email_change_old_{user.id}"
        cache_key_new = f"email_change_new_{user.id}"
        await adelete_cache(cache_key_old)
        await adelete_cache(cache_key_new)

        return user


class LoginRecordSerializer(Serializer):
    id = IntegerField(read_only=True)
    device = CharField(read_only=True)
    ip_address = IPAddressField(read_only=True)
    location = CharField(read_only=True)
    login_time = DateTimeField(read_only=True)
    status = CharField(read_only=True)

    async def ato_representation(self, instance):
        return {
            'id': instance.id,
            'device': instance.device,
            'ip_address': instance.ip_address or '',
            'location': instance.location,
            'login_time': instance.login_time.strftime('%Y-%m-%d %H:%M:%S'),
            'status': instance.status,
            'status_display': instance.get_status_display(),
        }


class SendPhoneCodeSerializer(Serializer):
    phone = CharField(required=True, max_length=15, error_messages={
        'required': '手机号不能为空',
        'max_length': '手机号不能超过15个字符',
    })
    target = ChoiceField(
        required=True,
        choices=['old', 'new'],
        error_messages={
            'required': '验证目标不能为空',
            'invalid_choice': '验证目标无效',
        }
    )

    def validate_phone(self, value):
        if not value.isdigit():
            raise ValidationError('手机号只能包含数字')
        if len(value) != 11:
            raise ValidationError('手机号必须为11位')
        return value

    async def asave(self):
        phone = self.validated_data['phone']
        target = self.validated_data['target']
        user = self.context['request'].user

        code = RandCode.get_digit_characters_code_6()
        cache_key = f"phone_change_{target}_{user.id}"
        await aset_cache(cache_key, {'code': code, 'phone': phone}, timeout=300)

        return phone


class ChangePhoneSerializer(Serializer):
    new_phone = CharField(required=True, max_length=15, error_messages={
        'required': '新手机号不能为空',
        'max_length': '手机号不能超过15个字符',
    })
    code = CharField(required=True, max_length=6, min_length=6, error_messages={
        'required': '验证码不能为空',
        'min_length': '验证码必须为6位',
        'max_length': '验证码必须为6位',
    })

    def validate_new_phone(self, value):
        if not value.isdigit():
            raise ValidationError('手机号只能包含数字')
        if len(value) != 11:
            raise ValidationError('手机号必须为11位')
        user = self.context['request'].user
        if user.phone_number == value:
            raise ValidationError('新手机号与当前手机号相同')
        return value

    async def avalidate(self, attrs):
        """异步版 validate（验证码在 Redis），由视图在 is_valid 后调用"""
        user = self.context['request'].user
        code = attrs['code']
        new_phone = attrs['new_phone']

        cache_key = f"phone_change_new_{user.id}"
        cached = await aget_cache(cache_key)

        if cached is None:
            raise ValidationError({'code': '验证码已过期，请重新获取'})
        if cached['code'] != code:
            raise ValidationError({'code': '验证码错误'})
        if cached['phone'] != new_phone:
            raise ValidationError({'new_phone': '手机号与发送验证码时的手机号不一致'})

        return attrs

    async def asave(self):
        user = self.context['request'].user
        user.phone_number = self.validated_data['new_phone']
        await user.asave()

        cache_key_old = f"phone_change_old_{user.id}"
        cache_key_new = f"phone_change_new_{user.id}"
        await adelete_cache(cache_key_old)
        await adelete_cache(cache_key_new)

        return user