from rest_framework import serializers
from django.contrib.auth import get_user_model
from allauth.account.models import EmailAddress
from django.contrib.auth.models import Permission
from  Sistemas.models import Sistema
from .models import ClientesA24, Sistemas_por_cliente_A24, DeviceA24,Modulo


class CustomPermissionSerializer(serializers.ModelSerializer):
    activo = serializers.BooleanField(read_only=True)
    class Meta:
        model = Permission
        fields = '__all__'

class ModulosSerializer(serializers.ModelSerializer):
    class Meta:
        model=Modulo
        fields = '__all__'
        depth =1

class Sistema_A24_PKRF(serializers.PrimaryKeyRelatedField):
    def to_internal_value(self,data):
        try:
            return Sistema.objects.get(nombre_sistema=data)
        except Sistema.DoesNotExist:
            raise serializers.ValidationError("Sistema no existe")

class ClientA24_PKRF(serializers.PrimaryKeyRelatedField):
    def to_internal_value(self,data):
        try:
            return ClientesA24.objects.get(RFC=data)
        except ClientesA24.DoesNotExist:
            raise serializers.ValidationError("No existe Cliente")

class ClientA24_Create_PKRF(serializers.PrimaryKeyRelatedField):
    def to_internal_value(self,data):
        try:
            return ClientesA24.objects.get(RFC=data)
        except ClientesA24.DoesNotExist:
            return None

#--------SERAILIZERS

class Sistema_Serializer(serializers.ModelSerializer):
    class Meta:
        model = Sistema
        fields = ('nombre_sistema',)

class ClientesA24Serailizer(serializers.ModelSerializer):
    class Meta:
        model =ClientesA24
        fields = ('pk','RFC', 'Nombre','Activo','fecha_baja',)

class  DeviceA24_admin_Serialiazer(serializers.ModelSerializer):
    clienteA24 = serializers.SerializerMethodField()
    sistema = serializers.SerializerMethodField()

    class Meta:
        model = DeviceA24
        fields = '__all__'

    def get_clienteA24(self, obj):
        return obj.clienteA24.RFC if obj.clienteA24.RFC else ""
    def get_sistema(self,obj):
        return obj.sistema.nombre_sistema if obj.sistema.nombre_sistema else ""


class SerialiazerA24(serializers.ModelSerializer):
    clienteA24  = ClientA24_PKRF(queryset=ClientesA24.objects.all())
    sistema     = Sistema_A24_PKRF(queryset=Sistema.objects.all())

    token       = serializers.CharField(read_only=True)    
    class Meta:
        model = DeviceA24
        fields= ('clienteA24', 'deviceName', 'deviceOS', 'deviceIP', 'token', 'sistema', 'MAC', 'dataBase',)

    def create(self, validated_data):
        # Extraer los datos obligatorios de la solicitud
        clienteA24 = validated_data['clienteA24']
        deviceName = validated_data['deviceName']
        deviceOS = validated_data['deviceOS']
        deviceIP = validated_data['deviceIP']
        MAC = validated_data['MAC']
        sistema=validated_data['sistema']
        dataBase = validated_data['dataBase']

        # Verificar si ya existe un dispositivo con los mismos datos
        existing_device = DeviceA24.objects.filter(
            clienteA24=clienteA24,
            #deviceName=deviceName,
            #deviceOS=deviceOS,
            #deviceIP=deviceIP,
            MAC=MAC,
            sistema=sistema,
            dataBase=dataBase
        ).first()

        if existing_device:
            # Si ya existe un dispositivo con los mismos datos, puedes devolverlo
            return existing_device

        # Si no existe, crear un nuevo objeto DeviceA24
        device_a24 = DeviceA24.objects.create(
            clienteA24=clienteA24,
            deviceName=deviceName,
            deviceOS=deviceOS,
            deviceIP=deviceIP,
            MAC=MAC,
            sistema=sistema,
            dataBase=dataBase,
        )

        # Generar el nombre de usuario y otros campos automáticos
        device_a24.username = device_a24.generate_username(clienteA24, deviceName, MAC)
        device_a24.save()  # Guardar para generar el timestamp

        return device_a24

class Sistema_Por_Cliente_Serializer(serializers.ModelSerializer):
    id_sistema  = Sistema_A24_PKRF(queryset=Sistema.objects.all())
    cliente     = ClientA24_Create_PKRF(queryset=ClientesA24.objects.all())
    clienteA24  = serializers.CharField(read_only=True)
    token = serializers.CharField(read_only=True)
    nombre_sistema = serializers.SerializerMethodField()  # Agrega estos campos
    rfc_cliente = serializers.SerializerMethodField()
    class Meta:
        model = Sistemas_por_cliente_A24
        fields = ('id_sistema','cliente', 'clienteA24', 'token', 'nombre_sistema', 'rfc_cliente',)

    def create(self, validated_data):
        cliente = validated_data.get('cliente')
        print('validated_data', validated_data)
        if not cliente:
            
            print("context clienteA24 ",self.context.get('clienteA24'))
            print("context DeviceA24 ",self.context.get('DeviceA24'))

            nuevo_cliente = self.context.get('clienteA24')
            cliente = ClientesA24.objects.create(**nuevo_cliente)

        sistema_por_cliente = Sistemas_por_cliente_A24.objects.create(
            id_sistema=validated_data['id_sistema'],
            cliente=cliente
        )
        
        device_serializer_data = self.context.get('DeviceA24')
        device_serailizer = SerialiazerA24(data=device_serializer_data)
        if device_serailizer.is_valid():
            device = device_serailizer.save()            
            sistema_por_cliente.token=device.token
        else:
            sistema_por_cliente.token=""

        return sistema_por_cliente
        
    def get_nombre_sistema(self, obj):
        return obj.id_sistema.nombre_sistema if obj.id_sistema else ""

    def get_rfc_cliente(self, obj):
        return obj.cliente.RFC if obj.cliente else ""


User = get_user_model()
class SignupSerializer(serializers.Serializer):
    password = serializers.CharField(write_only=True)
    password2 = serializers.CharField(write_only=True)
    class Meta:
        model = User
        fields = ['username', 'password', 'email', 'first_name', 'last_name']
    def validate(self, data):
        print(f'DATA {data}')
        if data['password'] != data['password2']:
            raise serializers.ValidationError("Las contraseñas no coinciden.")
        return data

    def create(self, validated_data):
        print(f'CREATE {validated_data}')
        password2 = validated_data.get('password2')
        if password2:
            validated_data.pop('password2')
        
        # Asegurarse de tener el campo 'username' en validated_data
        username   = self.context['request'].data.get('username')
        email      = self.context['request'].data.get('email')
        first_name = self.context['request'].data.get('first_name')
        last_name  = self.context['request'].data.get('last_name')
        if not username:
            raise serializers.ValidationError("El campo 'username' es requerido.")
        
        # Crear el usuario con los datos validados
        user = User.objects.create_user(username=username, password=validated_data['password'], email=email, first_name=first_name, last_name= last_name)
        # Crea el objeto Email asociado al usuario
        EmailAddress.objects.create(user=user, email=user.email, primary=True, verified=False)
        return user