from rest_framework import serializers
from .models import User, Department


class DepartmentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Department
        fields = ["id", "name", "description", "created_at"]


class UserSerializer(serializers.ModelSerializer):
    """Serializer for User model"""

    password = serializers.CharField(write_only=True, required=True, style={'input_type': 'password'})
    permissions = serializers.SerializerMethodField(read_only=True)
    department_id = serializers.PrimaryKeyRelatedField(
        queryset=Department.objects.all(),
        source='department',
        required=False,
        allow_null=True
    )

    class Meta:
        model = User
        fields = [
            'id', 'email', 'name', 'password', 'permissions',
            'can_add_documents', 'can_create_folders', 'can_download',
            'can_share_by_email',
            'can_view', 'can_edit_folders', 'can_edit_documents',
            'can_delete_documents', 'can_delete_folders', 'can_create_users',
            'is_active', 'date_joined', 'department_id',
            'deleted_at',
        ]
        read_only_fields = ['id', 'date_joined', 'deleted_at']

    def get_permissions(self, obj):
        """Get user permissions as a dictionary"""
        return obj.get_permissions_dict()

    def validate(self, data):
        """Validate that users don't assign permissions they don't have"""
        request = self.context.get('request')
        
        if request and request.method in ['POST', 'PUT', 'PATCH']:
            user = request.user
            
            if not user.is_superuser:
                permission_fields = [
                    'can_add_documents', 'can_create_folders', 'can_download',
                    'can_share_by_email',
                    'can_view', 'can_edit_folders', 'can_edit_documents',
                    'can_delete_documents', 'can_delete_folders', 'can_create_users'
                ]
                
                for field in permission_fields:
                    if field in data:
                        # Verificar si el usuario actual tiene ese permiso
                        if not getattr(user, field, False):
                            raise serializers.ValidationError(
                                {field: 'No tienes permiso para asignar este permiso'}
                            )
        
        return data

    def create(self, validated_data):
        """Create a new user with encrypted password"""
        password = validated_data.pop('password')
        user = User.objects.create_user(password=password, **validated_data)
        return user

    def update(self, instance, validated_data):
        """Update user, handling password separately"""
        password = validated_data.pop('password', None)

        for attr, value in validated_data.items():
            setattr(instance, attr, value)

        if password:
            instance.set_password(password)

        instance.save()
        return instance


class UserListSerializer(serializers.ModelSerializer):
    """Simplified serializer for user lists"""

    permissions = serializers.SerializerMethodField(read_only=True)
    department_name = serializers.CharField(source='department.name', read_only=True)
    department_id = serializers.PrimaryKeyRelatedField(
        read_only=True,
        source='department'
    )

    class Meta:
        model = User
        fields = [
            'id', 'email', 'name', 'is_active', 'date_joined', 'is_superuser',
            'permissions', 'department_name', 'department_id', 'deleted_at'
        ]
        read_only_fields = ['id', 'date_joined', 'deleted_at']

    def get_permissions(self, obj):
        """Get user permissions as a dictionary"""
        return obj.get_permissions_dict()


class ChangePasswordSerializer(serializers.Serializer):
    """Serializer for password change"""

    old_password = serializers.CharField(required=True, write_only=True)
    new_password = serializers.CharField(required=True, write_only=True)

    def validate_old_password(self, value):
        """Validate that old password is correct"""
        user = self.context['request'].user
        if not user.check_password(value):
            raise serializers.ValidationError('La contraseña actual es incorrecta')
        return value

    def validate_new_password(self, value):
        """Validate new password"""
        if len(value) < 8:
            raise serializers.ValidationError('La contraseña debe tener al menos 8 caracteres')
        return value

    def save(self):
        """Update user password"""
        user = self.context['request'].user
        user.set_password(self.validated_data['new_password'])
        user.save()
        return user


class UserRestoreSerializer(serializers.ModelSerializer):
    """Serializer para restaurar usuarios eliminados"""

    class Meta:
        model = User
        fields = ['id', 'deleted_at']
        read_only_fields = ['id', 'deleted_at']

    def update(self, instance, validated_data):
        """Restaurar usuario (soft delete reverse)"""
        instance.restore()
        return instance