from rest_framework import serializers
from .models import Folder, Document, DocumentVersion
from users.serializers import UserListSerializer
from users.models import User, Department
import re


class FolderSerializer(serializers.ModelSerializer):
    """Serializer for Folder model"""

    created_by_detail = UserListSerializer(source='created_by', read_only=True)
    updated_by_detail = UserListSerializer(source='updated_by', read_only=True)
    full_path = serializers.SerializerMethodField(read_only=True)
    subfolders_count = serializers.SerializerMethodField(read_only=True)
    documents_count = serializers.SerializerMethodField(read_only=True)
    allowed_users_ids = serializers.PrimaryKeyRelatedField(
        many=True,
        source='allowed_users',
        queryset=User.objects.all(),
        required=False
    )
    department_id = serializers.PrimaryKeyRelatedField(
        source='department',
        queryset=Department.objects.all(),
        required=False,
        allow_null=True
    )

    class Meta:
        model = Folder
        fields = [
            'id', 'name', 'description', 'parent', 'is_public',
            'allowed_users', 'allowed_users_ids', 'created_by', 'created_by_detail',
            'updated_by', 'updated_by_detail', 'created_at', 'updated_at',
            'full_path', 'subfolders_count', 'documents_count', 'department_id',
            'deleted_at',
        ]
        read_only_fields = [
            'id', 'created_by', 'created_at', 'updated_by',
            'updated_at', 'deleted_at'
        ]

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['allowed_users_ids'].queryset = User.objects.all()

    def get_full_path(self, obj):
        return obj.get_full_path()

    def get_subfolders_count(self, obj):
        return obj.subfolders.count()

    def get_documents_count(self, obj):
        return obj.documents.count()

    def create(self, validated_data):
        request = self.context.get('request')
        validated_data['created_by'] = request.user
        validated_data['updated_by'] = request.user
        return super().create(validated_data)

    def update(self, instance, validated_data):
        request = self.context.get('request')
        validated_data['updated_by'] = request.user
        return super().update(instance, validated_data)


class FolderListSerializer(serializers.ModelSerializer):
    """Simplified serializer for folder lists"""

    full_path = serializers.SerializerMethodField(read_only=True)
    subfolders_count = serializers.SerializerMethodField(read_only=True)
    documents_count = serializers.SerializerMethodField(read_only=True)
    allowed_users_ids = serializers.PrimaryKeyRelatedField(
        many=True,
        source='allowed_users',
        queryset=User.objects.all(),
        required=False
    )
    department_id = serializers.PrimaryKeyRelatedField(
    source='department',
    read_only=True
    )
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['allowed_users_ids'].queryset = User.objects.all()

    class Meta:
        model = Folder
        fields = [
            'id', 'name', 'parent', 'is_public', 'created_at', 'updated_at',
            'full_path', 'subfolders_count', 'documents_count', 'department_id',
            'deleted_at', 'allowed_users_ids'
        ]
        read_only_fields = ['id', 'created_at', 'updated_at', 'deleted_at']

    def get_full_path(self, obj):
        return obj.get_full_path()

    def get_subfolders_count(self, obj):
        return obj.subfolders.count()

    def get_documents_count(self, obj):
        return obj.documents.count()


class DocumentSerializer(serializers.ModelSerializer):
    """Serializer for Document model"""

    created_by_detail = UserListSerializer(source='created_by', read_only=True)
    updated_by_detail = UserListSerializer(source='updated_by', read_only=True)
    file_info = serializers.SerializerMethodField(read_only=True)
    allowed_users_ids = serializers.PrimaryKeyRelatedField(
        many=True,
        source='allowed_users',
        queryset=User.objects.all(),
        required=False
    )

    file = serializers.FileField(required=False, allow_null=True)

    class Meta:
        model = Document
        fields = [
            'id', 'name', 'description', 'file', 'folder', 'file_size',
            'file_type', 'is_public', 'allowed_users', 'allowed_users_ids',
            'created_by', 'created_by_detail', 'updated_by', 'updated_by_detail',
            'created_at', 'updated_at', 'file_info', 'deleted_at',
        ]
        read_only_fields = [
            'id', 'file_size', 'file_type', 'created_by', 'created_at',
            'updated_by', 'updated_at', 'deleted_at'
        ]

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['allowed_users_ids'].queryset = User.objects.all()

    def get_file_info(self, obj):
        return obj.get_file_info()

    def create(self, validated_data):
        request = self.context.get('request')
        validated_data['created_by'] = request.user
        validated_data['updated_by'] = request.user
        
        file = validated_data.get('file')
        if file:
            validated_data['file_size'] = file.size
        
        return super().create(validated_data)

    def update(self, instance, validated_data):
        request = self.context.get('request')
        validated_data['updated_by'] = request.user
        
        file = validated_data.get('file')
        if file:
            if instance.file:
                instance.file.delete(save=False)
            validated_data['file_size'] = file.size
        
        return super().update(instance, validated_data)


class DocumentListSerializer(serializers.ModelSerializer):
    """Simplified serializer for document lists"""

    file_info = serializers.SerializerMethodField(read_only=True)
    folder_name = serializers.CharField(source='folder.name', read_only=True)

    class Meta:
        model = Document
        fields = [
            'id', 'name', 'folder', 'folder_name', 'file_type', 'file_size',
            'is_public', 'created_at', 'updated_at', 'file_info', 'deleted_at'  # 👈 agregado
        ]
        read_only_fields = ['id', 'created_at', 'updated_at', 'deleted_at']

    def get_file_info(self, obj):
        return obj.get_file_info()


class DocumentVersionSerializer(serializers.ModelSerializer):
    """Serializer for DocumentVersion model"""

    created_by_detail = UserListSerializer(source='created_by', read_only=True)

    class Meta:
        model = DocumentVersion
        fields = [
            'id', 'document', 'file', 'version_number', 'comment',
            'created_by', 'created_by_detail', 'created_at', 'deleted_at'  # 👈 agregado
        ]
        read_only_fields = ['id', 'version_number', 'created_by', 'created_at', 'deleted_at']

    def create(self, validated_data):
        request = self.context.get('request')
        document = validated_data['document']
        last_version = document.versions.first()
        version_number = 1 if not last_version else last_version.version_number + 1
        validated_data['version_number'] = version_number
        validated_data['created_by'] = request.user
        return super().create(validated_data)


# 🔹 Serializers para restauración (opcionales)
class FolderRestoreSerializer(serializers.ModelSerializer):
    class Meta:
        model = Folder
        fields = ['id', 'deleted_at']
        read_only_fields = ['id', 'deleted_at']


class DocumentRestoreSerializer(serializers.ModelSerializer):
    class Meta:
        model = Document
        fields = ['id', 'deleted_at']
        read_only_fields = ['id', 'deleted_at']


class DocumentVersionRestoreSerializer(serializers.ModelSerializer):
    class Meta:
        model = DocumentVersion
        fields = ['id', 'deleted_at']
        read_only_fields = ['id', 'deleted_at']


class EmailListField(serializers.Field):
    """Campo personalizado para listas de emails"""
    def to_internal_value(self, data):
        if isinstance(data, str):
            data = [email.strip() for email in data.split(',') if email.strip()]
        
        if not isinstance(data, list):
            raise serializers.ValidationError("Debe ser una lista o una cadena de emails separados por comas.")
        
        if not data:
            raise serializers.ValidationError("La lista de emails no puede estar vacía.")
        
        email_regex = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
        for email in data:
            if not re.match(email_regex, email):
                raise serializers.ValidationError(f"Email inválido: {email}")
        
        return data

    def to_representation(self, value):
        return value


class DocumentEmailSerializer(serializers.Serializer):
    """Serializer para enviar documentos por email"""
    emails = EmailListField(
        required=True,
        help_text="Lista de direcciones de correo electrónico (puede ser una lista o cadena separada por comas)"
    )
    subject = serializers.CharField(
        max_length=200, 
        required=False,
        allow_blank=True,
        help_text="Asunto del correo (opcional)"
    )
    message = serializers.CharField(
        required=False,
        allow_blank=True,
        help_text="Mensaje personalizado (opcional)"
    )
    
    def validate_subject(self, value):
        """Si no se proporciona asunto, usar uno por defecto"""
        if not value:
            return None
        return value.strip()
    
    def validate_message(self, value):
        """Limpiar el mensaje"""
        return value.strip() if value else ""
    
    
class DocumentBulkDownloadSerializer(serializers.Serializer):
    document_ids = serializers.ListField(
        child=serializers.IntegerField(),
        min_length=1,
        max_length=50,  # Límite para evitar abusos
        help_text="Lista de IDs de documentos a descargar"
    )
    
    zip_name = serializers.CharField(
        max_length=100,
        required=False,
        default='documentos',
        help_text="Nombre del archivo ZIP (sin extensión)"
    )
    
    def validate_document_ids(self, value):
        if len(value) != len(set(value)):
            raise serializers.ValidationError("Los IDs de documentos no deben repetirse")
        
        # Verificar que existen documentos con esos IDs (sin verificar permisos aquí)
        existing_count = Document.objects.filter(id__in=value).count()
        if existing_count != len(value):
            raise serializers.ValidationError(
                f"Algunos documentos no existen. Solicitados: {len(value)}, Encontrados: {existing_count}"
            )
        
        return value


class DocumentShareLinkSerializer(serializers.Serializer):
    expires_in_minutes = serializers.IntegerField(required=False, default=60, min_value=1, max_value=10080)


class DocumentBulkShareLinkSerializer(DocumentBulkDownloadSerializer):
    expires_in_minutes = serializers.IntegerField(required=False, default=60, min_value=1, max_value=10080)